lean/OAI/Probability/LogConcave/TensorGraphs/History.lean

import Mathlib
import OAI.Probability.LogConcave.JetEstimates.WireStep
import OAI.Probability.LogConcave.TensorGraphs.Live
import OAI.Probability.LogConcave.TensorGraphs.AdjointMatrix

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.Frontier
open scoped Classical

variable {E C : Type*} (a b : E → ℕ)

abbrev History (n : ℕ) := ∀k : Fin (n+1),Live a b k.val → C

def Consistent {n : ℕ} (h : History (C:=C) a b n) : Prop :=
  ∀k (hk : k<n) (e : Spectator a b k),
    h ⟨k+1,by omega⟩ ⟨e.val,by change a e.val≤k+1; have := e.property.1; omega,e.property.2⟩ =
    h ⟨k,by omega⟩ ⟨e.val,e.property.1,by change k<b e.val; have := e.property.2; omega⟩

def historyOf {n : ℕ} (c : E → C) : History (C:=C) a b n := fun _ e => c e.val

lemma historyOf_consistent {n : ℕ} (c : E → C) :
    Consistent a b (historyOf (n:=n) a b c) := by
  intro k hk e
  rfl

lemma consistent_color {n : ℕ} (hab : ∀e,a e<b e) (han : ∀e,a e≤n)
    {h : History (C:=C) a b n} (hh : Consistent a b h) (e : E)
    (k : ℕ) (hak : a e≤k) (hkn : k≤n) (hkb : k<b e) :
    h ⟨k,by omega⟩ ⟨e,hak,hkb⟩ =
    h ⟨a e,by have := han e; omega⟩ ⟨e,le_rfl,hab e⟩ := by
  induction k,hak using Nat.le_induction with
  | base => rfl
  | succ k hak ih =>
    have hk : k<n := by omega
    have he : a e≤k ∧ k+1<b e := ⟨hak,hkb⟩
    exact (hh k hk ⟨e,he⟩).trans (ih (by omega) (by omega))

