lean/OAI/Computability/WeisfeilerLeman/Simulation.lean

import OAI.Computability.WeisfeilerLeman.Tableau

namespace OAI

universe uA uJ uK uAlphabet

namespace WLTime.CircuitEncoding.Tableau
variable {A : Type uA} {J : Type uJ} {K : Type uK} (F : A → A → A → A) (s : Equiv.Perm J) (t : Equiv.Perm K)
  (e : J ≃ K) (u : J → A) (v : K → A)

theorem run_reindex (hstep : ∀ j,e (s j)=t (e j)) (hinit : ∀ j,u j=v (e j))
    (n : ℕ) (j : J) : run F s u n j=run F t v n (e j) := by
  have hinv (j : J) : e (s.symm j)=t.symm (e j) := by
    apply t.injective
    rw [t.apply_symm_apply,← hstep,s.apply_symm_apply]
  induction n generalizing j with
  | zero => exact hinit j
  | succ n ih => simp only [run_succ,ih,hinv,hstep]
end WLTime.CircuitEncoding.Tableau

namespace WLTime.Digits

theorem value_lt_base_iff {q m : ℕ} (hm : 0< m) (a : Word (q+1) m) :
    value a< m ↔ ∀ i : Fin q,(a i.succ).val=0 := by
  rw [← value_eq_zero_iff hm (fun i => a i.succ),value_succ]
  have hhead := (a 0).isLt
  constructor
  · intro h
    by_contra hh
    have hx : 1 ≤ value (fun i => a i.succ) := Nat.one_le_iff_ne_zero.mpr hh
    have hh' := Nat.mul_le_mul_left m hx
    omega
  · intro h
    simp only [h,Nat.mul_zero,Nat.add_zero]
    exact hhead

 theorem finEquiv_val {n : ℕ} [NeZero n] (j : Fin n) :
    (ZMod.finEquiv n j).val=j.val := by
  cases n with
  | zero => exact Fin.elim0 j
  | succ n => rfl

 theorem finEquiv_shift {n : ℕ} [NeZero n] (j : Fin n) :
    ZMod.finEquiv n (inc n j)=OneTape.ringShift n (ZMod.finEquiv n j) := by
  apply ZMod.val_injective
  rw [finEquiv_val,inc_value]
  change (if j.val+1=n then 0 else j.val+1)=((ZMod.finEquiv n j)+1).val
  have h1 : (1 : ZMod n).val=1%n := by simpa only [Nat.cast_one] using ZMod.val_natCast n 1
  rw [ZMod.val_add,finEquiv_val,h1]
  by_cases hn : n=1
  · subst n
    simp
  · have hn' : 1<n := by have := NeZero.ne n; omega
    rw [Nat.mod_eq_of_lt hn']
    by_cases hj : j.val+1=n
    · simp [hj]
    · rw [ite_eq_right hj,Nat.mod_eq_of_lt (by have := j.isLt; omega)]

end WLTime.Digits

namespace WLTime.OneTape
variable (M : OneTape)
open CircuitEncoding

 def blankCell : M.Cell := (⟨0,by have := M.symbols_ge; omega⟩,none)

 def inputCell (w : List Bool) (i : Fin w.length) : M.Cell :=
  (M.toTM.symbol (w.getD i.val false),
    if i.val=0 then some ⟨0,by have := M.states_ge; omega⟩ else none)

 theorem ring_initial_digits (w : List Bool) (hm : 0< w.length) (q : ℕ)
    [NeZero (w.length^(q+1))] (j : Fin (w.length^(q+1))) :
    BoxTableau.initialRing (M.inputCell w) M.blankCell j=
      M.snapshot (M.ringInitial (w.length^(q+1)) w) (ZMod.finEquiv (w.length^(q+1)) j) := by
  have hval : Digits.value (Digits.encode.symm j)=j.val := by
    simp only [Digits.value,Equiv.apply_symm_apply]
  have hzero : ZMod.finEquiv (w.length^(q+1)) j=0 ↔ j.val=0 := by
    rw [← ZMod.val_eq_zero,Digits.finEquiv_val]
  unfold BoxTableau.initialRing BoxTableau.initialDigit
  by_cases hj : j.val< w.length
  · have ht := (Digits.value_lt_base_iff hm (Digits.encode.symm j)).mp (hval ▸ hj)
    rw [ite_eq_left ht]
    have ha : ((Digits.encode.symm j) 0).val=j.val := by
      have hz := (Digits.value_eq_zero_iff hm (fun i => Digits.encode.symm j i.succ)).mpr ht
      rw [Digits.value_succ,hz,Nat.mul_zero,Nat.add_zero] at hval
      exact hval
    simp [inputCell,snapshot,ringInitial,Digits.finEquiv_val,ha,hj,hzero]
  · have ht : ¬∀ i : Fin q,(Digits.encode.symm j i.succ).val=0 := by
      rw [← Digits.value_lt_base_iff hm,hval]
      exact hj
    rw [ite_eq_right ht]
    have hz : j.val≠0 := by omega
    simp [blankCell,snapshot,ringInitial,Digits.finEquiv_val,hj,hzero,hz]

theorem product_simulation (w : List Bool) (hm : 0< w.length) (d q T : ℕ)
    (hT : T ≤ w.length^d-1) (hL : 2*T+w.length+2< w.length^(q+1))
    (hh : (M.run lineShift (M.initial w) T).state.val=1 ∨
      (M.run lineShift (M.initial w) T).state.val=2) :
    (∀ g, (BoxTableau.schematic M.localRule (M.inputCell w) M.blankCell M.letterAccepting :
      Schematic (d+(q+1)) w.length _ _ _ _).expand.test g=true →
      ¬(BoxTableau.schematic M.localRule (M.inputCell w) M.blankCell M.letterAccepting).expand.TrueAt g) ↔
      ¬M.toTM.accepts w := by
  let : NeZero (w.length^(q+1)) := ⟨Nat.ne_of_gt (Nat.pow_pos hm)⟩
  rw [BoxTableau.local_equivalence M.localRule (M.inputCell w) M.blankCell M.letterAccepting hm]
  rw [← M.ring_accepts_iff w T (w.length^(q+1)) (w.length^d-1) hL hT hh]
  simp only [not_exists]
  constructor
  · intro h j
    let f : Fin (w.length^(q+1)) ≃ ZMod (w.length^(q+1)) := (ZMod.finEquiv _).toEquiv
    have he := Tableau.run_reindex M.localRule (Digits.inc _) (ringShift _) f
      (BoxTableau.initialRing (M.inputCell w) M.blankCell) (M.snapshot (M.ringInitial _ w))
      Digits.finEquiv_shift (M.ring_initial_digits w hm q) (w.length^d-1) (f.symm j)
    exact (by simpa only [f.apply_symm_apply] using he) ▸ h (f.symm j)
  · intro h j
    have he := Tableau.run_reindex M.localRule (Digits.inc _) (ringShift _) (ZMod.finEquiv _).toEquiv
      (BoxTableau.initialRing (M.inputCell w) M.blankCell) (M.snapshot (M.ringInitial _ w))
      Digits.finEquiv_shift (M.ring_initial_digits w hm q) (w.length^d-1) j
    rw [he]
    exact h _

end WLTime.OneTape

namespace WLTime.CircuitEncoding.BoxTableau
open NatCode ProductBox
namespace Formula
variable {Alphabet : Type uAlphabet} {J : Type uJ} {d q m : ℕ}

def labelDomain (e : Label Alphabet d q) (M a : Expr J) : Fin (d+q) → Predicate J :=
  match e with
  | .left _ _ _ t s => Fin.addCases (fun i => ProductBox.Formula.carryDomain t.castSucc i M a)
      (fun i => ProductBox.Formula.carryDomain s i M a)
  | .center _ _ _ t => Fin.addCases (fun i => ProductBox.Formula.carryDomain t.castSucc i M a)
      (fun _ => .truth true)
  | .bridge _ _ _ => fun _ => .truth true
  | .right _ _ _ t s => Fin.addCases (fun i => ProductBox.Formula.carryDomain t.castSucc i M a)
      (fun i => ProductBox.Formula.borrowDomain s i M a)
  | .out _ _ _ => fun _ => .truth true

def labelCoord (e : Label Alphabet d q) (M a : Expr J) : Fin (d+q) → Expr J :=
  match e with
  | .left _ _ _ t s => Fin.addCases (fun i => ProductBox.Formula.carryCoord t.castSucc i M a)
      (fun i => ProductBox.Formula.carryCoord s i M a)
  | .center _ _ _ t => Fin.addCases (fun i => ProductBox.Formula.carryCoord t.castSucc i M a) (fun _ => a)
  | .bridge _ _ _ => fun _ => a
  | .right _ _ _ t s => Fin.addCases (fun i => ProductBox.Formula.carryCoord t.castSucc i M a)
      (fun i => ProductBox.Formula.borrowCoord s i M a)
  | .out _ _ _ => fun _ => a

 theorem labelDomain_correct (e : Label Alphabet d q) (M a : Expr J) (i : Fin (d+q))
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (labelDomain e M a i).Holds σ w ↔ x∈(box e).domain i := by
  cases e with
  | left f g h t s =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelDomain,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryDomain_correct t.castSucc i M a σ w x hM ha
    · simpa only [labelDomain,box,Box.product,Fin.addCases_right] using ProductBox.Formula.carryDomain_correct s i M a σ w x hM ha
  | center f g h t =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelDomain,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryDomain_correct t.castSucc i M a σ w x hM ha
    · simp only [labelDomain,Fin.addCases_right,box,Box.product,Box.identity,Predicate.Holds,Finset.mem_univ]
  | bridge f g h => simp only [labelDomain,box,Box.identity,Predicate.Holds,Finset.mem_univ]
  | right f g h t s =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelDomain,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryDomain_correct t.castSucc i M a σ w x hM ha
    · simpa only [labelDomain,box,Box.product,Fin.addCases_right] using ProductBox.Formula.borrowDomain_correct s i M a σ w x hM ha
  | out f g h => simp only [labelDomain,box,Box.identity,Predicate.Holds,Finset.mem_univ]

 theorem labelCoord_correct (e : Label Alphabet d q) (M a : Expr J) (i : Fin (d+q))
    (σ : J → ℕ) (w : List Bool) (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (labelCoord e M a i).eval σ w=((box e).coord i x).val := by
  cases e with
  | left f g h t s =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelCoord,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryCoord_correct t.castSucc i M a σ w x hM ha
    · simpa only [labelCoord,box,Box.product,Fin.addCases_right] using ProductBox.Formula.carryCoord_correct s i M a σ w x hM ha
  | center f g h t =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelCoord,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryCoord_correct t.castSucc i M a σ w x hM ha
    · simpa only [labelCoord,box,Box.product,Box.identity,Fin.addCases_right,Equiv.refl_apply] using ha
  | bridge f g h => exact ha
  | right f g h t s =>
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simpa only [labelCoord,box,Box.product,Fin.addCases_left] using ProductBox.Formula.carryCoord_correct t.castSucc i M a σ w x hM ha
    · simpa only [labelCoord,box,Box.product,Fin.addCases_right] using ProductBox.Formula.borrowCoord_correct s i M a σ w x hM ha
  | out f g h => exact ha

noncomputable def position (input : Alphabet → Expr J → Predicate J) (s : Alphabet ⊕ Fin q)
    (a : Expr J) : Fin (q+1) → Predicate J :=
  match s with
  | .inl f => Fin.cases (input f a) (fun _ => .eq a (.const 0))
  | .inr i => fun j => if j=i.succ then (Predicate.eq a (.const 0)).neg else .truth true

noncomputable def seed (input : Alphabet → Expr J → Predicate J) (s : Alphabet ⊕ Fin q)
    (a : Expr J) : Fin (d+(q+1)) → Predicate J :=
  Fin.addCases (fun _ => .eq a (.const 0)) (position input s a)

def test (M a : Expr J) : Fin (d+(q+1)) → Predicate J :=
  Fin.addCases (fun _ => .eq (.binary .add a (.const 1)) M) (fun _ => .truth true)

 theorem position_correct [DecidableEq Alphabet] (input : Fin m → Alphabet)
    (C : Alphabet → Expr J → Predicate J) (σ : J → ℕ) (w : List Bool)
    (hC : ∀f a (x : Fin m),a.eval σ w=x.val → ((C f a).Holds σ w ↔ input x=f))
    (s : Alphabet ⊕ Fin q) (a : Expr J) (i : Fin (q+1)) (x : Fin m) (ha : a.eval σ w=x.val) :
    (position C s a i).Holds σ w ↔ x∈positionDomain input s i := by
  cases s with
  | inl f =>
    refine Fin.cases ?_ (fun j => ?_) i
    · simpa only [position,positionDomain,Fin.cases_zero,Finset.mem_filter,Finset.mem_univ,true_and]
        using hC f a x ha
    · simp only [position,positionDomain,Fin.cases_succ,Predicate.Holds,Expr.eval,ha,
        Finset.mem_filter,Finset.mem_univ,true_and]
  | inr j =>
    simp only [position,positionDomain,Finset.mem_filter,Finset.mem_univ,true_and]
    split_ifs <;> simp_all only [Predicate.Holds,Expr.eval,true_implies,false_implies]

 theorem seed_correct [DecidableEq Alphabet] (input : Fin m → Alphabet)
    (C : Alphabet → Expr J → Predicate J) (σ : J → ℕ) (w : List Bool)
    (hC : ∀f a (x : Fin m),a.eval σ w=x.val → ((C f a).Holds σ w ↔ input x=f))
    (s : Alphabet ⊕ Fin q) (a : Expr J) (i : Fin (d+(q+1))) (x : Fin m) (ha : a.eval σ w=x.val) :
    (seed C s a i).Holds σ w ↔ x∈seedDomain input s i := by
  refine Fin.addCases (fun i => ?_) (fun i => ?_) i
  · simp only [seed,seedDomain,Fin.addCases_left,Predicate.Holds,Expr.eval,ha,
      Finset.mem_filter,Finset.mem_univ,true_and]
  · simpa only [seed,seedDomain,Fin.addCases_right] using position_correct input C σ w hC s a i x ha

 theorem test_correct (accepting : Alphabet → Prop) (f : {f // accepting f})
    (M a : Expr J) (i : Fin (d+(q+1))) (σ : J → ℕ) (w : List Bool)
    (x : Fin m) (hM : M.eval σ w=m) (ha : a.eval σ w=x.val) :
    (test M a i).Holds σ w ↔ x∈testDomain accepting f i := by
  refine Fin.addCases (fun i => ?_) (fun i => ?_) i
  · simp only [test,testDomain,Fin.addCases_left,Predicate.Holds,Expr.eval,Binary.eval,hM,ha,
      Finset.mem_filter,Finset.mem_univ,true_and]
  · simp only [test,testDomain,Fin.addCases_right,Predicate.Holds,Finset.mem_univ]
end Formula
end WLTime.CircuitEncoding.BoxTableau

namespace WLTime.OneTape
open NatCode
variable (M : OneTape) {J : Type uJ}
noncomputable def inputPredicate (f : M.Cell) (a : Expr J) : Predicate J := by
  classical
  exact (((Predicate.bit a).conj (.truth (decide (M.toTM.symbol true=f.1)))).disj
    ((Predicate.bit a).neg.conj (.truth (decide (M.toTM.symbol false=f.1))))).conj
      (((Predicate.eq a (.const 0)).conj (.truth (decide (some (⟨0,by have := M.states_ge; omega⟩ : Fin M.states)=f.2)))).disj
        ((Predicate.eq a (.const 0)).neg.conj (.truth (decide ((none : Option (Fin M.states))=f.2)))))

 theorem inputPredicate_correct (f : M.Cell) (a : Expr J) (σ : J → ℕ) (w : List Bool)
    (x : Fin w.length) (ha : a.eval σ w=x.val) :
    (M.inputPredicate f a).Holds σ w ↔ M.inputCell w x=f := by
  classical
  simp only [inputPredicate,Predicate.holds_disj,Predicate.Holds,Expr.eval,ha,
    decide_eq_true_eq,inputCell,Prod.ext_iff]
  cases w.getD x.val false <;> by_cases hx : x.val=0 <;> simp [hx] <;> tauto
end WLTime.OneTape

namespace WLTime.NatCode
variable {J : Type uJ}
namespace Predicate
 theorem bounded_mono (p : Predicate J) (σ : J → ℕ) (w : List Bool) {A B : ℕ}
    (h : p.Bounded σ w A) (hAB : A≤B) : p.Bounded σ w B := by
  induction p with
  | truth => trivial
  | eq a b | lt a b => exact ⟨a.bounded_mono σ w h.1 hAB,b.bounded_mono σ w h.2 hAB⟩
  | bit a => exact a.bounded_mono σ w h hAB
  | conj a b ha hb => exact ⟨ha h.1,hb h.2⟩
  | neg a ha => exact ha h

@[simp] theorem bounded_disj (p q : Predicate J) (σ : J → ℕ) (w : List Bool) (B : ℕ) :
    (p.disj q).Bounded σ w B ↔ p.Bounded σ w B ∧ q.Bounded σ w B := Iff.rfl

@[simp] theorem bounded_all (l : List (Predicate J)) (σ : J → ℕ) (w : List Bool) (B : ℕ) :
    (all l).Bounded σ w B ↔ ∀p∈l,p.Bounded σ w B := by
  induction l with
  | nil => simp only [all,List.foldr_nil,Bounded,List.not_mem_nil,false_implies,implies_true]
  | cons p l ih =>
    change p.Bounded σ w B ∧ (all l).Bounded σ w B ↔ _
    simp only [ih,List.mem_cons,forall_eq_or_imp]

@[simp] theorem bounded_any (l : List (Predicate J)) (σ : J → ℕ) (w : List Bool) (B : ℕ) :
    (any l).Bounded σ w B ↔ ∀p∈l,p.Bounded σ w B := by
  simp only [any,Bounded,bounded_all,List.mem_map,forall_exists_index,and_imp,forall_apply_eq_imp_iff₂]
end Predicate
namespace Expr
 theorem addOne_bounded (a : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (ha : a.Bounded σ w B) : (binary .add a (.const 1)).Bounded σ w (B+1) :=
  ⟨a.bounded_mono σ w ha (by omega),by change 1≤B+1; omega,by
    change a.eval σ w+1≤B+1
    exact Nat.add_le_add_right (a.eval_le σ w B ha) 1⟩

 theorem subOne_bounded (a : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (hB : 1≤B) (ha : a.Bounded σ w B) : (binary .sub a (.const 1)).Bounded σ w B :=
  ⟨ha,hB,by change a.eval σ w-1≤B; exact (Nat.sub_le _ _).trans (a.eval_le σ w B ha)⟩

 theorem incCode_bounded (M a : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (hB : 1≤B) (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (incCode M a).Bounded σ w (5*B) := by
  have ht := addOne_bounded a σ w B ha
  have h := choose_bounded (.eq (.binary .add a (.const 1)) M) (.const 0)
    (.binary .add a (.const 1)) σ w (B+1) ⟨ht,M.bounded_mono σ w hM (by omega)⟩ (by exact Nat.zero_le _) ht
  exact (incCode M a).bounded_mono σ w h (by omega)

 theorem decCode_bounded (M a : Expr J) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (hB : 1≤B) (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (decCode M a).Bounded σ w (3*B) := by
  have h := choose_bounded (.eq a (.const 0)) (.binary .sub M (.const 1))
    (.binary .sub a (.const 1)) σ w B ⟨ha,Nat.zero_le _⟩ (subOne_bounded M σ w B hB hM)
      (subOne_bounded a σ w B hB ha)
  exact (decCode M a).bounded_mono σ w h (by omega)
end Expr
end WLTime.NatCode

namespace WLTime.ProductBox.Formula
open NatCode
variable {d : ℕ} {J : Type uJ}
 theorem carryDomain_bounded (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (carryDomain p i M a).Bounded σ w (2*B) := by
  have ht := (Expr.binary .add a (.const 1)).bounded_mono σ w (Expr.addOne_bounded a σ w B ha) (by omega : B+1≤2*B)
  have hm := M.bounded_mono σ w hM (by omega : B≤2*B)
  unfold carryDomain
  split_ifs <;> first | exact ⟨ht,hm⟩ | trivial

 theorem carryCoord_bounded (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (carryCoord p i M a).Bounded σ w (5*B) := by
  unfold carryCoord
  split_ifs
  · exact Expr.incCode_bounded M a σ w B hB hM ha
  · exact a.bounded_mono σ w ha (by omega)

 theorem borrowCoord_bounded (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (borrowCoord p i M a).Bounded σ w (3*B) := by
  unfold borrowCoord
  split_ifs
  · exact Expr.decCode_bounded M a σ w B hB hM ha
  · exact a.bounded_mono σ w ha (by omega)

 theorem borrowDomain_bounded (p : Fin (d+1)) (i : Fin d) (M a : Expr J)
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (borrowDomain p i M a).Bounded σ w (6*B) := by
  have h := carryDomain_bounded p i M (borrowCoord p i M a) σ w (3*B) (by omega)
    (M.bounded_mono σ w hM (by omega)) (borrowCoord_bounded p i M a σ w B hB hM ha)
  simpa only [borrowDomain,← Nat.mul_assoc] using h
end WLTime.ProductBox.Formula
namespace WLTime.CircuitEncoding.BoxTableau.Formula
open NatCode
variable {Alphabet : Type uAlphabet} {d q : ℕ} {J : Type uJ}
 theorem labelDomain_bounded (e : Label Alphabet d q) (M a : Expr J) (i : Fin (d+q))
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (labelDomain e M a i).Bounded σ w (6*B) := by
  have hcarry {n} (p : Fin (n+1)) (j : Fin n) :=
    (ProductBox.Formula.carryDomain p j M a).bounded_mono σ w
      (ProductBox.Formula.carryDomain_bounded p j M a σ w B hB hM ha) (by omega : 2*B≤6*B)
  have hborrow {n} (p : Fin (n+1)) (j : Fin n) :=
    ProductBox.Formula.borrowDomain_bounded p j M a σ w B hB hM ha
  cases e with
  | left f g h t s =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelDomain,Fin.addCases_left] using hcarry t.castSucc j
    · simpa only [labelDomain,Fin.addCases_right] using hcarry s j
  | center f g h t =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelDomain,Fin.addCases_left] using hcarry t.castSucc j
    · simp only [labelDomain,Fin.addCases_right,Predicate.Bounded]
  | bridge | out => trivial
  | right f g h t s =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelDomain,Fin.addCases_left] using hcarry t.castSucc j
    · simpa only [labelDomain,Fin.addCases_right] using hborrow s j

 theorem labelCoord_bounded (e : Label Alphabet d q) (M a : Expr J) (i : Fin (d+q))
    (σ : J → ℕ) (w : List Bool) (B : ℕ) (hB : 1≤B)
    (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (labelCoord e M a i).Bounded σ w (6*B) := by
  have hcarry {n} (p : Fin (n+1)) (j : Fin n) :=
    (ProductBox.Formula.carryCoord p j M a).bounded_mono σ w
      (ProductBox.Formula.carryCoord_bounded p j M a σ w B hB hM ha) (by omega : 5*B≤6*B)
  have hborrow {n} (p : Fin (n+1)) (j : Fin n) :=
    (ProductBox.Formula.borrowCoord p j M a).bounded_mono σ w
      (ProductBox.Formula.borrowCoord_bounded p j M a σ w B hB hM ha) (by omega : 3*B≤6*B)
  have hid := a.bounded_mono σ w ha (by omega : B≤6*B)
  cases e with
  | left f g h t s =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelCoord,Fin.addCases_left] using hcarry t.castSucc j
    · simpa only [labelCoord,Fin.addCases_right] using hcarry s j
  | center f g h t =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelCoord,Fin.addCases_left] using hcarry t.castSucc j
    · simpa only [labelCoord,Fin.addCases_right] using hid
  | bridge | out => exact hid
  | right f g h t s =>
    refine Fin.addCases (fun j => ?_) (fun j => ?_) i
    · simpa only [labelCoord,Fin.addCases_left] using hcarry t.castSucc j
    · simpa only [labelCoord,Fin.addCases_right] using hborrow s j

 theorem position_bounded (C : Alphabet → Expr J → Predicate J) (s : Alphabet ⊕ Fin q)
    (a : Expr J) (i : Fin (q+1)) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (ha : a.Bounded σ w B) (hC : ∀f,(C f a).Bounded σ w B) :
    (position C s a i).Bounded σ w B := by
  cases s with
  | inl f =>
    refine Fin.cases ?_ (fun j => ?_) i
    · simpa only [position,Fin.cases_zero] using hC f
    · simpa only [position,Fin.cases_succ,Predicate.Bounded,Expr.Bounded,and_true] using
        (show a.Bounded σ w B ∧ 0≤B from ⟨ha,Nat.zero_le _⟩)
  | inr j =>
    simp only [position]
    split_ifs
    · exact ⟨ha,Nat.zero_le _⟩
    · trivial

 theorem seed_bounded (C : Alphabet → Expr J → Predicate J) (s : Alphabet ⊕ Fin q)
    (a : Expr J) (i : Fin (d+(q+1))) (σ : J → ℕ) (w : List Bool) (B : ℕ)
    (ha : a.Bounded σ w B) (hC : ∀f,(C f a).Bounded σ w B) :
    (seed C s a i).Bounded σ w B := by
  refine Fin.addCases (fun j => ?_) (fun j => ?_) i
  · simpa only [seed,Fin.addCases_left,Predicate.Bounded,Expr.Bounded] using
      (show a.Bounded σ w B ∧ 0≤B from ⟨ha,Nat.zero_le _⟩)
  · simpa only [seed,Fin.addCases_right] using position_bounded C s a j σ w B ha hC

 theorem test_bounded (M a : Expr J) (i : Fin (d+(q+1))) (σ : J → ℕ) (w : List Bool)
    (B : ℕ) (hB : 1≤B) (hM : M.Bounded σ w B) (ha : a.Bounded σ w B) :
    (test (d:=d) (q:=q) M a i).Bounded σ w (2*B) := by
  refine Fin.addCases (fun j => ?_) (fun j => ?_) i
  · simp only [test,Fin.addCases_left,Predicate.Bounded]
    exact ⟨(Expr.binary .add a (.const 1)).bounded_mono σ w (Expr.addOne_bounded a σ w B ha) (by omega),
      M.bounded_mono σ w hM (by omega)⟩
  · simp only [test,Fin.addCases_right,Predicate.Bounded]
end WLTime.CircuitEncoding.BoxTableau.Formula

end OAI