Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Probability.LogConcave.TensorGraphs.IncidentMatrix
import OAI.Probability.LogConcave.JetEstimates.JetCongrList

namespace OAI

section
section
noncomputable section
open MeasureTheory Filter
open scoped ENNReal NNReal Topology

section UpperProof
open MeasureTheory ProbabilityTheory Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology
open Function MeasureTheory Set Filter
open scoped Topology NNReal

namespace LogConcaveSampling.AdjointRemoval
variable {d : ℕ} {P : Type*}

lemma hessian_congr_on_tokens (H : Point d → ℝ) (b c : P → Point d) (h : Hessian P)
    (he : ∀i∈h.tokens,b i=c i) : hessian H b h=hessian H c h := by
  have hf : b h.first=c h.first := he _ (by simp [Hessian.tokens])
  have hs : b h.second=c h.second := he _ (by simp [Hessian.tokens])
  unfold hessian
  rw [hf,hs]
  apply JetCalculus.jet_congr_on_list
  intro i hi
  exact he i (by simp [Hessian.tokens,hi])
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
open GraphSchedule
open scoped Classical

variable {n d : ℕ} {S : State (Fin (n+1))}

noncomputable def hessianIncidenceTensor
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
    (h : S.hessians) (x : Point d)
    (a : {t : Edge (U:=InternalEdge β) q //
      IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
        (Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inr h) q t} → Fin d) : ℝ :=
  hessian H (fun i => if hi : destination hS i=Sum.inr h then
    b (a ⟨Sum.inl (Sum.inr i),Or.inr hi⟩) else 0) h x