noncomputable def historyEquiv {n : ℕ} (hab : ∀e,a e<b e) (han : ∀e,a e≤n) :
    (E → C) ≃ {h : History (C:=C) a b n // Consistent a b h} where
  toFun c := ⟨historyOf a b c,historyOf_consistent a b c⟩
  invFun h e := h.val ⟨a e,by have := han e; omega⟩ ⟨e,le_rfl,hab e⟩
  left_inv c := rfl
  right_inv h := by
    apply Subtype.ext
    funext k e
    exact (consistent_color a b hab han h.property e.val k.val
      e.property.1 (by have := k.isLt; omega) e.property.2).symm

theorem sum_consistent_histories [Fintype E] [Fintype C] {n : ℕ}
    (hab : ∀e,a e<b e) (han : ∀e,a e≤n)
    (F : History (C:=C) a b n → ℝ) :
    (∑h : History (C:=C) a b n,if Consistent a b h then F h else 0)=
      ∑c : E → C,F (historyOf a b c) := by
  classical
  rw [← Fintype.sum_subtype_add_sum_subtype (Consistent a b)]
  have hz : (∑i : {h : History (C:=C) a b n // ¬Consistent a b h},
      if Consistent a b i.val then F i.val else 0)=0 := by
    apply Finset.sum_eq_zero
    intro i hi
    simp only [i.property,ite_false]
  rw [hz,add_zero]
  simp only [Subtype.property,ite_true]
  exact ((historyEquiv (C:=C) a b hab han).sum_comp (fun h => F h.val)).symm
end LogConcaveSampling.Frontier
namespace LogConcaveSampling.Frontier
open scoped BigOperators Classical
open TensorEnergy

variable {E C : Type*} [Fintype E] [Fintype C]
    (a b : E → ℕ) (hab : ∀e,a e<b e)

def graphStep (A : ∀k,(Outgoing a k → C) → (Incoming b k → C) → ℝ) (k : ℕ) :
    (Live a b (k+1) → C) → (Live a b k → C) → ℝ :=
  wireStep (A k) (inputCoordinates a b hab k) (outputCoordinates a b hab k)

omit [Fintype E] [Fintype C] in
lemma consistent_iff_spectators {n : ℕ} (h : History (C:=C) a b n) :
    Consistent a b h ↔ ∀k : Fin n,
      (outputCoordinates a b hab k.val (h k.succ)).2 =
      (inputCoordinates a b hab k.val (h k.castSucc)).2 := by
  constructor
  · intro hh k
    funext e
    exact hh k.val k.isLt e
  · intro hh k hk e
    exact congrFun (hh ⟨k,hk⟩) e

omit [Fintype C] in

lemma pathWeight_graphStep
    (A : ∀k,(Outgoing a k → C) → (Incoming b k → C) → ℝ)
    (n : ℕ) (h : History (C:=C) a b n) :
    pathWeight (D:=fun k => Live a b k → C) (graphStep a b hab A) n h =
      if Consistent a b h then
        ∏k : Fin n,A k.val (outputCoordinates a b hab k.val (h k.succ)).1
          (inputCoordinates a b hab k.val (h k.castSucc)).1
      else 0 := by
  classical
  by_cases hc : Consistent a b h
  · rw [ite_eq_left hc]
    unfold pathWeight graphStep wireStep
    exact Finset.prod_congr rfl (fun k _ => by
      rw [ite_eq_left ((consistent_iff_spectators a b hab h).mp hc k),mul_one])
  · rw [ite_eq_right hc]
    have he : ∃k : Fin n,
      (outputCoordinates a b hab k.val (h k.succ)).2 ≠
      (inputCoordinates a b hab k.val (h k.castSucc)).2 := by
      simpa only [not_forall] using
        (mt (consistent_iff_spectators a b hab h).mpr hc)
    obtain ⟨k,hk⟩ := he
    apply Finset.prod_eq_zero (Finset.mem_univ k)
    simp only [graphStep,wireStep,ite_eq_right hk,mul_zero]

theorem coordinate_sum_eq_circuit
    (A : ∀k,(Outgoing a k → C) → (Incoming b k → C) → ℝ) (n : ℕ)
    (han : ∀e,a e≤n) (B : (Live a b 0 → C) → (Live a b n → C) → ℝ) :
    (∑c : E → C,(∏k : Fin n,A k.val (fun e => c e.val) (fun e => c e.val))*
      B (fun e => c e.val) (fun e => c e.val)) =
    ∑i,∑j,circuit (D:=fun k => Live a b k → C) (graphStep a b hab A) n j i*B i j := by
  have hs := sum_consistent_histories (C:=C) a b hab han
    (fun h => (∏k : Fin n,A k.val (outputCoordinates a b hab k.val (h k.succ)).1
      (inputCoordinates a b hab k.val (h k.castSucc)).1)*B (h 0) (h (Fin.last n)))
  have hp := circuit_path_expansion (D:=fun k => Live a b k → C) (graphStep a b hab A) n B
  have hs' : (∑h : History (C:=C) a b n,if Consistent a b h then
      (∏k : Fin n,A k.val (outputCoordinates a b hab k.val (h k.succ)).1
        (inputCoordinates a b hab k.val (h k.castSucc)).1)*B (h 0) (h (Fin.last n)) else 0)=
      (∑c : E → C,(∏k : Fin n,A k.val (fun e => c e.val) (fun e => c e.val))*
        B (fun e => c e.val) (fun e => c e.val)) := hs
  rw [←hs',←hp]
  apply Finset.sum_congr rfl
  intro h hh
  rw [pathWeight_graphStep]
  split_ifs <;> simp only [zero_mul]

include hab in

theorem coordinate_contraction_bound
    (A : ∀k,(Outgoing a k → C) → (Incoming b k → C) → ℝ) (M : ℕ → ℝ)
    (hM : ∀k,0≤M k) (hA : ∀k,Bound (A k) ((M k)^2))
    (n : ℕ) (han : ∀e,a e≤n) (close : (Live a b 0 → C) ≃ (Live a b n → C)) :
    |∑c : E → C,(∏k : Fin n,A k.val (fun e => c e.val) (fun e => c e.val))*
      (if (fun e : Live a b n => c e.val)=close (fun e : Live a b 0 => c e.val)
        then 1 else 0)| ≤
      (Fintype.card (Live a b 0 → C):ℝ)*(∏k∈Finset.range n,M k) := by
  rw [coordinate_sum_eq_circuit a b hab A n han
    (fun i j => if j=close i then 1 else 0)]
  simp only [mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true]
  exact closed_wire_circuit_bound (D:=fun k => Live a b k → C)
    (I:=fun k => Incoming b k → C) (O:=fun k => Outgoing a k → C)
    (S:=fun k => Spectator a b k → C) A M hM hA
    (inputCoordinates a b hab) (outputCoordinates a b hab) n close
end LogConcaveSampling.Frontier
namespace LogConcaveSampling.GraphSchedule
open scoped Classical

variable {V U : Type*} [Fintype V] (key : V → ℕ) (src dst : U → V)

abbrev Edge (q : ℕ) := U ⊕ (Fin q ⊕ Fin q)

def length : ℕ := Finset.univ.sup key+1

lemma key_lt_length (v : V) : key v<length key :=
  lt_of_le_of_lt (Finset.le_sup (f:=key) (Finset.mem_univ v)) (Nat.lt_succ_self _)

def emit (_first last : V) (q : ℕ) : Edge (U:=U) q → ℕ
  | Sum.inl e => min (key (src e)+1) (key (dst e)+1)
  | Sum.inr (Sum.inl _) => 0
  | Sum.inr (Sum.inr _) => key last+1

def absorb (first _last : V) (q : ℕ) : Edge (U:=U) q → ℕ
  | Sum.inl e => max (key (src e)+1) (key (dst e)+1)
  | Sum.inr (Sum.inl _) => key first+1
  | Sum.inr (Sum.inr _) => length key+1

include key in
lemma emit_lt_absorb (hkey : Function.Injective key) (hne : ∀e,src e≠dst e)
    (first last : V) (q : ℕ) (e : Edge (U:=U) q) :
    emit key src dst first last q e<absorb key src dst first last q e := by
  rcases e with e | (i|i)
  · exact min_lt_max.mpr (by
      intro he
      have hh : key (src e)=key (dst e) := by omega
      exact hne e (hkey hh))
  · exact Nat.zero_lt_succ _
  · exact Nat.add_lt_add_right (key_lt_length key last) 1

lemma emit_le_length (first last : V) (q : ℕ) (e : Edge (U:=U) q) :
    emit key src dst first last q e≤length key := by
  rcases e with e | (i|i)
  · exact (min_le_left _ _).trans (key_lt_length key (src e))
  · exact Nat.zero_le _
  · exact key_lt_length key last

noncomputable def inputEdges (first last : V) (q : ℕ) :
    Frontier.Live (emit key src dst first last q) (absorb key src dst first last q) 0 ≃ Fin q where
  toFun e := by
    rcases e with ⟨e,he⟩
    rcases e with e | (i|i)
    · simp only [emit] at he
      omega
    · exact i
    · simp only [emit] at he
      omega
  invFun i := ⟨Sum.inr (Sum.inl i),Nat.zero_le _,Nat.zero_lt_succ _⟩
  left_inv e := by
    rcases e with ⟨e,he⟩
    rcases e with e | (i|i)
    · simp only [emit] at he
      omega
    · rfl
    · simp only [emit] at he
      omega
  right_inv i := rfl

noncomputable def outputEdges (first last : V) (q : ℕ) :
    Frontier.Live (emit key src dst first last q) (absorb key src dst first last q)
      (length key) ≃ Fin q where
  toFun e := by
    rcases e with ⟨e,he⟩
    rcases e with e | (i|i)
    · have hs := key_lt_length key (src e)
      have ht := key_lt_length key (dst e)
      simp only [absorb] at he
      omega
    · have hs := key_lt_length key first
      simp only [absorb] at he
      omega
    · exact i
  invFun i := ⟨Sum.inr (Sum.inr i),key_lt_length key last,Nat.lt_succ_self _⟩
  left_inv e := by
    rcases e with ⟨e,he⟩
    rcases e with e | (i|i)
    · have hs := key_lt_length key (src e)
      have ht := key_lt_length key (dst e)
      simp only [absorb] at he
      omega
    · have hs := key_lt_length key first
      simp only [absorb] at he
      omega
    · rfl
  right_inv i := rfl

noncomputable def close {C : Type*} (first last : V) (q : ℕ) :
    (Frontier.Live (emit key src dst first last q) (absorb key src dst first last q) 0 → C) ≃
      (Frontier.Live (emit key src dst first last q) (absorb key src dst first last q)
        (length key) → C) :=
  Equiv.arrowCongr ((inputEdges key src dst first last q).trans
    (outputEdges key src dst first last q).symm) (Equiv.refl C)

lemma input_card [Fintype U] (first last : V) (q d : ℕ) :
    Fintype.card (Frontier.Live (emit key src dst first last q)
      (absorb key src dst first last q) 0 → Fin d)=d^q := by
  rw [Fintype.card_fun,Fintype.card_fin,Fintype.card_congr (inputEdges key src dst first last q),
    Fintype.card_fin]
end LogConcaveSampling.GraphSchedule
namespace LogConcaveSampling.GraphSchedule
open scoped Classical

variable {V U : Type*} [Fintype V] (key : V → ℕ) (src dst : U → V)

def Adjacent (u v : V) : Prop :=
  ∃e,(src e=u ∧ dst e=v) ∨ (src e=v ∧ dst e=u)

lemma incident_sides (first last : V) (q : ℕ) {u v : V}
    (h : Adjacent src dst u v) (huv : key u<key v) :
    Nonempty (Frontier.Outgoing (emit key src dst first last q) (key u)) ∧
    Nonempty (Frontier.Incoming (absorb key src dst first last q) (key v)) := by
  obtain ⟨e,he⟩ := h
  rcases he with ⟨hs,ht⟩ | ⟨hs,ht⟩
  · constructor
    · exact ⟨⟨Sum.inl e,by simp only [emit,hs,ht,min_eq_left (Nat.add_le_add_right huv.le 1)]⟩⟩
    · exact ⟨⟨Sum.inl e,by simp only [absorb,hs,ht,max_eq_right (Nat.add_le_add_right huv.le 1)]⟩⟩
  · constructor
    · exact ⟨⟨Sum.inl e,by simp only [emit,hs,ht,min_eq_right (Nat.add_le_add_right huv.le 1)]⟩⟩
    · exact ⟨⟨Sum.inl e,by simp only [absorb,hs,ht,max_eq_left (Nat.add_le_add_right huv.le 1)]⟩⟩

theorem factor_splits_nonempty (first last : V) (q : ℕ) (hq : 0<q)
    (horder : ∀v,(v=first ∨ ∃u,Adjacent src dst u v ∧ key u<key v) ∧
      (v=last ∨ ∃w,Adjacent src dst v w ∧ key v<key w)) (v : V) :
    Nonempty (Frontier.Incoming (absorb key src dst first last q) (key v)) ∧
    Nonempty (Frontier.Outgoing (emit key src dst first last q) (key v)) := by
  obtain ⟨hi,ho⟩ := horder v
  constructor
  · rcases hi with rfl | ⟨u,hu,hk⟩
    · exact ⟨⟨Sum.inr (Sum.inl ⟨0,hq⟩),rfl⟩⟩
    · exact (incident_sides key src dst first last q hu hk).2
  · rcases ho with rfl | ⟨w,hw,hk⟩
    · exact ⟨⟨Sum.inr (Sum.inr ⟨0,hq⟩),rfl⟩⟩
    · exact (incident_sides key src dst first last q hw hk).1
end LogConcaveSampling.GraphSchedule
namespace LogConcaveSampling.AdjointRemoval
variable {n : ℕ} {S : State (Fin (n+1))}

abbrev InternalEdge (β : Fin n → ℕ) := ((k : Fin n) × Fin (β k)) ⊕ Fin (n+1)

def edgeSource (β : Fin n → ℕ) : InternalEdge β → TargetVertex S
  | Sum.inl e => Sum.inl e.1.castSucc
  | Sum.inr i => Sum.inl i

def edgeTarget (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) : InternalEdge β → TargetVertex S
  | Sum.inl e => Sum.inl e.1.succ
  | Sum.inr i => destination hS i

lemma internal_adjacent (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (e : InternalEdge β) :
    Adjacent hS (edgeSource (S:=S) β e) (edgeTarget hS β e) := by
  rcases e with ⟨k,i⟩ | i
  · exact Or.inl ⟨k,Or.inl ⟨rfl,rfl⟩⟩
  · exact Or.inr ⟨i,Or.inl ⟨rfl,rfl⟩⟩

lemma internal_source_ne (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (e : InternalEdge β) :
    edgeSource (S:=S) β e ≠ edgeTarget hS β e :=
  adjacent_ne hS (internal_adjacent hS β e)

lemma adjacent_has_edge (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (hβ : ∀k,0<β k) {u v : TargetVertex S} (h : Adjacent hS u v) :
    GraphSchedule.Adjacent (edgeSource (S:=S) β) (edgeTarget hS β) u v := by
  rcases h with ⟨k,h⟩ | ⟨i,h⟩
  · refine ⟨Sum.inl ⟨k,⟨0,hβ k⟩⟩,?_⟩
    rcases h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
    · exact Or.inl ⟨rfl,rfl⟩
    · exact Or.inr ⟨rfl,rfl⟩
  · refine ⟨Sum.inr i,?_⟩
    rcases h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
    · exact Or.inl ⟨rfl,rfl⟩
    · exact Or.inr ⟨rfl,rfl⟩

theorem actual_removal_schedule
    (hS : S∈expand (Fintype.card (Fin (n+1))) initial)
    (β : Fin n → ℕ) (hβ : ∀k,0<β k) :
    ∃key : TargetVertex S → ℕ,Function.Injective key ∧
      ∀(q : ℕ),0<q → ∀v : TargetVertex S,
        Nonempty (Frontier.Incoming
          (GraphSchedule.absorb key (edgeSource (S:=S) β) (edgeTarget hS β)
            (Sum.inl 0) (Sum.inl (Fin.last n)) q) (key v)) ∧
        Nonempty (Frontier.Outgoing
          (GraphSchedule.emit key (edgeSource (S:=S) β) (edgeTarget hS β)
            (Sum.inl 0) (Sum.inl (Fin.last n)) q) (key v)) := by
  obtain ⟨key,hkey,_,hsplit⟩ := actual_removal_graph_order hS
  refine ⟨key,hkey,fun q hq v => ?_⟩
  apply GraphSchedule.factor_splits_nonempty key (edgeSource (S:=S) β) (edgeTarget hS β)
    (Sum.inl 0) (Sum.inl (Fin.last n)) q hq _ v
  intro w
  obtain ⟨hi,ho⟩ := hsplit w
  constructor
  · rcases hi with h | ⟨u,hu,hk⟩
    · exact Or.inl h
    · exact Or.inr ⟨u,adjacent_has_edge hS β hβ hu,hk⟩
  · rcases ho with h | ⟨u,hu,hk⟩
    · exact Or.inl h
    · exact Or.inr ⟨u,adjacent_has_edge hS β hβ hu,hk⟩
end LogConcaveSampling.AdjointRemoval
namespace LogConcaveSampling.GraphSchedule
open scoped Classical

variable {V U C : Type*} [Fintype V] (key : V → ℕ) (src dst : U → V)
local instance edgeDecEqC (q : ℕ) : DecidableEq (Edge (U:=U) q) := Classical.decEq _
local instance finDecEqC (d : ℕ) : DecidableEq (Fin d) := Classical.decEq _

lemma close_output_apply (first last : V) (q : ℕ)
    (x : Frontier.Live (emit key src dst first last q) (absorb key src dst first last q) 0 → C)
    (i : Fin q) :
    close key src dst first last q x
      ⟨Sum.inr (Sum.inr i),key_lt_length key last,Nat.lt_succ_self _⟩=
    x ⟨Sum.inr (Sum.inl i),Nat.zero_le _,Nat.zero_lt_succ _⟩ := rfl

lemma closing_iff (first last : V) (q : ℕ) (c : Edge (U:=U) q → C) :
    (fun e : Frontier.Live (emit key src dst first last q)
      (absorb key src dst first last q) (length key) => c e.val)=
        close key src dst first last q
          (fun e : Frontier.Live (emit key src dst first last q)
            (absorb key src dst first last q) 0 => c e.val) ↔
    ∀i : Fin q,c (Sum.inr (Sum.inr i))=c (Sum.inr (Sum.inl i)) := by
  constructor
  · intro h i
    exact congrFun h ⟨Sum.inr (Sum.inr i),key_lt_length key last,Nat.lt_succ_self _⟩
  · intro h
    funext e
    obtain ⟨i,rfl⟩ := (outputEdges key src dst first last q).symm.surjective e
    exact h i

def duplicate {q : ℕ} (c : U ⊕ Fin q → C) : Edge (U:=U) q → C
  | Sum.inl u => c (Sum.inl u)
  | Sum.inr (Sum.inl i) => c (Sum.inr i)
  | Sum.inr (Sum.inr i) => c (Sum.inr i)

noncomputable def cutColorEquiv (q : ℕ) :
    (U ⊕ Fin q → C) ≃
      {c : Edge (U:=U) q → C // ∀i : Fin q,c (Sum.inr (Sum.inr i))=c (Sum.inr (Sum.inl i))} where
  toFun c := ⟨duplicate c,fun _ => rfl⟩
  invFun c := Sum.elim (fun u => c.val (Sum.inl u)) (fun i => c.val (Sum.inr (Sum.inl i)))
  left_inv c := by funext e; cases e <;> rfl
  right_inv c := by
    apply Subtype.ext
    funext e
    rcases e with e | (i|i)
    · rfl
    · rfl
    · exact (c.property i).symm

theorem sum_closed_coordinates [Fintype U] [Fintype C]
    (first last : V) (q : ℕ) (F : (Edge (U:=U) q → C) → ℝ) :
    (∑c : Edge (U:=U) q → C,F c*
      (if (fun e : Frontier.Live (emit key src dst first last q)
        (absorb key src dst first last q) (length key) => c e.val)=
          close key src dst first last q
            (fun e : Frontier.Live (emit key src dst first last q)
              (absorb key src dst first last q) 0 => c e.val) then 1 else 0))=
      ∑c : U ⊕ Fin q → C,F (duplicate c) := by
  simp_rw [closing_iff,mul_ite,mul_one,mul_zero]
  let P (c : Edge (U:=U) q → C) := ∀i : Fin q,c (Sum.inr (Sum.inr i))=c (Sum.inr (Sum.inl i))
  rw [←Fintype.sum_subtype_add_sum_subtype P]
  have hz : (∑i : {c : Edge (U:=U) q → C // ¬P c},if P i.val then F i.val else 0)=0 := by
    apply Finset.sum_eq_zero
    intro i hi
    simp only [i.property,ite_false]
  change (∑i : {c : Edge (U:=U) q → C // P c},if P i.val then F i.val else 0)+
    (∑i : {c : Edge (U:=U) q → C // ¬P c},if P i.val then F i.val else 0)=_
  rw [hz,add_zero]
  simp only [Subtype.property,ite_true]
  exact ((cutColorEquiv (U:=U) (C:=C) q).sum_comp (fun c => F c.val)).symm
end LogConcaveSampling.GraphSchedule
namespace LogConcaveSampling.GraphSchedule
open scoped BigOperators Classical
open TensorEnergy

variable {V U : Type*} [Fintype V] [Fintype U]
local instance edgeDecEq (q : ℕ) : DecidableEq (Edge (U:=U) q) := Classical.decEq _
local instance finDecEq (d : ℕ) : DecidableEq (Fin d) := Classical.decEq _

theorem scheduled_coordinate_bound (key : V → ℕ) (src dst : U → V)
    (hkey : Function.Injective key) (hne : ∀e,src e≠dst e)
    (first last : V) (q d : ℕ)
    (A : ∀k,(Frontier.Outgoing (emit key src dst first last q) k → Fin d) →
      (Frontier.Incoming (absorb key src dst first last q) k → Fin d) → ℝ)
    (M : ℕ → ℝ) (hM : ∀k,0≤M k) (hA : ∀k,Bound (A k) ((M k)^2)) :
    |∑c : Edge (U:=U) q → Fin d,
      (∏k : Fin (length key),A k.val (fun e => c e.val) (fun e => c e.val))*
      (if (fun e : Frontier.Live (emit key src dst first last q)
          (absorb key src dst first last q) (length key) => c e.val)=
        close key src dst first last q
          (fun e : Frontier.Live (emit key src dst first last q)
            (absorb key src dst first last q) 0 => c e.val) then 1 else 0)|≤
      (d:ℝ)^q*(∏k∈Finset.range (length key),M k) := by
  calc
    _ ≤ (Fintype.card (Frontier.Live (emit key src dst first last q)
      (absorb key src dst first last q) 0 → Fin d):ℝ)*
        (∏k∈Finset.range (length key),M k) := by
      exact Frontier.coordinate_contraction_bound (E:=Edge (U:=U) q) (C:=Fin d)
        (emit key src dst first last q) (absorb key src dst first last q)
        (emit_lt_absorb key src dst hkey hne first last q) A M hM hA (length key)
        (emit_le_length key src dst first last q) (close key src dst first last q)
    _ = _ := by
      rw [Fintype.card_fun,Fintype.card_fin,
        Fintype.card_congr (inputEdges key src dst first last q),Fintype.card_fin,Nat.cast_pow]
end LogConcaveSampling.GraphSchedule
namespace LogConcaveSampling.GraphSchedule
open scoped BigOperators Classical
open TensorEnergy

variable {V U : Type*} [Fintype V] [Fintype U]
local instance edgeDecEqR (q : ℕ) : DecidableEq (Edge (U:=U) q) := Classical.decEq _
local instance finDecEqR (d : ℕ) : DecidableEq (Fin d) := Classical.decEq _

theorem reduced_coordinate_bound (key : V → ℕ) (src dst : U → V)
    (hkey : Function.Injective key) (hne : ∀e,src e≠dst e)
    (first last : V) (q d : ℕ)
    (A : ∀k,(Frontier.Outgoing (emit key src dst first last q) k → Fin d) →
      (Frontier.Incoming (absorb key src dst first last q) k → Fin d) → ℝ)
    (M : ℕ → ℝ) (hM : ∀k,0≤M k) (hA : ∀k,Bound (A k) ((M k)^2)) :
    |∑c : U ⊕ Fin q → Fin d,
      ∏k : Fin (length key),A k.val (fun e => duplicate c e.val) (fun e => duplicate c e.val)|≤
      (d:ℝ)^q*(∏k∈Finset.range (length key),M k) := by
  rw [←sum_closed_coordinates key src dst first last q
    (fun c => ∏k : Fin (length key),A k.val (fun e => c e.val) (fun e => c e.val))]
  exact scheduled_coordinate_bound key src dst hkey hne first last q d A M hM hA
end LogConcaveSampling.GraphSchedule

end UpperProof
end
end
end

end OAI