Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Probability.LogConcave.TensorGraphs.Inside
import OAI.Probability.LogConcave.JetEstimates.PolySmooth

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
open MeasureTheory
open scoped RealInnerProductSpace NNReal

lemma regular_of_polySmooth {d : ℕ} {P : Type*}
    {H : Point d → ℝ} {f : P → Point d → ℝ} (b : P → Point d) {K : ℝ≥0}
    (hH : PolySmooth H) (ht : HasGaussianLowerTail H)
    (hL : LipschitzWith K (gradient H)) (hf : ∀p,PolySmooth (f p)) :
    Regular H b f K := by
  refine ⟨hH.smooth,ht,hL,fun p => (hf p).smooth,
    fun p l => ((hf p).jet b l).polyC1,?_⟩
  intro h
  exact (((hH.directional (b h.second)).directional (b h.first)).jet b h.extra).polyC1

end LogConcaveSampling.AdjointRemoval

namespace LogConcaveSampling.TraceWords
open MeasureTheory Matrix
open scoped RealInnerProductSpace NNReal

variable {d : ℕ} {I J K : Type*} [Fintype I] [Fintype J] [Fintype K]
    [DecidableEq I] [DecidableEq J]

omit [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] in

theorem integral_word_expansion
    {H : Point d → ℝ} {F : I → J → K → Point d → ℝ}
    (b : K → Point d) {L : ℝ≥0} (hH : PolySmooth H)
    (ht : HasGaussianLowerTail H) (hL : LipschitzWith L (gradient H))
    (hF : ∀i j k,PolySmooth (F i j k)) (w : List (I×J)) :
    (∫x,eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w ∂gibbs H)=
      ((AdjointRemoval.expand w.length AdjointRemoval.initial).map (fun S =>
        ∑a : Fin w.length → K,∫x,
          (∏p : Fin w.length,JetCalculus.jet (fun q => b (a q)) (S.derivatives p)
            (F (w.get p).1 (w.get p).2 (a p)) x)*
          (S.hessians.map (fun h => AdjointRemoval.hessian H (fun q => b (a q)) h x)).prod
          ∂gibbs H)).sum := by
  have he (x : Point d) := eval_eq_prod_get
    ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w
  simp_rw [he]
  have hr (a : Fin w.length → K) : AdjointRemoval.Regular H (fun p => b (a p))
      (fun p => F (w.get p).1 (w.get p).2 (a p)) L :=
    AdjointRemoval.regular_of_polySmooth _ hH ht hL (fun p => hF _ _ _)
  simpa only [Fintype.card_fin] using
    AdjointRemoval.tensor_actual_adjoint_expansion_branch_first hr

def adjointMatrix (H : Point d → ℝ) (b : K → Point d)
    (F : I → J → K → Point d → ℝ) (x : Point d) : Matrix I J ℝ :=
  fun i j => tensorAdjoint H b (F i j) x

omit [DecidableEq J] in