lemma hessianIncidenceTensor_global
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
    (h : S.hessians) (x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
    hessianIncidenceTensor hS β q H b h x (fun t => duplicate c t.val)=
      hessian H (fun i => b (c (Sum.inl (Sum.inr i)))) h x := by
  unfold hessianIncidenceTensor
  refine congrFun (hessian_congr_on_tokens (P:=Fin (n+1)) H _ _
    (h : Hessian (Fin (n+1))) ?_) x
  intro i hi
  have hd : destination hS i=Sum.inr h :=
    (destination_iff_mem hS i (Sum.inr h)).mpr hi
  simp only [dite_eq_left hd]
  rfl
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
open GraphSchedule
open scoped Classical

variable {n d : ℕ} {S : State (Fin (n+1))}

abbrev TraceEdge (β : Fin n → ℕ) (q : ℕ) :=
  ((k : Fin n) × Fin (β k)) ⊕ (Fin q ⊕ Fin q)

def traceEmbed (β : Fin n → ℕ) (q : ℕ) : TraceEdge β q → Edge (U:=InternalEdge β) q
  | Sum.inl e => Sum.inl (Sum.inl e)
  | Sum.inr e => Sum.inr e

abbrev PrimaryTraceSlot
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :=
  {t : TraceEdge β q //
    IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
      (Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q (traceEmbed β q t)}

noncomputable def primaryIncidenceTensor
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (b : Fin d → Point d) (i : Fin (n+1))
    (F : (PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ) (x : Point d)
    (a : {t : Edge (U:=InternalEdge β) q //
      IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
        (Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} → Fin d) : ℝ :=
  JetCalculus.jet (fun j => if hj : destination hS j=Sum.inl i then
    b (a ⟨Sum.inl (Sum.inr j),Or.inr hj⟩) else 0) (S.derivatives i)
      (F (fun t => a ⟨traceEmbed β q t.val,t.property⟩)
        (a ⟨Sum.inl (Sum.inr i),Or.inl rfl⟩)) x

lemma primaryIncidenceTensor_global
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (b : Fin d → Point d) (i : Fin (n+1))
    (F : (PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
    (x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
    primaryIncidenceTensor hS β q b i F x (fun t => duplicate c t.val)=
      JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
        (F (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x := by
  unfold primaryIncidenceTensor
  apply congrFun (JetCalculus.jet_congr_on_list _ _ _ _ ?_) x
  intro j hj
  have hd : destination hS j=Sum.inl i :=
    (destination_iff_mem hS j (Sum.inl i)).mpr hj
  simp only [dite_eq_left hd]
  rfl
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
open GraphSchedule TensorEnergy MeasureTheory
open scoped BigOperators Classical ENNReal

variable {n d : ℕ} {S : State (Fin (n+1))}
local instance edgeDecEqBT (β : Fin n → ℕ) (q : ℕ) :
    DecidableEq (Edge (U:=InternalEdge β) q) := Classical.decEq _
local instance cutDecEqBT (β : Fin n → ℕ) (q : ℕ) :
    DecidableEq (InternalEdge β ⊕ Fin q) :=
  @instDecidableEqSum _ _ (Classical.decEq _) (Classical.decEq _)

noncomputable def branchIncidenceTensor
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
    (F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
    (x : Point d) (v : TargetVertex S) :
    ({t : Edge (U:=InternalEdge β) q //
      IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
        (Sum.inl 0) (Sum.inl (Fin.last n)) v q t} → Fin d) → ℝ :=
  match v with
  | Sum.inl i => primaryIncidenceTensor hS β q b i (F i) x
  | Sum.inr h => hessianIncidenceTensor hS β q H b h x

lemma branchIncidenceTensor_global
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
    (F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
    (x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
    (∏v,branchIncidenceTensor hS β q H b F x v (fun t => duplicate c t.val))=
      (∏i,JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
        (F i (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x)*
      (S.hessians.map (fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod := by
  rw [Fintype.prod_sum_type]
  simp only [branchIncidenceTensor,primaryIncidenceTensor_global,hessianIncidenceTensor_global]
  congr 1
  change (Finset.univ.val.map (fun h : S.hessians =>
    hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod=_
  exact congrArg Multiset.prod (Multiset.map_univ S.hessians
    (fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x))

theorem literal_branch_integral_bound
    (μ : Measure (Point d))
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (hβ : ∀k,0<β k) (q : ℕ) (hq : 0<q)
    (H : Point d → ℝ) (b : Fin d → Point d)
    (F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
    (M : TargetVertex S → Point d → ℝ) (hM : ∀v x,0≤M v x)
    (hT : ∀v x,AllSplitBound (branchIncidenceTensor hS β q H b F x v) (M v x))
    (B : Fin (n+1) → ℝ≥0∞) (C : S.hessians → ℝ≥0∞)
    (hMp : ∀i,AEMeasurable (fun x => ENNReal.ofReal (M (Sum.inl i) x)) μ)
    (hp : ∀i,(∫⁻x,ENNReal.ofReal (M (Sum.inl i) x)^(n+1) ∂μ)≤B i^(n+1))
    (hh : ∀h x,ENNReal.ofReal (M (Sum.inr h) x)≤C h) (hC : ∀h,C h≠⊤) :
    (∫⁻x,ENNReal.ofReal |∑c : InternalEdge β ⊕ Fin q → Fin d,
      (∏i,JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
        (F i (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x)*
      (S.hessians.map (fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod| ∂μ)≤
      (d:ℝ≥0∞)^q*((∏i,B i)*(∏h,C h)) := by
  have hb := actual_tensor_integral_bound μ hS β hβ q d hq
    (branchIncidenceTensor hS β q H b F) M hM hT B C hMp hp hh hC
  convert hb using 1
  congr 1
  funext x
  congr 2
  apply Finset.sum_congr rfl
  intro c _
  exact (branchIncidenceTensor_global hS β q H b F x c).symm
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
open GraphSchedule
open scoped Classical

variable {n : ℕ} {S : State (Fin (n+1))}

noncomputable def primaryIncidentCases
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
    {t : Edge (U:=InternalEdge β) q //
      IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
        (Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} ≃
      PrimaryTraceSlot hS β q i ⊕ (Unit ⊕ {j : Fin (n+1) // destination hS j=Sum.inl i}) where
  toFun t := by
    rcases t with ⟨(e|j)|e,ht⟩
    · exact Sum.inl ⟨Sum.inl e,ht⟩
    · by_cases hj : j=i
      · exact Sum.inr (Sum.inl ())
      · exact Sum.inr (Sum.inr ⟨j,ht.resolve_left (fun h => hj (Sum.inl.inj h))⟩)
    · exact Sum.inl ⟨Sum.inr e,ht⟩
  invFun t := by
    rcases t with t | (u | j)
    · exact ⟨traceEmbed β q t.val,t.property⟩
    · exact ⟨Sum.inl (Sum.inr i),Or.inl rfl⟩
    · exact ⟨Sum.inl (Sum.inr j.val),Or.inr j.property⟩
  left_inv t := by
    rcases t with ⟨(e|j)|e,ht⟩
    · rfl
    · dsimp only
      split_ifs with hj
      · subst j; rfl
      · rfl
    · rfl
  right_inv t := by
    rcases t with ⟨e|e,ht⟩ | (u | ⟨j,hj⟩)
    · rfl
    · rfl
    · cases u
      dsimp only
      simp only [dite_true]
    · dsimp only
      rw [dite_eq_right (destination_primary_ne hS hj)]

noncomputable def primarySlotEquiv
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
    (PrimaryTraceSlot hS β q i ⊕ (Unit ⊕ Fin (S.derivatives i).length)) ≃
      {t : Edge (U:=InternalEdge β) q //
        IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
          (Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} :=
  (Equiv.sumCongr (Equiv.refl _) (Equiv.sumCongr (Equiv.refl _) (derivativeEdgeEquiv hS i))).trans
    (primaryIncidentCases hS β q i).symm

lemma primarySlotEquiv_trace
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) (t : PrimaryTraceSlot hS β q i) :
    (primarySlotEquiv hS β q i (Sum.inl t)).val=traceEmbed β q t.val := rfl

lemma primarySlotEquiv_source
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
    (primarySlotEquiv hS β q i (Sum.inr (Sum.inl ()))).val=Sum.inl (Sum.inr i) := rfl

lemma primarySlotEquiv_derivative
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) (k : Fin (S.derivatives i).length) :
    (primarySlotEquiv hS β q i (Sum.inr (Sum.inr k))).val=
      Sum.inl (Sum.inr ((S.derivatives i).get k)) := rfl
end LogConcaveSampling.AdjointRemoval

end UpperProof
end
end
end

end OAI

	import Mathlib
	import OAI.Probability.LogConcave.TensorGraphs.IncidentMatrix
	import OAI.Probability.LogConcave.JetEstimates.JetCongrList

	namespace OAI

	section
	section
	noncomputable section
	open MeasureTheory Filter
	open scoped ENNReal NNReal Topology

	section UpperProof
	open MeasureTheory ProbabilityTheory Filter
	open scoped ENNReal NNReal RealInnerProductSpace Topology
	open Function MeasureTheory Set Filter
	open scoped Topology NNReal

	namespace LogConcaveSampling.AdjointRemoval
	variable {d : ℕ} {P : Type*}

	lemma hessian_congr_on_tokens (H : Point d → ℝ) (b c : P → Point d) (h : Hessian P)
	(he : ∀i∈h.tokens,b i=c i) : hessian H b h=hessian H c h := by
	have hf : b h.first=c h.first := he _ (by simp [Hessian.tokens])
	have hs : b h.second=c h.second := he _ (by simp [Hessian.tokens])
	unfold hessian
	rw [hf,hs]
	apply JetCalculus.jet_congr_on_list
	intro i hi
	exact he i (by simp [Hessian.tokens,hi])
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	open GraphSchedule
	open scoped Classical

	variable {n d : ℕ} {S : State (Fin (n+1))}

	noncomputable def hessianIncidenceTensor
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
	(h : S.hessians) (x : Point d)
	(a : {t : Edge (U:=InternalEdge β) q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inr h) q t} → Fin d) : ℝ :=
	hessian H (fun i => if hi : destination hS i=Sum.inr h then
	b (a ⟨Sum.inl (Sum.inr i),Or.inr hi⟩) else 0) h x

	lemma hessianIncidenceTensor_global
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
	(h : S.hessians) (x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
	hessianIncidenceTensor hS β q H b h x (fun t => duplicate c t.val)=
	hessian H (fun i => b (c (Sum.inl (Sum.inr i)))) h x := by
	unfold hessianIncidenceTensor
	refine congrFun (hessian_congr_on_tokens (P:=Fin (n+1)) H _ _
	(h : Hessian (Fin (n+1))) ?_) x
	intro i hi
	have hd : destination hS i=Sum.inr h :=
	(destination_iff_mem hS i (Sum.inr h)).mpr hi
	simp only [dite_eq_left hd]
	rfl
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	open GraphSchedule
	open scoped Classical

	variable {n d : ℕ} {S : State (Fin (n+1))}

	abbrev TraceEdge (β : Fin n → ℕ) (q : ℕ) :=
	((k : Fin n) × Fin (β k)) ⊕ (Fin q ⊕ Fin q)

	def traceEmbed (β : Fin n → ℕ) (q : ℕ) : TraceEdge β q → Edge (U:=InternalEdge β) q
	\| Sum.inl e => Sum.inl (Sum.inl e)
	\| Sum.inr e => Sum.inr e

	abbrev PrimaryTraceSlot
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :=
	{t : TraceEdge β q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q (traceEmbed β q t)}

	noncomputable def primaryIncidenceTensor
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (b : Fin d → Point d) (i : Fin (n+1))
	(F : (PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ) (x : Point d)
	(a : {t : Edge (U:=InternalEdge β) q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} → Fin d) : ℝ :=
	JetCalculus.jet (fun j => if hj : destination hS j=Sum.inl i then
	b (a ⟨Sum.inl (Sum.inr j),Or.inr hj⟩) else 0) (S.derivatives i)
	(F (fun t => a ⟨traceEmbed β q t.val,t.property⟩)
	(a ⟨Sum.inl (Sum.inr i),Or.inl rfl⟩)) x

	lemma primaryIncidenceTensor_global
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (b : Fin d → Point d) (i : Fin (n+1))
	(F : (PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
	(x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
	primaryIncidenceTensor hS β q b i F x (fun t => duplicate c t.val)=
	JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
	(F (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x := by
	unfold primaryIncidenceTensor
	apply congrFun (JetCalculus.jet_congr_on_list _ _ _ _ ?_) x
	intro j hj
	have hd : destination hS j=Sum.inl i :=
	(destination_iff_mem hS j (Sum.inl i)).mpr hj
	simp only [dite_eq_left hd]
	rfl
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	open GraphSchedule TensorEnergy MeasureTheory
	open scoped BigOperators Classical ENNReal

	variable {n d : ℕ} {S : State (Fin (n+1))}
	local instance edgeDecEqBT (β : Fin n → ℕ) (q : ℕ) :
	DecidableEq (Edge (U:=InternalEdge β) q) := Classical.decEq _
	local instance cutDecEqBT (β : Fin n → ℕ) (q : ℕ) :
	DecidableEq (InternalEdge β ⊕ Fin q) :=
	@instDecidableEqSum _ _ (Classical.decEq _) (Classical.decEq _)

	noncomputable def branchIncidenceTensor
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
	(F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
	(x : Point d) (v : TargetVertex S) :
	({t : Edge (U:=InternalEdge β) q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) v q t} → Fin d) → ℝ :=
	match v with
	\| Sum.inl i => primaryIncidenceTensor hS β q b i (F i) x
	\| Sum.inr h => hessianIncidenceTensor hS β q H b h x

	lemma branchIncidenceTensor_global
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (H : Point d → ℝ) (b : Fin d → Point d)
	(F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
	(x : Point d) (c : InternalEdge β ⊕ Fin q → Fin d) :
	(∏v,branchIncidenceTensor hS β q H b F x v (fun t => duplicate c t.val))=
	(∏i,JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
	(F i (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x)*
	(S.hessians.map (fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod := by
	rw [Fintype.prod_sum_type]
	simp only [branchIncidenceTensor,primaryIncidenceTensor_global,hessianIncidenceTensor_global]
	congr 1
	change (Finset.univ.val.map (fun h : S.hessians =>
	hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod=_
	exact congrArg Multiset.prod (Multiset.map_univ S.hessians
	(fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x))

	theorem literal_branch_integral_bound
	(μ : Measure (Point d))
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (hβ : ∀k,0<β k) (q : ℕ) (hq : 0<q)
	(H : Point d → ℝ) (b : Fin d → Point d)
	(F : ∀i,(PrimaryTraceSlot hS β q i → Fin d) → Fin d → Point d → ℝ)
	(M : TargetVertex S → Point d → ℝ) (hM : ∀v x,0≤M v x)
	(hT : ∀v x,AllSplitBound (branchIncidenceTensor hS β q H b F x v) (M v x))
	(B : Fin (n+1) → ℝ≥0∞) (C : S.hessians → ℝ≥0∞)
	(hMp : ∀i,AEMeasurable (fun x => ENNReal.ofReal (M (Sum.inl i) x)) μ)
	(hp : ∀i,(∫⁻x,ENNReal.ofReal (M (Sum.inl i) x)^(n+1) ∂μ)≤B i^(n+1))
	(hh : ∀h x,ENNReal.ofReal (M (Sum.inr h) x)≤C h) (hC : ∀h,C h≠⊤) :
	(∫⁻x,ENNReal.ofReal \|∑c : InternalEdge β ⊕ Fin q → Fin d,
	(∏i,JetCalculus.jet (fun j => b (c (Sum.inl (Sum.inr j)))) (S.derivatives i)
	(F i (fun t => duplicate c (traceEmbed β q t.val)) (c (Sum.inl (Sum.inr i)))) x)*
	(S.hessians.map (fun h => hessian H (fun j => b (c (Sum.inl (Sum.inr j)))) h x)).prod\| ∂μ)≤
	(d:ℝ≥0∞)^q((∏i,B i)(∏h,C h)) := by
	have hb := actual_tensor_integral_bound μ hS β hβ q d hq
	(branchIncidenceTensor hS β q H b F) M hM hT B C hMp hp hh hC
	convert hb using 1
	congr 1
	funext x
	congr 2
	apply Finset.sum_congr rfl
	intro c _
	exact (branchIncidenceTensor_global hS β q H b F x c).symm
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	open GraphSchedule
	open scoped Classical

	variable {n : ℕ} {S : State (Fin (n+1))}

	noncomputable def primaryIncidentCases
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
	{t : Edge (U:=InternalEdge β) q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} ≃
	PrimaryTraceSlot hS β q i ⊕ (Unit ⊕ {j : Fin (n+1) // destination hS j=Sum.inl i}) where
	toFun t := by
	rcases t with ⟨(e\|j)\|e,ht⟩
	· exact Sum.inl ⟨Sum.inl e,ht⟩
	· by_cases hj : j=i
	· exact Sum.inr (Sum.inl ())
	· exact Sum.inr (Sum.inr ⟨j,ht.resolve_left (fun h => hj (Sum.inl.inj h))⟩)
	· exact Sum.inl ⟨Sum.inr e,ht⟩
	invFun t := by
	rcases t with t \| (u \| j)
	· exact ⟨traceEmbed β q t.val,t.property⟩
	· exact ⟨Sum.inl (Sum.inr i),Or.inl rfl⟩
	· exact ⟨Sum.inl (Sum.inr j.val),Or.inr j.property⟩
	left_inv t := by
	rcases t with ⟨(e\|j)\|e,ht⟩
	· rfl
	· dsimp only
	split_ifs with hj
	· subst j; rfl
	· rfl
	· rfl
	right_inv t := by
	rcases t with ⟨e\|e,ht⟩ \| (u \| ⟨j,hj⟩)
	· rfl
	· rfl
	· cases u
	dsimp only
	simp only [dite_true]
	· dsimp only
	rw [dite_eq_right (destination_primary_ne hS hj)]

	noncomputable def primarySlotEquiv
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
	(PrimaryTraceSlot hS β q i ⊕ (Unit ⊕ Fin (S.derivatives i).length)) ≃
	{t : Edge (U:=InternalEdge β) q //
	IncidentAt (edgeSource (S:=S) β) (edgeTarget hS β)
	(Sum.inl 0) (Sum.inl (Fin.last n)) (Sum.inl i) q t} :=
	(Equiv.sumCongr (Equiv.refl _) (Equiv.sumCongr (Equiv.refl _) (derivativeEdgeEquiv hS i))).trans
	(primaryIncidentCases hS β q i).symm

	lemma primarySlotEquiv_trace
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) (t : PrimaryTraceSlot hS β q i) :
	(primarySlotEquiv hS β q i (Sum.inl t)).val=traceEmbed β q t.val := rfl

	lemma primarySlotEquiv_source
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) :
	(primarySlotEquiv hS β q i (Sum.inr (Sum.inl ()))).val=Sum.inl (Sum.inr i) := rfl

	lemma primarySlotEquiv_derivative
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(β : Fin n → ℕ) (q : ℕ) (i : Fin (n+1)) (k : Fin (S.derivatives i).length) :
	(primarySlotEquiv hS β q i (Sum.inr (Sum.inr k))).val=
	Sum.inl (Sum.inr ((S.derivatives i).get k)) := rfl
	end LogConcaveSampling.AdjointRemoval

	end UpperProof
	end
	end
	end

	end OAI