theorem integral_trace_expansion
    {H : Point d → ℝ} {F : I → J → K → Point d → ℝ}
    (b : K → Point d) {L : ℝ≥0} (hH : PolySmooth H)
    (ht : HasGaussianLowerTail H) (hL : LipschitzWith L (gradient H))
    (hF : ∀i j k,PolySmooth (F i j k)) (s : ℕ) :
    (∫x,((adjointMatrix H b F x*(adjointMatrix H b F x).transpose)^s).trace ∂gibbs H)=
    ((closed (I:=I) (J:=J) s).map (fun w =>
      ((AdjointRemoval.expand w.length AdjointRemoval.initial).map (fun S =>
        ∑a : Fin w.length → K,∫x,
          (∏p : Fin w.length,JetCalculus.jet (fun q => b (a q)) (S.derivatives p)
            (F (w.get p).1 (w.get p).2 (a p)) x)*
          (S.hessians.map (fun h => AdjointRemoval.hessian H (fun q => b (a q)) h x)).prod
          ∂gibbs H)).sum)).sum := by
  have hw (w : List (I×J)) : Integrable
      (fun x => eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w) (gibbs H) := by
    have he (x : Point d) := eval_eq_prod_get
      ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w
    simp_rw [he]
    exact (PolySmooth.prod Finset.univ (fun p _ =>
      hH.tensorAdjoint (hF (w.get p).1 (w.get p).2) b)).integrable hH.smooth.continuous ht
  have hsum (T : List (List (I×J))) : Integrable
      (fun x => (T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum) (gibbs H) := by
    induction T with
    | nil => simp
    | cons w T ih =>
      change Integrable (fun x => eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w+
        (T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum) (gibbs H)
      exact (hw w).add ih
  simp_rw [trace_power]
  have hl (T : List (List (I×J))) :
      (∫x,(T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum ∂gibbs H)=
        (T.map (fun w => ∫x,eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w ∂gibbs H)).sum := by
    induction T with
    | nil => simp
    | cons w T ih =>
      simp only [List.map_cons,List.sum_cons]
      rw [integral_add (hw w) (hsum T),ih]
  change (∫x,((closed (I:=I) (J:=J) s).map
    (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum ∂gibbs H)=_
  rw [hl]
  simp_rw [integral_word_expansion b hH ht hL hF]
end LogConcaveSampling.TraceWords
namespace LogConcaveSampling.AdjointRemoval
variable {P : Type*} [Fintype P] [DecidableEq P]

def Hessian.tokens (h : Hessian P) : Multiset P :=
  h.first::ₘh.second::ₘ(h.extra : Multiset P)

def State.tokens (S : State P) : Multiset P :=
  S.pending.val+(∑p,(S.derivatives p : Multiset P))+
    (S.hessians.map Hessian.tokens).sum

lemma initial_tokens : (initial (P:=P)).tokens=Finset.univ.val := by
  simp [State.tokens,initial]

lemma hitPrimary_tokens (S : State P) {i j : P} (hi : i∈S.pending) :
    (hitPrimary S i j).tokens=S.tokens := by
  have he : (∑k,(Function.update S.derivatives j (i::S.derivatives j) k : Multiset P))=
      i::ₘ(∑k,(S.derivatives k : Multiset P)) := by
    have hl : (fun k => (Function.update S.derivatives j (i::S.derivatives j) k : Multiset P))=
        Function.update (fun k => (S.derivatives k : Multiset P)) j (i::ₘ(S.derivatives j : Multiset P)) := by
      funext k
      by_cases hk : k=j
      · subst k; simp
      · simp [Function.update_of_ne hk]
    rw [hl,Finset.sum_update_of_mem (Finset.mem_univ j),Finset.sdiff_singleton_eq_erase]
    rw [←Finset.add_sum_erase Finset.univ (fun k => (S.derivatives k : Multiset P)) (Finset.mem_univ j)]
    simp only [Multiset.cons_add]
  have hp : i::ₘ(S.pending.erase i).val=S.pending.val := by
    exact Multiset.cons_erase hi
  simp only [State.tokens,hitPrimary,he]
  rw [Multiset.add_cons,←Multiset.cons_add,hp]

lemma pair_tokens (S : State P) {i j : P} (hi : i∈S.pending) (hj : j∈S.pending) (hij : i≠j) :
    (pair S i j).tokens=S.tokens := by
  have hj' : j∈S.pending.erase i := Finset.mem_erase.mpr ⟨hij.symm,hj⟩
  have hp : i::ₘj::ₘ((S.pending.erase i).erase j).val=S.pending.val := by
    rw [show j::ₘ((S.pending.erase i).erase j).val=(S.pending.erase i).val from Multiset.cons_erase hj']
    exact Multiset.cons_erase hi
  simp only [State.tokens,pair,Multiset.map_cons,Multiset.sum_cons,Hessian.tokens,Multiset.coe_nil]
  rw [Multiset.cons_add,Multiset.cons_add,zero_add,Multiset.add_cons,Multiset.add_cons,
    ←Multiset.cons_add,←Multiset.cons_add,←Multiset.cons_add,←Multiset.cons_add,hp]

lemma hitHessian_tokens (S : State P) {i : P} (hi : i∈S.pending)
    {h : Hessian P} (hh : h∈S.hessians) : (hitHessian S i h).tokens=S.tokens := by
  have hm := congrArg (fun t : Multiset (Hessian P) => (t.map Hessian.tokens).sum)
    (Multiset.cons_erase hh)
  simp only [Multiset.map_cons,Multiset.sum_cons] at hm
  have hp : i::ₘ(S.pending.erase i).val=S.pending.val := Multiset.cons_erase hi
  have hh' : (h.hit i).tokens=i::ₘh.tokens := by
    simp only [Hessian.tokens,Hessian.hit,←Multiset.cons_coe]
    rw [Multiset.cons_swap h.second i,Multiset.cons_swap h.first i]
  simp only [State.tokens,hitHessian,Multiset.map_cons,Multiset.sum_cons,hh']
  rw [Multiset.cons_add,hm,Multiset.add_cons,←Multiset.cons_add,←Multiset.cons_add,hp]

lemma Step.tokens {S T : State P} (h : Step S T) : T.tokens=S.tokens := by
  cases h with
  | primary i j hi hij => exact hitPrimary_tokens S hi
  | pair i j hi hj hij => exact pair_tokens S hi hj hij
  | hessian i h hi hh => exact hitHessian_tokens S hi hh

theorem mem_expand_tokens {n : ℕ} {S : State P}
    (hS : S∈expand n initial) : S.tokens=Finset.univ.val := by
  have hr := mem_expand_reachable hS
  clear hS
  have he : S.tokens=(initial (P:=P)).tokens := by
    induction hr with
    | refl => rfl
    | tail hr ht ih => exact ht.tokens.trans ih
  exact he.trans initial_tokens

theorem terminal_ports {S : State P} (hS : S∈expand (Fintype.card P) initial) :
    (∑p,(S.derivatives p : Multiset P))+(S.hessians.map Hessian.tokens).sum=Finset.univ.val := by
  have he := mem_expand_tokens hS
  have ht := mem_expand_terminal (by simp [initial]) hS
  simpa only [State.tokens,ht,Finset.empty_val,zero_add] using he
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
variable {P : Type*} [Fintype P] [DecidableEq P]

abbrev TargetVertex (S : State P) := P ⊕ S.hessians

def ports (S : State P) : TargetVertex S → Multiset P
  | Sum.inl p => (S.derivatives p : Multiset P)
  | Sum.inr h => (h : Hessian P).tokens

lemma sum_ports (S : State P) : (∑v,ports S v)=
    (∑p,(S.derivatives p : Multiset P))+(S.hessians.map Hessian.tokens).sum := by
  rw [Fintype.sum_sum_type]
  congr 1
  change (Finset.univ.val.map (fun h : S.hessians => (h : Hessian P).tokens)).sum=_
  rw [Multiset.map_univ]

abbrev Port (S : State P) := (v : TargetVertex S) × ports S v

def portLabel (S : State P) (p : Port S) : P := p.2

theorem portLabel_bijective {S : State P} (hS : S∈expand (Fintype.card P) initial) :
    Function.Bijective (portLabel S) := by
  have hs : (∑v,ports S v)=Finset.univ.val := (sum_ports S).trans (terminal_ports hS)
  apply (Fintype.bijective_iff_surjective_and_card _).mpr
  constructor
  · intro i
    have hi : i∈∑v,ports S v := by rw [hs]; exact Finset.mem_univ i
    obtain ⟨v,_,hv⟩ := Multiset.mem_sum.mp hi
    refine ⟨⟨v,(ports S v).mkToType i ⟨0,Multiset.count_pos.mpr hv⟩⟩,rfl⟩
  · simp only [Port,Fintype.card_sigma,Multiset.card_coe]
    rw [←Multiset.card_sum,hs]
    rfl

noncomputable def portEquiv {S : State P} (hS : S∈expand (Fintype.card P) initial) :
    Port S ≃ P := Equiv.ofBijective (portLabel S) (portLabel_bijective hS)

noncomputable def destination {S : State P} (hS : S∈expand (Fintype.card P) initial)
    (i : P) : TargetVertex S := ((portEquiv hS).symm i).1

lemma destination_label {S : State P} (hS : S∈expand (Fintype.card P) initial)
    (p : Port S) : destination hS (portLabel S p)=p.1 := by
  exact congrArg Sigma.fst ((portEquiv hS).symm_apply_apply p)

lemma label_mem_destination {S : State P} (hS : S∈expand (Fintype.card P) initial)
    (i : P) : i∈ports S (destination hS i) := by
  have hp := @Multiset.coe_mem P _ (ports S (destination hS i)) (((portEquiv hS).symm i).2)
  change portLabel S ((portEquiv hS).symm i)∈_ at hp
  change portEquiv hS ((portEquiv hS).symm i)∈_ at hp
  simpa only [Equiv.apply_symm_apply] using hp

lemma destination_primary_ne {S : State P} (hS : S∈expand (Fintype.card P) initial)
    {i j : P} (h : destination hS i=Sum.inl j) : i≠j := by
  have hi := label_mem_destination hS i
  rw [h] at hi
  exact (reachable_good (mem_expand_reachable hS)).1 j i hi

theorem hessian_distinguished_neighbors {S : State P}
    (hS : S∈expand (Fintype.card P) initial) (h : S.hessians) :
    destination hS (h : Hessian P).first=Sum.inr h ∧
    destination hS (h : Hessian P).second=Sum.inr h ∧
    (h : Hessian P).first≠(h : Hessian P).second := by
  have hf : (h : Hessian P).first∈ports S (Sum.inr h) := by
    simp [ports,Hessian.tokens]
  have hs : (h : Hessian P).second∈ports S (Sum.inr h) := by
    simp [ports,Hessian.tokens]
  have lift (i : P) (hi : i∈ports S (Sum.inr h)) : destination hS i=Sum.inr h := by
    let p : Port S := ⟨Sum.inr h,(ports S (Sum.inr h)).mkToType i ⟨0,Multiset.count_pos.mpr hi⟩⟩
    exact destination_label hS p
  exact ⟨lift _ hf,lift _ hs,(reachable_good (mem_expand_reachable hS)).2 h Multiset.coe_mem⟩
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.AdjointRemoval
variable {n : ℕ} {S : State (Fin (n+1))}

def Adjacent (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (u v : TargetVertex S) : Prop :=
  (∃k : Fin n,(u=Sum.inl k.castSucc ∧ v=Sum.inl k.succ) ∨
    (v=Sum.inl k.castSucc ∧ u=Sum.inl k.succ)) ∨
  (∃i : Fin (n+1),(u=Sum.inl i ∧ v=destination hS i) ∨
    (v=Sum.inl i ∧ u=destination hS i))

lemma adjacent_ne (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    {u v : TargetVertex S} (h : Adjacent hS u v) : u≠v := by
  intro he
  rcases h with ⟨k,(⟨rfl,rfl⟩|⟨rfl,rfl⟩)⟩ | ⟨i,(⟨rfl,rfl⟩|⟨rfl,rfl⟩)⟩
  · have hh : k.castSucc=k.succ := Sum.inl.inj he
    have hv := congrArg Fin.val hh
    simp only [Fin.val_castSucc,Fin.val_succ] at hv
    omega
  · have hh : k.succ=k.castSucc := Sum.inl.inj he
    have hv := congrArg Fin.val hh
    simp only [Fin.val_castSucc,Fin.val_succ] at hv
    omega
  · exact destination_primary_ne hS he.symm rfl
  · exact destination_primary_ne hS he rfl

theorem actual_removal_graph_order
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial) :
    ∃ key : TargetVertex S → ℕ, Function.Injective key ∧
      (∀u v,Adjacent hS u v → key u≠key v) ∧
      ∀v : TargetVertex S,
        (v=Sum.inl 0 ∨ ∃u,Adjacent hS u v ∧ key u<key v) ∧
        (v=Sum.inl (Fin.last n) ∨ ∃w,Adjacent hS v w ∧ key v<key w) := by
  let left (h : S.hessians) : Fin (n+1) := min (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second
  let right (h : S.hessians) : Fin (n+1) := max (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second
  have hp (h : S.hessians) : left h<right h := by
    have hh := (hessian_distinguished_neighbors hS h).2.2
    exact min_lt_max.mpr hh
  have hchain (k : Fin n) : Adjacent hS (Sum.inl k.castSucc) (Sum.inl k.succ) :=
    Or.inl ⟨k,Or.inl ⟨rfl,rfl⟩⟩
  have hleft (h : S.hessians) : Adjacent hS (Sum.inl (left h)) (Sum.inr h) := by
    obtain ⟨hf,hs,_⟩ := hessian_distinguished_neighbors hS h
    refine Or.inr ⟨left h,Or.inl ⟨rfl,?_⟩⟩
    cases min_choice (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second with
    | inl he => exact (he ▸ hf).symm
    | inr he => exact (he ▸ hs).symm
  have hright (h : S.hessians) : Adjacent hS (Sum.inr h) (Sum.inl (right h)) := by
    obtain ⟨hf,hs,_⟩ := hessian_distinguished_neighbors hS h
    refine Or.inr ⟨right h,Or.inr ⟨rfl,?_⟩⟩
    cases max_choice (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second with
    | inl he => exact (he ▸ hf).symm
    | inr he => exact (he ▸ hs).symm
  obtain ⟨key,hkey,horder⟩ := TraceOpening.ordered_nontrivial_splits left right hp
    (Adjacent hS) hchain hleft hright
  exact ⟨key,hkey,fun u v huv hEq => adjacent_ne hS huv (hkey hEq),horder⟩
end LogConcaveSampling.AdjointRemoval

end UpperProof
end
end
end

end OAI

	import Mathlib
	import OAI.Probability.LogConcave.TensorGraphs.Inside
	import OAI.Probability.LogConcave.JetEstimates.PolySmooth

	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
	open MeasureTheory
	open scoped RealInnerProductSpace NNReal

	lemma regular_of_polySmooth {d : ℕ} {P : Type*}
	{H : Point d → ℝ} {f : P → Point d → ℝ} (b : P → Point d) {K : ℝ≥0}
	(hH : PolySmooth H) (ht : HasGaussianLowerTail H)
	(hL : LipschitzWith K (gradient H)) (hf : ∀p,PolySmooth (f p)) :
	Regular H b f K := by
	refine ⟨hH.smooth,ht,hL,fun p => (hf p).smooth,
	fun p l => ((hf p).jet b l).polyC1,?_⟩
	intro h
	exact (((hH.directional (b h.second)).directional (b h.first)).jet b h.extra).polyC1

	end LogConcaveSampling.AdjointRemoval

	namespace LogConcaveSampling.TraceWords
	open MeasureTheory Matrix
	open scoped RealInnerProductSpace NNReal

	variable {d : ℕ} {I J K : Type*} [Fintype I] [Fintype J] [Fintype K]
	[DecidableEq I] [DecidableEq J]

	omit [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J] in

	theorem integral_word_expansion
	{H : Point d → ℝ} {F : I → J → K → Point d → ℝ}
	(b : K → Point d) {L : ℝ≥0} (hH : PolySmooth H)
	(ht : HasGaussianLowerTail H) (hL : LipschitzWith L (gradient H))
	(hF : ∀i j k,PolySmooth (F i j k)) (w : List (I×J)) :
	(∫x,eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w ∂gibbs H)=
	((AdjointRemoval.expand w.length AdjointRemoval.initial).map (fun S =>
	∑a : Fin w.length → K,∫x,
	(∏p : Fin w.length,JetCalculus.jet (fun q => b (a q)) (S.derivatives p)
	(F (w.get p).1 (w.get p).2 (a p)) x)*
	(S.hessians.map (fun h => AdjointRemoval.hessian H (fun q => b (a q)) h x)).prod
	∂gibbs H)).sum := by
	have he (x : Point d) := eval_eq_prod_get
	((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w
	simp_rw [he]
	have hr (a : Fin w.length → K) : AdjointRemoval.Regular H (fun p => b (a p))
	(fun p => F (w.get p).1 (w.get p).2 (a p)) L :=
	AdjointRemoval.regular_of_polySmooth _ hH ht hL (fun p => hF _ _ _)
	simpa only [Fintype.card_fin] using
	AdjointRemoval.tensor_actual_adjoint_expansion_branch_first hr

	def adjointMatrix (H : Point d → ℝ) (b : K → Point d)
	(F : I → J → K → Point d → ℝ) (x : Point d) : Matrix I J ℝ :=
	fun i j => tensorAdjoint H b (F i j) x

	omit [DecidableEq J] in

	theorem integral_trace_expansion
	{H : Point d → ℝ} {F : I → J → K → Point d → ℝ}
	(b : K → Point d) {L : ℝ≥0} (hH : PolySmooth H)
	(ht : HasGaussianLowerTail H) (hL : LipschitzWith L (gradient H))
	(hF : ∀i j k,PolySmooth (F i j k)) (s : ℕ) :
	(∫x,((adjointMatrix H b F x*(adjointMatrix H b F x).transpose)^s).trace ∂gibbs H)=
	((closed (I:=I) (J:=J) s).map (fun w =>
	((AdjointRemoval.expand w.length AdjointRemoval.initial).map (fun S =>
	∑a : Fin w.length → K,∫x,
	(∏p : Fin w.length,JetCalculus.jet (fun q => b (a q)) (S.derivatives p)
	(F (w.get p).1 (w.get p).2 (a p)) x)*
	(S.hessians.map (fun h => AdjointRemoval.hessian H (fun q => b (a q)) h x)).prod
	∂gibbs H)).sum)).sum := by
	have hw (w : List (I×J)) : Integrable
	(fun x => eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w) (gibbs H) := by
	have he (x : Point d) := eval_eq_prod_get
	((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w
	simp_rw [he]
	exact (PolySmooth.prod Finset.univ (fun p _ =>
	hH.tensorAdjoint (hF (w.get p).1 (w.get p).2) b)).integrable hH.smooth.continuous ht
	have hsum (T : List (List (I×J))) : Integrable
	(fun x => (T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum) (gibbs H) := by
	induction T with
	\| nil => simp
	\| cons w T ih =>
	change Integrable (fun x => eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w+
	(T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum) (gibbs H)
	exact (hw w).add ih
	simp_rw [trace_power]
	have hl (T : List (List (I×J))) :
	(∫x,(T.map (eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum ∂gibbs H)=
	(T.map (fun w => ∫x,eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ) w ∂gibbs H)).sum := by
	induction T with
	\| nil => simp
	\| cons w T ih =>
	simp only [List.map_cons,List.sum_cons]
	rw [integral_add (hw w) (hsum T),ih]
	change (∫x,((closed (I:=I) (J:=J) s).map
	(eval ((fun i j => tensorAdjoint H b (F i j) x) : Matrix I J ℝ))).sum ∂gibbs H)=_
	rw [hl]
	simp_rw [integral_word_expansion b hH ht hL hF]
	end LogConcaveSampling.TraceWords
	namespace LogConcaveSampling.AdjointRemoval
	variable {P : Type*} [Fintype P] [DecidableEq P]

	def Hessian.tokens (h : Hessian P) : Multiset P :=
	h.first::ₘh.second::ₘ(h.extra : Multiset P)

	def State.tokens (S : State P) : Multiset P :=
	S.pending.val+(∑p,(S.derivatives p : Multiset P))+
	(S.hessians.map Hessian.tokens).sum

	lemma initial_tokens : (initial (P:=P)).tokens=Finset.univ.val := by
	simp [State.tokens,initial]

	lemma hitPrimary_tokens (S : State P) {i j : P} (hi : i∈S.pending) :
	(hitPrimary S i j).tokens=S.tokens := by
	have he : (∑k,(Function.update S.derivatives j (i::S.derivatives j) k : Multiset P))=
	i::ₘ(∑k,(S.derivatives k : Multiset P)) := by
	have hl : (fun k => (Function.update S.derivatives j (i::S.derivatives j) k : Multiset P))=
	Function.update (fun k => (S.derivatives k : Multiset P)) j (i::ₘ(S.derivatives j : Multiset P)) := by
	funext k
	by_cases hk : k=j
	· subst k; simp
	· simp [Function.update_of_ne hk]
	rw [hl,Finset.sum_update_of_mem (Finset.mem_univ j),Finset.sdiff_singleton_eq_erase]
	rw [←Finset.add_sum_erase Finset.univ (fun k => (S.derivatives k : Multiset P)) (Finset.mem_univ j)]
	simp only [Multiset.cons_add]
	have hp : i::ₘ(S.pending.erase i).val=S.pending.val := by
	exact Multiset.cons_erase hi
	simp only [State.tokens,hitPrimary,he]
	rw [Multiset.add_cons,←Multiset.cons_add,hp]

	lemma pair_tokens (S : State P) {i j : P} (hi : i∈S.pending) (hj : j∈S.pending) (hij : i≠j) :
	(pair S i j).tokens=S.tokens := by
	have hj' : j∈S.pending.erase i := Finset.mem_erase.mpr ⟨hij.symm,hj⟩
	have hp : i::ₘj::ₘ((S.pending.erase i).erase j).val=S.pending.val := by
	rw [show j::ₘ((S.pending.erase i).erase j).val=(S.pending.erase i).val from Multiset.cons_erase hj']
	exact Multiset.cons_erase hi
	simp only [State.tokens,pair,Multiset.map_cons,Multiset.sum_cons,Hessian.tokens,Multiset.coe_nil]
	rw [Multiset.cons_add,Multiset.cons_add,zero_add,Multiset.add_cons,Multiset.add_cons,
	←Multiset.cons_add,←Multiset.cons_add,←Multiset.cons_add,←Multiset.cons_add,hp]

	lemma hitHessian_tokens (S : State P) {i : P} (hi : i∈S.pending)
	{h : Hessian P} (hh : h∈S.hessians) : (hitHessian S i h).tokens=S.tokens := by
	have hm := congrArg (fun t : Multiset (Hessian P) => (t.map Hessian.tokens).sum)
	(Multiset.cons_erase hh)
	simp only [Multiset.map_cons,Multiset.sum_cons] at hm
	have hp : i::ₘ(S.pending.erase i).val=S.pending.val := Multiset.cons_erase hi
	have hh' : (h.hit i).tokens=i::ₘh.tokens := by
	simp only [Hessian.tokens,Hessian.hit,←Multiset.cons_coe]
	rw [Multiset.cons_swap h.second i,Multiset.cons_swap h.first i]
	simp only [State.tokens,hitHessian,Multiset.map_cons,Multiset.sum_cons,hh']
	rw [Multiset.cons_add,hm,Multiset.add_cons,←Multiset.cons_add,←Multiset.cons_add,hp]

	lemma Step.tokens {S T : State P} (h : Step S T) : T.tokens=S.tokens := by
	cases h with
	\| primary i j hi hij => exact hitPrimary_tokens S hi
	\| pair i j hi hj hij => exact pair_tokens S hi hj hij
	\| hessian i h hi hh => exact hitHessian_tokens S hi hh

	theorem mem_expand_tokens {n : ℕ} {S : State P}
	(hS : S∈expand n initial) : S.tokens=Finset.univ.val := by
	have hr := mem_expand_reachable hS
	clear hS
	have he : S.tokens=(initial (P:=P)).tokens := by
	induction hr with
	\| refl => rfl
	\| tail hr ht ih => exact ht.tokens.trans ih
	exact he.trans initial_tokens

	theorem terminal_ports {S : State P} (hS : S∈expand (Fintype.card P) initial) :
	(∑p,(S.derivatives p : Multiset P))+(S.hessians.map Hessian.tokens).sum=Finset.univ.val := by
	have he := mem_expand_tokens hS
	have ht := mem_expand_terminal (by simp [initial]) hS
	simpa only [State.tokens,ht,Finset.empty_val,zero_add] using he
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	variable {P : Type*} [Fintype P] [DecidableEq P]

	abbrev TargetVertex (S : State P) := P ⊕ S.hessians

	def ports (S : State P) : TargetVertex S → Multiset P
	\| Sum.inl p => (S.derivatives p : Multiset P)
	\| Sum.inr h => (h : Hessian P).tokens

	lemma sum_ports (S : State P) : (∑v,ports S v)=
	(∑p,(S.derivatives p : Multiset P))+(S.hessians.map Hessian.tokens).sum := by
	rw [Fintype.sum_sum_type]
	congr 1
	change (Finset.univ.val.map (fun h : S.hessians => (h : Hessian P).tokens)).sum=_
	rw [Multiset.map_univ]

	abbrev Port (S : State P) := (v : TargetVertex S) × ports S v

	def portLabel (S : State P) (p : Port S) : P := p.2

	theorem portLabel_bijective {S : State P} (hS : S∈expand (Fintype.card P) initial) :
	Function.Bijective (portLabel S) := by
	have hs : (∑v,ports S v)=Finset.univ.val := (sum_ports S).trans (terminal_ports hS)
	apply (Fintype.bijective_iff_surjective_and_card _).mpr
	constructor
	· intro i
	have hi : i∈∑v,ports S v := by rw [hs]; exact Finset.mem_univ i
	obtain ⟨v,_,hv⟩ := Multiset.mem_sum.mp hi
	refine ⟨⟨v,(ports S v).mkToType i ⟨0,Multiset.count_pos.mpr hv⟩⟩,rfl⟩
	· simp only [Port,Fintype.card_sigma,Multiset.card_coe]
	rw [←Multiset.card_sum,hs]
	rfl

	noncomputable def portEquiv {S : State P} (hS : S∈expand (Fintype.card P) initial) :
	Port S ≃ P := Equiv.ofBijective (portLabel S) (portLabel_bijective hS)

	noncomputable def destination {S : State P} (hS : S∈expand (Fintype.card P) initial)
	(i : P) : TargetVertex S := ((portEquiv hS).symm i).1

	lemma destination_label {S : State P} (hS : S∈expand (Fintype.card P) initial)
	(p : Port S) : destination hS (portLabel S p)=p.1 := by
	exact congrArg Sigma.fst ((portEquiv hS).symm_apply_apply p)

	lemma label_mem_destination {S : State P} (hS : S∈expand (Fintype.card P) initial)
	(i : P) : i∈ports S (destination hS i) := by
	have hp := @Multiset.coe_mem P _ (ports S (destination hS i)) (((portEquiv hS).symm i).2)
	change portLabel S ((portEquiv hS).symm i)∈_ at hp
	change portEquiv hS ((portEquiv hS).symm i)∈_ at hp
	simpa only [Equiv.apply_symm_apply] using hp

	lemma destination_primary_ne {S : State P} (hS : S∈expand (Fintype.card P) initial)
	{i j : P} (h : destination hS i=Sum.inl j) : i≠j := by
	have hi := label_mem_destination hS i
	rw [h] at hi
	exact (reachable_good (mem_expand_reachable hS)).1 j i hi

	theorem hessian_distinguished_neighbors {S : State P}
	(hS : S∈expand (Fintype.card P) initial) (h : S.hessians) :
	destination hS (h : Hessian P).first=Sum.inr h ∧
	destination hS (h : Hessian P).second=Sum.inr h ∧
	(h : Hessian P).first≠(h : Hessian P).second := by
	have hf : (h : Hessian P).first∈ports S (Sum.inr h) := by
	simp [ports,Hessian.tokens]
	have hs : (h : Hessian P).second∈ports S (Sum.inr h) := by
	simp [ports,Hessian.tokens]
	have lift (i : P) (hi : i∈ports S (Sum.inr h)) : destination hS i=Sum.inr h := by
	let p : Port S := ⟨Sum.inr h,(ports S (Sum.inr h)).mkToType i ⟨0,Multiset.count_pos.mpr hi⟩⟩
	exact destination_label hS p
	exact ⟨lift _ hf,lift _ hs,(reachable_good (mem_expand_reachable hS)).2 h Multiset.coe_mem⟩
	end LogConcaveSampling.AdjointRemoval
	namespace LogConcaveSampling.AdjointRemoval
	variable {n : ℕ} {S : State (Fin (n+1))}

	def Adjacent (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	(u v : TargetVertex S) : Prop :=
	(∃k : Fin n,(u=Sum.inl k.castSucc ∧ v=Sum.inl k.succ) ∨
	(v=Sum.inl k.castSucc ∧ u=Sum.inl k.succ)) ∨
	(∃i : Fin (n+1),(u=Sum.inl i ∧ v=destination hS i) ∨
	(v=Sum.inl i ∧ u=destination hS i))

	lemma adjacent_ne (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
	{u v : TargetVertex S} (h : Adjacent hS u v) : u≠v := by
	intro he
	rcases h with ⟨k,(⟨rfl,rfl⟩\|⟨rfl,rfl⟩)⟩ \| ⟨i,(⟨rfl,rfl⟩\|⟨rfl,rfl⟩)⟩
	· have hh : k.castSucc=k.succ := Sum.inl.inj he
	have hv := congrArg Fin.val hh
	simp only [Fin.val_castSucc,Fin.val_succ] at hv
	omega
	· have hh : k.succ=k.castSucc := Sum.inl.inj he
	have hv := congrArg Fin.val hh
	simp only [Fin.val_castSucc,Fin.val_succ] at hv
	omega
	· exact destination_primary_ne hS he.symm rfl
	· exact destination_primary_ne hS he rfl

	theorem actual_removal_graph_order
	(hS : S∈expand (Fintype.card (Fin (n+1))) initial) :
	∃ key : TargetVertex S → ℕ, Function.Injective key ∧
	(∀u v,Adjacent hS u v → key u≠key v) ∧
	∀v : TargetVertex S,
	(v=Sum.inl 0 ∨ ∃u,Adjacent hS u v ∧ key u<key v) ∧
	(v=Sum.inl (Fin.last n) ∨ ∃w,Adjacent hS v w ∧ key v<key w) := by
	let left (h : S.hessians) : Fin (n+1) := min (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second
	let right (h : S.hessians) : Fin (n+1) := max (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second
	have hp (h : S.hessians) : left h<right h := by
	have hh := (hessian_distinguished_neighbors hS h).2.2
	exact min_lt_max.mpr hh
	have hchain (k : Fin n) : Adjacent hS (Sum.inl k.castSucc) (Sum.inl k.succ) :=
	Or.inl ⟨k,Or.inl ⟨rfl,rfl⟩⟩
	have hleft (h : S.hessians) : Adjacent hS (Sum.inl (left h)) (Sum.inr h) := by
	obtain ⟨hf,hs,_⟩ := hessian_distinguished_neighbors hS h
	refine Or.inr ⟨left h,Or.inl ⟨rfl,?_⟩⟩
	cases min_choice (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second with
	\| inl he => exact (he ▸ hf).symm
	\| inr he => exact (he ▸ hs).symm
	have hright (h : S.hessians) : Adjacent hS (Sum.inr h) (Sum.inl (right h)) := by
	obtain ⟨hf,hs,_⟩ := hessian_distinguished_neighbors hS h
	refine Or.inr ⟨right h,Or.inr ⟨rfl,?_⟩⟩
	cases max_choice (h : Hessian (Fin (n+1))).first (h : Hessian (Fin (n+1))).second with
	\| inl he => exact (he ▸ hf).symm
	\| inr he => exact (he ▸ hs).symm
	obtain ⟨key,hkey,horder⟩ := TraceOpening.ordered_nontrivial_splits left right hp
	(Adjacent hS) hchain hleft hright
	exact ⟨key,hkey,fun u v huv hEq => adjacent_ne hS huv (hkey hEq),horder⟩
	end LogConcaveSampling.AdjointRemoval

	end UpperProof
	end
	end
	end

	end OAI