Add lean source and binary files (part 42)

lean/OAI/Combinatorics/ContingencyTables/Machines/ListSubtractProgram.lean

@@ -0,0 +1,88 @@
+import OAI.Combinatorics.ContingencyTables.Transport.BoundedCellShift
+import OAI.Combinatorics.ContingencyTables.Machines.NetworkFeasibilityProgram
+
+namespace OAI
+
+/-! # Binary subtraction at one list coordinate
+
+The scan depends on the stored list length. The subtracted amount remains
+binary throughout and never controls a loop.
+-/
+
+namespace ContingencyTables.ListSubtractProgram
+
+open MatchingFPRAS.TreeTyped Polynomial
+
+abbrev Input := (List ℕ×ℕ)×ℕ
+abbrev Cell := Input×ℕ
+
+def entry (z : Cell) : ℕ :=
+  z.1.1.1.getD z.2 0-if z.2=z.1.1.2 then z.1.2 else 0
+
+def entryRealizer : Realizer entry := by
+  let read : Realizer (fun z : Cell=>z.1.1.1.getD z.2 0) :=
+    composition (pair (composition (composition first first) first) second) (getDFast 0)
+  let amount : Realizer (fun z : Cell=>if z.2=z.1.1.2 then z.1.2 else 0) :=
+    (choose (composition (pair second (composition (composition first first) second)) natEqual)
+      (composition first second) (constant 0)).congr (by
+        intro z
+        simp only [Function.comp_apply,decide_eq_true_eq])
+  exact composition (pair read amount) subtract
+
+lemma polynomial_entry : PolynomialTime entryRealizer := by
+  unfold entryRealizer
+  apply polynomial_composition
+  · apply polynomial_pair
+    · exact polynomial_composition (polynomial_pair
+        (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+          polynomial_first) polynomial_second) (polynomial_getDFast 0)
+    · exact polynomial_congr _ (polynomial_choose
+        (polynomial_composition (polynomial_pair polynomial_second
+          (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+            polynomial_second)) polynomial_natEqual)
+        (polynomial_composition polynomial_first polynomial_second) (polynomial_constant 0))
+  · exact polynomial_subtract
+
+def indices (z : Input) : List ℕ := List.range z.1.1.length
+
+def indicesRealizer : Realizer indices :=
+  composition (composition (composition first first) listLength) range
+
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1.1).trans ((weight_fst z.1).trans (weight_fst z))
+
+def subtractAt (z : Input) : List ℕ :=
+  (indices z).map (fun i=>entry (z,i))
+
+def subtractAtRealizer : Realizer subtractAt :=
+  composition (pair identity indicesRealizer) (mapWith entryRealizer)
+
+lemma polynomial_subtractAt : PolynomialTime subtractAtRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
+    (polynomial_mapWith polynomial_entry)
+
+lemma subtractAt_length (xs : List ℕ) (i t : ℕ) :
+    (subtractAt ((xs,i),t)).length=xs.length := by
+  simp [subtractAt,indices]
+
+lemma subtractAt_ofFn {m : ℕ} (x : Fin m→ℕ) (i : Fin m) (t : ℕ) :
+    subtractAt ((List.ofFn x,i.val),t)=List.ofFn (BoundedCellShift.margin x i t) := by
+  simp only [subtractAt,indices,List.length_ofFn,DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,
+    List.map_ofFn]
+  apply congrArg List.ofFn
+  funext j
+  simp only [entry,List.getD_eq_getElem?_getD,List.getElem?_ofFn,BoundedCellShift.margin]
+  by_cases h : j=i
+  · subst j
+    simp
+  · have hn : j.val≠i.val := fun he=>h (Fin.ext he)
+    simp [h,hn]
+
+end ContingencyTables.ListSubtractProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ListWordProgram.lean

@@ -0,0 +1,88 @@
+import OAI.Combinatorics.ContingencyTables.Transport.ListBitProposal
+import OAI.Combinatorics.MatchingCount.Complexity.TreeChoiceCosts
+import OAI.Combinatorics.MatchingCount.Machines.TreeSum
+
+namespace OAI
+
+/-! # Binary execution of the finite-list proposal
+
+The list is scanned only up to its own length. A binary index beyond the
+end produces `none`; its numerical magnitude never determines a loop bound.
+-/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+open scoped BigOperators
+
+variable {A : Type} [Codec A] [Inhabited A]
+
+def getOptionFast : Realizer (fun x : List A×ℕ => x.1[x.2]?) :=
+  (choose (composition (pair second (composition first listLength)) less)
+    (composition (getDFast default) TreeTyped.some) (constant none)).congr (by
+      intro x
+      simp only [Function.comp_apply,decide_eq_true_eq]
+      by_cases h : x.2<x.1.length
+      · rw [ite_eq_left h,List.getD_eq_getElem?_getD,List.getElem?_eq_getElem h]
+        rfl
+      · rw [ite_eq_right h,List.getElem?_eq_none (by omega)])
+
+theorem polynomial_getOptionFast : PolynomialTime (getOptionFast (A := A)) := by
+  unfold getOptionFast
+  exact polynomial_congr _ (polynomial_choose
+    (polynomial_composition (polynomial_pair polynomial_second
+      (polynomial_composition polynomial_first polynomial_listLength)) polynomial_less)
+    (polynomial_composition (polynomial_getDFast default) polynomial_some)
+    (polynomial_constant none))
+
+def listWordChoice (x : List A×List Bool) : Option A :=
+  x.1[StackAddition.value x.2]?
+
+def listWordChoiceRealizer : Realizer (listWordChoice (A := A)) :=
+  composition (pair first (composition second bitValue)) getOptionFast
+
+theorem polynomial_listWordChoice : PolynomialTime (listWordChoiceRealizer (A := A)) :=
+  polynomial_composition
+    (polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_bitValue))
+    polynomial_getOptionFast
+
+omit [Codec A] [Inhabited A] in
+lemma bitValue_eq_word (k : ℕ) (bits : Fin k → Bool) :
+    StackAddition.value (List.ofFn bits)=(FairBits.binaryWordEquiv k bits).val := by
+  have hv (k : ℕ) (bits : Fin k → Bool) :
+      StackAddition.value (List.ofFn bits)=∑ i, (bits i).toNat*2^i.val := by
+    induction k with
+    | zero => simp [StackAddition.value]
+    | succ k ih =>
+      rw [List.ofFn_succ,StackAddition.value,ih,Fin.sum_univ_succ]
+      simp only [Fin.val_zero,pow_zero,Nat.mul_one,Fin.val_succ,pow_succ]
+      rw [Finset.mul_sum]
+      congr 1
+      apply Finset.sum_congr rfl
+      intro i _
+      ring
+  rw [hv]
+  change _=∑ i : Fin k, (finTwoEquiv.symm (bits i)).val*2^i.val
+  apply Finset.sum_congr rfl
+  intro i _
+  cases bits i <;> rfl
+
+omit [Codec A] [Inhabited A] in
+theorem listWordChoice_ofFn (xs : List A) (k : ℕ) (bits : Fin k → Bool) :
+    listWordChoice (xs,List.ofFn bits)=FairBits.listBitDraw xs k bits := by
+  simp only [listWordChoice,FairBits.listBitDraw,bitValue_eq_word]
+
+omit [Codec A] [Inhabited A] in
+/-- The literal binary program has the previously proved dyadic proposal
+law, including all unused indices that return `none`. -/
+theorem listWordChoice_mass [Fintype A] [DecidableEq A]
+    (xs : List A) (hxs : xs.Nodup) (k : ℕ) (hk : xs.length≤2^k) (a : A) :
+    (FirstSuccess.mapLaw
+      (FirstSuccess.uniformLaw (α := Fin k → Bool))
+      (fun bits => listWordChoice (xs,List.ofFn bits))).mass (some a)=
+        if a∈xs then 1/(2:ℚ)^k else 0 := by
+  simp_rw [listWordChoice_ofFn]
+  exact FairBits.listBitDraw_mass xs hxs k hk a
+
+end ContingencyTables.ProfilePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/LiteralProgram.lean

@@ -0,0 +1,144 @@
+import OAI.Combinatorics.MatchingCount.Tapes.PackedExecution
+import OAI.Combinatorics.MatchingCount.Machines.OnlinePhysicalProgram
+import OAI.Combinatorics.MatchingCount.Machines.PhysicalProgramMap
+import OAI.Combinatorics.MatchingCount.Machines.PhysicalProgramSeal
+
+namespace OAI
+
+/-! # Public binary input and output for typed finite programs
+
+Literal packing is independent of the counting algorithm. Its cost includes every packing, execution, and printing step.
+-/
+
+namespace ContingencyTables.LiteralProgram
+open MatchingFPRAS Turing PhysicalPost PhysicalStream LiteralPacked TreeTyped Polynomial
+
+noncomputable def pack : Program := Program.ofTM1 packCode .start (fun _ => 0)
+noncomputable def erase : Program := Program.ofTM1 (LiteralTape.eraseCode header.length) () ()
+noncomputable def unpack : Program := Program.ofTM1 unpackCode .start (fun _ => 0)
+noncomputable def post : Program := erase.seq unpack
+noncomputable def packTime (n : ℕ) : ℕ :=
+  (1+LiteralBlockMap.budget 1 (18*width) n 0)*MachineCost.programCost packCode
+noncomputable def postTime (n : ℕ) : ℕ :=
+  MachineCost.programCost (LiteralTape.eraseCode header.length)+
+    (1+LiteralBlockMap.budget (18*width) 1 n 0)*MachineCost.programCost unpackCode
+
+lemma packTime_mono {n m : ℕ} (h : n ≤ m) : packTime n ≤ packTime m := by
+  unfold packTime LiteralBlockMap.budget
+  gcongr
+
+lemma postTime_mono {n m : ℕ} (h : n ≤ m) : postTime n ≤ postTime m := by
+  unfold postTime LiteralBlockMap.budget
+  gcongr
+
+lemma pack_realizes (as : List Symbol) (ha : ∀ a∈as,a≠0) :
+    pack.Realizes (Tape.mk₁ as) (.done (Tape.mk₁ (TreePost.packed as))) (packTime as.length) :=
+  Program.realizes_TM1 _ _ _ _ _ _ _ (pack_exec as ha)
+
+lemma post_realizes (as : List Symbol) (ha : ∀ a∈as,a≠6 ∧ a≠7) :
+    post.Realizes (Tape.mk₁ (TreePost.packed as)) (.done (Tape.mk₁ as)) (postTime as.length) := by
+  have h1 : erase.Realizes (Tape.mk₁ (TreePost.packed as))
+      (.done (Tape.mk₁ (as.reverse.flatMap chunk)))
+      (MachineCost.programCost (LiteralTape.eraseCode header.length)) := by
+    rw [packed_eq]
+    exact (Program.realizes_TM1 _ _ _ _ _ _ _
+      (LiteralTape.erase_exec header (as.reverse.flatMap chunk))).mono (by simp only [Nat.one_mul]; rfl)
+  have h2 : unpack.Realizes (Tape.mk₁ (as.reverse.flatMap chunk)) (.done (Tape.mk₁ as))
+      ((1+LiteralBlockMap.budget (18*width) 1 as.length 0)*MachineCost.programCost unpackCode) :=
+    Program.realizes_TM1 _ _ _ _ _ _ _ (unpack_exec as ha)
+  exact Program.seq_realizes erase unpack _ (.done (Tape.mk₁ (as.reverse.flatMap chunk)))
+    (fun _ => .done (Tape.mk₁ as)) _ _ h1 h2
+
+noncomputable def wrap {f : List Symbol → Experiment (List Symbol)}
+    (F : OnlineTree.Realizer f) : Program := (pack.seq (OnlineTree.physicalProgram F)).seq post
+
+noncomputable def wrapTime {f : List Symbol → Experiment (List Symbol)}
+    (F : OnlineTree.Realizer f) (as : List Symbol) : ℕ :=
+  packTime as.length+OnlineTree.physicalCost F as+postTime ((f as).worst List.length)
+
+private lemma experiment_all_and {A : Type} {p : Experiment A} {P Q : A → Prop}
+    (hp : p.All P) (hq : p.All Q) : p.All (fun a => P a ∧ Q a) := by
+  induction p with
+  | done a => exact ⟨hp,hq⟩
+  | read p ih => exact ⟨ih false hp.1 hq.1,ih true hp.2 hq.2⟩
+  | delay n p ih => exact ih hp hq
+
+lemma wrap_realizes {f : List Symbol → Experiment (List Symbol)}
+    (F : OnlineTree.Realizer f) (as : List Symbol) (ha : ∀ a∈as,a≠0)
+    (hout : (f as).All (fun bs => ∀ b∈bs,b≠6 ∧ b≠7)) :
+    (wrap F).Realizes (Tape.mk₁ as) ((f as).map Tape.mk₁) (wrapTime F as) := by
+  have h1 : (pack.seq (OnlineTree.physicalProgram F)).Realizes (Tape.mk₁ as)
+      ((f as).map (fun bs => Tape.mk₁ (TreePost.packed bs)))
+      (packTime as.length+OnlineTree.physicalCost F as) :=
+    Program.seq_realizes pack (OnlineTree.physicalProgram F) _ (.done (Tape.mk₁ (TreePost.packed as)))
+      (fun _ => (f as).map (fun bs => Tape.mk₁ (TreePost.packed bs))) _ _
+      (pack_realizes as ha) (OnlineTree.physical_realizes F as)
+  exact Program.seq_realizes_map _ _ _ (f as) (fun bs => Tape.mk₁ (TreePost.packed bs))
+    (fun bs => .done (Tape.mk₁ bs)) _ _ h1
+    ((experiment_all_and hout (Experiment.all_worst (f as) List.length)).mono
+      (fun bs hbs => (post_realizes bs hbs.1).mono (postTime_mono hbs.2)))
+
+/-- A polynomial representing the exact elementary block-map cost. -/
+noncomputable def budgetPolynomial (w H : ℕ) (p q : Polynomial ℕ) : Polynomial ℕ :=
+  (p+1)*(C (3+w+H)+2*(q+p*C (H+w)))
+
+lemma eval_budgetPolynomial (w H : ℕ) (p q : Polynomial ℕ) (n : ℕ) :
+    (budgetPolynomial w H p q).eval n=LiteralBlockMap.budget w H (p.eval n) (q.eval n) := by
+  simp only [budgetPolynomial,LiteralBlockMap.budget,eval_mul,eval_add,eval_C,eval_one,eval_ofNat]
+
+/-- Any polynomial bound on the typed experiment gives a polynomial bound
+on the complete public binary execution. -/
+theorem polynomial_wrap {f : List Symbol → Experiment (List Symbol)}
+    (F : OnlineTree.Realizer f) (p : Polynomial ℕ)
+    (hp : ∀ as,F.cost as+(f as).worst weight ≤ p.eval (weight as)) :
+    ∃ q : Polynomial ℕ,∀ as,wrapTime F as ≤ q.eval as.length := by
+  let b : Polynomial ℕ := 18*X+1
+  let v := p.comp b
+  let a := OnlineStack.accesses F.program.code
+  let o := OnlineStack.overhead F.program.code
+  let pk : Polynomial ℕ := (1+budgetPolynomial 1 (18*width) X 0)*C (MachineCost.programCost packCode)
+  let out : Polynomial ℕ := C (MachineCost.programCost (LiteralTape.eraseCode header.length))+
+    (1+budgetPolynomial (18*width) 1 v 0)*C (MachineCost.programCost unpackCode)
+  let fac : Polynomial ℕ := C o*(1+2*C a*(b+v*C a+1))+1
+  refine ⟨pk+v*fac+out,fun as => ?_⟩
+  have hv : v.eval as.length=p.eval (weight as) := by
+    simp only [v,b,eval_comp,eval_add,eval_mul,eval_ofNat,eval_X,eval_one,LiteralCodec.weight_word]
+  have hc : F.cost as ≤ v.eval as.length := by rw [hv]; exact (Nat.le_add_right _ _).trans (hp as)
+  have hw : (f as).worst weight ≤ v.eval as.length := by rw [hv]; exact (Nat.le_add_left _ _).trans (hp as)
+  have hl : (f as).worst List.length ≤ v.eval as.length :=
+    Experiment.worst_le _ _ _ ((Experiment.all_worst _ weight).mono
+      (fun bs hbs => (list_length_le_weight bs).trans (hbs.trans hw)))
+  have hf : OnlineStack.Executes.factor F.program.code (weight as) (F.cost as) ≤ fac.eval as.length := by
+    have he : fac.eval as.length=OnlineStack.Executes.factor F.program.code (weight as) (v.eval as.length) := by
+      simp only [fac,b,eval_add,eval_mul,eval_C,eval_ofNat,eval_one,eval_X,
+        OnlineStack.Executes.factor,LiteralCodec.weight_word,a,o]
+    rw [he]
+    exact OnlineStack.Executes.factor_mono _ _ _ _ le_rfl hc
+  have hpk : pk.eval as.length=packTime as.length := by
+    simp only [pk,eval_mul,eval_add,eval_one,eval_C,eval_budgetPolynomial,eval_X,eval_zero,packTime]
+  have hout : out.eval as.length=postTime (v.eval as.length) := by
+    simp only [out,eval_add,eval_mul,eval_one,eval_C,eval_budgetPolynomial,eval_zero,postTime]
+  simp only [eval_add,eval_mul,hpk,hout]
+  unfold wrapTime OnlineTree.physicalCost
+  exact Nat.add_le_add (Nat.add_le_add_left (Nat.mul_le_mul hc hf) _) (postTime_mono hl)
+
+/-- Deterministic typed programs therefore execute on the public binary
+tape with one fixed finite transition table and a polynomial time bound. -/
+theorem deterministic_compiles {f : List Symbol → List Symbol}
+    (F : TreeTyped.Realizer f) (hF : PolynomialTime F)
+    (hout : ∀ as,∀ b∈f as,b≠6 ∧ b≠7) :
+    ∃ (A : RandomMachine) (q : Polynomial ℕ),∀ as,(∀ a∈as,a≠0) →
+      ∀ t,q.eval as.length ≤ t → ∀ bits : Fin t → Bool,
+      (run A as bits).state=none ∧ (run A as bits).tape.right₀=ListBlank.mk (f as) := by
+  obtain ⟨p,hp⟩ := hF
+  obtain ⟨q,hq⟩ := polynomial_wrap (OnlineTree.deterministic F) p hp
+  refine ⟨(wrap (OnlineTree.deterministic F)).machine,q,?_⟩
+  intro as ha t ht bits
+  have hr := wrap_realizes (OnlineTree.deterministic F) as ha (hout as)
+  apply hr.run_all (fun T => T.right₀=ListBlank.mk (f as)) _ t ((hq as).trans ht) bits
+  change (Tape.mk₁ (f as)).right₀=ListBlank.mk (f as)
+  simp only [Tape.mk₁,Tape.mk₂,Tape.mk'_right₀]
+
+end ContingencyTables.LiteralProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/LowerCapacityProgram.lean

@@ -0,0 +1,111 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ListSubtractProgram
+
+namespace OAI
+
+/-! # Executable subtraction of a lower bound from a capacity matrix -/
+
+namespace ContingencyTables.LowerCapacityProgram
+
+open MatchingFPRAS.TreeTyped Polynomial ResidualGraphProgram
+
+abbrev Input := (NatMatrix×(ℕ×ℕ))×ℕ
+abbrev RowInput := Input×ℕ
+
+def readRow (z : RowInput) : List ℕ := z.1.1.1.getD z.2 []
+
+def readRowRealizer : Realizer readRow :=
+  composition (pair (composition (composition first first) first) second) (getDFast [])
+
+lemma polynomial_readRow : PolynomialTime readRowRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_first) polynomial_second) (polynomial_getDFast [])
+
+def selected (z : RowInput) : Bool := decide (z.2=z.1.1.2.1)
+
+def selectedRealizer : Realizer selected :=
+  composition (pair second (composition (composition (composition first first) second) first)) natEqual
+
+lemma polynomial_selected : PolynomialTime selectedRealizer :=
+  polynomial_composition (polynomial_pair polynomial_second
+    (polynomial_composition
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_second) polynomial_first)) polynomial_natEqual
+
+def shiftedInput (z : RowInput) : ListSubtractProgram.Input :=
+  ((readRow z,z.1.1.2.2),z.1.2)
+
+def shiftedInputRealizer : Realizer shiftedInput :=
+  pair (pair readRowRealizer
+    (composition (composition (composition first first) second) second))
+    (composition first second)
+
+lemma polynomial_shiftedInput : PolynomialTime shiftedInputRealizer :=
+  polynomial_pair (polynomial_pair polynomial_readRow
+    (polynomial_composition
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_second) polynomial_second))
+    (polynomial_composition polynomial_first polynomial_second)
+
+def row (z : RowInput) : List ℕ :=
+  if z.2=z.1.1.2.1 then ListSubtractProgram.subtractAt (shiftedInput z) else readRow z
+
+def rowRealizer : Realizer row :=
+  (choose selectedRealizer
+    (composition (f := shiftedInput) (g := ListSubtractProgram.subtractAt)
+      shiftedInputRealizer ListSubtractProgram.subtractAtRealizer) readRowRealizer).congr (by
+        intro z
+        simp only [Function.comp_apply,row,selected,decide_eq_true_eq])
+
+lemma polynomial_row : PolynomialTime rowRealizer :=
+  polynomial_congr _ (polynomial_choose polynomial_selected
+    (polynomial_composition polynomial_shiftedInput ListSubtractProgram.polynomial_subtractAt)
+    polynomial_readRow)
+
+def indices (z : Input) : List ℕ := List.range z.1.1.length
+
+def indicesRealizer : Realizer indices :=
+  composition (composition (composition first first) listLength) range
+
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1.1).trans ((weight_fst z.1).trans (weight_fst z))
+
+def matrix (z : Input) : NatMatrix := (indices z).map (fun i=>row (z,i))
+def matrixRealizer : Realizer matrix :=
+  composition (pair identity indicesRealizer) (mapWith rowRealizer)
+lemma polynomial_matrix : PolynomialTime matrixRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
+    (polynomial_mapWith polynomial_row)
+
+lemma matrix_code {m n : ℕ} (b : Fin m→Fin n→ℕ) (i₀ : Fin m) (j₀ : Fin n) (t : ℕ) :
+    matrix ((natCode b,(i₀.val,j₀.val)),t)=natCode (BoundedCellShift.lower b i₀ j₀ t) := by
+  simp only [matrix,indices,natCode,List.length_ofFn,DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,
+    List.map_ofFn]
+  apply congrArg List.ofFn
+  funext i
+  dsimp only [Function.comp_apply]
+  have hr : readRow ((((List.ofFn (fun i=>List.ofFn (b i)),(i₀.val,j₀.val)),t),i.val))=
+      List.ofFn (b i) := by
+    simp only [readRow,List.getD_eq_getElem?_getD,List.getElem?_ofFn,i.isLt,
+      dite_true,Option.getD_some,Fin.eta]
+  by_cases hi : i=i₀
+  · subst i
+    simp only [row,ite_true,shiftedInput,hr]
+    rw [ListSubtractProgram.subtractAt_ofFn]
+    apply congrArg List.ofFn
+    funext j
+    simp [BoundedCellShift.margin,BoundedCellShift.lower]
+  · have hn : i.val≠i₀.val := fun he=>hi (Fin.ext he)
+    simp only [row,hn,ite_false,hr]
+    apply congrArg List.ofFn
+    funext j
+    simp [BoundedCellShift.lower,hi]
+
+end ContingencyTables.LowerCapacityProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/MatrixCodeEquality.lean

@@ -0,0 +1,45 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.ProfileCodeEquality
+import OAI.Combinatorics.ContingencyTables.Dense.DenseIntegerProgram
+
+namespace OAI
+
+/-! # Polynomial equality of explicitly stored rectangular arrays -/
+
+namespace ContingencyTables.DensePrograms
+open MatchingFPRAS.TreeTyped
+
+def matrixSignature (X : MatrixCode) : List ℕ×List ℕ := (X.map List.length,X.flatten)
+
+def matrixSignatureRealizer : Realizer matrixSignature := pair (map listLength) flatten
+
+lemma polynomial_matrixSignature : PolynomialTime matrixSignatureRealizer :=
+  polynomial_pair (polynomial_map polynomial_listLength) polynomial_flatten
+
+lemma matrixSignature_injective : Function.Injective matrixSignature := by
+  intro X Y h
+  exact List.eq_iff_flatten_eq.mpr ⟨congrArg Prod.snd h,congrArg Prod.fst h⟩
+
+def matrixEqual : Realizer (fun z : MatrixCode×MatrixCode => decide (z.1=z.2)) :=
+  (composition (pair (composition first matrixSignatureRealizer)
+    (composition second matrixSignatureRealizer)) ProfilePrograms.profileCodeEqual).congr (by
+      intro z
+      simp only [Function.comp_apply,matrixSignature_injective.eq_iff])
+
+lemma polynomial_matrixEqual : PolynomialTime matrixEqual := by
+  unfold matrixEqual
+  apply polynomial_congr
+  exact polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_matrixSignature)
+    (polynomial_composition polynomial_second polynomial_matrixSignature))
+    ProfilePrograms.polynomial_profileCodeEqual
+
+lemma matrixCode_injective {m n : ℕ} :
+    Function.Injective (matrixCode (m := m) (n := n)) := by
+  intro X Y h
+  have hi := List.ofFn_injective h
+  funext i
+  exact List.ofFn_injective (congrFun hi i)
+
+end ContingencyTables.DensePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/MatrixEncoding.lean

@@ -0,0 +1,63 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.GreedyPublicProgram
+
+namespace OAI
+
+/-! # The public matrix encoding uniquely identifies a fixed-shape table -/
+
+namespace ContingencyTables.Algorithms
+open MatchingFPRAS MatchingFPRAS.LiteralParse Turing
+
+lemma encodeMatrix_flat {m n : ℕ} (X : Fin m → Fin n → ℕ) :
+    encodeMatrix X=((List.ofFn fun i => List.ofFn (X i)).flatten).flatMap encodeNat := by
+  rw [←GreedyFeasibleTable.printMatrix_ofFn]
+  simp only [GreedyFeasibleTable.printMatrix,List.flatten_eq_flatMap,List.flatMap_assoc,id_eq]
+
+lemma matrix_flat_injective (m n : ℕ) (X Y : Fin m → Fin n → ℕ)
+    (h : (List.ofFn (fun i => List.ofFn (X i))).flatten=
+      (List.ofFn (fun i => List.ofFn (Y i))).flatten) : X=Y := by
+  have hr : List.ofFn (fun i => List.ofFn (X i))=List.ofFn (fun i => List.ofFn (Y i)) :=
+    List.eq_iff_flatten_eq.mpr ⟨h,by
+      simp only [List.map_ofFn]
+      congr 1
+      funext i
+      exact (List.length_ofFn).trans (List.length_ofFn.symm)⟩
+  have hf := List.ofFn_injective hr
+  funext i
+  exact List.ofFn_injective (congrFun hf i)
+
+lemma encodeMatrix_injective {m n : ℕ} :
+    Function.Injective (encodeMatrix (m := m) (n := n)) := by
+  intro X Y h
+  have hp := congrArg parse h
+  rw [encodeMatrix_flat,encodeMatrix_flat,GreedyFeasibleTable.parse_natWords,
+    GreedyFeasibleTable.parse_natWords] at hp
+  exact matrix_flat_injective m n X Y hp
+
+lemma parse_blank_extension (as : List Symbol) (n : ℕ) :
+    parse (as++List.replicate n (0:Symbol))=parse as := by
+  have hz : (List.replicate n (0:Symbol)).foldr (fun a ns => numStep (a,ns)) []=[] := by
+    induction n with
+    | zero => rfl
+    | succ n ih =>
+      simp only [List.replicate_succ,List.foldr_cons,ih]
+      rfl
+  unfold parse
+  rw [List.foldr_append,hz]
+
+/-- Parsing natural-number fields is unchanged by trailing tape blanks. -/
+def blankNumbers (tape : ListBlank Symbol) : List ℕ :=
+  tape.liftOn parse (by
+    rintro as _ ⟨n,rfl⟩
+    exact (parse_blank_extension as n).symm)
+
+lemma blankMatrix_injective {m n : ℕ} (X Y : Fin m → Fin n → ℕ)
+    (h : ListBlank.mk (encodeMatrix X)=ListBlank.mk (encodeMatrix Y)) : X=Y := by
+  have hp := congrArg blankNumbers h
+  change parse (encodeMatrix X)=parse (encodeMatrix Y) at hp
+  rw [encodeMatrix_flat,encodeMatrix_flat,GreedyFeasibleTable.parse_natWords,
+    GreedyFeasibleTable.parse_natWords] at hp
+  exact matrix_flat_injective m n X Y hp
+
+end ContingencyTables.Algorithms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/MatrixSubtractProgram.lean

@@ -0,0 +1,99 @@
+import OAI.Combinatorics.ContingencyTables.Dense.DenseIntegerProgram
+import OAI.Combinatorics.ContingencyTables.Transport.DirectedBFSCode
+import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialGrid
+
+namespace OAI
+
+/-! # Entrywise natural subtraction on a supplied matrix shape -/
+
+namespace ContingencyTables.MatrixSubtractProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial DensePrograms
+
+abbrev Input := MatrixCode × MatrixCode
+abbrev RowInput := Input × ℕ
+
+def entry (z : RowInput × ℕ) : ℕ :=
+  matrixEntry (z.1.1.1,(z.1.2,z.2))-matrixEntry (z.1.1.2,(z.1.2,z.2))
+def entryRealizer : Realizer entry := by
+  let left : Realizer (fun z : RowInput × ℕ => matrixEntry (z.1.1.1,(z.1.2,z.2))) :=
+    composition (f := fun z : RowInput × ℕ => (z.1.1.1,(z.1.2,z.2))) (g := matrixEntry)
+      (pair (composition (composition first first) first)
+        (pair (composition first second) second)) matrixEntryRealizer
+  let right : Realizer (fun z : RowInput × ℕ => matrixEntry (z.1.1.2,(z.1.2,z.2))) :=
+    composition (f := fun z : RowInput × ℕ => (z.1.1.2,(z.1.2,z.2))) (g := matrixEntry)
+      (pair (composition (composition first first) second)
+        (pair (composition first second) second)) matrixEntryRealizer
+  exact composition (f := fun z : RowInput × ℕ =>
+    (matrixEntry (z.1.1.1,(z.1.2,z.2)),matrixEntry (z.1.1.2,(z.1.2,z.2))))
+    (g := fun p : ℕ × ℕ => p.1-p.2) (pair left right) subtract
+lemma polynomial_entry : PolynomialTime entryRealizer := by
+  unfold entryRealizer
+  exact polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_first)
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        polynomial_second)) polynomial_matrixEntry)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_second)
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        polynomial_second)) polynomial_matrixEntry)) polynomial_subtract
+
+def sourceRow (z : RowInput) : List ℕ := z.1.1.getD z.2 []
+def sourceRowRealizer : Realizer sourceRow :=
+  composition (pair (composition first first) second) (getDFast [])
+lemma polynomial_sourceRow : PolynomialTime sourceRowRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+    (polynomial_getDFast [])
+
+def columns (z : RowInput) : List ℕ := List.range (sourceRow z).length
+def columnsRealizer : Realizer columns :=
+  composition (f := sourceRow) (g := fun xs : List ℕ => List.range xs.length)
+    sourceRowRealizer (composition listLength range)
+lemma polynomial_columns : PolynomialTime columnsRealizer := by
+  apply polynomial_composition polynomial_sourceRow
+  apply polynomial_boundedRange polynomial_listLength X
+  intro xs
+  simpa only [eval_X] using list_length_le_weight xs
+
+def row (z : RowInput) : List ℕ := (columns z).map (fun j => entry (z,j))
+def rowRealizer : Realizer row :=
+  composition (pair identity columnsRealizer) (mapWith entryRealizer)
+lemma polynomial_row : PolynomialTime rowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_columns)
+    (polynomial_mapWith polynomial_entry)
+
+def indices (z : Input) : List ℕ := List.range z.1.length
+def indicesRealizer : Realizer indices := composition (composition first listLength) range
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange (polynomial_composition polynomial_first polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1).trans (weight_fst z)
+
+def matrix (z : Input) : MatrixCode := (indices z).map (fun i => row (z,i))
+def matrixRealizer : Realizer matrix :=
+  composition (pair identity indicesRealizer) (mapWith rowRealizer)
+theorem polynomial_matrix : PolynomialTime matrixRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
+    (polynomial_mapWith polynomial_row)
+
+theorem matrix_code {m n : ℕ} (B Y : Fin m → Fin n → ℕ) :
+    matrix (matrixCode B,matrixCode Y)=matrixCode (fun i j => B i j-Y i j) := by
+  simp only [matrix,indices,matrixCode,List.length_ofFn,DirectedBFSCode.range_eq_map,
+    ←List.ofFn_eq_map,List.map_ofFn,Function.comp_def]
+  apply congrArg List.ofFn
+  funext i
+  simp only [row,columns,sourceRow,List.getD_eq_getElem?_getD,List.getElem?_ofFn,
+    i.isLt,dite_true,Option.getD_some,List.length_ofFn,DirectedBFSCode.range_eq_map,
+    ←List.ofFn_eq_map,List.map_ofFn,Function.comp_def,entry]
+  apply congrArg List.ofFn
+  funext j
+  exact congrArg₂ Nat.sub (matrixEntry_code B i j) (matrixEntry_code Y i j)
+
+end ContingencyTables.MatrixSubtractProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/MaximalListProgram.lean

@@ -0,0 +1,78 @@
+import OAI.Combinatorics.ContingencyTables.Dense.DenseExponentListProgram
+import OAI.Combinatorics.MatchingCount.Machines.TreeIndex
+
+namespace OAI
+
+/-! # Computing a maximal margin in binary -/
+
+namespace ContingencyTables.DensePrograms
+open MatchingFPRAS.TreeTyped
+
+def maximumIndex (xs : List ℕ) : ℕ := xs.idxOf (listMaximum (xs,0))
+
+def maximumIndexRealizer : Realizer maximumIndex :=
+  composition (pair (composition (pair identity (constant 0)) listMaximumRealizer) identity)
+    (indexOf natEqual)
+
+theorem polynomial_maximumIndex : PolynomialTime maximumIndexRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant 0))
+      polynomial_listMaximum) polynomial_identity) (polynomial_indexOf polynomial_natEqual)
+
+lemma listMaximum_mem_or_default (xs : List ℕ) (a : ℕ) :
+    listMaximum (xs,a)=a ∨ listMaximum (xs,a)∈xs := by
+  induction xs generalizing a with
+  | nil => exact Or.inl rfl
+  | cons b bs ih =>
+    change listMaximum (bs,max b a)=a ∨ listMaximum (bs,max b a)∈b::bs
+    rcases ih (max b a) with he|hm
+    · rw [he]
+      rcases le_total b a with h|h
+      · exact Or.inl (max_eq_right h)
+      · exact Or.inr (by simp [max_eq_left h])
+    · exact Or.inr (List.mem_cons_of_mem b hm)
+
+lemma listMaximum_mem (xs : List ℕ) (hx : xs≠[]) : listMaximum (xs,0)∈xs := by
+  cases xs with
+  | nil => exact (hx rfl).elim
+  | cons a xs =>
+    change listMaximum (xs,max a 0)∈a::xs
+    rw [Nat.max_zero]
+    rcases listMaximum_mem_or_default xs a with he|hm
+    · simp [he]
+    · exact List.mem_cons_of_mem a hm
+
+theorem maximumIndex_lt (xs : List ℕ) (hx : xs≠[]) : maximumIndex xs < xs.length :=
+  List.idxOf_lt_length_iff.mpr (listMaximum_mem xs hx)
+
+theorem maximumIndex_value (xs : List ℕ) (hx : xs≠[]) :
+    xs.getD (maximumIndex xs) 0=listMaximum (xs,0) := by
+  rw [List.getD_eq_getElem xs 0 (maximumIndex_lt xs hx)]
+  exact List.getElem_idxOf (maximumIndex_lt xs hx)
+
+theorem maximumIndex_maximal (xs : List ℕ) (hx : xs≠[]) (a : ℕ) (ha : a∈xs) :
+    a≤xs.getD (maximumIndex xs) 0 := by
+  rw [maximumIndex_value xs hx]
+  exact le_listMaximum_member xs 0 a ha
+
+def maximumPosition {n : ℕ} (f : Fin (n+1) → ℕ) : Fin (n+1) :=
+  ⟨maximumIndex (List.ofFn f),by
+    simpa only [List.length_ofFn] using maximumIndex_lt (List.ofFn f)
+      (by intro h; have := congrArg List.length h; simp only [List.length_ofFn,List.length_nil] at this; omega)⟩
+
+theorem maximumPosition_spec {n : ℕ} (f : Fin (n+1) → ℕ) (i : Fin (n+1)) :
+    f i≤f (maximumPosition f) := by
+  have hx : List.ofFn f≠[] := by
+    intro h
+    have := congrArg List.length h
+    simp only [List.length_ofFn,List.length_nil] at this
+    omega
+  have hm := maximumIndex_maximal (List.ofFn f) hx (f i) (List.mem_ofFn.mpr ⟨i,rfl⟩)
+  have he : (List.ofFn f).getD (maximumIndex (List.ofFn f)) 0=f (maximumPosition f) := by
+    rw [List.getD_eq_getElem (List.ofFn f) 0 (maximumIndex_lt (List.ofFn f) hx),List.getElem_ofFn]
+    rfl
+  rwa [he] at hm
+
+end ContingencyTables.DensePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/MedianFractionProgram.lean

@@ -0,0 +1,248 @@
+import OAI.Combinatorics.MatchingCount.Complexity.TreeFractionCosts
+import OAI.Combinatorics.MatchingCount.Machines.TreeFastLookup
+import OAI.Combinatorics.MatroidCounting.CommonBases
+
+namespace OAI
+
+/-! # Binary fraction median with polynomial running time -/
+
+namespace ContingencyTables.MedianFractionProgram
+open MatchingFPRAS MatchingFPRAS.TreeTyped MatchingFPRAS.TreeFraction Polynomial
+
+abbrev State := Fraction × (List Fraction × List Fraction)
+
+def insertRaw (q : Fraction) : List Fraction → List Fraction
+  | [] => [q]
+  | x::xs => if TreeFraction.less (x,q) then x::insertRaw q xs else q::x::xs
+
+def step (z : Fraction × State) : State :=
+  (z.2.1,(z.1::z.2.2.1,
+    if TreeFraction.less (z.1,z.2.1) then z.1::z.2.2.2 else z.2.1::z.1::z.2.2.1))
+
+def stepRealizer : Realizer step := by
+  let q : Realizer (fun z : Fraction × State => z.2.1) := composition second first
+  let xs : Realizer (fun z : Fraction × State => z.1::z.2.2.1) :=
+    composition (pair first (composition (composition second second) first)) listCons
+  let yes : Realizer (fun z : Fraction × State => z.1::z.2.2.2) :=
+    composition (pair first (composition (composition second second) second)) listCons
+  let no : Realizer (fun z : Fraction × State => z.2.1::z.1::z.2.2.1) :=
+    composition (pair q xs) listCons
+  exact pair q (pair xs (choose (composition (pair first q) TreeFraction.lessRealizer) yes no))
+
+lemma polynomial_step : PolynomialTime stepRealizer := by
+  unfold stepRealizer
+  exact polynomial_pair (polynomial_composition polynomial_second polynomial_first)
+    (polynomial_pair
+      (polynomial_composition (polynomial_pair polynomial_first
+        (polynomial_composition (polynomial_composition polynomial_second polynomial_second)
+          polynomial_first)) polynomial_listCons)
+      (polynomial_choose
+        (polynomial_composition (polynomial_pair polynomial_first
+          (polynomial_composition polynomial_second polynomial_first)) TreeFraction.polynomial_less)
+        (polynomial_composition (polynomial_pair polynomial_first
+          (polynomial_composition (polynomial_composition polynomial_second polynomial_second)
+            polynomial_second)) polynomial_listCons)
+        (polynomial_composition (polynomial_pair
+          (polynomial_composition polynomial_second polynomial_first)
+          (polynomial_composition (polynomial_pair polynomial_first
+            (polynomial_composition (polynomial_composition polynomial_second polynomial_second)
+              polynomial_first)) polynomial_listCons)) polynomial_listCons)))
+
+def insert (z : Fraction × List Fraction) : List Fraction :=
+  (z.2.reverse.foldl (fun s x => step (x,s)) (z.1,([],[z.1]))).2.2
+
+lemma insert_fold (q : Fraction) (xs : List Fraction) :
+    xs.reverse.foldl (fun s x => step (x,s)) (q,([],[q])) = (q,(xs,insertRaw q xs)) := by
+  induction xs with
+  | nil => rfl
+  | cons x xs ih =>
+    simp only [List.reverse_cons,List.foldl_append,ih,List.foldl_cons,List.foldl_nil]
+    rfl
+
+lemma insert_eq (q : Fraction) (xs : List Fraction) : insert (q,xs)=insertRaw q xs := by
+  unfold insert
+  rw [insert_fold]
+
+lemma insert_weight (q : Fraction) (xs : List Fraction) :
+    weight (insertRaw q xs)=1+weight q+weight xs := by
+  induction xs with
+  | nil => simp [insertRaw]
+  | cons x xs ih =>
+    simp only [insertRaw]
+    split <;> simp only [weight_cons,ih]
+    all_goals omega
+
+lemma fold_weight (xs : List Fraction) (q : Fraction) (zs ys : List Fraction) :
+    let t := xs.foldl (fun s x => step (x,s)) (q,(zs,ys))
+    t.1=q ∧ weight t.2.1+1=weight zs+weight xs ∧
+      weight t.2.2 ≤ max (weight ys) (weight q+weight zs+1)+weight xs := by
+  induction xs generalizing zs ys with
+  | nil =>
+    exact ⟨rfl,by simp only [List.foldl_nil,weight_nil],by
+      simpa only [List.foldl_nil,weight_nil] using
+        (Nat.le_max_left (weight ys) (weight q+weight zs+1)).trans (Nat.le_succ _)⟩
+  | cons x xs ih =>
+    rw [List.foldl_cons]
+    change (let t := xs.foldl (fun s x => step (x,s)) (q,(x::zs,if TreeFraction.less (x,q) then x::ys else q::x::zs));
+      t.1=q ∧ weight t.2.1+1=weight zs+weight (x::xs) ∧
+        weight t.2.2 ≤ max (weight ys) (weight q+weight zs+1)+weight (x::xs))
+    have hh := ih (x::zs) (if TreeFraction.less (x,q) then x::ys else q::x::zs)
+    dsimp only at hh ⊢
+    refine ⟨hh.1,?_,?_⟩
+    · simp only [weight_cons] at hh ⊢; omega
+    · by_cases h : TreeFraction.less (x,q)=true
+      · simp only [h,ite_true,weight_cons] at hh ⊢; omega
+      · simp only [h,Bool.false_eq_true,ite_false,weight_cons] at hh ⊢; omega
+
+lemma state_weight (s : State) :
+    weight s=1+weight s.1+(1+weight s.2.1+weight s.2.2) := by
+  rcases s with ⟨q,xs,ys⟩
+  simp only [weight_prod]
+
+lemma polynomial_stepFold : PolynomialTime (fold stepRealizer) := by
+  apply polynomial_fold polynomial_step (5*X+5)
+  intro xs s pre post he
+  rcases s with ⟨q,zs,ys⟩
+  have hh := fold_weight pre q zs ys
+  have hp := weight_prefix he
+  simp only [eval_add,eval_mul,eval_ofNat,eval_X,weight_prod]
+  rw [state_weight,hh.1]
+  omega
+
+def insertRealizer : Realizer insert := by
+  let prep : Realizer (fun z : Fraction × List Fraction => (z.2.reverse,(z.1,([],[z.1])))) :=
+    pair (composition second reverse)
+      (pair first (pair (constant ([] : List Fraction)) (composition (pair first (constant ([] : List Fraction))) listCons)))
+  let tail : Realizer (fun z : List Fraction × State =>
+      (z.1.foldl (fun s x => step (x,s)) z.2).2.2) :=
+    composition (f := fun z : List Fraction × State =>
+      (z.1.foldl (fun s x => step (x,s)) z.2).2) (g := fun z => z.2)
+      (composition (fold stepRealizer) second) second
+  exact composition
+    (f := fun z : Fraction × List Fraction => (z.2.reverse,(z.1,([],[z.1]))))
+    (g := fun z : List Fraction × State =>
+      (z.1.foldl (fun s x => step (x,s)) z.2).2.2) prep tail
+
+lemma polynomial_insert : PolynomialTime insertRealizer := by
+  unfold insertRealizer
+  exact polynomial_composition
+    (polynomial_pair (polynomial_composition polynomial_second polynomial_reverse)
+      (polynomial_pair polynomial_first (polynomial_pair (polynomial_constant ([] : List Fraction))
+        (polynomial_composition (polynomial_pair polynomial_first (polynomial_constant ([] : List Fraction)))
+          polynomial_listCons))))
+    (polynomial_composition (polynomial_composition polynomial_stepFold polynomial_second)
+      polynomial_second)
+
+def sort (xs : List Fraction) : List Fraction :=
+  xs.reverse.foldl (fun s x => insert (x,s)) []
+
+def sortRealizer : Realizer sort :=
+  composition (f := fun xs : List Fraction => (xs.reverse,([] : List Fraction)))
+    (g := fun z : List Fraction × List Fraction => z.1.foldl (fun s x => insert (x,s)) z.2)
+    (pair reverse (constant [])) (fold insertRealizer)
+
+lemma sortFold_weight (xs zs : List Fraction) :
+    weight (xs.foldl (fun s x => insert (x,s)) zs)+1=weight zs+weight xs := by
+  induction xs generalizing zs with
+  | nil => simp
+  | cons x xs ih =>
+    have hh := ih (insert (x,zs))
+    simp only [List.foldl_cons,insert_eq,insert_weight,weight_cons] at hh ⊢
+    omega
+
+lemma polynomial_insertFold : PolynomialTime (fold insertRealizer) := by
+  apply polynomial_fold polynomial_insert (2*X)
+  intro xs zs pre post he
+  have hh := sortFold_weight pre zs
+  have hp := weight_prefix he
+  simp only [eval_mul,eval_ofNat,eval_X,weight_prod]
+  omega
+
+lemma polynomial_sort : PolynomialTime sortRealizer :=
+  polynomial_composition (polynomial_pair polynomial_reverse (polynomial_constant ([] : List Fraction)))
+    polynomial_insertFold
+
+lemma insert_pos (q : Fraction) (xs : List Fraction) (hq : 0 < q.2)
+    (hx : ∀ x∈xs,0 < x.2) : ∀ y∈insertRaw q xs,0 < y.2 := by
+  induction xs with
+  | nil => simpa only [insertRaw,List.mem_singleton] using fun y hy => hy ▸ hq
+  | cons x xs ih =>
+    have hxx := hx x (by simp)
+    have ht := ih (fun y hy => hx y (by simp [hy]))
+    simp only [insertRaw]
+    split <;> intro y hy <;> simp only [List.mem_cons] at hy
+    · rcases hy with rfl|hy
+      · exact hxx
+      · exact ht y hy
+    · rcases hy with rfl|rfl|hy
+      · exact hq
+      · exact hxx
+      · exact hx y (by simp [hy])
+
+lemma insert_map (q : Fraction) (xs : List Fraction) (hq : 0 < q.2)
+    (hx : ∀ x∈xs,0 < x.2) :
+    (insertRaw q xs).map val=(xs.map val).orderedInsert (·≤·) (val q) := by
+  induction xs with
+  | nil => rfl
+  | cons x xs ih =>
+    have hxx := hx x (by simp)
+    have ht := ih (fun y hy => hx y (by simp [hy]))
+    simp only [insertRaw,List.map_cons,List.orderedInsert_cons,TreeFraction.less_val x q hxx hq]
+    by_cases h : val x < val q
+    · simp [h,not_le.mpr h,ht]
+    · simp [h,le_of_not_gt h]
+
+lemma sort_cons (x : Fraction) (xs : List Fraction) : sort (x::xs)=insert (x,sort xs) := by
+  simp only [sort,List.reverse_cons,List.foldl_append,List.foldl_cons,List.foldl_nil]
+
+lemma sort_pos (xs : List Fraction) (hx : ∀ x∈xs,0 < x.2) : ∀ y∈sort xs,0 < y.2 := by
+  induction xs with
+  | nil => simp [sort]
+  | cons x xs ih =>
+    rw [sort_cons,insert_eq]
+    exact insert_pos x (sort xs) (hx x (by simp))
+      (ih (fun y hy => hx y (by simp [hy])))
+
+lemma sort_map (xs : List Fraction) (hx : ∀ x∈xs,0 < x.2) :
+    (sort xs).map val=(xs.map val).mergeSort (·≤·) := by
+  rw [List.mergeSort_eq_insertionSort]
+  induction xs with
+  | nil => rfl
+  | cons x xs ih =>
+    have ht : ∀ y∈xs,0 < y.2 := fun y hy => hx y (by simp [hy])
+    rw [sort_cons,insert_eq,insert_map x (sort xs) (hx x (by simp)) (sort_pos xs ht),ih ht]
+    rfl
+
+def median (xs : List Fraction) : Fraction :=
+  (sort (xs.map TreeFraction.normalize)).getD (xs.length/2) (0,1)
+
+def medianRealizer : Realizer median :=
+  composition (f := fun xs : List Fraction => (sort (xs.map TreeFraction.normalize),xs.length/2))
+    (g := fun z : List Fraction × ℕ => z.1.getD z.2 (0,1)) (pair (composition (f := fun xs : List Fraction => xs.map TreeFraction.normalize)
+      (g := sort) (TreeTyped.map normalizeRealizer) sortRealizer)
+    (composition (pair listLength (constant 2)) quotient)) (getDFast (0,1))
+
+lemma polynomial_median : PolynomialTime medianRealizer :=
+  polynomial_composition
+    (polynomial_pair (polynomial_composition (polynomial_map TreeFraction.polynomial_normalize)
+      polynomial_sort)
+      (polynomial_composition (polynomial_pair polynomial_listLength (polynomial_constant 2))
+        polynomial_quotient)) (polynomial_getDFast (0,1))
+
+lemma median_val (xs : List Fraction) :
+    val (median xs)=CommonBasesFPRAS.rationalMedian (xs.map val) := by
+  have hs := sort_map (xs.map TreeFraction.normalize) (by
+    intro y hy
+    obtain ⟨x,_,rfl⟩ := List.mem_map.mp hy
+    exact normalize_den_pos x)
+  have hm : (xs.map TreeFraction.normalize).map val=xs.map val := by
+    simp only [List.map_map,Function.comp_def,normalize_val]
+  rw [hm] at hs
+  unfold median CommonBasesFPRAS.rationalMedian
+  rw [←hs,List.length_map]
+  simp only [List.getD_eq_getElem?_getD,List.getElem?_map]
+  cases (sort (xs.map TreeFraction.normalize))[xs.length/2]? <;> simp only [Option.getD_none,Option.map_none,Option.getD_some,Option.map_some,val, Nat.cast_zero,zero_div]
+
+end ContingencyTables.MedianFractionProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/NatListEquality.lean

@@ -0,0 +1,74 @@
+import OAI.Combinatorics.ContingencyTables.Machines.IntegerMatrixProgram
+
+namespace OAI
+
+/-! # Binary list equality for matching tabulated states and outputs -/
+
+namespace ContingencyTables.NatListEquality
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+def indices (z : List ℕ×List ℕ) : List ℕ := List.range z.1.length
+
+def indicesRealizer : Realizer indices := composition (composition first listLength) range
+
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange (polynomial_composition polynomial_first polynomial_listLength)
+    Polynomial.X
+  intro z
+  simpa only [Polynomial.eval_X,Function.comp_apply] using
+    (list_length_le_weight z.1).trans (weight_fst z)
+
+def atEqual (z : (List ℕ×List ℕ)×ℕ) : Bool := decide (z.1.1.getD z.2 0=z.1.2.getD z.2 0)
+
+def atEqualRealizer : Realizer atEqual :=
+  composition (pair
+    (composition (pair (composition first first) second) (getDFast 0))
+    (composition (pair (composition first second) second) (getDFast 0))) natEqual
+
+lemma polynomial_atEqual : PolynomialTime atEqualRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+      (polynomial_getDFast 0))
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_second) polynomial_second)
+      (polynomial_getDFast 0))) polynomial_natEqual
+
+def listEqual (z : List ℕ×List ℕ) : Bool :=
+  decide (z.1.length=z.2.length) && (indices z).all (fun i => atEqual (z,i))
+
+def listEqualRealizer : Realizer listEqual :=
+  (composition (pair
+    (composition (pair (composition first listLength) (composition second listLength)) natEqual)
+    (composition (composition (pair identity indicesRealizer) (mapWith atEqualRealizer)) all))
+    boolAnd).congr (by
+      intro z
+      simp only [Function.comp_apply,List.all_map,Function.comp_def,id_eq,listEqual])
+
+theorem polynomial_listEqual : PolynomialTime listEqualRealizer := by
+  unfold listEqualRealizer
+  apply polynomial_congr
+  exact polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_listLength)
+      (polynomial_composition polynomial_second polynomial_listLength)) polynomial_natEqual)
+    (polynomial_composition (polynomial_composition
+      (polynomial_pair polynomial_identity polynomial_indices)
+      (polynomial_mapWith polynomial_atEqual)) polynomial_all)) polynomial_boolAnd
+
+theorem listEqual_true (xs ys : List ℕ) : listEqual (xs,ys)=true ↔ xs=ys := by
+  simp only [listEqual,Bool.and_eq_true,decide_eq_true_eq,List.all_eq_true]
+  constructor
+  · rintro ⟨hlen,h⟩
+    apply List.ext_getElem hlen
+    intro i hi hj
+    have hv:=of_decide_eq_true (h i (List.mem_range.mpr hi))
+    simpa only [atEqual,List.getD_eq_getElem?_getD,List.getElem?_eq_getElem hi,
+      List.getElem?_eq_getElem hj,Option.getD_some] using hv
+  · intro h
+    subst ys
+    exact ⟨rfl,fun _ _ => by simp [atEqual]⟩
+
+end ContingencyTables.NatListEquality
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/NaturalBlockProgram.lean

@@ -0,0 +1,95 @@
+import OAI.Combinatorics.ContingencyTables.Machines.DependentWordProgram
+import Mathlib.Data.List.SplitLengths
+
+namespace OAI
+
+/-! # Bounded scans of natural-number blocks
+
+Numeric widths select bounded slices of the supplied list. They never
+control an allocation, so malformed widths preserve polynomial cost.
+-/
+
+namespace ContingencyTables.NaturalBlockProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial
+
+abbrev Input := List ℕ × List ℕ
+abbrev Entry := Input × ℕ
+
+def start (z : Entry) : ℕ := (z.1.1.take z.2).sum
+def startRealizer : Realizer start :=
+  composition (composition (pair (composition first first) second) takeFast) listSum
+lemma polynomial_start : PolynomialTime startRealizer :=
+  polynomial_composition (polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+    polynomial_takeFast) polynomial_listSum
+
+def block (z : Entry) : List ℕ :=
+  (z.1.2.drop (start z)).take (z.1.1.getD z.2 0)
+def blockRealizer : Realizer block :=
+  composition (pair
+    (composition (pair (composition first second) startRealizer) dropFast)
+    (composition (pair (composition first first) second) (getDFast 0))) takeFast
+lemma polynomial_block : PolynomialTime blockRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_second) polynomial_start)
+      polynomial_dropFast)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+      (polynomial_getDFast 0))) polynomial_takeFast
+
+def indices (z : Input) : List ℕ := List.range z.1.length
+def indicesRealizer : Realizer indices := composition (composition first listLength) range
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange (polynomial_composition polynomial_first polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1).trans (weight_fst z)
+
+def blocks (z : Input) : List (List ℕ) := (indices z).map (fun i => block (z,i))
+def blocksRealizer : Realizer blocks :=
+  composition (pair identity indicesRealizer) (mapWith blockRealizer)
+theorem polynomial_blocks : PolynomialTime blocksRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_indices)
+    (polynomial_mapWith polynomial_block)
+
+lemma block_splitLengths (widths values : List ℕ) (i : ℕ) :
+    block ((widths,values),i)=(widths.splitLengths values).getD i [] := by
+  induction widths generalizing values i with
+  | nil => simp [block,start]
+  | cons w ws ih =>
+    cases i with
+    | zero => simp [block,start,List.splitLengths_cons]
+    | succ i =>
+      simpa only [block,start,List.take_succ_cons,List.sum_cons,List.getD_cons_succ,
+        List.splitLengths_cons,List.drop_drop,Nat.add_comm] using ih (values.drop w) i
+
+theorem blocks_eq_splitLengths (widths values : List ℕ) :
+    blocks (widths,values)=widths.splitLengths values := by
+  apply List.ext_getElem
+  · simp [blocks,indices]
+  · intro i hi hj
+    have hiw : i < widths.length := by
+      simpa only [blocks,indices,List.length_map,List.length_range] using hi
+    simp only [blocks,indices,List.getElem_map,List.getElem_range]
+    have h := block_splitLengths widths values i
+    simpa only [List.getD_eq_getElem?_getD,List.getElem?_eq_getElem hj,Option.getD_some] using h
+
+lemma splitLengths_flatten (rows : List (List ℕ)) :
+    (rows.map List.length).splitLengths rows.flatten=rows := by
+  induction rows with
+  | nil => rfl
+  | cons row rows ih =>
+    simpa only [List.map_cons,List.flatten_cons,List.splitLengths_cons,
+      List.take_left,List.drop_left] using congrArg (List.cons row) ih
+
+/-- A literal list of rows is recovered exactly from its stored row
+lengths and its flattened code, including rows of length zero. -/
+theorem blocks_flatten (rows : List (List ℕ)) :
+    blocks (rows.map List.length,rows.flatten)=rows := by
+  rw [blocks_eq_splitLengths,splitLengths_flatten]
+
+end ContingencyTables.NaturalBlockProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/NetworkCapacityProgram.lean

@@ -0,0 +1,233 @@
+import OAI.Combinatorics.ContingencyTables.Transport.NetworkVertexCode
+import OAI.Combinatorics.ContingencyTables.Machines.FlowLoopProgram
+
+namespace OAI
+
+/-! # Constructing the bounded-table capacity network in binary -/
+
+namespace ContingencyTables.NetworkCapacityProgram
+
+open MatchingFPRAS.TreeTyped Polynomial NetworkVertexCode ResidualGraphProgram
+
+abbrev EntryInput := Input×(ℕ×ℕ)
+
+def kindRealizer : Realizer (fun z : ℕ×ℕ=>kind z.1 z.2) :=
+  (choose (composition (pair second (constant 0)) natEqual) (constant 0)
+    (choose (composition (pair second (constant 1)) natEqual) (constant 1)
+      (choose (composition (pair second (composition (pair (constant 2) first) add)) less)
+        (constant 2) (constant 3)))).congr (by
+          intro z
+          simp only [Function.comp_apply,kind,decide_eq_true_eq])
+
+lemma polynomial_kind : PolynomialTime kindRealizer :=
+  polynomial_congr _ (polynomial_choose
+    (polynomial_composition (polynomial_pair polynomial_second (polynomial_constant 0))
+      polynomial_natEqual) (polynomial_constant 0)
+    (polynomial_choose
+      (polynomial_composition (polynomial_pair polynomial_second (polynomial_constant 1))
+        polynomial_natEqual) (polynomial_constant 1)
+      (polynomial_choose
+        (polynomial_composition (polynomial_pair polynomial_second
+          (polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_first)
+            polynomial_add)) polynomial_less)
+        (polynomial_constant 2) (polynomial_constant 3))))
+
+def rowCount (z : EntryInput) : ℕ := z.1.1.1.length
+
+def rowCountRealizer : Realizer rowCount :=
+  composition (composition (composition first first) first) listLength
+
+lemma polynomial_rowCount : PolynomialTime rowCountRealizer :=
+  polynomial_composition (polynomial_composition
+    (polynomial_composition polynomial_first polynomial_first) polynomial_first)
+    polynomial_listLength
+
+def columnBase (z : EntryInput) : ℕ := 2+rowCount z
+
+def columnBaseRealizer : Realizer columnBase :=
+  composition (f := fun z : EntryInput=>(2,rowCount z))
+    (g := fun a : ℕ×ℕ=>a.1+a.2) (pair (constant 2) rowCountRealizer) add
+
+lemma polynomial_columnBase : PolynomialTime columnBaseRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_rowCount)
+    polynomial_add
+
+def kinds (z : EntryInput) : ℕ×ℕ :=
+  (kind (rowCount z) z.2.1,kind (rowCount z) z.2.2)
+
+def kindsRealizer : Realizer kinds :=
+  pair (composition (pair rowCountRealizer (composition second first)) kindRealizer)
+    (composition (pair rowCountRealizer (composition second second)) kindRealizer)
+
+lemma polynomial_kinds : PolynomialTime kindsRealizer :=
+  polynomial_pair (polynomial_composition (polynomial_pair polynomial_rowCount
+    (polynomial_composition polynomial_second polynomial_first)) polynomial_kind)
+    (polynomial_composition (polynomial_pair polynomial_rowCount
+      (polynomial_composition polynomial_second polynomial_second)) polynomial_kind)
+
+def pattern (a b : ℕ) (z : EntryInput) : Bool :=
+  decide ((kinds z).1=a) && decide ((kinds z).2=b)
+
+def patternRealizer (a b : ℕ) : Realizer (pattern a b) :=
+  composition kindsRealizer (composition (pair
+    (composition (pair first (constant a)) natEqual)
+    (composition (pair second (constant b)) natEqual)) boolAnd)
+
+lemma polynomial_pattern (a b : ℕ) : PolynomialTime (patternRealizer a b) :=
+  polynomial_composition polynomial_kinds (polynomial_composition
+    (polynomial_pair
+      (polynomial_composition (polynomial_pair polynomial_first (polynomial_constant a))
+        polynomial_natEqual)
+      (polynomial_composition (polynomial_pair polynomial_second (polynomial_constant b))
+        polynomial_natEqual)) polynomial_boolAnd)
+
+def rowRead (z : EntryInput) : ℕ := z.1.1.1.getD (z.2.2-2) 0
+
+def rowReadRealizer : Realizer rowRead :=
+  composition (pair (composition (composition first first) first)
+    (composition (pair (composition second second) (constant 2)) subtract)) (getDFast 0)
+
+lemma polynomial_rowRead : PolynomialTime rowReadRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_first)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_second polynomial_second) (polynomial_constant 2))
+      polynomial_subtract)) (polynomial_getDFast 0)
+
+def columnRead (z : EntryInput) : ℕ := z.1.1.2.getD (z.2.1-columnBase z) 0
+
+def columnReadRealizer : Realizer columnRead :=
+  composition (pair (composition (composition first first) second)
+    (composition (pair (composition second first) columnBaseRealizer) subtract)) (getDFast 0)
+
+lemma polynomial_columnRead : PolynomialTime columnReadRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_second)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_second polynomial_first) polynomial_columnBase)
+      polynomial_subtract)) (polynomial_getDFast 0)
+
+def boundRead (z : EntryInput) : ℕ :=
+  capacityEntry (z.1.2,(z.2.1-2,z.2.2-columnBase z))
+
+def boundReadRealizer : Realizer boundRead :=
+  composition (pair (composition first second)
+    (pair (composition (pair (composition second first) (constant 2)) subtract)
+      (composition (pair (composition second second) columnBaseRealizer) subtract)))
+    capacityEntryRealizer
+
+lemma polynomial_boundRead : PolynomialTime boundReadRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_second)
+    (polynomial_pair
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_second polynomial_first) (polynomial_constant 2))
+        polynomial_subtract)
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_second polynomial_second) polynomial_columnBase)
+        polynomial_subtract))) polynomial_capacityEntry
+
+def entryRealizer : Realizer entry :=
+  (choose (patternRealizer 0 2) rowReadRealizer
+    (choose (patternRealizer 2 3) boundReadRealizer
+      (choose (patternRealizer 3 1) columnReadRealizer (constant 0)))).congr (by
+        intro z
+        have hp (a b : ℕ) : pattern a b z=true ↔
+            kind z.1.1.1.length z.2.1=a ∧ kind z.1.1.1.length z.2.2=b := by
+          change ((decide (kind z.1.1.1.length z.2.1=a)) &&
+            (decide (kind z.1.1.1.length z.2.2=b)))=true ↔ _
+          rw [Bool.and_eq_true]
+          constructor
+          · rintro ⟨ha,hb⟩
+            exact ⟨_root_.of_decide_eq_true ha,_root_.of_decide_eq_true hb⟩
+          · rintro ⟨ha,hb⟩
+            exact ⟨_root_.decide_eq_true ha,_root_.decide_eq_true hb⟩
+        simp only [hp,columnBase,rowRead,columnRead,boundRead,entry,rowCount])
+
+lemma polynomial_entry : PolynomialTime entryRealizer :=
+  polynomial_congr _ (polynomial_choose (polynomial_pattern 0 2) polynomial_rowRead
+    (polynomial_choose (polynomial_pattern 2 3) polynomial_boundRead
+      (polynomial_choose (polynomial_pattern 3 1) polynomial_columnRead (polynomial_constant 0))))
+
+def vertexCountRealizer : Realizer vertexCount :=
+  composition (f := fun z : Input=>(2,z.1.1.length+z.1.2.length))
+    (g := fun a : ℕ×ℕ=>a.1+a.2)
+    (pair (constant 2) (composition
+      (f := fun z : Input=>(z.1.1.length,z.1.2.length))
+      (g := fun a : ℕ×ℕ=>a.1+a.2)
+      (pair (composition (composition first first) listLength)
+        (composition (composition first second) listLength)) add)) add
+
+lemma polynomial_vertexCount : PolynomialTime vertexCountRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_constant 2)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_listLength)
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
+        polynomial_listLength)) polynomial_add)) polynomial_add
+
+def vertices (z : Input) : List ℕ := List.range (vertexCount z)
+def verticesRealizer : Realizer vertices := composition vertexCountRealizer range
+
+lemma polynomial_vertices : PolynomialTime verticesRealizer := by
+  apply polynomial_boundedRange polynomial_vertexCount (2+2*X)
+  intro z
+  have hr := (list_length_le_weight z.1.1).trans ((weight_fst z.1).trans (weight_fst z))
+  have hc := (list_length_le_weight z.1.2).trans ((weight_snd z.1).trans (weight_fst z))
+  simp only [vertexCount,eval_add,eval_ofNat,eval_mul,eval_X]
+  omega
+
+def row (z : Input×ℕ) : List ℕ :=
+  (vertices z.1).map (fun v=>entry (z.1,(z.2,v)))
+
+def rowRealizer : Realizer row :=
+  composition (pair identity (composition first verticesRealizer))
+    (mapWith (composition
+      (pair (composition first first) (pair (composition first second) second)) entryRealizer))
+
+lemma polynomial_row : PolynomialTime rowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition polynomial_first polynomial_vertices))
+    (polynomial_mapWith (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        polynomial_second)) polynomial_entry))
+
+def matrixRealizer : Realizer matrix :=
+  composition (pair identity verticesRealizer) (mapWith rowRealizer)
+
+lemma polynomial_matrix : PolynomialTime matrixRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_vertices)
+    (polynomial_mapWith polynomial_row)
+
+def solve (z : Input) : FlowMatrix := FlowLoopProgram.run (matrix z,(0,1))
+
+def solveRealizer : Realizer solve :=
+  composition (pair matrixRealizer (constant (0,1))) FlowLoopProgram.runRealizer
+
+lemma polynomial_solve : PolynomialTime solveRealizer :=
+  polynomial_composition (polynomial_pair polynomial_matrix (polynomial_constant (0,1)))
+    FlowLoopProgram.polynomial_run
+
+theorem solve_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    solve (data r c b)=flowCode (EdmondsKarpAlgorithm.maxFlow
+      (BoundedTableFeasibility.networkCapacity r c b)
+      (BoundedTableFeasibility.vertices m n LayeredTableNetwork.source)
+      (BoundedTableFeasibility.vertices m n LayeredTableNetwork.sink)) := by
+  have hs : (BoundedTableFeasibility.vertices m n (LayeredTableNetwork.source :
+      LayeredTableNetwork.Vertex m n)).val=0 := index_vertices _
+  have ht : (BoundedTableFeasibility.vertices m n (LayeredTableNetwork.sink :
+      LayeredTableNetwork.Vertex m n)).val=1 := index_vertices _
+  unfold solve
+  rw [matrix_code]
+  simpa only [hs,ht] using FlowLoopProgram.run_code
+    (BoundedTableFeasibility.networkCapacity r c b)
+    (BoundedTableFeasibility.vertices m n LayeredTableNetwork.source)
+    (BoundedTableFeasibility.vertices m n LayeredTableNetwork.sink)
+    BoundedTableFeasibility.source_ne_sink
+
+end ContingencyTables.NetworkCapacityProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/NetworkFeasibilityProgram.lean

@@ -0,0 +1,106 @@
+import OAI.Combinatorics.ContingencyTables.Machines.NetworkCapacityProgram
+
+namespace OAI
+
+/-! # The actual polynomial binary bounded-table feasibility test -/
+
+namespace ContingencyTables.NetworkFeasibilityProgram
+
+open MatchingFPRAS.TreeTyped NetworkVertexCode NetworkCapacityProgram ResidualGraphProgram
+open scoped BigOperators
+
+def sourcePair (z : Input) : SignedPairProgram.Signed :=
+  SignedPairProgram.sum ((solve z).getD 0 [])
+
+def sourcePairRealizer : Realizer sourcePair :=
+  composition (composition (pair solveRealizer (constant 0)) (getDFast []))
+    SignedPairProgram.sumRealizer
+
+lemma polynomial_sourcePair : PolynomialTime sourcePairRealizer :=
+  polynomial_composition (polynomial_composition
+    (polynomial_pair polynomial_solve (polynomial_constant 0)) (polynomial_getDFast []))
+    SignedPairProgram.polynomial_sum
+
+def inputValues (z : Input) : (ℕ×ℕ)×SignedPairProgram.Signed :=
+  ((z.1.1.sum,z.1.2.sum),sourcePair z)
+
+def inputValuesRealizer : Realizer inputValues :=
+  pair (pair (composition (composition first first) listSum)
+    (composition (composition first second) listSum)) sourcePairRealizer
+
+lemma polynomial_inputValues : PolynomialTime inputValuesRealizer :=
+  polynomial_pair (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_listSum)
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
+      polynomial_listSum)) polynomial_sourcePair
+
+def testValues (z : (ℕ×ℕ)×SignedPairProgram.Signed) : Bool :=
+  decide (z.1.1=z.1.2) && decide (z.2.1=z.1.1+z.2.2)
+
+def testValuesRealizer : Realizer testValues :=
+  composition (pair (composition first natEqual)
+    (composition (pair (composition second first)
+      (composition (pair (composition first first) (composition second second)) add))
+      natEqual)) boolAnd
+
+lemma polynomial_testValues : PolynomialTime testValuesRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_natEqual)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_second polynomial_first)
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_first polynomial_first)
+        (polynomial_composition polynomial_second polynomial_second)) polynomial_add))
+      polynomial_natEqual)) polynomial_boolAnd
+
+def test (z : Input) : Bool := testValues (inputValues z)
+def testRealizer : Realizer test := composition inputValuesRealizer testValuesRealizer
+
+lemma polynomial_test : PolynomialTime testRealizer :=
+  polynomial_composition polynomial_inputValues polynomial_testValues
+
+lemma flowCode_row_value {n : ℕ} (f : PublishedEdmondsKarp.Flow n) (s : Fin n) :
+    SignedPairProgram.value (SignedPairProgram.sum ((flowCode f).getD s.val []))=
+      PublishedEdmondsKarp.value s f := by
+  have hr : (flowCode f).getD s.val []=
+      List.ofFn (fun v=>ForestAffineProgram.signedParts (f s v)) := by
+    simp only [flowCode,List.getD_eq_getElem?_getD,List.getElem?_ofFn,s.isLt,
+      dite_true,Option.getD_some,Fin.eta]
+  rw [hr,SignedPairProgram.value_sum]
+  simp only [List.map_ofFn,Function.comp_def,SignedPairProgram.value,
+    ForestAffineProgram.signedParts_sub,List.sum_ofFn,PublishedEdmondsKarp.value]
+
+lemma sourcePair_value {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    SignedPairProgram.value (sourcePair (data r c b))=
+      LayeredTableNetwork.value (BoundedTableFeasibility.computedFlow r c b) := by
+  unfold sourcePair
+  rw [solve_code]
+  have hs : (BoundedTableFeasibility.vertices m n (LayeredTableNetwork.source :
+      LayeredTableNetwork.Vertex m n)).val=0 := index_vertices _
+  rw [←hs,flowCode_row_value]
+  exact (BoundedTableFeasibility.pull_value _).symm
+
+lemma test_eq_feasible {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    test (data r c b)=BoundedTableFeasibility.feasibleTest r c b := by
+  apply Bool.eq_iff_iff.mpr
+  simp only [test,testValues,inputValues,Bool.and_eq_true,decide_eq_true_eq,
+    BoundedTableFeasibility.feasibleTest,data,List.sum_ofFn]
+  have hv := sourcePair_value r c b
+  have he : (sourcePair (data r c b)).1=
+      (∑ i,r i)+(sourcePair (data r c b)).2 ↔
+      SignedPairProgram.value (sourcePair (data r c b))=∑ i,(r i:ℤ) := by
+    unfold SignedPairProgram.value
+    rw [←Nat.cast_sum]
+    omega
+  exact and_congr_right (fun _=>he.trans (by rw [hv]))
+
+theorem test_correct {m n : ℕ} (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1)
+    (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    test (data r c b)=true ↔ ∃ X,HasMargins X r c ∧ ∀ i j,X i j≤b i j := by
+  rw [test_eq_feasible]
+  exact BoundedTableFeasibility.feasibleTest_correct hEK r c b
+
+end ContingencyTables.NetworkFeasibilityProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/NetworkTableProgram.lean

@@ -0,0 +1,174 @@
+import OAI.Combinatorics.ContingencyTables.Machines.NetworkFeasibilityProgram
+
+namespace OAI
+
+/-! # Extracting the bounded table from the executed flow
+
+The output reads the row-to-column arcs of the computed flow. Both the
+matrix dimensions and the encoded entries are obtained from the input;
+there is no choice of a mathematical witness in the program.
+-/
+
+namespace ContingencyTables.NetworkTableProgram
+
+open MatchingFPRAS.TreeTyped Polynomial NetworkVertexCode ResidualGraphProgram
+open scoped BigOperators
+
+abbrev Prepared := (List ℕ×List ℕ)×FlowMatrix
+abbrev CellInput := Prepared×(ℕ×ℕ)
+
+def cell (z : CellInput) : ℕ :=
+  let a := flowEntry (z.1.2,(2+z.2.1,2+z.1.1.1.length+z.2.2))
+  a.1-a.2
+
+def cellRealizer : Realizer cell := by
+  let F : Realizer (fun z : CellInput=>z.1.2) := composition first second
+  let I : Realizer (fun z : CellInput=>2+z.2.1) :=
+    composition (f := fun z : CellInput=>(2,z.2.1))
+      (g := fun a : ℕ×ℕ=>a.1+a.2) (pair (constant 2) (composition second first)) add
+  let J : Realizer (fun z : CellInput=>2+z.1.1.1.length+z.2.2) :=
+    composition (f := fun z : CellInput=>(2+z.1.1.1.length,z.2.2))
+      (g := fun a : ℕ×ℕ=>a.1+a.2)
+      (pair (composition (f := fun z : CellInput=>(2,z.1.1.1.length))
+        (g := fun a : ℕ×ℕ=>a.1+a.2)
+        (pair (constant 2) (composition (composition (composition first first) first) listLength)) add)
+        (composition second second)) add
+  exact composition (f := fun z : CellInput=>
+    flowEntry (z.1.2,(2+z.2.1,2+z.1.1.1.length+z.2.2)))
+    (g := fun a : SignedPairProgram.Signed=>a.1-a.2)
+    (composition (f := fun z : CellInput=>
+      (z.1.2,(2+z.2.1,2+z.1.1.1.length+z.2.2))) (g := flowEntry)
+      (pair F (pair I J)) flowEntryRealizer) subtract
+
+lemma polynomial_cell : PolynomialTime cellRealizer := by
+  unfold cellRealizer
+  apply polynomial_composition
+  · apply polynomial_composition
+    · exact polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        (polynomial_pair
+          (polynomial_composition (polynomial_pair (polynomial_constant 2)
+            (polynomial_composition polynomial_second polynomial_first)) polynomial_add)
+          (polynomial_composition (polynomial_pair
+            (polynomial_composition (polynomial_pair (polynomial_constant 2)
+              (polynomial_composition
+                (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+                  polynomial_first) polynomial_listLength)) polynomial_add)
+            (polynomial_composition polynomial_second polynomial_second)) polynomial_add))
+    · exact polynomial_flowEntry
+  · exact polynomial_subtract
+
+def rowIndices (z : Prepared) : List ℕ := List.range z.1.1.length
+def columnIndices (z : Prepared) : List ℕ := List.range z.1.2.length
+
+def rowIndicesRealizer : Realizer rowIndices :=
+  composition (composition (composition first first) listLength) range
+
+def columnIndicesRealizer : Realizer columnIndices :=
+  composition (composition (composition first second) listLength) range
+
+lemma polynomial_rowIndices : PolynomialTime rowIndicesRealizer := by
+  apply polynomial_boundedRange
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1.1).trans ((weight_fst z.1).trans (weight_fst z))
+
+lemma polynomial_columnIndices : PolynomialTime columnIndicesRealizer := by
+  apply polynomial_boundedRange
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
+      polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using
+    (list_length_le_weight z.1.2).trans ((weight_snd z.1).trans (weight_fst z))
+
+def row (z : Prepared×ℕ) : List ℕ :=
+  (columnIndices z.1).map (fun j=>cell (z.1,(z.2,j)))
+
+def rowRealizer : Realizer row :=
+  composition (pair identity (composition first columnIndicesRealizer))
+    (mapWith (composition (f := fun z : (Prepared×ℕ)×ℕ=>(z.1.1,(z.1.2,z.2)))
+      (g := cell) (pair (composition first first)
+        (pair (composition first second) second)) cellRealizer))
+
+lemma polynomial_row : PolynomialTime rowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition polynomial_first polynomial_columnIndices))
+    (polynomial_mapWith (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        polynomial_second)) polynomial_cell))
+
+def table (z : Prepared) : NatMatrix :=
+  (rowIndices z).map (fun i=>row (z,i))
+
+def tableRealizer : Realizer table :=
+  composition (pair identity rowIndicesRealizer) (mapWith rowRealizer)
+
+lemma polynomial_table : PolynomialTime tableRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_rowIndices)
+    (polynomial_mapWith polynomial_row)
+
+def prepare (z : Input) : Prepared :=
+  (z.1,NetworkCapacityProgram.solve z)
+
+def prepareRealizer : Realizer prepare :=
+  pair first NetworkCapacityProgram.solveRealizer
+
+lemma polynomial_prepare : PolynomialTime prepareRealizer :=
+  polynomial_pair polynomial_first NetworkCapacityProgram.polynomial_solve
+
+def output (z : Input) : NatMatrix := table (prepare z)
+def outputRealizer : Realizer output := composition prepareRealizer tableRealizer
+lemma polynomial_output : PolynomialTime outputRealizer :=
+  polynomial_composition polynomial_prepare polynomial_table
+
+private lemma signedParts_toNat (z : ℤ) :
+    (ForestAffineProgram.signedParts z).1-(ForestAffineProgram.signedParts z).2=z.toNat := by
+  cases z <;> simp [ForestAffineProgram.signedParts]
+
+lemma cell_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ)
+    (i : Fin m) (j : Fin n) :
+    cell (prepare (data r c b),(i.val,j.val))=
+      LayeredTableNetwork.decode (BoundedTableFeasibility.computedFlow r c b) i j := by
+  let f := EdmondsKarpAlgorithm.maxFlow (BoundedTableFeasibility.networkCapacity r c b)
+    (BoundedTableFeasibility.vertices m n LayeredTableNetwork.source)
+    (BoundedTableFeasibility.vertices m n LayeredTableNetwork.sink)
+  have he := flowEntry_code f
+    (BoundedTableFeasibility.vertices m n (LayeredTableNetwork.row i))
+    (BoundedTableFeasibility.vertices m n (LayeredTableNetwork.column j))
+  simp only [index_vertices,LayeredTableNetwork.row,LayeredTableNetwork.column,index] at he
+  have hlen : (data r c b).1.1.length=m := by simp only [data,List.length_ofFn]
+  dsimp only [cell,prepare]
+  rw [hlen,NetworkCapacityProgram.solve_code,he]
+  change (ForestAffineProgram.signedParts (f _ _)).1-
+    (ForestAffineProgram.signedParts (f _ _)).2=(f _ _).toNat
+  exact signedParts_toNat _
+
+lemma output_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    output (data r c b)=natCode
+      (LayeredTableNetwork.decode (BoundedTableFeasibility.computedFlow r c b)) := by
+  simp only [output,table,row,rowIndices,columnIndices,prepare,data,List.length_ofFn,
+    DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn,natCode]
+  apply congrArg List.ofFn
+  funext i
+  apply congrArg List.ofFn
+  funext j
+  exact cell_code r c b i j
+
+/-- The computed list output encodes a table with the supplied margins and
+bounds whenever the concrete feasibility test accepts. -/
+theorem output_correct {m n : ℕ} (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1)
+    (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ)
+    (ht : NetworkFeasibilityProgram.test (data r c b)=true) :
+    ∃ X, output (data r c b)=natCode X ∧ HasMargins X r c ∧ ∀ i j,X i j≤b i j := by
+  have hp : (∑ i,r i)=∑ j,c j ∧
+      LayeredTableNetwork.value (BoundedTableFeasibility.computedFlow r c b)=∑ i,(r i:ℤ) := by
+    simpa only [NetworkFeasibilityProgram.test_eq_feasible,
+      BoundedTableFeasibility.feasibleTest,decide_eq_true_eq] using ht
+  exact ⟨_,output_code r c b,LayeredTableNetwork.decode_boundedTable r c b _
+    (BoundedTableFeasibility.computedFlow_feasible hEK r c b) hp.2 hp.1⟩
+
+end ContingencyTables.NetworkTableProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/OffsetCountProgram.lean

@@ -0,0 +1,87 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ScaledWordProgram
+import Mathlib.Algebra.Order.Floor.Div
+
+namespace OAI
+
+/-! # Exact binary tabulation of the bounded offset law -/
+
+namespace ContingencyTables.OffsetCountPrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+def ceilQuotient (z : ℕ×ℕ) : ℕ := (z.1+z.2-1)/z.2
+
+def ceilQuotientRealizer : Realizer ceilQuotient :=
+  composition (pair
+    (composition (pair (composition (pair first second) add) (constant 1)) subtract)
+    second) quotient
+
+lemma polynomial_ceilQuotient : PolynomialTime ceilQuotientRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair polynomial_first polynomial_second) polynomial_add)
+      (polynomial_constant 1)) polynomial_subtract)
+    polynomial_second) polynomial_quotient
+
+lemma ceilQuotient_eq (n d : ℕ) (hd : 0<d) :
+    ceilQuotient (n,d)=⌈(n:ℚ)/d⌉₊ := by
+  change n ⌈/⌉ d=⌈(n:ℚ)/d⌉₊
+  have hdq : (0:ℚ)<d := by exact_mod_cast hd
+  apply le_antisymm
+  · rw [ceilDiv_le_iff_le_mul hd]
+    have hh:=Nat.le_ceil ((n:ℚ)/d)
+    have hn : n≤⌈(n:ℚ)/d⌉₊*d := by exact_mod_cast (div_le_iff₀ hdq).mp hh
+    simpa only [Nat.mul_comm] using hn
+  · rw [Nat.ceil_le,div_le_iff₀ hdq]
+    have hn : n≤d*(n ⌈/⌉ d) := by
+      simpa only [smul_eq_mul] using (le_smul_ceilDiv (b := n) hd)
+    have hn' : n≤(n ⌈/⌉ d)*d := by simpa only [Nat.mul_comm] using hn
+    exact_mod_cast hn'
+
+abbrev Input := (ℕ×ℕ)×ℕ
+
+def endpoint (z : Input) : ℕ := ceilQuotient (z.2*z.1.2,z.1.1)
+
+def endpointRealizer : Realizer endpoint :=
+  composition (pair
+    (composition (pair second (composition first second)) multiply)
+    (composition first first)) ceilQuotientRealizer
+
+lemma polynomial_endpoint : PolynomialTime endpointRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_second
+      (polynomial_composition polynomial_first polynomial_second)) polynomial_multiply)
+    (polynomial_composition polynomial_first polynomial_first)) polynomial_ceilQuotient
+
+def offsetCount (z : Input) : ℕ := endpoint (z.1,z.2+1)-endpoint z
+
+def offsetCountRealizer : Realizer offsetCount :=
+  composition (pair
+    (composition (pair first (composition second successor)) endpointRealizer)
+    endpointRealizer) subtract
+
+lemma polynomial_offsetCount : PolynomialTime offsetCountRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_first
+      (polynomial_composition polynomial_second polynomial_successor)) polynomial_endpoint)
+    polynomial_endpoint) polynomial_subtract
+
+lemma endpoint_eq (M Q β : ℕ) (hM : 0<M) :
+    endpoint ((M,Q),β)=FairBits.endpoint M Q β := by
+  rw [endpoint,ceilQuotient_eq _ _ hM]
+  simp only [FairBits.endpoint,Nat.cast_mul]
+
+/-- Only two ceiling divisions are required, regardless of the number of
+random words whose probability is being counted. -/
+theorem offsetCount_eq (M Q β : ℕ) (hM : 0<M) (hQ : 0<Q) (hβ : β<M) :
+    offsetCount ((M,Q),β)=(FairBits.fiber M Q β).card := by
+  rw [FairBits.fiber_card hM hQ hβ,offsetCount,endpoint_eq _ _ _ hM,endpoint_eq _ _ _ hM]
+
+theorem scaledLaw_mass (M k : ℕ) (hM : 0<M) (β : Fin M) :
+    (FairBits.scaledLaw M k hM).mass β=
+      (offsetCount ((M,2^k),β.val):ℚ)/(2:ℚ)^k := by
+  rw [offsetCount_eq _ _ _ hM (by positivity) β.isLt]
+  simp only [FairBits.scaledLaw,FairBits.outputMass,Nat.cast_pow,Nat.cast_ofNat]
+
+end ContingencyTables.OffsetCountPrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/OnlineIntegerRetry.lean

@@ -0,0 +1,183 @@
+import OAI.Combinatorics.ContingencyTables.Machines.OnlineRetryPrefix
+import OAI.Combinatorics.MatchingCount.Machines.OnlineTree
+
+namespace OAI
+
+/-! # A fixed online machine for repeat-until-success -/
+
+namespace ContingencyTables.OnlineIntegerRetry
+open MatchingFPRAS MatchingFPRAS.TreeData MatchingFPRAS.TreeMachine
+open MatchingFPRAS.TreeFunction
+open MatchingFPRAS.TreeTyped (Codec)
+open MatchingFPRAS.RegisterProc MatchingFPRAS.OnlineStack
+open MatchingFPRAS.PhysicalStream
+
+inductive Label where
+  | prepare | trial | decode | test | retry | finish | halt
+  deriving DecidableEq, Inhabited
+
+instance : Fintype Label := ⟨{.prepare,.trial,.decode,.test,.retry,.finish,.halt}, by
+  intro x; cases x <;> simp⟩
+
+def prepareProc : RegisterProc.Proc (K Reg) :=
+  RegisterProc.seq (copy 0 1 (by decide)) (cons 1 2 (by decide))
+def retryProc : RegisterProc.Proc (K Reg) :=
+  RegisterProc.seq (split 1 2 (by decide))
+    (RegisterProc.seq (copy 1 0 (by decide)) (clear 1))
+def finishProc : RegisterProc.Proc (K Reg) :=
+  RegisterProc.seq (clear 1)
+    (RegisterProc.seq (split 1 2 (by decide)) (clear 1))
+
+lemma prepare_exec (x s : Data) :
+    RegisterProc.Exec prepareProc (encodeEnv (env x .nil s))
+      (encodeEnv (env x .nil (.cons x s))) (5*TreeFunction.size x+8) := by
+  exact ((copy01 x .nil s).seq (cons12 x x s)).mono (by simp only [size_nil]; omega)
+
+lemma retry_exec (x y s : Data) :
+    RegisterProc.Exec retryProc (encodeEnv (env y .nil (.cons x s)))
+      (encodeEnv (env x .nil s)) (6*TreeFunction.size x+TreeFunction.size y+11) := by
+  exact ((split12 y .nil x s).seq ((copy10 y x s).seq (clear1 x x s))).mono
+    (by simp only [size_nil]; omega)
+
+lemma finish_exec (x y s : Data) :
+    RegisterProc.Exec finishProc (encodeEnv (env y (bit true) (.cons x s)))
+      (encodeEnv (env y .nil s)) (3*TreeFunction.size x+12) := by
+  exact ((clear1 y (bit true) (.cons x s)).seq
+    ((split12 y .nil x s).seq (clear1 y x s))).mono (by
+      simp only [bit,ite_true,size_cons,size_nil]
+      omega)
+
+variable {A B : Type} [Codec A] [Codec B] [Inhabited B]
+variable {f : A → Experiment (Option B)} (F : OnlineTree.Realizer f)
+
+def instructions : Label → OnlineControl.Instr Reg Label
+  | .prepare => .call (OnlineProc.deterministic prepareProc) .trial
+  | .trial => .call F.program .decode
+  | .decode => .call (OnlineProc.deterministic (split 1 0 (by decide))) .test
+  | .test => .branch 1 .retry .finish
+  | .retry => .call (OnlineProc.deterministic retryProc) .prepare
+  | .finish => .call (OnlineProc.deterministic finishProc) .halt
+  | .halt => .halt
+
+/-- A single finite control graph, independent of the number of retries. -/
+def program : OnlineProc.Proc (K Reg) := OnlineControl.compile (instructions F)
+
+def output (a : A) (s : Data) : Option B → Option Label×Env Reg
+  | none => (some .prepare,env (TreeTyped.encode a) .nil s)
+  | some b => (none,env (TreeTyped.encode b) .nil s)
+
+def prefixExperiment (a : A) : ℕ → Experiment (Option B)
+  | 0 => .done none
+  | N+1 => (f a).bind (fun b => b.elim (prefixExperiment a N) (fun b => .done (some b)))
+
+def stepCost (a : A) : ℕ := F.cost a+12*TreeFunction.size (TreeTyped.encode a)+TreeFunction.size (TreeTyped.encode (default : B))+40
+
+lemma prefix_step (a : A) (s : Data) (rest : Experiment (Option B))
+    (hrest : OnlineRetryPrefix.At (instructions F) (output a s)
+      (some .prepare) (env (TreeTyped.encode a) .nil s) rest) :
+    ∃ q,OnlineRetryPrefix.At (instructions F) (output a s)
+      (some .prepare) (env (TreeTyped.encode a) .nil s) q ∧
+      (∀ g : Option B → ℚ,q.mean g=
+        ((f a).bind (fun b => b.elim rest (fun b => .done (some b)))).mean g) ∧
+      q.cost ≤ rest.cost+stepCost F a := by
+  classical
+  let M:=instructions F
+  let out : Option B → Option Label×Env Reg := output a s
+  obtain ⟨u,hu,hum,huc⟩:=F.correct a (.cons (TreeTyped.encode a) s)
+  have next (b : Option B) : ∃ q,
+      OnlineRetryPrefix.At M out (some .decode)
+        (env (TreeTyped.encode b) .nil (.cons (TreeTyped.encode a) s)) q ∧
+      (∀ g : Option B → ℚ,q.mean g=(b.elim rest (fun b => .done (some b))).mean g) ∧
+      q.cost ≤ rest.cost+6*TreeFunction.size (TreeTyped.encode a)+TreeFunction.size (TreeTyped.encode (default : B))+27 := by
+    cases b with
+    | none =>
+      obtain ⟨v,hv,hvm,hvc⟩:=OnlineRetryPrefix.deterministicCall M out .retry .prepare
+        retryProc rfl _ _ _ (retry_exec (TreeTyped.encode a) (TreeTyped.encode (default : B)) s) rest hrest
+      have ht:=OnlineRetryPrefix.nilBranch M out .test .retry .finish 1 rfl
+        (env (TreeTyped.encode (default : B)) (bit false) (.cons (TreeTyped.encode a) s)) rfl v hv
+      obtain ⟨q,hq,hqm,hqc⟩:=OnlineRetryPrefix.deterministicCall M out .decode .test
+        (split 1 0 (by decide)) rfl _ _ _
+        (split10 (bit false) (TreeTyped.encode (default : B)) .nil (.cons (TreeTyped.encode a) s))
+        (.delay 1 v) ht
+      refine ⟨q,hq,?_,?_⟩
+      · intro g
+        exact (hqm g).trans (hvm g)
+      · simp only [Experiment.cost,bit,Bool.false_eq_true,ite_false,size_nil] at hqc
+        omega
+    | some b =>
+      have hh:=OnlineRetryPrefix.halt M out .halt rfl (some b) rfl
+      obtain ⟨v,hv,hvm,hvc⟩:=OnlineRetryPrefix.deterministicCall M out .finish .halt
+        finishProc rfl _ _ _ (finish_exec (TreeTyped.encode a) (TreeTyped.encode b) s)
+        (.delay 1 (.done (some b))) hh
+      have ht:=OnlineRetryPrefix.consBranch M out .test .retry .finish 1 rfl
+        (env (TreeTyped.encode b) (bit true) (.cons (TreeTyped.encode a) s)) .nil .nil rfl v hv
+      obtain ⟨q,hq,hqm,hqc⟩:=OnlineRetryPrefix.deterministicCall M out .decode .test
+        (split 1 0 (by decide)) rfl _ _ _
+        (split10 (bit true) (TreeTyped.encode b) .nil (.cons (TreeTyped.encode a) s)) (.delay 1 v) ht
+      refine ⟨q,hq,?_,?_⟩
+      · intro g
+        exact (hqm g).trans (hvm g)
+      · simp only [Experiment.cost,bit,ite_true,size_cons,size_nil] at hqc hvc
+        omega
+  choose v hv hvm hvc using next
+  have ht:=OnlineRetryPrefix.call M out .trial .decode F.program rfl
+    (env (TreeTyped.encode a) .nil (.cons (TreeTyped.encode a) s))
+    (fun b => env (TreeTyped.encode b) .nil (.cons (TreeTyped.encode a) s)) u hu v hv
+  obtain ⟨q,hq,hqm,hqc⟩:=OnlineRetryPrefix.deterministicCall M out .prepare .trial
+    prepareProc rfl _ _ _ (prepare_exec (TreeTyped.encode a) s) (.delay 1 (u.bind v)) ht
+  refine ⟨q,hq,?_,?_⟩
+  · intro g
+    rw [hqm,Experiment.mean,Experiment.mean_bind]
+    simp_rw [hvm]
+    rw [Experiment.mean_bind]
+    exact hum _
+  · have hb:=Experiment.cost_bind_le u v
+      (rest.cost+6*TreeFunction.size (TreeTyped.encode a)+TreeFunction.size (TreeTyped.encode (default : B))+27) hvc
+    simp only [Experiment.cost] at hqc
+    unfold stepCost
+    omega
+
+/-- All finite prefix laws belong to the same fixed looping program.
+Failure leaves the original input at the live retry entry. -/
+theorem prefix_correct (a : A) (s : Data) (N : ℕ) :
+    ∃ q,OnlineRetryPrefix.At (instructions F) (output a s)
+      (some .prepare) (env (TreeTyped.encode a) .nil s) q ∧
+      (∀ g : Option B → ℚ,q.mean g=(prefixExperiment (f := f) a N).mean g) ∧
+      q.cost ≤ N*stepCost F a := by
+  induction N with
+  | zero => exact ⟨.done none,.done none,fun _ => rfl,by simp [Experiment.cost]⟩
+  | succ N ih =>
+    obtain ⟨p,hp,hpm,hpc⟩:=ih
+    obtain ⟨q,hq,hqm,hqc⟩:=prefix_step F a s p hp
+    refine ⟨q,hq,?_,?_⟩
+    · intro g
+      rw [hqm,prefixExperiment,Experiment.mean_bind,Experiment.mean_bind]
+      congr 1
+      funext b
+      cases b <;> simp only [Option.elim_none,Option.elim_some,hpm]
+    · rw [Nat.succ_mul]
+      omega
+
+/-- The finite prefixes also execute on the actual compiled tape machine.
+The failed endpoint still has a live control state. -/
+theorem physical_prefix (a : A) (s : Data) (N H : ℕ)
+    (hH : StackCost.StackBound (OnlineTree.initial (program F) (TreeTyped.encode a) s).stk H) :
+    ∃ q,PhysicalPost.Implements (OnlineStack.table (program F).code (program F).coin)
+      (fun b => OnlineStack.cfg (OnlineControl.cfg (instructions F)
+        (output a s b).1 (output a s b).2))
+      (OnlineStack.cfg (OnlineTree.initial (program F) (TreeTyped.encode a) s)) q ∧
+      (∀ g : Option B → ℚ,q.mean g=(prefixExperiment (f := f) a N).mean g) ∧
+      q.cost ≤ (N*stepCost F a)*
+        OnlineStack.Executes.factor (program F).code H (N*stepCost F a) := by
+  obtain ⟨p,hp,hpm,hpc⟩:=prefix_correct F a s N
+  have hp' : Executes (program F).code (program F).coin
+      (fun b => OnlineControl.cfg (instructions F) (output a s b).1 (output a s b).2)
+      (OnlineTree.initial (program F) (TreeTyped.encode a) s) p := hp
+  obtain ⟨q,hq,hqm,hqc⟩:=hp'.compile H hH
+  refine ⟨q,hq,fun g => (hqm g).trans (hpm g),?_⟩
+  exact hqc.trans (Nat.mul_le_mul hpc
+    (OnlineStack.Executes.factor_mono H H p.cost (N*stepCost F a) le_rfl hpc))
+
+end ContingencyTables.OnlineIntegerRetry
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/OnlinePartialCall.lean

@@ -0,0 +1,108 @@
+import OAI.Combinatorics.ContingencyTables.Machines.OnlineRetryPrefix
+
+namespace OAI
+
+/-! # Calling the actual retry loop without pretending it has halted -/
+
+namespace ContingencyTables.OnlinePartialCall
+open MatchingFPRAS MatchingFPRAS.TreeData
+open MatchingFPRAS.TreeMachine (Env K encodeEnv)
+open MatchingFPRAS.OnlineStack MatchingFPRAS.OnlineControl
+open MatchingFPRAS.PhysicalStream Turing
+
+variable {R Λ α : Type} [DecidableEq R]
+
+def embed (M : Λ → Instr R Λ) (l : Λ) :
+    (procedure (M l)).Label → Label M := fun u => .inr ⟨l,u⟩
+
+def callCfg (M : Λ → Instr R Λ) (l : Λ)
+    (c : TM2.Cfg (fun _ : K R => Bool) (procedure (M l)).Label RegisterProc.Store) :=
+  StackComposition.mapCfg (embed M l) ((successor (M l)).map Sum.inl) c
+
+/-- A finite prefix of a called procedure can end at a live internal label.
+Only actual halts return to the continuation label. -/
+theorem partial_call (M : Λ → Instr R Λ) (l : Λ)
+    (hcall : ∃ P next, M l = .call P next) (E : Env R)
+    (out : α → TM2.Cfg (fun _ : K R => Bool) (procedure (M l)).Label RegisterProc.Store)
+    (p : Experiment α)
+    (hp : Executes (procedure (M l)).code (procedure (M l)).coin out
+      ⟨some default,none,encodeEnv E⟩ p) :
+    Executes (code M) (coins M) (fun a => callCfg M l (out a))
+      (OnlineControl.cfg M (some l) E) (.delay 1 p) := by
+  have hh := hp.relabel (code M) (coins M) (embed M l)
+    ((successor (M l)).map Sum.inl) (fun _ => rfl) (fun _ => rfl)
+  obtain ⟨P,next,h⟩ := hcall
+  apply Executes.step _ _ _ _ rfl
+  simpa only [OnlineControl.cfg,code,h,TM2.stepAux,callCfg,StackComposition.mapCfg_some,embed] using hh
+
+abbrev Config (M : Λ → Instr R Λ) :=
+  TM2.Cfg (fun _ : K R => Bool) (Label M) RegisterProc.Store
+
+def At (M : Λ → Instr R Λ) (out : α → Config M)
+    (l : Option Λ) (E : Env R) (p : Experiment α) : Prop :=
+  Executes (code M) (coins M) out (OnlineControl.cfg M l E) p
+
+lemma halt (M : Λ → Instr R Λ) (out : α → Config M)
+    (l : Λ) (h : M l=.halt) (a : α) (E : Env R) (ha : out a=OnlineControl.cfg M none E) :
+    At M out (some l) E (.delay 1 (.done a)) := by
+  apply Executes.step _ _ _ _ rfl
+  simp only [code,h,TM2.stepAux]
+  change Executes (code M) (coins M) out (OnlineControl.cfg M none E) (.done a)
+  rw [←ha]
+  exact .done a
+
+lemma nilBranch (M : Λ → Instr R Λ) (out : α → Config M)
+    (l a b : Λ) (i : R) (h : M l=.branch i a b)
+    (E : Env R) (hi : E i=.nil) (p : Experiment α)
+    (hp : At M out (some a) E p) : At M out (some l) E (.delay 1 p) := by
+  apply Executes.step _ _ _ _ rfl
+  simpa only [At,code,h,TM2.stepAux,encodeEnv,hi,encode,List.head?_cons,
+    Option.getD_some,Bool.cond_false,OnlineControl.cfg,Option.map_some] using hp
+
+lemma consBranch (M : Λ → Instr R Λ) (out : α → Config M)
+    (l a b : Λ) (i : R) (h : M l=.branch i a b)
+    (E : Env R) (x y : Data) (hi : E i=.cons x y) (p : Experiment α)
+    (hp : At M out (some b) E p) : At M out (some l) E (.delay 1 p) := by
+  apply Executes.step _ _ _ _ rfl
+  simpa only [At,code,h,TM2.stepAux,encodeEnv,hi,encode,List.head?_cons,
+    Option.getD_some,Bool.cond_true,OnlineControl.cfg,Option.map_some] using hp
+
+lemma call {β : Type} (M : Λ → Instr R Λ) (out : α → Config M)
+    (l next : Λ) (P : OnlineProc.Proc (K R)) (h : M l=.call P next)
+    (E : Env R) (F : β → Env R) (q : Experiment β)
+    (hq : Executes P.code P.coin (fun b => ⟨none,none,encodeEnv (F b)⟩)
+      ⟨some default,none,encodeEnv E⟩ q)
+    (p : β → Experiment α) (hp : ∀ b,At M out (some next) (F b) (p b)) :
+    At M out (some l) E (.delay 1 (q.bind p)) := by
+  have hq' : Executes (procedure (M l)).code (procedure (M l)).coin
+      (fun b => ⟨none,none,encodeEnv (F b)⟩) ⟨some default,none,encodeEnv E⟩ q := by
+    rw [show procedure (M l)=P by rw [h]; rfl]
+    exact hq
+  have hh:=hq'.relabel (code M) (coins M) (fun u => Sum.inr ⟨l,u⟩)
+    ((successor (M l)).map Sum.inl) (fun _ => rfl) (fun _ => rfl)
+  apply Executes.step _ _ _ _ rfl
+  have hb:=hh.bind p out (fun b => by
+    simpa only [At,OnlineControl.cfg,StackComposition.mapCfg_none,h,successor,Option.map_some] using hp b)
+  simpa only [code,h,TM2.stepAux,StackComposition.mapCfg_some] using hb
+
+lemma deterministicCall (M : Λ → Instr R Λ) (out : α → Config M)
+    (l next : Λ) (P : RegisterProc.Proc (K R))
+    (h : M l=.call (OnlineProc.deterministic P) next)
+    (E F : Env R) (n : ℕ) (he : RegisterProc.Exec P (encodeEnv E) (encodeEnv F) n)
+    (p : Experiment α) (hp : At M out (some next) F p) :
+    ∃ q,At M out (some l) E q ∧ (∀ f : α → ℚ,q.mean f=p.mean f) ∧
+      q.cost ≤ n+1+p.cost := by
+  obtain ⟨k,hk,he⟩:=he
+  obtain ⟨r,hr,hm,hc⟩:=Executes.of_run P.code k _ _ _ he
+  refine ⟨.delay 1 (r.bind (fun _ => p)),
+    call M out l next (OnlineProc.deterministic P) h E (fun _ : Unit => F)
+      r hr (fun _ => p) (fun _ => hp),?_,?_⟩
+  · intro f
+    simpa only [Experiment.mean,Experiment.mean_bind] using hm (fun _ => p.mean f)
+  · have hh:=Experiment.cost_bind_le r (fun _ => p) p.cost (fun _ => le_rfl)
+    simp only [Experiment.cost]
+    omega
+
+end ContingencyTables.OnlinePartialCall
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/OnlineRetryPrefix.lean

@@ -0,0 +1,94 @@
+import OAI.Combinatorics.MatchingCount.Machines.OnlineControl
+
+namespace OAI
+
+/-! # Finite execution prefixes of the unbounded exact-rejection loop -/
+
+namespace ContingencyTables.OnlineRetryPrefix
+open MatchingFPRAS MatchingFPRAS.TreeData MatchingFPRAS.PhysicalStream
+open MatchingFPRAS.TreeMachine (Env K encodeEnv)
+open MatchingFPRAS.RegisterProc MatchingFPRAS.OnlineStack
+open MatchingFPRAS.OnlineControl Turing
+
+variable {R Λ α : Type} [DecidableEq R]
+
+/-- A failed finite prefix ends at the live retry label, while a successful
+prefix ends in the machine's halted configuration. -/
+def At (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l : Option Λ) (E : Env R) (p : Experiment α) : Prop :=
+  Executes (code M) (coins M) (fun a => OnlineControl.cfg M (out a).1 (out a).2) (OnlineControl.cfg M l E) p
+
+lemma done (M : Λ → Instr R Λ) (out : α → Option Λ×Env R) (a : α) :
+    At M out (out a).1 (out a).2 (.done a) := .done a
+
+lemma halt (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l : Λ) (h : M l=.halt) (a : α) (ha : (out a).1=none) :
+    At M out (some l) (out a).2 (.delay 1 (.done a)) := by
+  apply Executes.step _ _ _ _ rfl
+  have hd:=done M out a
+  simpa only [At,code,h,TM2.stepAux,OnlineControl.cfg,ha,Option.map_none] using hd
+
+lemma go (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l k : Λ) (h : M l=.go k) (E : Env R) (p : Experiment α)
+    (hp : At M out (some k) E p) :
+    At M out (some l) E (.delay 1 p) := by
+  apply Executes.step _ _ _ _ rfl
+  simpa only [At,code,h,TM2.stepAux,OnlineControl.cfg,Option.map_some] using hp
+
+lemma nilBranch (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l a b : Λ) (i : R) (h : M l=.branch i a b)
+    (E : Env R) (hi : E i=.nil) (p : Experiment α)
+    (hp : At M out (some a) E p) :
+    At M out (some l) E (.delay 1 p) := by
+  apply Executes.step _ _ _ _ rfl
+  simpa only [At,code,h,TM2.stepAux,encodeEnv,hi,encode,List.head?_cons,
+    Option.getD_some,Bool.cond_false,OnlineControl.cfg,Option.map_some] using hp
+
+lemma consBranch (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l a b : Λ) (i : R) (h : M l=.branch i a b)
+    (E : Env R) (x y : Data) (hi : E i=.cons x y) (p : Experiment α)
+    (hp : At M out (some b) E p) :
+    At M out (some l) E (.delay 1 p) := by
+  apply Executes.step _ _ _ _ rfl
+  simpa only [At,code,h,TM2.stepAux,encodeEnv,hi,encode,List.head?_cons,
+    Option.getD_some,Bool.cond_true,OnlineControl.cfg,Option.map_some] using hp
+
+lemma call {β : Type} (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l next : Λ) (P : OnlineProc.Proc (K R)) (h : M l=.call P next)
+    (E : Env R) (F : β → Env R) (q : Experiment β)
+    (hq : Executes P.code P.coin (fun b => ⟨none,none,encodeEnv (F b)⟩)
+      ⟨some default,none,encodeEnv E⟩ q)
+    (p : β → Experiment α) (hp : ∀ b,At M out (some next) (F b) (p b)) :
+    At M out (some l) E (.delay 1 (q.bind p)) := by
+  have hq' : Executes (procedure (M l)).code (procedure (M l)).coin
+      (fun b => ⟨none,none,encodeEnv (F b)⟩) ⟨some default,none,encodeEnv E⟩ q := by
+    rw [show procedure (M l)=P by rw [h]; rfl]
+    exact hq
+  have hh:=hq'.relabel (code M) (coins M) (fun u => Sum.inr ⟨l,u⟩)
+    ((successor (M l)).map Sum.inl) (fun _ => rfl) (fun _ => rfl)
+  apply Executes.step _ _ _ _ rfl
+  have hb:=hh.bind p (fun a => OnlineControl.cfg M (out a).1 (out a).2) (fun b => by
+    simpa only [At,OnlineControl.cfg,StackComposition.mapCfg_none,h,successor,Option.map_some] using hp b)
+  simpa only [code,h,TM2.stepAux,StackComposition.mapCfg_some] using hb
+
+lemma deterministicCall (M : Λ → Instr R Λ) (out : α → Option Λ×Env R)
+    (l next : Λ) (P : RegisterProc.Proc (K R))
+    (h : M l=.call (OnlineProc.deterministic P) next)
+    (E F : Env R) (n : ℕ) (he : RegisterProc.Exec P (encodeEnv E) (encodeEnv F) n)
+    (p : Experiment α) (hp : At M out (some next) F p) :
+    ∃ q,At M out (some l) E q ∧ (∀ f : α → ℚ,q.mean f=p.mean f) ∧
+      q.cost ≤ n+1+p.cost := by
+  obtain ⟨k,hk,he⟩:=he
+  obtain ⟨r,hr,hm,hc⟩:=Executes.of_run P.code k _ _ _ he
+  refine ⟨.delay 1 (r.bind (fun _ => p)),
+    call M out l next (OnlineProc.deterministic P) h E (fun _ : Unit => F)
+      r hr (fun _ => p) (fun _ => hp),?_,?_⟩
+  · intro f
+    simpa only [Experiment.mean,Experiment.mean_bind] using hm (fun _ => p.mean f)
+  · have hh:=Experiment.cost_bind_le r (fun _ => p) p.cost (fun _ => le_rfl)
+    simp only [Experiment.cost]
+    omega
+
+end ContingencyTables.OnlineRetryPrefix
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/OnlineRetryRuntime.lean

@@ -0,0 +1,58 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.PhysicalRetryTail
+
+namespace OAI
+
+/-! # Expected physical time of the implemented online rejection loop -/
+
+namespace ContingencyTables.OnlineRetryRuntime
+open MatchingFPRAS MatchingFPRAS.PhysicalStream MatchingFPRAS.PhysicalPost
+
+variable {A B : Type} [TreeTyped.Codec A] [TreeTyped.Codec B] [Inhabited B]
+variable {f : A → Experiment (Option B)} (F : OnlineTree.Realizer f)
+
+noncomputable def machineTable :=
+  OnlineStack.table (OnlineIntegerRetry.program F).code (OnlineIntegerRetry.program F).coin
+
+noncomputable def initialCfg (a : A) (s : TreeData.Data) :=
+  OnlineStack.cfg (OnlineTree.initial (OnlineIntegerRetry.program F) (TreeTyped.encode a) s)
+
+noncomputable def outputCfg (a : A) (s : TreeData.Data) (b : Option B) :=
+  OnlineStack.cfg (OnlineControl.cfg (OnlineIntegerRetry.instructions F)
+    (OnlineIntegerRetry.output a s b).1 (OnlineIntegerRetry.output a s b).2)
+
+noncomputable def attemptBound (a : A) (H : ℕ) : ℕ :=
+  OnlineIntegerRetry.stepCost F a *
+    OnlineStack.Executes.factor (OnlineIntegerRetry.program F).code H
+      (OnlineIntegerRetry.stepCost F a) + 1
+
+lemma output_halted (a : A) (s : TreeData.Data) (b : B) :
+    (outputCfg F a s (some b)).state=none := rfl
+
+/-- This statement concerns the fixed physical transition table of the
+online loop, not only the abstract number of rejection attempts. -/
+theorem expected_time (a : A) (s : TreeData.Data) (H : ℕ)
+    (hH : StackCost.StackBound
+      (OnlineTree.initial (OnlineIntegerRetry.program F) (TreeTyped.encode a) s).stk H)
+    (hf : ∀ N,(OnlineIntegerRetry.prefixExperiment (f := f) a N).mean
+      (fun b => if b=none then 1 else 0) ≤ (1/2:ℚ)^N) :
+    Summable (PhysicalRetryTail.tail (machineTable F) (initialCfg F a s)) ∧
+      (∑' t,PhysicalRetryTail.tail (machineTable F) (initialCfg F a s) t) ≤
+        2*(attemptBound F a H:ℝ) := by
+  apply GeometricRuntime.expected_time_half _ (attemptBound F a H) (Nat.zero_lt_succ _)
+    (PhysicalRetryTail.tail_nonnegative _ _) (PhysicalRetryTail.tail_antitone _ _)
+  intro N
+  obtain ⟨q,hq,hqm,hqc⟩:=PhysicalRetryIteration.linear_physical_prefix F a s H hH N
+  have hc : q.cost ≤ N*attemptBound F a H :=
+    hqc.trans (Nat.mul_le_mul_left N (Nat.le_add_right _ _))
+  have hb:=PhysicalRetryTail.tail_le_failure (machineTable F) (outputCfg F a s)
+    (initialCfg F a s) q hq (output_halted F a s) _ hc
+  have hp : (q.mean (fun b => if b=none then 1 else 0):ℝ) ≤ (1/2:ℝ)^N := by
+    rw [hqm]
+    have h := (Rat.cast_le (K := ℝ)).mpr (hf N)
+    norm_num only [Rat.cast_pow,Rat.cast_div,Rat.cast_one,Rat.cast_ofNat] at h
+    exact h
+  exact hb.trans hp
+
+end ContingencyTables.OnlineRetryRuntime
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PackedMatrixInjective.lean

@@ -0,0 +1,39 @@
+import OAI.Combinatorics.ContingencyTables.Machines.LiteralProgram
+import OAI.Combinatorics.ContingencyTables.Machines.MatrixEncoding
+import OAI.Combinatorics.ContingencyTables.Sampling.ProfilePublicMachine
+
+namespace OAI
+
+/-! # Packed physical output still identifies its contingency table -/
+
+namespace ContingencyTables.PackedMatrixInjective
+open MatchingFPRAS MatchingFPRAS.PhysicalStream MatchingFPRAS.PhysicalPost Turing
+
+lemma deterministic_unique (P : Program) (input X Y : Tape Symbol) (n m : ℕ)
+    (hX : P.Realizes input (.done X) n) (hY : P.Realizes input (.done Y) m) : X=Y := by
+  obtain ⟨p,hp,hpm,_⟩ := hX
+  obtain ⟨q,hq,hqm,_⟩ := hY
+  have ha : p.All (fun T => T=X) := Experiment.all_of_mean_eq hpm _ rfl
+  have hb : q.All (fun T => T=Y) := Experiment.all_of_mean_eq hqm _ rfl
+  have he := hp.padded_execution (fun _ => rfl) (p.cost+q.cost) (Nat.le_add_right _ _) (fun _ => false)
+  have hf := hq.padded_execution (fun _ => rfl) (p.cost+q.cost) (Nat.le_add_left _ _) (fun _ => false)
+  rw [Experiment.all_run p _ ha] at he
+  rw [Experiment.all_run q _ hb] at hf
+  exact congrArg Cfg.tape (he.symm.trans hf)
+
+lemma table_injective {m n : ℕ} {r : Fin m → ℕ} {c : Fin n → ℕ} (X Y : Table r c)
+    (h : Tape.mk₁ (TreePost.packed (GreedyFeasibleTable.printMatrix (DensePrograms.matrixCode X.val)))=
+      Tape.mk₁ (TreePost.packed (GreedyFeasibleTable.printMatrix (DensePrograms.matrixCode Y.val)))) : X=Y := by
+  have hx := LiteralProgram.post_realizes (GreedyFeasibleTable.printMatrix (DensePrograms.matrixCode X.val))
+    (ProfilePrograms.printMatrix_alphabet _)
+  have hy := LiteralProgram.post_realizes (GreedyFeasibleTable.printMatrix (DensePrograms.matrixCode Y.val))
+    (ProfilePrograms.printMatrix_alphabet _)
+  rw [←h] at hy
+  have ht := deterministic_unique LiteralProgram.post _ _ _ _ _ hx hy
+  have he := congrArg Tape.right₀ ht
+  simp only [Tape.mk₁,Tape.mk₂,Tape.mk'_right₀,DensePrograms.matrixCode,GreedyFeasibleTable.printMatrix_ofFn] at he
+  exact Subtype.ext (Algorithms.blankMatrix_injective X.val Y.val he)
+
+end ContingencyTables.PackedMatrixInjective
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PairedCatalogProgram.lean

@@ -0,0 +1,147 @@
+import OAI.Combinatorics.ContingencyTables.Machines.CanonicalInitialEncoding
+
+namespace OAI
+
+/-! # Computing paired-coordinate metadata from a binary profile
+
+Consecutive coordinates are paired by the bounded list scan
+(0,1),(2,3),.... This is the exact metadata of the canonical paired-label
+order, rather than a catalog supplied as an external oracle.
+-/
+
+namespace ContingencyTables.PairedCatalogProgram
+
+open MatchingFPRAS.TreeTyped ProfilePrograms
+
+def indexPair (i : ℕ) : ℕ×ℕ := (2*i,2*i+1)
+
+def twiceRealizer : Realizer (fun i : ℕ => 2*i) :=
+  composition (f := fun i : ℕ => (2,i)) (g := fun z : ℕ×ℕ => z.1*z.2)
+    (pair (constant 2) identity) multiply
+
+def indexPairRealizer : Realizer indexPair :=
+  pair twiceRealizer
+    (composition (f := fun i : ℕ => (2*i,1)) (g := fun z : ℕ×ℕ => z.1+z.2)
+      (pair twiceRealizer (constant 1)) add)
+
+lemma polynomial_indexPair : PolynomialTime indexPairRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_identity)
+      polynomial_multiply)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_identity)
+        polynomial_multiply) (polynomial_constant 1)) polynomial_add)
+
+def indicesRealizer : Realizer (fun xs : List ℕ => List.range (xs.length/2)) :=
+  composition (composition (pair listLength (constant 2)) quotient) range
+
+lemma polynomial_indices : PolynomialTime indicesRealizer := by
+  apply polynomial_boundedRange
+    (polynomial_composition (polynomial_pair polynomial_listLength (polynomial_constant 2))
+      polynomial_quotient) Polynomial.X
+  intro xs
+  simpa only [Function.comp_apply,Polynomial.eval_X] using
+    (Nat.div_le_self xs.length 2).trans (list_length_le_weight xs)
+
+def catalog (xs : List ℕ) : List (ℕ×ℕ) := (List.range (xs.length/2)).map indexPair
+
+def catalogRealizer : Realizer catalog := composition indicesRealizer (map indexPairRealizer)
+
+theorem polynomial_catalog : PolynomialTime catalogRealizer :=
+  polynomial_composition polynomial_indices (polynomial_map polynomial_indexPair)
+
+def pairList {α : Type*} : List α → List (α×Bool)
+  | [] => []
+  | a::xs => (a,false)::(a,true)::pairList xs
+
+lemma pairList_length {α : Type*} (xs : List α) : (pairList xs).length=2*xs.length := by
+  induction xs with
+  | nil => rfl
+  | cons a xs ih => simp only [pairList,List.length_cons,ih]; omega
+
+lemma pairList_product {α : Type*} (xs : List α) : pairList xs=xs.product [false,true] := by
+  induction xs with
+  | nil => rfl
+  | cons a xs ih =>
+    change (a,false)::(a,true)::pairList xs=(a,false)::(a,true)::xs.product [false,true]
+    rw [ih]
+
+lemma pairList_get_even {α : Type*} (xs : List α) (i : ℕ) (hi : i<xs.length) :
+    (pairList xs)[2*i]'(by rw [pairList_length]; omega)=(xs[i],false) := by
+  induction xs generalizing i with
+  | nil => simp at hi
+  | cons a xs ih =>
+    cases i with
+    | zero => rfl
+    | succ i =>
+      simpa only [pairList,Nat.mul_succ,List.getElem_cons_succ] using
+        ih i (Nat.lt_of_succ_lt_succ hi)
+
+lemma pairList_get_odd {α : Type*} (xs : List α) (i : ℕ) (hi : i<xs.length) :
+    (pairList xs)[2*i+1]'(by rw [pairList_length]; omega)=(xs[i],true) := by
+  induction xs generalizing i with
+  | nil => simp at hi
+  | cons a xs ih =>
+    cases i with
+    | zero => rfl
+    | succ i =>
+      simpa only [pairList,Nat.mul_succ,List.getElem_cons_succ,Nat.add_assoc] using
+        ih i (Nat.lt_of_succ_lt_succ hi)
+
+noncomputable section
+open CanonicalInitialEncoding InitialTransversals CompanionArithmeticProposal
+open scoped Classical
+variable {q : ℕ} (b : Fin q → ℕ)
+
+def labelOrder : Fin (copyOrder b).length ≃ Copy b :=
+  List.Nodup.getEquivOfForallMemList (copyOrder b) (copyOrder_nodup b) (copyOrder_mem b)
+
+lemma coordinate_false (i : Fin (copyOrder b).length) :
+    (CanonicalInitialEncoding.coordinateEquiv b (labelOrder b i,false)).val=2*i.val := by
+  have hl : (pairOrder b).length=2*(copyOrder b).length := by
+    change ((copyOrder b).product [false,true]).length=2*(copyOrder b).length
+    rw [←pairList_product]
+    exact pairList_length _
+  let k : Fin (pairOrder b).length := ⟨2*i.val,by rw [hl]; omega⟩
+  have hk : (CanonicalInitialEncoding.coordinateEquiv b).symm k=(labelOrder b i,false) := by
+    change (pairOrder b)[k.val]=((copyOrder b)[i.val],false)
+    simpa only [pairOrder,←pairList_product,k] using pairList_get_even (copyOrder b) i.val i.isLt
+  have he := congrArg (fun a => (CanonicalInitialEncoding.coordinateEquiv b a).val) hk
+  simpa only [Equiv.apply_symm_apply,k] using he.symm
+
+lemma coordinate_true (i : Fin (copyOrder b).length) :
+    (CanonicalInitialEncoding.coordinateEquiv b (labelOrder b i,true)).val=2*i.val+1 := by
+  have hl : (pairOrder b).length=2*(copyOrder b).length := by
+    change ((copyOrder b).product [false,true]).length=2*(copyOrder b).length
+    rw [←pairList_product]
+    exact pairList_length _
+  let k : Fin (pairOrder b).length := ⟨2*i.val+1,by rw [hl]; omega⟩
+  have hk : (CanonicalInitialEncoding.coordinateEquiv b).symm k=(labelOrder b i,true) := by
+    change (pairOrder b)[k.val]=((copyOrder b)[i.val],true)
+    simpa only [pairOrder,←pairList_product,k] using pairList_get_odd (copyOrder b) i.val i.isLt
+  have he := congrArg (fun a => (CanonicalInitialEncoding.coordinateEquiv b a).val) hk
+  simpa only [Equiv.apply_symm_apply,k] using he.symm
+
+/-- Every state encoded in the canonical order has exactly the pair
+catalog computed by the polynomial consecutive-coordinate scan. -/
+theorem catalog_encode (S : Set (Copy b×Bool)) :
+    catalog (encodeSet (CanonicalInitialEncoding.coordinateEquiv b) S)=
+      List.ofFn (fun i : Fin (copyOrder b).length =>
+        ((CanonicalInitialEncoding.coordinateEquiv b (labelOrder b i,false)).val,
+          (CanonicalInitialEncoding.coordinateEquiv b (labelOrder b i,true)).val)) := by
+  have hl : (pairOrder b).length=2*(copyOrder b).length := by
+    change ((copyOrder b).product [false,true]).length=2*(copyOrder b).length
+    rw [←pairList_product]
+    exact pairList_length _
+  simp only [catalog,encodeSet,List.length_ofFn,hl]
+  rw [Nat.mul_div_cancel_left _ (by decide : 0<2)]
+  apply List.ext_getElem
+  · simp
+  · intro i hi hj
+    simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn,indexPair,
+      coordinate_false,coordinate_true]
+
+end
+end ContingencyTables.PairedCatalogProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PairedDemandProgram.lean

@@ -0,0 +1,213 @@
+import OAI.Combinatorics.ContingencyTables.Transport.PairedProfileSemantics
+import OAI.Combinatorics.ContingencyTables.Machines.SparseViewMatrixProgram
+import OAI.Combinatorics.ContingencyTables.Machines.MatrixSubtractProgram
+import OAI.Combinatorics.ContingencyTables.Rooted.RootedOracleWalkProgram
+
+namespace OAI
+
+/-! # Replacing the oracle demand by the current encoded paired state
+
+Only the retained-cell catalog and the supplied state are scanned. The
+large cells receive zero in each sparse view and hence retain their full
+capacity in the complemented column demand.
+-/
+
+namespace ContingencyTables.PairedDemandProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms
+
+abbrev Input := RootedDemandProgram.Input × List ℕ
+
+def cellInput (d : RootedForestCatalog.Data) : CompanionCellCatalog.Input :=
+  ((d.1.2,d.2),d.1.1.2)
+def cellInputRealizer : Realizer cellInput :=
+  pair (pair (composition first second) second) (composition (composition first first) second)
+lemma polynomial_cellInput : PolynomialTime cellInputRealizer :=
+  polynomial_pair (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+    polynomial_second) (polynomial_composition
+      (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+
+def cells (z : Input) : CompanionCellCatalog.Input := cellInput z.1.1
+def cellsRealizer : Realizer cells :=
+  composition (f := fun z : Input => z.1.1) (g := cellInput)
+    (composition first first) cellInputRealizer
+lemma polynomial_cells : PolynomialTime cellsRealizer :=
+  polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+    polynomial_cellInput
+
+def counts (z : Input) : List (ℕ × ℕ) :=
+  PairedProfileProgram.profileRows (CompanionCellCatalog.capacities (cells z),z.2)
+def countsRealizer : Realizer counts :=
+  composition (f := fun z : Input => (CompanionCellCatalog.capacities (cells z),z.2))
+    (g := PairedProfileProgram.profileRows)
+    (pair (composition (f := cells) (g := CompanionCellCatalog.capacities)
+      cellsRealizer CompanionCellCatalog.capacitiesRealizer) second)
+    PairedProfileProgram.profileRowsRealizer
+lemma polynomial_counts : PolynomialTime countsRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_cells CompanionCellCatalog.polynomial_capacities)
+    polynomial_second) PairedProfileProgram.polynomial_profileRows
+
+def sideEntry (z : Bool × (ℕ × ℕ)) : ℕ := if z.1 then z.2.2 else z.2.1
+def sideEntryRealizer : Realizer sideEntry :=
+  choose first (composition second second) (composition second first)
+lemma polynomial_sideEntry : PolynomialTime sideEntryRealizer :=
+  polynomial_choose polynomial_first
+    (polynomial_composition polynomial_second polynomial_second)
+    (polynomial_composition polynomial_second polynomial_first)
+
+def values (z : Input × Bool) : List ℕ := (counts z.1).map (fun p => sideEntry (z.2,p))
+def valuesRealizer : Realizer values :=
+  composition (f := fun z : Input × Bool => (z.2,counts z.1))
+    (g := fun p : Bool × List (ℕ × ℕ) => p.2.map (fun a => sideEntry (p.1,a)))
+    (pair second (composition (f := Prod.fst) (g := counts) first countsRealizer))
+    (mapWith sideEntryRealizer)
+lemma polynomial_values : PolynomialTime valuesRealizer :=
+  polynomial_composition (polynomial_pair polynomial_second
+    (polynomial_composition polynomial_first polynomial_counts))
+    (polynomial_mapWith polynomial_sideEntry)
+
+def viewInput (z : Input × Bool) : SparseViewMatrixProgram.Input :=
+  (z.1.1.1.1.2,(CompanionCellCatalog.catalog (cells z.1),values z))
+def viewInputRealizer : Realizer viewInput :=
+  pair (composition (composition (composition (composition first first) first) first) second)
+    (pair (composition (f := fun z : Input × Bool => cells z.1)
+      (g := CompanionCellCatalog.catalog)
+      (composition (f := Prod.fst) (g := cells) first cellsRealizer)
+      CompanionCellCatalog.catalogRealizer) valuesRealizer)
+lemma polynomial_viewInput : PolynomialTime viewInputRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_composition (polynomial_composition
+      (polynomial_composition polynomial_first polynomial_first) polynomial_first)
+        polynomial_first) polynomial_second)
+    (polynomial_pair (polynomial_composition
+      (polynomial_composition polynomial_first polynomial_cells)
+      CompanionCellCatalog.polynomial_catalog) polynomial_values)
+
+def viewMatrix (z : Input × Bool) : MatrixCode := SparseViewMatrixProgram.matrix (viewInput z)
+def viewMatrixRealizer : Realizer viewMatrix :=
+  composition (f := viewInput) (g := SparseViewMatrixProgram.matrix)
+    viewInputRealizer SparseViewMatrixProgram.matrixRealizer
+lemma polynomial_viewMatrix : PolynomialTime viewMatrixRealizer :=
+  polynomial_composition polynomial_viewInput SparseViewMatrixProgram.polynomial_matrix
+
+def complement (z : Input) : MatrixCode :=
+  MatrixSubtractProgram.matrix (z.1.1.2,viewMatrix (z,true))
+def complementRealizer : Realizer complement :=
+  composition (f := fun z : Input => (z.1.1.2,viewMatrix (z,true)))
+    (g := MatrixSubtractProgram.matrix)
+    (pair (composition (composition first first) second)
+      (composition (f := fun z : Input => (z,true)) (g := viewMatrix)
+        (pair identity (constant true)) viewMatrixRealizer)) MatrixSubtractProgram.matrixRealizer
+lemma polynomial_complement : PolynomialTime complementRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_second)
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant true))
+      polynomial_viewMatrix)) MatrixSubtractProgram.polynomial_matrix
+
+def output (z : Input) : RootedDemandProgram.Input :=
+  (z.1.1,(z.1.2.1,(viewMatrix (z,false),complement z)))
+def outputRealizer : Realizer output :=
+  pair (composition first first)
+    (pair (composition (composition first second) first)
+      (pair (composition (f := fun z : Input => (z,false)) (g := viewMatrix)
+        (pair identity (constant false)) viewMatrixRealizer) complementRealizer))
+theorem polynomial_output : PolynomialTime outputRealizer :=
+  polynomial_pair (polynomial_composition polynomial_first polynomial_first)
+    (polynomial_pair (polynomial_composition
+      (polynomial_composition polynomial_first polynomial_second) polynomial_first)
+      (polynomial_pair (polynomial_composition
+        (polynomial_pair polynomial_identity (polynomial_constant false)) polynomial_viewMatrix)
+        polynomial_complement))
+
+noncomputable section
+open CompanionFactorialApplication CompanionArithmeticProposal PairedProfileSemantics
+open SmallContextCoordinates PhysicalCompletionFibres FirstPaperProfiles SmallGraphProfiles
+
+variable {m n : ℕ} (A : Instance (Fin m) (Fin n))
+
+lemma cells_data (x q : Fin m → Fin n → ℕ) (code : List ℕ) :
+    cells (RootedDemandProgram.data A x q,code)=CompanionCellCatalog.input A := rfl
+
+lemma catalog_eq :
+    CompanionCellCatalog.catalog (CompanionCellCatalog.input A)=
+      cellCatalog A.small (CompanionCellCatalog.cellEquiv A) := by
+  rw [cellCatalog]
+  symm
+  calc
+    List.ofFn (fun i =>
+        ((CompanionCellCatalog.cellEquiv A i).val.1.val,
+          (CompanionCellCatalog.cellEquiv A i).val.2.val))=
+        List.ofFn (fun i : Fin (CompanionCellCatalog.catalog
+          (CompanionCellCatalog.input A)).length =>
+            (CompanionCellCatalog.catalog (CompanionCellCatalog.input A))[i.val]) := by
+      apply congrArg List.ofFn
+      funext i
+      exact CompanionCellCatalog.catalogCell_coordinates A i
+    _=_ := List.ofFn_get _
+
+lemma values_data (x q : Fin m → Fin n → ℕ) (S : Set (Labels A × Bool)) (side : Bool) :
+    values ((RootedDemandProgram.data A x q,
+      encodeSet (CompanionComputedInitial.coordinateOrder A) S),side)=
+        viewList A.small (CompanionCellCatalog.cellEquiv A)
+          (CompanionWeightOracle.profile A S) side := by
+  unfold values counts
+  rw [cells_data,CompanionCellCatalog.capacities_eq]
+  change (PairedProfileProgram.profileRows
+      (List.ofFn (CompanionComputedInitial.capacities A),
+        encodeSet (CompanionComputedInitial.coordinateOrder A) S)).map _=_
+  rw [profileRows_physical]
+  simp only [List.map_ofFn,Function.comp_def,viewList,sideEntry]
+  cases side <;> rfl
+
+lemma viewMatrix_data (x q : Fin m → Fin n → ℕ) (S : Set (Labels A × Bool)) (side : Bool) :
+    viewMatrix ((RootedDemandProgram.data A x q,
+      encodeSet (CompanionComputedInitial.coordinateOrder A) S),side)=
+        matrixCode (smallView A.small (CompanionWeightOracle.profile A S) side) := by
+  let z : Input := (RootedDemandProgram.data A x q,
+    encodeSet (CompanionComputedInitial.coordinateOrder A) S)
+  have hi : viewInput (z,side)=
+      ((List.ofFn (fun i => (A.r i).toNat),List.ofFn (fun j => (A.c j).toNat)),
+        (cellCatalog A.small (CompanionCellCatalog.cellEquiv A),
+          viewList A.small (CompanionCellCatalog.cellEquiv A)
+            (CompanionWeightOracle.profile A S) side)) := by
+    apply Prod.ext
+    · rfl
+    · apply Prod.ext
+      · exact (congrArg CompanionCellCatalog.catalog (cells_data A x q _)).trans (catalog_eq A)
+      · exact values_data A x q S side
+  change SparseViewMatrixProgram.matrix (viewInput (z,side))=_
+  rw [hi]
+  rw [SparseViewMatrixProgram.matrix_ofFn]
+  apply congrArg matrixCode
+  funext i j
+  exact lookupView_eq A.small (CompanionCellCatalog.cellEquiv A)
+    (CompanionWeightOracle.profile A S) side i j
+
+/-- The current code replaces both demand arrays; the old demand only
+provides the immutable graph, capacities, margins and baseline. -/
+theorem output_data (x q : Fin m → Fin n → ℕ) (S : Set (Labels A × Bool)) :
+    output (RootedDemandProgram.data A x q,
+      encodeSet (CompanionComputedInitial.coordinateOrder A) S)=
+        RootedDemandProgram.data A
+          (ForestCountIdentification.smallX A.small (CompanionWeightOracle.profile A S))
+          (fun i j => A.b i j-
+            ForestCountIdentification.smallY A.small (CompanionWeightOracle.profile A S) i j) := by
+  have hq : complement (RootedDemandProgram.data A x q,
+      encodeSet (CompanionComputedInitial.coordinateOrder A) S)=
+      matrixCode (fun i j => A.b i j-
+        smallView A.small (CompanionWeightOracle.profile A S) true i j) := by
+    change MatrixSubtractProgram.matrix (matrixCode A.b,viewMatrix
+      ((RootedDemandProgram.data A x q,
+        encodeSet (CompanionComputedInitial.coordinateOrder A) S),true))=_
+    rw [viewMatrix_data]
+    exact MatrixSubtractProgram.matrix_code _ _
+  unfold output
+  rw [viewMatrix_data,hq]
+  rfl
+
+end
+end ContingencyTables.PairedDemandProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PairedFactorialProgram.lean

@@ -0,0 +1,131 @@
+import OAI.Combinatorics.ContingencyTables.Transport.PairedProfileSemantics
+import OAI.Combinatorics.ContingencyTables.Machines.FractionAggregateProgram
+import OAI.Combinatorics.MatchingCount.Complexity.TreeNumericCosts
+
+namespace OAI
+
+/-! # The exact factorial multiplier from the encoded paired state
+
+Every factorial argument is bounded by the supplied code length. In a
+valid code each cell block has length twice its capacity, so the computed
+denominator is exactly the manuscript's capacity factorial.
+-/
+
+namespace ContingencyTables.PairedFactorialProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial PairedProfileProgram
+open scoped BigOperators Classical
+
+def sideFactor (z : List ℕ × Bool) : ℕ := (sideCount z).factorial
+def sideFactorRealizer : Realizer sideFactor := composition sideCountRealizer factorial
+lemma polynomial_sideFactor : PolynomialTime sideFactorRealizer := by
+  apply polynomial_boundedFactorial polynomial_sideCount X
+  intro z
+  simpa only [eval_X] using (sideCount_le z.1 z.2).trans
+    ((list_length_le_weight z.1).trans (weight_fst z))
+
+def pairCount (xs : List ℕ) : ℕ := xs.length/2
+def pairCountRealizer : Realizer pairCount :=
+  composition (pair listLength (constant 2)) quotient
+lemma polynomial_pairCount : PolynomialTime pairCountRealizer :=
+  polynomial_composition (polynomial_pair polynomial_listLength (polynomial_constant 2))
+    polynomial_quotient
+
+def denominator (xs : List ℕ) : ℕ := (pairCount xs).factorial
+def denominatorRealizer : Realizer denominator := composition pairCountRealizer factorial
+lemma polynomial_denominator : PolynomialTime denominatorRealizer := by
+  apply polynomial_boundedFactorial polynomial_pairCount X
+  intro xs
+  simpa only [eval_X,pairCount] using (Nat.div_le_self xs.length 2).trans (list_length_le_weight xs)
+
+def numerator (xs : List ℕ) : ℕ := sideFactor (xs,false)*sideFactor (xs,true)
+def numeratorRealizer : Realizer numerator :=
+  composition (f := fun xs : List ℕ => (sideFactor (xs,false),sideFactor (xs,true)))
+    (g := fun p : ℕ × ℕ => p.1*p.2)
+    (pair
+      (composition (f := fun xs : List ℕ => (xs,false)) (g := sideFactor)
+        (pair identity (constant false)) sideFactorRealizer)
+      (composition (f := fun xs : List ℕ => (xs,true)) (g := sideFactor)
+        (pair identity (constant true)) sideFactorRealizer)) multiply
+lemma polynomial_numerator : PolynomialTime numeratorRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant false))
+      polynomial_sideFactor)
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant true))
+      polynomial_sideFactor)) polynomial_multiply
+
+def rowRatio (xs : List ℕ) : TreeFraction.Fraction :=
+  TreeFraction.normalize (numerator xs,denominator xs)
+def rowRatioRealizer : Realizer rowRatio :=
+  composition (pair numeratorRealizer denominatorRealizer) TreeFraction.normalizeRealizer
+lemma polynomial_rowRatio : PolynomialTime rowRatioRealizer :=
+  polynomial_composition (polynomial_pair polynomial_numerator polynomial_denominator)
+    TreeFraction.polynomial_normalize
+
+def output (z : PairedProfileProgram.Input) : TreeFraction.Fraction :=
+  FractionAggregateProgram.product ((rows z).map rowRatio)
+def outputRealizer : Realizer output :=
+  composition (composition rowsRealizer (map rowRatioRealizer))
+    FractionAggregateProgram.productRealizer
+theorem polynomial_output : PolynomialTime outputRealizer :=
+  polynomial_composition (polynomial_composition polynomial_rows
+    (polynomial_map polynomial_rowRatio)) FractionAggregateProgram.polynomial_product
+
+lemma rowRatio_value (xs : List ℕ) :
+    TreeFraction.val (rowRatio xs)=
+      ((sideCount (xs,false)).factorial:ℚ)*(sideCount (xs,true)).factorial /
+        (xs.length/2).factorial := by
+  rw [rowRatio,TreeFraction.normalize_val]
+  simp only [TreeFraction.val,numerator,sideFactor,denominator,pairCount,Nat.cast_mul]
+
+noncomputable section
+open PairedProfileSemantics InitialTransversals CanonicalInitialEncoding
+open CompanionArithmeticProposal CompanionFactorialApplication
+
+variable {q : ℕ} (b : Fin q → ℕ)
+
+theorem output_canonical (S : Set (Copy b × Bool)) :
+    TreeFraction.val (output (List.ofFn b,encodeSet (coordinateEquiv b) S))=
+      ∏ i : Fin q,
+        ((∑ k : Fin (b i), if ((⟨i,k⟩ : Copy b),false) ∈ S then 1 else 0).factorial:ℚ)*
+          (∑ k : Fin (b i), if ((⟨i,k⟩ : Copy b),true) ∈ S then 1 else 0).factorial /
+            (b i).factorial := by
+  rw [output,FractionAggregateProgram.product_value,rows_encode]
+  simp only [cellRows,List.map_ofFn,List.prod_ofFn,Function.comp_apply]
+  apply Finset.prod_congr rfl
+  intro i _
+  rw [rowRatio_value]
+  have hc := counts_cellRow b S i
+  have hfalse := congrArg Prod.fst hc
+  have htrue := congrArg Prod.snd hc
+  change sideCount (_,false)=_ at hfalse
+  change sideCount (_,true)=_ at htrue
+  rw [hfalse,htrue,interleave_length,List.length_ofFn,
+    Nat.mul_div_cancel_left _ (by decide : 0 < 2)]
+
+variable {m n : ℕ} (A : Instance (Fin m) (Fin n))
+
+/-- The multiplier used by the executed weight oracle is the literal
+factorial ratio, for every subset, not just transversal states. -/
+theorem output_physical (S : Set (Labels A × Bool)) :
+    TreeFraction.val (output (List.ofFn (CompanionComputedInitial.capacities A),
+      encodeSet (CompanionComputedInitial.coordinateOrder A) S))=
+        CompanionWeightOracle.factorialRatio A S := by
+  rw [CompanionComputedInitial.encodeSet_reindex,output_canonical]
+  have hp (i) (side : Bool) :=
+    (physical_profile_reindex A S ((CompanionComputedInitial.cellOrder A).symm i) side).trans
+      (by rw [Equiv.apply_symm_apply,copy_viewCount])
+  simp_rw [←hp]
+  symm
+  unfold CompanionWeightOracle.factorialRatio CompanionWeightOracle.factorialNumerator
+    CompanionWeightOracle.factorialDenominator
+  simp only [Nat.cast_prod,Fintype.prod_prod_type,Fintype.prod_bool,Nat.cast_mul]
+  rw [←Finset.prod_div_distrib]
+  exact Fintype.prod_equiv (CompanionComputedInitial.cellOrder A) _ _ (fun s => by
+    simp only [Equiv.symm_apply_apply,CompanionComputedInitial.capacities]
+    ring)
+
+end
+end ContingencyTables.PairedFactorialProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PairedProfileProgram.lean

@@ -0,0 +1,163 @@
+import OAI.Combinatorics.ContingencyTables.Machines.NaturalBlockProgram
+import OAI.Combinatorics.ContingencyTables.Machines.PairedCatalogProgram
+
+namespace OAI
+
+/-! # Reading the two cell counts from the actual paired code
+
+The block widths come from the stored capacity list. Each count scans
+only supplied code entries and clips them to one, including on malformed
+input. No numeric capacity controls an unbounded allocation.
+-/
+
+namespace ContingencyTables.PairedProfileProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial
+
+abbrev ReadInput := (List ℕ × Bool) × (ℕ × ℕ)
+
+def sideValue (z : ReadInput) : ℕ :=
+  min (z.1.1.getD (if z.1.2 then z.2.2 else z.2.1) 0) 1
+def sideValueRealizer : Realizer sideValue :=
+  composition (f := fun z : ReadInput =>
+      (z.1.1.getD (if z.1.2 then z.2.2 else z.2.1) 0,1))
+    (g := fun p : ℕ × ℕ => min p.1 p.2)
+    (pair (composition (pair (composition first first)
+      (choose (composition first second) (composition second second)
+        (composition second first))) (getDFast 0)) (constant 1)) minimum
+lemma polynomial_sideValue : PolynomialTime sideValueRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_choose (polynomial_composition polynomial_first polynomial_second)
+        (polynomial_composition polynomial_second polynomial_second)
+        (polynomial_composition polynomial_second polynomial_first))) (polynomial_getDFast 0))
+    (polynomial_constant 1)) polynomial_minimum
+
+def sideEntries (z : List ℕ × Bool) : List ℕ :=
+  (PairedCatalogProgram.catalog z.1).map (fun p => sideValue (z,p))
+def sideEntriesRealizer : Realizer sideEntries :=
+  composition (pair identity (composition first PairedCatalogProgram.catalogRealizer))
+    (mapWith sideValueRealizer)
+lemma polynomial_sideEntries : PolynomialTime sideEntriesRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition polynomial_first PairedCatalogProgram.polynomial_catalog))
+    (polynomial_mapWith polynomial_sideValue)
+
+def sideCount (z : List ℕ × Bool) : ℕ := (sideEntries z).sum
+def sideCountRealizer : Realizer sideCount := composition sideEntriesRealizer listSum
+lemma polynomial_sideCount : PolynomialTime sideCountRealizer :=
+  polynomial_composition polynomial_sideEntries polynomial_listSum
+
+lemma sideCount_le (xs : List ℕ) (side : Bool) : sideCount (xs,side) ≤ xs.length := by
+  have hs : (sideEntries (xs,side)).sum ≤ (sideEntries (xs,side)).length := by
+    simpa using (List.sum_le_length_nsmul (sideEntries (xs,side)) 1 (by
+      intro a ha
+      obtain ⟨p,_,rfl⟩ := List.mem_map.mp ha
+      exact Nat.min_le_right _ _))
+  exact hs.trans (by
+    simp only [sideEntries,PairedCatalogProgram.catalog,List.length_map,List.length_range]
+    exact Nat.div_le_self _ _)
+
+abbrev Input := List ℕ × List ℕ
+
+def width (n : ℕ) : ℕ := 2*n
+def widthRealizer : Realizer width :=
+  composition (f := fun n : ℕ => (2,n)) (g := fun p : ℕ × ℕ => p.1*p.2)
+    (pair (constant 2) identity) multiply
+lemma polynomial_width : PolynomialTime widthRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_identity)
+    polynomial_multiply
+
+def rows (z : Input) : List (List ℕ) :=
+  NaturalBlockProgram.blocks (z.1.map width,z.2)
+def rowsRealizer : Realizer rows :=
+  composition (pair (composition first (map widthRealizer)) second)
+    NaturalBlockProgram.blocksRealizer
+lemma polynomial_rows : PolynomialTime rowsRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first (polynomial_map polynomial_width)) polynomial_second)
+    NaturalBlockProgram.polynomial_blocks
+
+def counts (xs : List ℕ) : ℕ × ℕ := (sideCount (xs,false),sideCount (xs,true))
+def countsRealizer : Realizer counts :=
+  pair (composition (f := fun xs : List ℕ => (xs,false)) (g := sideCount)
+    (pair identity (constant false)) sideCountRealizer)
+    (composition (f := fun xs : List ℕ => (xs,true)) (g := sideCount)
+      (pair identity (constant true)) sideCountRealizer)
+lemma polynomial_counts : PolynomialTime countsRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant false))
+      polynomial_sideCount)
+    (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant true))
+      polynomial_sideCount)
+
+def profileRows (z : Input) : List (ℕ × ℕ) := (rows z).map counts
+def profileRowsRealizer : Realizer profileRows := composition rowsRealizer (map countsRealizer)
+theorem polynomial_profileRows : PolynomialTime profileRowsRealizer :=
+  polynomial_composition polynomial_rows (polynomial_map polynomial_counts)
+
+def interleave : List (ℕ × ℕ) → List ℕ
+  | [] => []
+  | p :: ps => p.1 :: p.2 :: interleave ps
+
+lemma interleave_length (xs : List (ℕ × ℕ)) : (interleave xs).length=2*xs.length := by
+  induction xs with
+  | nil => rfl
+  | cons x xs ih => simp only [interleave,List.length_cons,ih]; omega
+
+lemma interleave_get_even (xs : List (ℕ × ℕ)) (i : ℕ) (hi : i < xs.length) :
+    (interleave xs)[2*i]'(by rw [interleave_length]; omega)=xs[i].1 := by
+  induction xs generalizing i with
+  | nil => simp at hi
+  | cons x xs ih =>
+    cases i with
+    | zero => rfl
+    | succ i =>
+      simpa only [interleave,Nat.mul_succ,List.getElem_cons_succ] using
+        ih i (Nat.lt_of_succ_lt_succ hi)
+
+lemma interleave_get_odd (xs : List (ℕ × ℕ)) (i : ℕ) (hi : i < xs.length) :
+    (interleave xs)[2*i+1]'(by rw [interleave_length]; omega)=xs[i].2 := by
+  induction xs generalizing i with
+  | nil => simp at hi
+  | cons x xs ih =>
+    cases i with
+    | zero => rfl
+    | succ i =>
+      simpa only [interleave,Nat.mul_succ,List.getElem_cons_succ,Nat.add_assoc] using
+        ih i (Nat.lt_of_succ_lt_succ hi)
+
+lemma sideEntries_interleave (xs : List (ℕ × ℕ)) (side : Bool) :
+    sideEntries (interleave xs,side)=
+      xs.map (fun p => min (if side then p.2 else p.1) 1) := by
+  apply List.ext_getElem
+  · simp only [sideEntries,PairedCatalogProgram.catalog,List.length_map,List.length_range,
+      interleave_length,Nat.mul_div_cancel_left _ (by decide : 0 < 2)]
+  · intro i hi _
+    have hii : i < xs.length := by
+      simpa only [sideEntries,PairedCatalogProgram.catalog,List.length_map,List.length_range,
+        interleave_length,Nat.mul_div_cancel_left _ (by decide : 0 < 2)] using hi
+    simp only [sideEntries,PairedCatalogProgram.catalog,List.getElem_map,List.getElem_range,
+      sideValue,PairedCatalogProgram.indexPair]
+    cases side with
+    | false =>
+      have hidx : 2*i < (interleave xs).length := by rw [interleave_length]; omega
+      simp only [Bool.false_eq_true,ite_false,List.getD_eq_getElem?_getD,
+        List.getElem?_eq_getElem hidx,Option.getD_some,interleave_get_even xs i hii]
+    | true =>
+      have hidx : 2*i+1 < (interleave xs).length := by rw [interleave_length]; omega
+      simp only [ite_true,List.getD_eq_getElem?_getD,
+        List.getElem?_eq_getElem hidx,Option.getD_some,interleave_get_odd xs i hii]
+
+lemma interleave_flatMap (xs : List (ℕ × ℕ)) :
+    interleave xs=xs.flatMap (fun p => [p.1,p.2]) := by
+  induction xs with
+  | nil => rfl
+  | cons p xs ih =>
+    change p.1 :: p.2 :: interleave xs=p.1 :: p.2 :: xs.flatMap (fun p => [p.1,p.2])
+    rw [ih]
+
+end ContingencyTables.PairedProfileProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PowerApproximationProgram.lean

@@ -0,0 +1,72 @@
+import OAI.Combinatorics.ContingencyTables.Machines.RoundedPowerProgram
+
+namespace OAI
+
+/-! # The executed power-of-two approximation used by the weight oracle
+
+Both stages are concrete binary programs: compute the rounded signed
+power, then bisect using natural cross-products and shared denominators.
+The two allowance lists determine the precision parameters.
+-/
+
+namespace ContingencyTables.PowerApproximationProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+abbrev Input := SignedFloorProgram.Input×(List Bool×List Bool)
+
+def prepare (z : Input) : DyadicRootProgram.Input :=
+  ((RoundedPowerProgram.output (z.1,z.2.1),z.2.1),z.2.2)
+def prepareRealizer : Realizer prepare :=
+  pair (pair
+    (composition (f := fun z : Input => (z.1,z.2.1)) (g := RoundedPowerProgram.output)
+      (pair first (composition second first)) RoundedPowerProgram.outputRealizer)
+    (composition second first)) (composition second second)
+lemma polynomial_prepare : PolynomialTime prepareRealizer :=
+  polynomial_pair (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_first
+      (polynomial_composition polynomial_second polynomial_first))
+      RoundedPowerProgram.polynomial_output)
+    (polynomial_composition polynomial_second polynomial_first))
+    (polynomial_composition polynomial_second polynomial_second)
+
+def output (z : Input) : TreeFraction.Fraction := DyadicRootProgram.output (prepare z)
+def outputRealizer : Realizer output :=
+  composition prepareRealizer DyadicRootProgram.outputRealizer
+theorem polynomial_output : PolynomialTime outputRealizer :=
+  polynomial_composition polynomial_prepare DyadicRootProgram.polynomial_output
+
+theorem output_value (p n d : ℕ) (degree depth : List Bool)
+    (hlo: -2≤((p:ℚ)-n)/d) (hhi: ((p:ℚ)-n)/d≤2) :
+    TreeFraction.val (output (((p,n),d),(degree,depth)))=
+      PowerOfTwoApproximation.approximation (((p:ℚ)-n)/d) degree.length depth.length := by
+  unfold output prepare
+  rw [DyadicRootProgram.output_value _ (RoundedPowerProgram.output_denominator_pos _),
+    RoundedPowerProgram.output_value p n d degree hlo hhi]
+  rfl
+
+/-- The encoded output agrees exactly with the rational value used by
+the existing finite-word correction laws. -/
+theorem output_approximate (p n d : ℕ) (degree depth : List Bool) (sigma : ℚ)
+    (hdegree: degree.length=PowerOfTwoApproximation.rootDegree sigma)
+    (hdepth: depth.length=PowerOfTwoApproximation.depth sigma)
+    (hlo: -2≤((p:ℚ)-n)/d) (hhi: ((p:ℚ)-n)/d≤2) :
+    TreeFraction.val (output (((p,n),d),(degree,depth)))=
+      PowerOfTwoApproximation.approximate (((p:ℚ)-n)/d) sigma := by
+  rw [output_value p n d degree depth hlo hhi,hdegree,hdepth]
+  rfl
+
+theorem output_error (p n d : ℕ) (degree depth : List Bool) (sigma : ℚ)
+    (hdegree: degree.length=PowerOfTwoApproximation.rootDegree sigma)
+    (hdepth: depth.length=PowerOfTwoApproximation.depth sigma)
+    (hlo: -2≤((p:ℚ)-n)/d) (hhi: ((p:ℚ)-n)/d≤2) (hsigma: 0<sigma) :
+    |(TreeFraction.val (output (((p,n),d),(degree,depth))):ℝ)-
+        (2:ℝ)^((((p:ℚ)-n)/d):ℝ)|≤
+      (sigma:ℝ)*(2:ℝ)^((((p:ℚ)-n)/d):ℝ) := by
+  rw [output_approximate p n d degree depth sigma hdegree hdepth hlo hhi]
+  simpa only [Rat.cast_div,Rat.cast_sub,Rat.cast_natCast] using
+    PowerOfTwoApproximation.approximate_error (((p:ℚ)-n)/d) sigma hlo hhi hsigma
+
+end ContingencyTables.PowerApproximationProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PreparedDenseCount.lean

@@ -0,0 +1,76 @@
+import OAI.Combinatorics.ContingencyTables.Dense.DenseCountProgram
+import OAI.Combinatorics.ContingencyTables.Machines.BoundedPowerProgram
+import OAI.Combinatorics.ContingencyTables.Dense.DenseTransitionCounts
+
+namespace OAI
+
+/-! # Polynomial transition entries with a shared acceptance allowance -/
+
+namespace ContingencyTables.DensePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped ProfilePrograms GridBoundary
+open scoped BigOperators Classical
+
+abbrev PreparedCountInput := List Bool×CountInput
+
+def preparedGap (z : PreparedCountInput) : ℕ :=
+  flatExponent (replaceFlat z.2)-flatExponent z.2.1
+
+def preparedGapRealizer : Realizer preparedGap :=
+  composition (pair
+    (composition (composition second replaceFlatRealizer) flatExponentRealizer)
+    (composition (composition second first) flatExponentRealizer)) subtract
+
+lemma polynomial_preparedGap : PolynomialTime preparedGapRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_second polynomial_replaceFlat)
+      polynomial_flatExponent)
+    (polynomial_composition (polynomial_composition polynomial_second polynomial_first)
+      polynomial_flatExponent)) polynomial_subtract
+
+def preparedOffCount (z : PreparedCountInput) : ℕ :=
+  if hasProposal (countProposalInput z.2) then
+    BoundedPowerPrograms.power (z.1,preparedGap z) else 0
+
+def preparedOffCountRealizer : Realizer preparedOffCount := by
+  let pin : Realizer (fun z : PreparedCountInput => (z.1,preparedGap z)) :=
+    pair first preparedGapRealizer
+  let powered := composition pin BoundedPowerPrograms.powerRealizer
+  exact choose (composition (composition second countProposalInputRealizer) hasProposalRealizer)
+    powered (constant 0)
+
+/-- The allowance is supplied once. Enumerating a row or the whole matrix
+then uses only polynomial-time operations on binary entries. -/
+theorem polynomial_preparedOffCount : PolynomialTime preparedOffCountRealizer := by
+  unfold preparedOffCountRealizer
+  exact polynomial_choose
+    (polynomial_composition (polynomial_composition polynomial_second polynomial_countProposalInput)
+      polynomial_hasProposal)
+    (polynomial_composition (polynomial_pair polynomial_first polynomial_preparedGap)
+      BoundedPowerPrograms.polynomial_power) (polynomial_constant 0)
+
+lemma preparedOffCount_eq (xs : List Bool) (z : CountInput) (h : xs.length=8*z.1.2^5) :
+    preparedOffCount (xs,z)=offCountCode z := by
+  unfold preparedOffCount offCountCode
+  simp only [BoundedPowerPrograms.power_eq,BinaryPowerPrograms.power_eq,preparedGap,
+    countPowerInput,h]
+
+lemma offCountCode_actual {m n d : ℕ} (R : Option (Fin m) → ℕ)
+    (P : Option (Fin n) → ℕ) (hq : m*n≤d)
+    (a b : Grid (I := Fin (m*n)) (4*d^8)) :
+    offCountCode ((((marginCode R,marginCode P),gridNatCode a),d),gridNatCode b)=
+      FiniteAcceptCounts.offCount a
+        (fun z : Fin (2^Nat.clog 2 (8*d)) => axisCodeStep a z)
+        (fun b => denseExponent R P d finProdFinEquiv b-
+          denseExponent R P d finProdFinEquiv a) (8*d^5) b := by
+  rw [offCountCode_eq]
+  by_cases hba : b=a
+  · subst b
+    have hn : ¬Neighbor a a := fun h => neighbor_ne a a h rfl
+    simp [FiniteAcceptCounts.offCount,hn]
+  · simp only [FiniteAcceptCounts.offCount,ite_eq_right hba]
+    rw [axisCodeStep_count (dense_proposal_code_bound d (m*n) hq)]
+    split_ifs <;> simp
+
+end ContingencyTables.DensePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PreparedOffsetCount.lean

@@ -0,0 +1,119 @@
+import OAI.Combinatorics.ContingencyTables.Machines.BoundedPowerProgram
+import OAI.Combinatorics.ContingencyTables.Machines.OffsetCountProgram
+import OAI.Combinatorics.ContingencyTables.Dense.DenseSuccessCounts
+
+namespace OAI
+
+/-! # Binary evaluation of the offset numerator product -/
+
+namespace ContingencyTables.DensePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped GridBoundary FairBits
+open scoped BigOperators
+
+/-- A shared bit allowance, widths, actual bit lengths and offsets. -/
+abbrev PreparedOffsetData := ((List Bool×List ℕ)×List ℕ)×List ℕ
+
+def preparedOffsetInput (z : PreparedOffsetData×ℕ) : OffsetCountPrograms.Input :=
+  ((z.1.1.1.2.getD z.2 0,
+    BoundedPowerPrograms.power (z.1.1.1.1,
+      z.1.1.1.1.length-z.1.1.2.getD z.2 0)),z.1.2.getD z.2 0)
+
+def preparedOffsetInputRealizer : Realizer preparedOffsetInput := by
+  let cap : Realizer (fun z : PreparedOffsetData×ℕ => z.1.1.1.1) :=
+    composition (composition (composition first first) first) first
+  let widths : Realizer (fun z : PreparedOffsetData×ℕ => z.1.1.1.2) :=
+    composition (composition (composition first first) first) second
+  let lengths : Realizer (fun z : PreparedOffsetData×ℕ => z.1.1.2) :=
+    composition (composition first first) second
+  let offsets : Realizer (fun z : PreparedOffsetData×ℕ => z.1.2) := composition first second
+  let M := composition (pair widths second) (getDFast 0)
+  let r := composition (pair lengths second) (getDFast 0)
+  let beta := composition (pair offsets second) (getDFast 0)
+  let gap := composition (pair (composition cap listLength) r) subtract
+  let Q := composition (pair cap gap) BoundedPowerPrograms.powerRealizer
+  exact pair (pair M Q) beta
+
+lemma polynomial_preparedOffsetInput : PolynomialTime preparedOffsetInputRealizer := by
+  have hcap : PolynomialTime (composition (composition (composition
+      (first (A := PreparedOffsetData) (B := ℕ)) first) first) first) := by tree_poly
+  have hw : PolynomialTime (composition (composition (composition
+      (first (A := PreparedOffsetData) (B := ℕ)) first) first) second) := by tree_poly
+  have hr : PolynomialTime (composition (composition
+      (first (A := PreparedOffsetData) (B := ℕ)) first) second) := by tree_poly
+  have ho : PolynomialTime (composition
+      (first (A := PreparedOffsetData) (B := ℕ)) second) := by tree_poly
+  have hM := polynomial_composition (polynomial_pair hw polynomial_second) (polynomial_getDFast 0)
+  have hR := polynomial_composition (polynomial_pair hr polynomial_second) (polynomial_getDFast 0)
+  have hB := polynomial_composition (polynomial_pair ho polynomial_second) (polynomial_getDFast 0)
+  have hg := polynomial_composition (polynomial_pair
+    (polynomial_composition hcap polynomial_listLength) hR) polynomial_subtract
+  have hQ := polynomial_composition (polynomial_pair hcap hg) BoundedPowerPrograms.polynomial_power
+  unfold preparedOffsetInputRealizer
+  exact polynomial_pair (polynomial_pair hM hQ) hB
+
+def preparedOffsetFactor (z : PreparedOffsetData×ℕ) : ℕ :=
+  OffsetCountPrograms.offsetCount (preparedOffsetInput z)
+
+def preparedOffsetFactorRealizer : Realizer preparedOffsetFactor :=
+  composition preparedOffsetInputRealizer OffsetCountPrograms.offsetCountRealizer
+
+lemma polynomial_preparedOffsetFactor : PolynomialTime preparedOffsetFactorRealizer :=
+  polynomial_composition polynomial_preparedOffsetInput OffsetCountPrograms.polynomial_offsetCount
+
+def preparedOffsetIndices (z : PreparedOffsetData) : List ℕ := List.range z.1.1.2.length
+
+def preparedOffsetIndicesRealizer : Realizer preparedOffsetIndices :=
+  composition (composition (composition (composition first first) second) listLength) range
+
+lemma polynomial_preparedOffsetIndices : PolynomialTime preparedOffsetIndicesRealizer := by
+  apply polynomial_boundedRange (polynomial_composition (polynomial_composition
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_listLength)
+    Polynomial.X
+  intro z
+  simpa only [Function.comp_apply,Polynomial.eval_X] using
+    (list_length_le_weight z.1.1.2).trans
+      ((weight_snd z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
+
+def preparedOffsetProduct (z : PreparedOffsetData) : ℕ :=
+  ((preparedOffsetIndices z).map (fun i => preparedOffsetFactor (z,i))).prod
+
+def preparedOffsetProductRealizer : Realizer preparedOffsetProduct :=
+  composition (composition (pair identity preparedOffsetIndicesRealizer)
+    (mapWith preparedOffsetFactorRealizer)) listProd
+
+/-- The product uses binary ceiling divisions and shared bounded powers.
+It is polynomial in its supplied bit allowance and integer data. -/
+theorem polynomial_preparedOffsetProduct : PolynomialTime preparedOffsetProductRealizer :=
+  polynomial_composition (polynomial_composition
+    (polynomial_pair polynomial_identity polynomial_preparedOffsetIndices)
+    (polynomial_mapWith polynomial_preparedOffsetFactor)) polynomial_listProd
+
+lemma preparedOffsetFactor_ofFn {q : ℕ} (cap : List Bool) (w r o : Fin q ��� ℕ)
+    (j : Fin q) (hr : r j≤cap.length) :
+    preparedOffsetFactor ((((cap,List.ofFn w),List.ofFn r),List.ofFn o),j.val)=
+      OffsetCountPrograms.offsetCount ((w j,2^r j),o j) := by
+  unfold preparedOffsetFactor preparedOffsetInput
+  simp only [List.getD_eq_getElem?_getD,List.getElem?_ofFn,j.isLt,dite_true,Option.getD_some]
+  rw [BoundedPowerPrograms.power_eq,Nat.sub_sub_self hr]
+
+private lemma range_prod (f : ℕ → ℕ) (q : ℕ) :
+    ((List.range q).map f).prod=∏ j : Fin q,f j.val := by
+  induction q with
+  | zero => simp
+  | succ q ih =>
+    rw [List.prod_range_succ,Fin.prod_univ_castSucc,ih]
+    rfl
+
+theorem preparedOffsetProduct_ofFn {q : ℕ} (cap : List Bool) (w r o : Fin q → ℕ)
+    (hr : ∀ j,r j≤cap.length) :
+    preparedOffsetProduct (((cap,List.ofFn w),List.ofFn r),List.ofFn o)=
+      ∏ j : Fin q,OffsetCountPrograms.offsetCount ((w j,2^r j),o j) := by
+  unfold preparedOffsetProduct preparedOffsetIndices
+  rw [List.length_ofFn,range_prod]
+  apply Finset.prod_congr rfl
+  intro j _
+  exact preparedOffsetFactor_ofFn cap w r o j (hr j)
+
+end ContingencyTables.DensePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PreparedTransitionCache.lean

@@ -0,0 +1,80 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.ProfileTransitionCount
+
+namespace OAI
+
+/-! # Computing the dense cache and the unused-bit multiplicity -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms
+
+attribute [local irreducible] residualParameters residualParametersRealizer canonicalBitCount
+  canonicalBitCountRealizer completionWeights completionWeightsRealizer
+
+abbrev TransitionCacheParameters := ResidualParameters×ℕ
+
+def completionMultiplicity (z : TransitionCacheParameters) : ℕ :=
+  BinaryPowerPrograms.power (2,z.2-canonicalBitCount (residualParameters z.1))
+
+def completionMultiplicityRealizer : Realizer completionMultiplicity := by
+  let used : Realizer (fun z : TransitionCacheParameters =>
+      canonicalBitCount (residualParameters z.1)) :=
+    composition (f := fun z : TransitionCacheParameters => residualParameters z.1)
+      (g := canonicalBitCount)
+      (composition (f := fun z : TransitionCacheParameters => z.1) (g := residualParameters)
+        first residualParametersRealizer) canonicalBitCountRealizer
+  let remaining : Realizer (fun z : TransitionCacheParameters =>
+      z.2-canonicalBitCount (residualParameters z.1)) :=
+    composition (f := fun z : TransitionCacheParameters =>
+      (z.2,canonicalBitCount (residualParameters z.1)))
+      (g := fun z : ℕ×ℕ => z.1-z.2) (pair second used) subtract
+  exact composition (f := fun z : TransitionCacheParameters =>
+      (2,z.2-canonicalBitCount (residualParameters z.1))) (g := BinaryPowerPrograms.power)
+    (pair (constant 2) remaining) BinaryPowerPrograms.powerRealizer
+
+def prepareTransitionCache (z : TransitionCacheParameters) : TransitionCache :=
+  (z.1,(completionMultiplicity z,completionWeights (residualParameters z.1)))
+
+def prepareTransitionCacheRealizer : Realizer prepareTransitionCache :=
+  pair first (pair completionMultiplicityRealizer
+    (composition (f := fun z : TransitionCacheParameters => residualParameters z.1)
+      (g := completionWeights)
+      (composition (f := fun z : TransitionCacheParameters => z.1) (g := residualParameters)
+        first residualParametersRealizer) completionWeightsRealizer))
+
+end ContingencyTables.ProfilePrograms
+
+namespace ContingencyTables.SmallGraphProfiles
+open ProfilePrograms DensePrograms PhysicalCompletionFibres FirstPaperPhysicalMarginal
+open SmallContextCoordinates CompletionCounts
+open scoped BigOperators Classical
+noncomputable section
+
+variable {m n q : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+variable (e : Fin q ≃ Cells (paperSmall r c))
+variable (hr : 0<(largeIndices ((dimensionAllowance (I := Fin m) (J := Fin n))^20,List.ofFn r)).length)
+variable (hc : 0<(largeIndices ((dimensionAllowance (I := Fin m) (J := Fin n))^20,List.ofFn c)).length)
+local notation "d" => dimensionAllowance (I := Fin m) (J := Fin n)
+local notation "R" => listedRows r c (d^20) (d^12) (stateCapacity r c) hr
+local notation "P" => listedColumns r c (d^20) (d^12) (stateCapacity r c) hc
+
+lemma completionMultiplicity_encoded (b h : ℕ) (x : PaperStates r c) :
+    completionMultiplicity ((((stateCodeData r c e x,d^12),(d,h)),25*(d+b+h+1)^62))=
+      2^(25*(d+b+h+1)^62-normalizedDrawBits (R x) (P x) d h) := by
+  unfold completionMultiplicity
+  rw [residualParameters_code r c hr hc e,BinaryPowerPrograms.power_eq,
+    canonicalBitCount_code (R x) (P x) (by have := listed_dimension_fourteen r c hr hc; omega)
+      (listed_paper_totals r c hr hc x)]
+
+lemma prepareTransitionCache_encoded (b h : ℕ) (x : PaperStates r c) :
+    prepareTransitionCache ((((stateCodeData r c e x,d^12),(d,h)),25*(d+b+h+1)^62))=
+      (((stateCodeData r c e x,d^12),(d,h)),
+        (2^(25*(d+b+h+1)^62-normalizedDrawBits (R x) (P x) d h),
+          completionWeights ((marginCode (R x),marginCode (P x)),(d,h)))) := by
+  unfold prepareTransitionCache
+  rw [completionMultiplicity_encoded r c e hr hc,
+    residualParameters_code r c hr hc e]
+
+end
+end ContingencyTables.SmallGraphProfiles
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/PublicInputLength.lean

@@ -0,0 +1,77 @@
+import OAI.Combinatorics.ContingencyTables.AlgorithmStatements
+import Mathlib.Data.Nat.Size
+
+namespace OAI
+
+/-! # Binary input lengths for the sampling machine -/
+
+namespace ContingencyTables.Algorithms
+open MatchingFPRAS
+open scoped BigOperators
+
+lemma encodeNat_length (n : ℕ) : (encodeNat n).length=n.size+1 := by
+  simp only [encodeNat,List.length_append,List.length_map,List.length_singleton,Nat.size_eq_bits_len]
+
+lemma encodeNat_length_le (n N : ℕ) (hn : n ≤ N) :
+    (encodeNat n).length ≤ Nat.clog 2 (N+1)+1 := by
+  rw [encodeNat_length]
+  have hs : n.size ≤ Nat.clog 2 (N+1) := Nat.size_le.mpr
+    ((Nat.lt_succ_of_le hn).trans_le (Nat.le_pow_clog (by decide) (N+1)))
+  omega
+
+private lemma natWords_length (ns : List ℕ) (N : ℕ) (h : ∀ n∈ns,n ≤ N) :
+    (ns.flatMap encodeNat).length ≤ ns.length*(Nat.clog 2 (N+1)+1) := by
+  induction ns with
+  | nil => simp
+  | cons n ns ih =>
+    have hn := encodeNat_length_le n N (h n (by simp))
+    have ht := ih (fun a ha => h a (by simp [ha]))
+    simp only [List.flatMap_cons,List.length_append,List.length_cons,Nat.add_mul,Nat.one_mul]
+    omega
+
+lemma encodeMargins_length {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+    (htotal : (∑ i,r i)=∑ j,c j) :
+    (encodeMargins r c).length ≤ m+n+2+(m+n)*(Nat.clog 2 ((∑ i,r i)+1)+1) := by
+  have hm : (encodeNat m).length ≤ m+1 := by
+    rw [encodeNat_length]
+    exact Nat.add_le_add_right (Nat.size_le.mpr (Nat.lt_two_pow_self)) 1
+  have hn : (encodeNat n).length ≤ n+1 := by
+    rw [encodeNat_length]
+    exact Nat.add_le_add_right (Nat.size_le.mpr (Nat.lt_two_pow_self)) 1
+  have hr := natWords_length (List.ofFn r) (∑ i,r i) (by
+    intro a ha
+    obtain ⟨i,rfl⟩ := List.mem_ofFn.mp ha
+    exact Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ i))
+  have hc := natWords_length (List.ofFn c) (∑ i,r i) (by
+    intro a ha
+    obtain ⟨j,rfl⟩ := List.mem_ofFn.mp ha
+    rw [htotal]
+    exact Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ j))
+  simp only [List.length_ofFn] at hr hc
+  simp only [List.flatMap_def,←List.ofFn_comp'] at hr hc
+  unfold encodeMargins
+  simp only [List.length_append]
+  nlinarith
+
+/-- The bit input length is polynomial in the parameters used by the
+paper's public sampling statement. -/
+theorem encodeSamplingInput_length {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+    (htotal : (∑ i,r i)=∑ j,c j) (k : ℕ) :
+    (encodeSamplingInput r c k).length ≤ 5*(samplingSize n r k)^2 := by
+  have hM := encodeMargins_length r c htotal
+  have hk : (encodeNat k).length ≤ k+1 := by
+    rw [encodeNat_length]
+    exact Nat.add_le_add_right (Nat.size_le.mpr (Nat.lt_two_pow_self)) 1
+  rw [encodeSamplingInput,List.length_append]
+  let S := samplingSize n r k
+  have hS : 1 ≤ S := by dsimp [S,samplingSize]; omega
+  have hmn : m+n ≤ S := by dsimp [S,samplingSize]; omega
+  have hl : Nat.clog 2 ((∑ i,r i)+1)+1 ≤ S := by dsimp [S,samplingSize]; omega
+  have hkS : k+1 ≤ S := by dsimp [S,samplingSize]; omega
+  have hp := Nat.mul_le_mul hmn hl
+  change _ ≤ 5*S^2
+  nlinarith
+
+end ContingencyTables.Algorithms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/QuadraticPrefixRuntime.lean

@@ -0,0 +1,84 @@
+import OAI.Combinatorics.ContingencyTables.Machines.GeometricRuntime
+import Mathlib.Analysis.PSeries
+import Mathlib.Analysis.SpecificLimits.Normed
+
+namespace OAI
+
+/-! # Expected time from geometrically accurate quadratic-cost prefixes -/
+
+namespace ContingencyTables.QuadraticPrefixRuntime
+open scoped BigOperators
+
+lemma weighted_geometric : HasSum (fun k : ℕ => (2*(k:ℝ)+3)*(1/2:ℝ)^k) 10 := by
+  have h0 := hasSum_geometric_of_norm_lt_one (by norm_num : ‖(1/2:ℝ)‖<1)
+  have h1 := hasSum_coe_mul_geometric_of_norm_lt_one (by norm_num : ‖(1/2:ℝ)‖<1)
+  convert (h1.mul_left 2).add (h0.mul_left 3) using 1
+  · funext k; ring
+  · norm_num
+
+/-- Quadratic simulation overhead preserves a finite expected running time.
+The small prefactor `δ` is retained through the entire estimate. -/
+theorem quadratic_bound (f : ℕ → ℝ) (T : ℕ) (hT : 0<T) (δ : ℝ) (hδ : 0≤δ)
+    (h0 : ∀ t,0≤f t) (hm : Antitone f) (hstart : f 0≤δ)
+    (hstep : ∀ N,f (T*(N+1)^2)≤δ*(1/2:ℝ)^N) :
+    Summable f ∧ (∑' t,f t)≤11*δ*T := by
+  let u : ℕ → ℕ := fun N => T*(N+1)^2
+  have hu : Monotone u := by
+    intro a b hab
+    dsimp only [u]
+    exact Nat.mul_le_mul_left T (Nat.pow_le_pow_left (by omega) 2)
+  have hup (N : ℕ) : 0<u N := Nat.mul_pos hT (pow_pos (by omega) _)
+  have hbound (R : ℕ) : ∑ t ∈ Finset.range R,f t≤11*δ*T := by
+    have hR : R≤u R := by
+      have ha : R≤(R+1)^2 := by nlinarith
+      have hb := Nat.mul_le_mul_right ((R+1)^2) (show 1≤T from hT)
+      exact ha.trans (by simpa only [Nat.one_mul] using hb)
+    have hs := Finset.le_sum_schlomilch (f := f) (u := u)
+      (by intro a b _ hab; exact hm hab) hup hu R
+    have hp : ∑ t ∈ Finset.range (u 0),f t≤T*δ := by
+      calc
+        _ ≤ ∑ _t ∈ Finset.range (u 0),δ := Finset.sum_le_sum (fun t _ => (hm (Nat.zero_le t)).trans hstart)
+        _ = T*δ := by simp [u]
+    have hb (k : ℕ) : (u (k+1)-u k) • f (u k)≤
+        (T:ℝ)*δ*((2*(k:ℝ)+3)*(1/2:ℝ)^k) := by
+      have he : u (k+1)=u k+T*(2*k+3) := by dsimp only [u]; ring
+      rw [he,Nat.add_sub_cancel_left,nsmul_eq_mul,Nat.cast_mul,Nat.cast_add,
+        Nat.cast_mul,Nat.cast_ofNat]
+      have hh := mul_le_mul_of_nonneg_left (hstep k) (by positivity : (0:ℝ)≤T*(2*k+3))
+      exact hh.trans_eq (by ring)
+    have hr : ∑ k ∈ Finset.range R,(u (k+1)-u k) • f (u k)≤10*T*δ := by
+      calc
+        _ ≤ ∑ k ∈ Finset.range R,(T:ℝ)*δ*((2*(k:ℝ)+3)*(1/2:ℝ)^k) :=
+          Finset.sum_le_sum (fun k _ => hb k)
+        _ = (T:ℝ)*δ*(∑ k ∈ Finset.range R,(2*(k:ℝ)+3)*(1/2:ℝ)^k) := by rw [Finset.mul_sum]
+        _ ≤ (T:ℝ)*δ*10 := mul_le_mul_of_nonneg_left
+          ((weighted_geometric.summable.sum_le_tsum (Finset.range R)
+            (fun k _ => by positivity)).trans_eq weighted_geometric.tsum_eq) (by positivity)
+        _ = 10*T*δ := by ring
+    have hi : ∑ t ∈ Finset.range R,f t≤∑ t ∈ Finset.range (u R),f t :=
+      Finset.sum_le_sum_of_subset_of_nonneg (Finset.range_mono hR) (fun t _ _ => h0 t)
+    exact (hi.trans hs).trans ((add_le_add hp hr).trans_eq (by ring))
+  exact ⟨summable_of_sum_range_le h0 hbound,Real.tsum_le_of_sum_range_le h0 hbound⟩
+
+/-- A bounded cheap prefix followed by a rare quadratic-cost correction. -/
+theorem expected_time (tail : ℕ → ℝ) (S T : ℕ) (hT : 0<T) (δ : ℝ) (hδ : 0≤δ)
+    (h0 : ∀ t,0≤tail t) (h1 : ∀ t,tail t≤1) (hm : Antitone tail)
+    (hgate : tail S≤δ)
+    (hstep : ∀ N,tail (S+T*(N+1)^2)≤δ*(1/2:ℝ)^N) :
+    Summable tail ∧ (∑' t,tail t)≤S+11*δ*T := by
+  obtain ⟨hs,hb⟩ := quadratic_bound (fun t => tail (t+S)) T hT δ hδ
+    (fun t => h0 _) (fun _ _ h => hm (Nat.add_le_add_right h S))
+    (by simpa only [Nat.zero_add] using hgate)
+    (by intro N; simpa only [Nat.add_comm] using hstep N)
+  have ht : Summable tail := (summable_nat_add_iff S).mp hs
+  refine ⟨ht,?_⟩
+  rw [←ht.sum_add_tsum_nat_add S]
+  have hp : ∑ t ∈ Finset.range S,tail t≤(S:ℝ) := by
+    calc
+      _ ≤ ∑ _t ∈ Finset.range S,(1:ℝ) := Finset.sum_le_sum (fun t _ => h1 t)
+      _ = (S:ℝ) := by simp
+  exact add_le_add hp hb
+
+end ContingencyTables.QuadraticPrefixRuntime
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/RationalIntervalProgram.lean

@@ -0,0 +1,97 @@
+import OAI.Combinatorics.ContingencyTables.Machines.FractionAcceptanceProgram
+import OAI.Combinatorics.ContingencyTables.Rooted.ForestScaledPenalty
+
+namespace OAI
+
+/-! # Exact binary arithmetic for a forest interval penalty
+
+A signed affine numerator is stored as a difference of two naturals.
+Its distance outside the interval [0,1] is a nonnegative fraction with
+the same denominator; no signed rational comparison is required.
+-/
+
+namespace ContingencyTables.RationalIntervalProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+abbrev Input := (ℕ×ℕ)×ℕ
+
+def numerator (z : Input) : ℕ := (z.1.2-z.1.1)+(z.1.1-(z.1.2+z.2))
+
+def numeratorRealizer : Realizer numerator := by
+  let P : Realizer (fun z : Input => z.1.1) := composition first first
+  let N : Realizer (fun z : Input => z.1.2) := composition first second
+  let D : Realizer (fun z : Input => z.2) := second
+  exact composition (pair (composition (pair N P) subtract)
+    (composition (pair P (composition (pair N D) add)) subtract)) add
+
+lemma polynomial_numerator : PolynomialTime numeratorRealizer := by
+  unfold numeratorRealizer
+  have hp := polynomial_composition
+    (polynomial_first (A := ℕ×ℕ) (B := ℕ)) polynomial_first
+  have hn := polynomial_composition
+    (polynomial_first (A := ℕ×ℕ) (B := ℕ)) polynomial_second
+  exact polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair hn hp) polynomial_subtract)
+    (polynomial_composition (polynomial_pair hp
+      (polynomial_composition (polynomial_pair hn polynomial_second) polynomial_add))
+      polynomial_subtract)) polynomial_add
+
+def intervalCode (z : Input) : TreeFraction.Fraction :=
+  TreeFraction.normalize (numerator z,z.2)
+
+def intervalCodeRealizer : Realizer intervalCode :=
+  composition (f := fun z : Input => (numerator z,z.2)) (g := TreeFraction.normalize)
+    (pair numeratorRealizer second) TreeFraction.normalizeRealizer
+
+theorem polynomial_intervalCode : PolynomialTime intervalCodeRealizer :=
+  polynomial_composition (polynomial_pair polynomial_numerator polynomial_second)
+    TreeFraction.polynomial_normalize
+
+lemma intervalCode_denominator (z : Input) : 0<(intervalCode z).2 :=
+  TreeFraction.normalize_den_pos _
+
+noncomputable section
+
+/-- Exact agreement with the interval cost in the forest density. The
+only side condition is the strictly positive tree capacity denominator. -/
+theorem intervalCode_value (p n d : ℕ) (hd : 0<d) :
+    TreeFraction.val (intervalCode ((p,n),d))=
+      max 0 (max (-(((p:ℚ)-n)/d)) (((p:ℚ)-n)/d-1)) := by
+  rw [intervalCode,TreeFraction.normalize_val]
+  change (((n-p)+(p-(n+d)):ℕ):ℚ)/d=_
+  have hdq : (0:ℚ)<d := by exact_mod_cast hd
+  let x : ℚ := ((p:ℚ)-n)/d
+  change (((n-p)+(p-(n+d)):ℕ):ℚ)/d=max 0 (max (-x) (x-1))
+  by_cases hpn : p≤n
+  · have hx : x≤0 := div_nonpos_of_nonpos_of_nonneg
+      (sub_nonpos.mpr (by exact_mod_cast hpn)) hdq.le
+    have hsub : p≤n+d := by omega
+    simp only [Nat.sub_eq_zero_of_le hsub,Nat.add_zero,Nat.cast_sub hpn,
+      max_eq_left (show x-1≤-x by linarith),max_eq_right (neg_nonneg.mpr hx)]
+    dsimp only [x]
+    ring
+  · have hnp : n≤p := by omega
+    have hx : 0≤x := div_nonneg (sub_nonneg.mpr (by exact_mod_cast hnp)) hdq.le
+    by_cases hpd : p≤n+d
+    · have hx1 : x≤1 := (div_le_one hdq).mpr (by
+        have hh : (p:ℚ)≤n+d := by exact_mod_cast hpd
+        linarith)
+      simp only [Nat.sub_eq_zero_of_le hnp,Nat.sub_eq_zero_of_le hpd,Nat.zero_add,
+        Nat.cast_zero,zero_div]
+      symm
+      exact max_eq_left (max_le (neg_nonpos.mpr hx) (by linarith))
+    · have hdp : n+d≤p := by omega
+      have hx1 : 1≤x := (le_div_iff₀ hdq).mpr (by
+        have hh : (n:ℚ)+d≤p := by exact_mod_cast hdp
+        linarith)
+      simp only [Nat.sub_eq_zero_of_le hnp,Nat.zero_add,Nat.cast_sub hdp,Nat.cast_add,
+        max_eq_right (show -x≤x-1 by linarith),max_eq_right (sub_nonneg.mpr hx1)]
+      dsimp only [x]
+      field_simp [hdq.ne']
+      ring
+
+end
+end ContingencyTables.RationalIntervalProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/RepeatedFractionProgram.lean

@@ -0,0 +1,89 @@
+import OAI.Combinatorics.ContingencyTables.Machines.MedianFractionProgram
+import OAI.Combinatorics.ContingencyTables.Machines.BooleanChunkProgram
+import OAI.Combinatorics.ContingencyTables.Dense.DenseMetropolisSemantics
+
+namespace OAI
+
+/-! # Independent repetition of a finite-word rational program
+
+The public confidence amplification only groups bits already supplied
+on the tape. Its binary count cannot cause an unbounded allocation.
+-/
+
+namespace ContingencyTables.RepeatedFractionProgram
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms
+
+variable {X : Type} [Codec X]
+abbrev Input (X : Type) := (X×(ℕ×ℕ))×List Bool
+
+def words (z : Input X) : List (List Bool) :=
+  (wordChunks (z.1.2.2,z.2)).take z.1.2.1
+def wordsRealizer : Realizer (words (X:=X)) :=
+  composition (f := fun z : Input X => (wordChunks (z.1.2.2,z.2),z.1.2.1))
+    (g := fun p : List (List Bool)×ℕ => p.1.take p.2)
+    (pair
+      (composition (f := fun z : Input X => (z.1.2.2,z.2)) (g := wordChunks)
+        (pair (composition (composition first second) second) second) wordChunksRealizer)
+      (composition (composition first second) first)) takeFast
+lemma polynomial_words : PolynomialTime (wordsRealizer (X:=X)) :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_second)
+      polynomial_second) polynomial_wordChunks)
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_first))
+    polynomial_takeFast
+
+variable {f : X×List Bool→TreeFraction.Fraction}
+
+def sample (f : X×List Bool→TreeFraction.Fraction) (z : Input X×List Bool) : TreeFraction.Fraction :=
+  f (z.1.1.1,z.2)
+def sampleRealizer (F : Realizer f) : Realizer (sample f) :=
+  composition (f := fun z : Input X×List Bool => (z.1.1.1,z.2)) (g := f)
+    (pair (composition (composition first first) first) second) F
+lemma polynomial_sample (F : Realizer f) (hF : PolynomialTime F) :
+    PolynomialTime (sampleRealizer F) :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first)
+    polynomial_second) hF
+
+def samples (f : X×List Bool→TreeFraction.Fraction) (z : Input X) : List TreeFraction.Fraction :=
+  (words z).map (fun bits => sample f (z,bits))
+def samplesRealizer (F : Realizer f) : Realizer (samples f) :=
+  composition (pair identity wordsRealizer) (mapWith (sampleRealizer F))
+lemma polynomial_samples (F : Realizer f) (hF : PolynomialTime F) :
+    PolynomialTime (samplesRealizer F) :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_words)
+    (polynomial_mapWith (polynomial_sample F hF))
+
+attribute [local irreducible] samples
+
+def output (f : X×List Bool→TreeFraction.Fraction) (z : Input X) : TreeFraction.Fraction :=
+  MedianFractionProgram.median (samples f z)
+def outputRealizer (F : Realizer f) : Realizer (output f) :=
+  composition (f := samples f) (g := MedianFractionProgram.median)
+    (samplesRealizer F) MedianFractionProgram.medianRealizer
+lemma polynomial_output (F : Realizer f) (hF : PolynomialTime F) :
+    PolynomialTime (outputRealizer F) :=
+  polynomial_composition (polynomial_samples F hF) MedianFractionProgram.polynomial_median
+
+open GridBoundary CommonBasesFPRAS
+
+omit [Codec X] in
+theorem output_ofFn (x : X) (r w : ℕ) (hw : 0 < w) (bits : Fin (r*w)→Bool) :
+    TreeFraction.val (output f ((x,(r,w)),List.ofFn bits))=
+      rationalMedian (List.ofFn (fun i : Fin r =>
+        TreeFraction.val (f (x,List.ofFn (gridWordEquiv r w bits i))))) := by
+  rw [output,MedianFractionProgram.median_val]
+  have hwords : words ((x,(r,w)),List.ofFn bits)=
+      List.ofFn (fun i : Fin r => List.ofFn (gridWordEquiv r w bits i)) := by
+    change (wordChunks (w,List.ofFn bits)).take r=_
+    rw [wordChunks_ofFn hw]
+    exact List.take_of_length_le (by simp)
+  unfold samples
+  rw [hwords]
+  simp only [List.map_ofFn]
+  rfl
+
+end ContingencyTables.RepeatedFractionProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ResidualDenseProgram.lean

@@ -0,0 +1,49 @@
+import OAI.Combinatorics.ContingencyTables.Rooted.LargeMarginProgram
+import OAI.Combinatorics.ContingencyTables.Dense.DenseCanonicalProgram
+
+namespace OAI
+
+/-! # A computed dense completion call from a retained small profile -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS.TreeTyped
+
+abbrev ResidualParameters := (ProfileCheckData×ℕ)×(ℕ×ℕ)
+abbrev ResidualDrawData := ResidualParameters×List Bool
+
+def residualParameters (z : ResidualParameters) : DensePrograms.CanonicalParameters :=
+  ((profilePaddedMargins true z.1,profilePaddedMargins false z.1),z.2)
+
+def residualParametersRealizer : Realizer residualParameters := by
+  let rows : Realizer (fun z : ResidualParameters => profilePaddedMargins true z.1) :=
+    composition (f := fun z : ResidualParameters => z.1) (g := profilePaddedMargins true)
+      first (profilePaddedMarginsRealizer true)
+  let columns : Realizer (fun z : ResidualParameters => profilePaddedMargins false z.1) :=
+    composition (f := fun z : ResidualParameters => z.1) (g := profilePaddedMargins false)
+      first (profilePaddedMarginsRealizer false)
+  exact pair (pair rows columns) second
+
+theorem polynomial_residualParameters : PolynomialTime residualParametersRealizer := by
+  unfold residualParametersRealizer
+  exact polynomial_pair (polynomial_pair
+    (polynomial_composition polynomial_first (polynomial_profilePaddedMargins true))
+    (polynomial_composition polynomial_first (polynomial_profilePaddedMargins false)))
+    polynomial_second
+
+def residualDenseDraw (z : ResidualDrawData) : DensePrograms.MatrixCode :=
+  DensePrograms.canonicalDenseDraw (residualParameters z.1,z.2)
+
+def residualDenseDrawRealizer : Realizer residualDenseDraw :=
+  composition (pair (composition first residualParametersRealizer) second)
+    DensePrograms.canonicalDenseDrawRealizer
+
+/-- The actual completion call computes the residual margins, selects
+their large rectangle, initializes it, and draws a dense matrix. -/
+theorem polynomial_residualDenseDraw : PolynomialTime residualDenseDrawRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_residualParameters) polynomial_second)
+    DensePrograms.polynomial_canonicalDenseDraw
+
+end ContingencyTables.ProfilePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ResidualGraphProgram.lean

@@ -0,0 +1,205 @@
+import OAI.Combinatorics.ContingencyTables.Machines.DirectedBFSRuntime
+import OAI.Combinatorics.ContingencyTables.Machines.SignedPairProgram
+import OAI.Combinatorics.ContingencyTables.Transport.ResidualSearch
+
+namespace OAI
+
+/-! # Binary construction and search of the actual residual graph -/
+
+namespace ContingencyTables.ResidualGraphProgram
+
+open MatchingFPRAS.TreeTyped DirectedBFSProgram SignedPairProgram
+
+abbrev NatMatrix := List (List ℕ)
+abbrev FlowMatrix := List (List Signed)
+abbrev Data := NatMatrix×FlowMatrix
+abbrev ArcInput := Data×(ℕ×ℕ)
+
+def matrixIndices (C : NatMatrix) : List ℕ := List.range C.length
+
+def matrixIndicesRealizer : Realizer matrixIndices := composition listLength range
+
+lemma polynomial_matrixIndices : PolynomialTime matrixIndicesRealizer := by
+  apply polynomial_boundedRange polynomial_listLength Polynomial.X
+  intro C
+  simpa only [Function.comp_apply,Polynomial.eval_X] using list_length_le_weight C
+
+def capacityEntry (z : NatMatrix×(ℕ×ℕ)) : ℕ :=
+  (z.1.getD z.2.1 []).getD z.2.2 0
+
+def capacityEntryRealizer : Realizer capacityEntry :=
+  composition (pair (composition (pair first (composition second first)) (getDFast []))
+    (composition second second)) (getDFast 0)
+
+lemma polynomial_capacityEntry : PolynomialTime capacityEntryRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_composition
+    (polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_first))
+    (polynomial_getDFast [])) (polynomial_composition polynomial_second polynomial_second))
+    (polynomial_getDFast 0)
+
+def flowEntry (z : FlowMatrix×(ℕ×ℕ)) : Signed :=
+  (z.1.getD z.2.1 []).getD z.2.2 (0,0)
+
+def flowEntryRealizer : Realizer flowEntry :=
+  composition (pair (composition (pair first (composition second first)) (getDFast []))
+    (composition second second)) (getDFast (0,0))
+
+lemma polynomial_flowEntry : PolynomialTime flowEntryRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_composition
+    (polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_first))
+    (polynomial_getDFast [])) (polynomial_composition polynomial_second polynomial_second))
+    (polynomial_getDFast (0,0))
+
+def arcData (z : ArcInput) : ℕ×Signed :=
+  (capacityEntry (z.1.1,z.2),flowEntry (z.1.2,z.2))
+
+def arcDataRealizer : Realizer arcData :=
+  pair (composition (pair (composition first first) second) capacityEntryRealizer)
+    (composition (pair (composition first second) second) flowEntryRealizer)
+
+lemma polynomial_arcData : PolynomialTime arcDataRealizer :=
+  polynomial_pair (polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+    polynomial_capacityEntry)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_second) polynomial_second)
+      polynomial_flowEntry)
+
+def residualValue (z : ℕ×Signed) : ℕ := (z.1+z.2.2)-z.2.1
+
+def residualValueRealizer : Realizer residualValue :=
+  composition (pair (composition (pair first (composition second second)) add)
+    (composition second first)) subtract
+
+lemma polynomial_residualValue : PolynomialTime residualValueRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_composition
+    (polynomial_pair polynomial_first (polynomial_composition polynomial_second polynomial_second))
+    polynomial_add) (polynomial_composition polynomial_second polynomial_first)) polynomial_subtract
+
+def positive (z : ℕ×Signed) : Bool := decide (z.2.1< z.1+z.2.2)
+
+def positiveRealizer : Realizer positive :=
+  composition (pair (composition second first)
+    (composition (pair first (composition second second)) add)) less
+
+lemma polynomial_positive : PolynomialTime positiveRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_second polynomial_first)
+    (polynomial_composition (polynomial_pair polynomial_first
+      (polynomial_composition polynomial_second polynomial_second)) polynomial_add)) polynomial_less
+
+def arc (z : ArcInput) : Bool := positive (arcData z)
+def arcRealizer : Realizer arc := composition arcDataRealizer positiveRealizer
+lemma polynomial_arc : PolynomialTime arcRealizer :=
+  polynomial_composition polynomial_arcData polynomial_positive
+
+def arcRow (z : Data×ℕ) : List Bool :=
+  (List.range z.1.1.length).map (fun v=>arc (z.1,(z.2,v)))
+
+def arcRowRealizer : Realizer arcRow :=
+  composition
+    (f := fun z : Data×ℕ=>(z,List.range z.1.1.length))
+    (g := fun z : (Data×ℕ)×List ℕ=>z.2.map (fun v=>arc (z.1.1,(z.1.2,v))))
+    (pair identity (composition
+      (f := fun z : Data×ℕ=>z.1.1) (g := matrixIndices)
+      (composition first first) matrixIndicesRealizer))
+    (mapWith (composition
+      (f := fun z : (Data×ℕ)×ℕ=>(z.1.1,(z.1.2,z.2))) (g := arc)
+      (pair (composition first first) (pair (composition first second) second)) arcRealizer))
+
+lemma polynomial_arcRow : PolynomialTime arcRowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_matrixIndices))
+    (polynomial_mapWith (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_second)
+        polynomial_second)) polynomial_arc))
+
+def graph (z : Data) : DirectedBFSCode.Graph :=
+  (List.range z.1.length).map (fun u=>arcRow (z,u))
+
+def graphRealizer : Realizer graph :=
+  composition
+    (f := fun z : Data=>(z,List.range z.1.length))
+    (g := fun z : Data×List ℕ=>z.2.map (fun u=>arcRow (z.1,u)))
+    (pair identity (composition (f := fun z : Data=>z.1) (g := matrixIndices)
+      first matrixIndicesRealizer)) (mapWith arcRowRealizer)
+
+lemma polynomial_graph : PolynomialTime graphRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition polynomial_first polynomial_matrixIndices))
+    (polynomial_mapWith polynomial_arcRow)
+
+def natCode {m n : ℕ} (c : Fin m→Fin n→ℕ) : NatMatrix :=
+  List.ofFn (fun u=>List.ofFn (c u))
+
+def flowCode {m n : ℕ} (f : Fin m→Fin n→ℤ) : FlowMatrix :=
+  List.ofFn (fun u=>List.ofFn (fun v=>ForestAffineProgram.signedParts (f u v)))
+
+lemma capacityEntry_code {m n : ℕ} (c : Fin m→Fin n→ℕ) (u : Fin m) (v : Fin n) :
+    capacityEntry (natCode c,(u.val,v.val))=c u v := by
+  simp only [capacityEntry,natCode,List.getD_eq_getElem?_getD,List.getElem?_ofFn,
+    u.isLt,v.isLt,dite_true,Option.getD_some,Fin.eta]
+
+lemma flowEntry_code {m n : ℕ} (f : Fin m→Fin n→ℤ) (u : Fin m) (v : Fin n) :
+    flowEntry (flowCode f,(u.val,v.val))=ForestAffineProgram.signedParts (f u v) := by
+  simp only [flowEntry,flowCode,List.getD_eq_getElem?_getD,List.getElem?_ofFn,
+    u.isLt,v.isLt,dite_true,Option.getD_some,Fin.eta]
+
+lemma residualValue_correct (c : ℕ) (z : Signed) :
+    residualValue (c,z)=((c:ℤ)-SignedPairProgram.value z).toNat := by
+  unfold residualValue SignedPairProgram.value
+  dsimp only
+  omega
+
+lemma positive_correct (c : ℕ) (z : Signed) :
+    positive (c,z)=decide (0<(c:ℤ)-SignedPairProgram.value z) := by
+  apply Bool.eq_iff_iff.mpr
+  change (decide (z.1 < c+z.2)=true) ↔
+    (decide (0<(c:ℤ)-SignedPairProgram.value z)=true)
+  rw [decide_eq_true_eq,decide_eq_true_eq]
+  change z.1 < c+z.2 ↔ 0<(c:ℤ)-((z.1:ℤ)-z.2)
+  omega
+
+lemma arc_code {n : ℕ} (c : PublishedEdmondsKarp.Capacity n)
+    (f : PublishedEdmondsKarp.Flow n) (u v : Fin n) :
+    arc ((natCode c,flowCode f),(u.val,v.val))=ResidualSearch.edge c f u v := by
+  simp only [arc,arcData,capacityEntry_code,flowEntry_code,positive_correct,
+    SignedPairProgram.value,ForestAffineProgram.signedParts_sub,ResidualSearch.edge]
+
+lemma graph_code {n : ℕ} (c : PublishedEdmondsKarp.Capacity n)
+    (f : PublishedEdmondsKarp.Flow n) :
+    graph (natCode c,flowCode f)=DirectedBFSCode.graphCode (ResidualSearch.edge c f) := by
+  simp only [graph,arcRow,natCode,List.length_ofFn,DirectedBFSCode.range_eq_map,
+    ←List.ofFn_eq_map,List.map_ofFn,DirectedBFSCode.graphCode]
+  apply congrArg List.ofFn
+  funext u
+  apply congrArg List.ofFn
+  funext v
+  exact arc_code c f u v
+
+def search (z : Data×(ℕ×ℕ)) : Option (List ℕ) :=
+  DirectedBFSCode.search (graph z.1) z.2.1 z.2.2
+
+def searchRealizer : Realizer search :=
+  composition (pair (pair (composition first graphRealizer) (composition second first))
+    (composition second second)) DirectedBFSRuntime.searchRealizer
+
+lemma polynomial_search : PolynomialTime searchRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_graph)
+    (polynomial_composition polynomial_second polynomial_first))
+    (polynomial_composition polynomial_second polynomial_second))
+    DirectedBFSRuntime.polynomial_search
+
+lemma search_code {n : ℕ} (c : PublishedEdmondsKarp.Capacity n)
+    (f : PublishedEdmondsKarp.Flow n) (s t : Fin n) :
+    search ((natCode c,flowCode f),(s.val,t.val))=
+      (ResidualSearch.search c f s t).map (List.map Fin.val) := by
+  rw [search,graph_code,DirectedBFSCode.search_code]
+  rfl
+
+end ContingencyTables.ResidualGraphProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ResidualWeightProgram.lean

@@ -0,0 +1,57 @@
+import OAI.Combinatorics.ContingencyTables.Transport.IntegerResidualCorrection
+import OAI.Combinatorics.ContingencyTables.Machines.VectorRetryProgram
+
+namespace OAI
+
+/-! # Binary computation of the rare branch's integer weights -/
+
+namespace ContingencyTables.ResidualWeightPrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+open scoped BigOperators Classical
+
+abbrev Input := (ℕ×ℕ)×(ℕ×ℕ)
+
+/-- Common denominator, inverse branch probability, number of tables,
+and the ordinary draw's numerator. -/
+def count (z : Input) : ℕ := z.1.1*z.1.2-z.2.1*(z.1.2-1)*z.2.2
+
+def countRealizer : Realizer count := by
+  let denominator : Realizer (fun z : Input => z.1.1) := composition first first
+  let branch : Realizer (fun z : Input => z.1.2) := composition first second
+  let cardinality : Realizer (fun z : Input => z.2.1) := composition second first
+  let numerator : Realizer (fun z : Input => z.2.2) := composition second second
+  let left := composition (pair denominator branch) multiply
+  let right := composition (pair (composition (pair cardinality
+    (composition branch predecessor)) multiply) numerator) multiply
+  exact composition (pair left right) subtract
+
+lemma polynomial_count : PolynomialTime countRealizer := by
+  unfold countRealizer
+  exact polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_composition polynomial_first polynomial_second)) polynomial_multiply)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_second polynomial_first)
+        (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
+          polynomial_predecessor)) polynomial_multiply)
+      (polynomial_composition polynomial_second polynomial_second)) polynomial_multiply))
+    polynomial_subtract
+
+lemma count_actual {A : Type*} [Fintype A] {Q : ℕ} (p : IntegerLaw A Q)
+    (T : ℕ) (hT : 0<T) (a : A) :
+    count ((Q,T),(Fintype.card A,p.count a))=IntegerResidualCorrection.count p T a := by
+  have ht : (T:ℤ)-1=((T-1:ℕ):ℤ) := by omega
+  have he : ResidualMixture.residualNumerator Q T (fun x => (p.count x:ℤ)) a=
+      ((Q*T:ℕ):ℤ)-((Fintype.card A*(T-1)*p.count a:ℕ):ℤ) := by
+    unfold ResidualMixture.residualNumerator
+    rw [ht]
+    push_cast
+    rfl
+  rw [IntegerResidualCorrection.count,he,Int.toNat_sub]
+  rfl
+
+end ContingencyTables.ResidualWeightPrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/RetryNumeratorProgram.lean

@@ -0,0 +1,121 @@
+import OAI.Combinatorics.ContingencyTables.Machines.BinaryPowerProgram
+import OAI.Combinatorics.ContingencyTables.Transport.IntegerLaw
+
+namespace OAI
+
+/-! # Binary first-success numerators via a two-coordinate recurrence -/
+
+namespace ContingencyTables.RetryNumeratorPrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+/-- Unary trial count; denominator, failure count, success count, fallback match. -/
+abbrev Input := List Bool×((ℕ×ℕ)×(ℕ×Bool))
+
+def twoEntries {A : Type} [Codec A] : Realizer (fun x : A×A => [x.1,x.2]) :=
+  composition (pair first (composition second BinaryPowerPrograms.singleton)) listCons
+
+lemma polynomial_twoEntries {A : Type} [Codec A] : PolynomialTime (twoEntries (A := A)) :=
+  polynomial_composition (polynomial_pair polynomial_first
+    (polynomial_composition polynomial_second BinaryPowerPrograms.polynomial_singleton))
+    polynomial_listCons
+
+def setup (z : Input) : ℕ×(List (List ℕ)×List ℕ) :=
+  (z.1.length,([[z.2.1.2,z.2.2.1],[0,z.2.1.1]],[(if z.2.2.2 then 1 else 0),1]))
+
+def setupRealizer : Realizer setup := by
+  let Q : Realizer (fun z : Input => z.2.1.1) := composition (composition second first) first
+  let phi : Realizer (fun z : Input => z.2.1.2) := composition (composition second first) second
+  let alpha : Realizer (fun z : Input => z.2.2.1) := composition (composition second second) first
+  let hit : Realizer (fun z : Input => z.2.2.2) := composition (composition second second) second
+  let column1 := composition (pair phi alpha) twoEntries
+  let column2 := composition (pair (constant 0) Q) twoEntries
+  let matrix := composition (pair column1 column2) twoEntries
+  let initial := choose hit (constant 1) (constant 0)
+  let vector := composition (pair initial (constant 1)) twoEntries
+  exact pair (composition first listLength) (pair matrix vector)
+
+lemma polynomial_setup : PolynomialTime setupRealizer := by
+  have hQ : PolynomialTime (composition (composition
+      (second (A := List Bool) (B := (ℕ×ℕ)×(ℕ×Bool))) first) first) := by tree_poly
+  have hphi : PolynomialTime (composition (composition
+      (second (A := List Bool) (B := (ℕ×ℕ)×(ℕ×Bool))) first) second) := by tree_poly
+  have halpha : PolynomialTime (composition (composition
+      (second (A := List Bool) (B := (ℕ×ℕ)×(ℕ×Bool))) second) first) := by tree_poly
+  have hhit : PolynomialTime (composition (composition
+      (second (A := List Bool) (B := (ℕ×ℕ)×(ℕ×Bool))) second) second) := by tree_poly
+  unfold setupRealizer
+  exact polynomial_pair (polynomial_composition polynomial_first polynomial_listLength)
+    (polynomial_pair (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair hphi halpha) polynomial_twoEntries)
+      (polynomial_composition (polynomial_pair (polynomial_constant 0) hQ) polynomial_twoEntries))
+      polynomial_twoEntries)
+      (polynomial_composition (polynomial_pair
+        (polynomial_choose hhit (polynomial_constant 1) (polynomial_constant 0))
+        (polynomial_constant 1)) polynomial_twoEntries))
+
+def count (z : Input) : ℕ := (IntegerMatrixPrograms.iterate (setup z)).headD 0
+
+def countRealizer : Realizer count :=
+  composition (composition setupRealizer IntegerMatrixPrograms.iterateRealizer) (head 0)
+
+/-- All stored numbers are binary; only the supplied trial marker controls
+iteration, so evaluation is polynomial in that marker and binary data. -/
+theorem polynomial_count : PolynomialTime countRealizer := by
+  have hi : PolynomialTime (composition setupRealizer IntegerMatrixPrograms.iterateRealizer) := by
+    obtain ⟨p,hp⟩ := polynomial_setup
+    apply work_composition ⟨p,hp⟩ IntegerMatrixPrograms.work_iterate (Polynomial.X+p)
+    intro z
+    have hl := (list_length_le_weight z.1).trans (weight_fst z)
+    have hw := weight_snd (setup z)
+    have hc := hp z
+    simp only [Polynomial.eval_add,Polynomial.eval_X,setup] at *
+    omega
+  exact polynomial_composition hi (polynomial_head 0)
+
+def recurrence (Q phi alpha initial : ℕ) : ℕ → ℕ
+  | 0 => initial
+  | n+1 => phi*recurrence Q phi alpha initial n+alpha*Q^n
+
+private lemma iterate_eq (B : List (List ℕ)) (v : List ℕ) (N : ℕ) :
+    IntegerMatrixPrograms.iterate (N,(B,v))=
+      ((fun v => IntegerMatrixPrograms.propagate (B,v))^[N]) v := by
+  induction N generalizing v with
+  | zero => rfl
+  | succ N ih =>
+    rw [IntegerMatrixPrograms.iterate_succ,ih,Function.iterate_succ_apply]
+
+private lemma propagate_two (Q phi alpha x y : ℕ) :
+    IntegerMatrixPrograms.propagate ([[phi,alpha],[0,Q]],[x,y])=
+      [phi*x+alpha*y,Q*y] := by
+  simp [IntegerMatrixPrograms.propagate,IntegerMatrixPrograms.dot_cons,
+    IntegerMatrixPrograms.dot_nil,Nat.mul_comm]
+
+lemma count_eq (xs : List Bool) (Q phi alpha : ℕ) (hit : Bool) :
+    count (xs,((Q,phi),(alpha,hit)))=
+      recurrence Q phi alpha (if hit then 1 else 0) xs.length := by
+  have hiter (N initial : ℕ) :
+      ((fun v => IntegerMatrixPrograms.propagate ([[phi,alpha],[0,Q]],v))^[N]) [initial,1]=
+        [recurrence Q phi alpha initial N,Q^N] := by
+    induction N with
+    | zero => simp [recurrence]
+    | succ N ih =>
+      rw [Function.iterate_succ_apply',ih,propagate_two]
+      simp only [recurrence,pow_succ]
+      rw [Nat.mul_comm Q (Q^N)]
+  unfold count setup
+  rw [iterate_eq,hiter]
+  rfl
+
+lemma recurrence_retry {A : Type*} [Fintype A] [DecidableEq A] {Q : ℕ}
+    (p : IntegerLaw (Option A) Q) (fallback x : A) (N : ℕ) :
+    recurrence Q (p.count none) (p.count (some x)) (if x=fallback then 1 else 0) N=
+      IntegerLaw.retryCount p fallback N x := by
+  induction N with
+  | zero => rfl
+  | succ N ih =>
+    rw [recurrence,ih,IntegerLaw.retryCount]
+    exact Nat.add_comm _ _
+
+end ContingencyTables.RetryNumeratorPrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/RoundedPowerProgram.lean

@@ -0,0 +1,133 @@
+import OAI.Combinatorics.ContingencyTables.Machines.SignedFloorProgram
+import OAI.Combinatorics.ContingencyTables.Machines.DyadicRootProgram
+import OAI.Combinatorics.ContingencyTables.Transport.PowerOfTwoApproximation
+
+namespace OAI
+
+/-! # Executing the rounded power used by the correction oracle
+
+The exponent lies in [-2,2]. Clipping the computed signed floor
+at twice the supplied degree allowance plus one is therefore inactive
+on valid inputs, and keeps every binary execution polynomial even on
+arbitrary malformed numerator/denominator data.
+-/
+
+namespace ContingencyTables.RoundedPowerProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial SignedPairProgram
+
+abbrev Input := SignedFloorProgram.ScaledInput
+
+def normalized (z : Input) : Signed := SignedPairProgram.normalize (SignedFloorProgram.scaledFloor z)
+def normalizedRealizer : Realizer normalized :=
+  composition SignedFloorProgram.scaledFloorRealizer SignedPairProgram.normalizeRealizer
+lemma polynomial_normalized : PolynomialTime normalizedRealizer :=
+  polynomial_composition SignedFloorProgram.polynomial_scaledFloor SignedPairProgram.polynomial_normalize
+
+def cap (z : Input) : ℕ := 2*z.2.length+1
+def capRealizer : Realizer cap := composition
+  (f:=fun z : Input=>2*z.2.length) (g:=Nat.succ)
+  (composition (f:=fun z : Input=>(2,z.2.length)) (g:=fun p : ℕ×ℕ=>p.1*p.2)
+    (pair (constant 2) (composition second listLength)) multiply) successor
+lemma polynomial_cap : PolynomialTime capRealizer :=
+  polynomial_composition (polynomial_composition
+    (polynomial_pair (polynomial_constant 2)
+      (polynomial_composition polynomial_second polynomial_listLength)) polynomial_multiply)
+    polynomial_successor
+
+def clipped (z : Input) : Signed :=
+  (min (normalized z).1 (cap z),min (normalized z).2 (cap z))
+def clippedRealizer : Realizer clipped := pair
+  (composition (pair (composition normalizedRealizer first) capRealizer) minimum)
+  (composition (pair (composition normalizedRealizer second) capRealizer) minimum)
+lemma polynomial_clipped : PolynomialTime clippedRealizer := polynomial_pair
+  (polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_normalized polynomial_first) polynomial_cap) polynomial_minimum)
+  (polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_normalized polynomial_second) polynomial_cap) polynomial_minimum)
+
+def positiveInput (z : Input) : ℕ×ℕ := (2,(clipped z).1)
+def negativeInput (z : Input) : ℕ×ℕ := (2,(clipped z).2)
+def positiveInputRealizer : Realizer positiveInput := pair (constant 2) (composition clippedRealizer first)
+def negativeInputRealizer : Realizer negativeInput := pair (constant 2) (composition clippedRealizer second)
+lemma polynomial_positiveInput : PolynomialTime positiveInputRealizer :=
+  polynomial_pair (polynomial_constant 2) (polynomial_composition polynomial_clipped polynomial_first)
+lemma polynomial_negativeInput : PolynomialTime negativeInputRealizer :=
+  polynomial_pair (polynomial_constant 2) (polynomial_composition polynomial_clipped polynomial_second)
+
+def positivePower (z : Input) : ℕ := BinaryPowerPrograms.power (positiveInput z)
+def negativePower (z : Input) : ℕ := BinaryPowerPrograms.power (negativeInput z)
+def positivePowerRealizer : Realizer positivePower :=
+  composition positiveInputRealizer BinaryPowerPrograms.powerRealizer
+def negativePowerRealizer : Realizer negativePower :=
+  composition negativeInputRealizer BinaryPowerPrograms.powerRealizer
+
+lemma polynomial_positivePower : PolynomialTime positivePowerRealizer := by
+  apply work_composition polynomial_positiveInput BinaryPowerPrograms.work_power (2*X+10)
+  intro z
+  have hl: z.2.length ≤ weight z:=(list_length_le_weight z.2).trans (weight_snd z)
+  have hm: (clipped z).1 ≤ cap z:=min_le_right _ _
+  have ht: weight (2:ℕ) ≤ 9:=by decide
+  simp only [positiveInput,cap,eval_add,eval_mul,eval_ofNat,eval_X] at *
+  omega
+
+lemma polynomial_negativePower : PolynomialTime negativePowerRealizer := by
+  apply work_composition polynomial_negativeInput BinaryPowerPrograms.work_power (2*X+10)
+  intro z
+  have hl: z.2.length ≤ weight z:=(list_length_le_weight z.2).trans (weight_snd z)
+  have hm: (clipped z).2 ≤ cap z:=min_le_right _ _
+  have ht: weight (2:ℕ) ≤ 9:=by decide
+  simp only [negativeInput,cap,eval_add,eval_mul,eval_ofNat,eval_X] at *
+  omega
+
+def output (z : Input) : TreeFraction.Fraction :=
+  TreeFraction.normalize (positivePower z,negativePower z)
+def outputRealizer : Realizer output :=
+  composition (pair positivePowerRealizer negativePowerRealizer) TreeFraction.normalizeRealizer
+theorem polynomial_output : PolynomialTime outputRealizer :=
+  polynomial_composition (polynomial_pair polynomial_positivePower polynomial_negativePower)
+    TreeFraction.polynomial_normalize
+
+lemma floor_bounds (beta : ℚ) (hlo : -2 ≤ beta) (hhi : beta ≤ 2) (s : ℕ) :
+    -2*(s:ℤ) ≤ ⌊(s:ℚ)*beta⌋ ∧ ⌊(s:ℚ)*beta⌋ ≤ 2*(s:ℤ) := by
+  have hL:=mul_le_mul_of_nonneg_left hlo (Nat.cast_nonneg s : (0:ℚ) ≤ s)
+  have hU:=mul_le_mul_of_nonneg_left hhi (Nat.cast_nonneg s : (0:ℚ) ≤ s)
+  constructor
+  · apply Int.le_floor.mpr
+    push_cast
+    linarith
+  · have hf: (⌊(s:ℚ)*beta⌋:ℚ) ≤ 2*s:=(Int.floor_le _).trans (by linarith)
+    exact_mod_cast hf
+
+lemma clipped_eq (p n d : ℕ) (xs : List Bool)
+    (hlo: -2 ≤ ((p:ℚ)-n)/d) (hhi: ((p:ℚ)-n)/d ≤ 2) :
+    clipped (((p,n),d),xs)=
+      ((⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋:ℤ).toNat,
+        (-⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋:ℤ).toNat) := by
+  have hb:=floor_bounds _ hlo hhi xs.length
+  have hp: (⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋:ℤ).toNat ≤ 2*xs.length+1:=by omega
+  have hn: (-⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋:ℤ).toNat ≤ 2*xs.length+1:=by omega
+  simp only [clipped,normalized,SignedPairProgram.normalize_eq,SignedFloorProgram.scaledFloor_value,
+    ForestAffineProgram.signedParts,cap,min_eq_left hp,min_eq_left hn]
+
+/-- The returned natural fraction is exactly the rational power used
+by the approximation, including negative rounded exponents. -/
+theorem output_value (p n d : ℕ) (xs : List Bool)
+    (hlo: -2 ≤ ((p:ℚ)-n)/d) (hhi: ((p:ℚ)-n)/d ≤ 2) :
+    TreeFraction.val (output (((p,n),d),xs))=
+      (2:ℚ)^PowerOfTwoApproximation.numerator (((p:ℚ)-n)/d) xs.length := by
+  rw [output,TreeFraction.normalize_val]
+  simp only [positivePower,negativePower,positiveInput,negativeInput,
+    BinaryPowerPrograms.power_eq,clipped_eq p n d xs hlo hhi,TreeFraction.val,Nat.cast_pow,Nat.cast_ofNat]
+  let q:ℤ:=⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋
+  change (2:ℚ)^q.toNat/(2:ℚ)^(-q).toNat=(2:ℚ)^q
+  have he: (q.toNat:ℤ)-(-q).toNat=q:=by omega
+  conv_rhs => rw [←he]
+  rw [zpow_sub₀ (by norm_num : (2:ℚ)≠0),zpow_natCast,zpow_natCast]
+
+theorem output_denominator_pos (z : Input) : 0<(output z).2 :=
+  TreeFraction.normalize_den_pos _
+
+end ContingencyTables.RoundedPowerProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScalarScheduleBounds.lean

@@ -0,0 +1,46 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ScalarScheduleProgram
+
+namespace OAI
+
+/-! # Numeric bounds for the fixed arithmetic circuits -/
+
+namespace ContingencyTables.ScalarScheduleProgram
+open Polynomial
+noncomputable section
+
+def Expr.bound : Expr → Polynomial ℕ
+  | .input _ => X
+  | .number n => C n
+  | .plus a b => a.bound+b.bound
+  | .times a b => a.bound*b.bound
+
+lemma Expr.eval_le (e : Expr) (xs : List ℕ) (M : ℕ)
+    (h : ∀ i,xs.getD i 0 ≤ M) : e.eval xs ≤ e.bound.eval M := by
+  induction e with
+  | input i => simpa only [Expr.eval,Expr.bound,Polynomial.eval_X] using h i
+  | number n => simp only [Expr.eval,Expr.bound,eval_C,le_refl]
+  | plus a b ha hb =>
+    simp only [Expr.eval,Expr.bound,Polynomial.eval_add]
+    exact Nat.add_le_add ha hb
+  | times a b ha hb =>
+    simp only [Expr.eval,Expr.bound,Polynomial.eval_mul]
+    exact Nat.mul_le_mul ha hb
+
+lemma getD_le_of_mem (xs : List ℕ) (M : ℕ) (h : ∀ x∈xs,x ≤ M) :
+    ∀ i,xs.getD i 0 ≤ M := by
+  induction xs with
+  | nil => intro i; simp
+  | cons x xs ih =>
+    intro i
+    cases i with
+    | zero => simpa using h x (by simp)
+    | succ i =>
+      simpa using ih (fun y hy => h y (by simp only [List.mem_cons]; exact Or.inr hy)) i
+
+lemma Expr.eval_le_of_mem (e : Expr) (xs : List ℕ) (M : ℕ) (h : ∀ x∈xs,x ≤ M) :
+    e.eval xs ≤ e.bound.eval M := e.eval_le xs M (getD_le_of_mem xs M h)
+
+end
+end ContingencyTables.ScalarScheduleProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScalarScheduleProgram.lean

@@ -0,0 +1,82 @@
+import OAI.Combinatorics.MatchingCount.Machines.TreeFastLookup
+import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialDivision
+
+namespace OAI
+
+/-! # Fixed arithmetic circuits for the scalar counting schedules
+
+These circuits only read a fixed finite list and perform binary addition
+and multiplication. Their syntax describes the fixed program, not a
+numeric loop selected by the input.
+-/
+
+namespace ContingencyTables.ScalarScheduleProgram
+open MatchingFPRAS.TreeTyped
+
+inductive Expr where
+  | input : ℕ → Expr
+  | number : ℕ → Expr
+  | plus : Expr → Expr → Expr
+  | times : Expr → Expr → Expr
+
+def Expr.eval : Expr → List ℕ → ℕ
+  | .input i, xs => xs.getD i 0
+  | .number n, _ => n
+  | .plus a b, xs => a.eval xs+b.eval xs
+  | .times a b, xs => a.eval xs*b.eval xs
+
+def Expr.realizer : (e : Expr) → Realizer e.eval
+  | .input i => composition (pair identity (constant i)) (getDFast 0)
+  | .number n => constant n
+  | .plus a b => composition (pair a.realizer b.realizer) add
+  | .times a b => composition (pair a.realizer b.realizer) multiply
+
+lemma Expr.polynomial (e : Expr) : PolynomialTime e.realizer := by
+  induction e with
+  | input i => exact polynomial_composition (polynomial_pair polynomial_identity
+      (polynomial_constant i)) (polynomial_getDFast 0)
+  | number n => exact polynomial_constant n
+  | plus a b ha hb => exact polynomial_composition (polynomial_pair ha hb) polynomial_add
+  | times a b ha hb => exact polynomial_composition (polynomial_pair ha hb) polynomial_multiply
+
+def Expr.pow (a : Expr) : ℕ → Expr
+  | 0 => .number 1
+  | n+1 => .times (a.pow n) a
+
+lemma Expr.eval_pow (a : Expr) (n : ℕ) (xs : List ℕ) :
+    (a.pow n).eval xs=(a.eval xs)^n := by
+  induction n with
+  | zero => rfl
+  | succ n ih => simp only [Expr.pow,Expr.eval,ih,pow_succ]
+
+
+instance (n : ℕ) : OfNat Expr n := ⟨.number n⟩
+instance : Add Expr := ⟨.plus⟩
+instance : Mul Expr := ⟨.times⟩
+instance : Pow Expr ℕ := ⟨Expr.pow⟩
+
+@[simp] lemma Expr.eval_power (a : Expr) (n : ℕ) (xs : List ℕ) :
+    (a^n).eval xs=(a.eval xs)^n := Expr.eval_pow a n xs
+
+@[simp] lemma Expr.eval_add (a b : Expr) (xs : List ℕ) :
+    (a+b).eval xs=a.eval xs+b.eval xs := rfl
+@[simp] lemma Expr.eval_mul (a b : Expr) (xs : List ℕ) :
+    (a*b).eval xs=a.eval xs*b.eval xs := rfl
+@[simp] lemma Expr.eval_ofNat (n : ℕ) (xs : List ℕ) :
+    (OfNat.ofNat n : Expr).eval xs=n := rfl
+
+def vector (es : List Expr) (xs : List ℕ) : List ℕ := es.map (fun e => e.eval xs)
+
+def vectorRealizer : (es : List Expr) → Realizer (vector es)
+  | [] => constant []
+  | e::es => composition (pair e.realizer (vectorRealizer es)) listCons
+
+lemma polynomial_vector (es : List Expr) : PolynomialTime (vectorRealizer es) := by
+  induction es with
+  | nil => exact polynomial_constant []
+  | cons e es ih => exact polynomial_composition (polynomial_pair e.polynomial ih) polynomial_listCons
+
+
+end ContingencyTables.ScalarScheduleProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScaledWordProgram.lean

@@ -0,0 +1,43 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ListWordProgram
+import OAI.Combinatorics.ContingencyTables.Transport.FiniteScaledDraw
+
+namespace OAI
+
+/-! # Polynomial binary execution of the bounded quotient draw -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+
+def scaledWordValue (x : ℕ×List Bool) : ℕ :=
+  x.1*StackAddition.value x.2/2^x.2.length
+
+def scaledWordRealizer : Realizer scaledWordValue :=
+  (composition (pair
+    (composition (pair first (composition second bitValue)) multiply)
+    (composition second bitDenominatorRealizer)) quotient).congr (by
+      intro x
+      simp only [Function.comp_apply,bitDenominator_eq,scaledWordValue])
+
+theorem polynomial_scaledWord : PolynomialTime scaledWordRealizer := by
+  unfold scaledWordRealizer
+  exact polynomial_congr _ (polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_first
+      (polynomial_composition polynomial_second polynomial_bitValue)) polynomial_multiply)
+    (polynomial_composition polynomial_second polynomial_bitDenominator)) polynomial_quotient)
+
+theorem scaledWordValue_ofFn (M k : ℕ) (hM : 0<M) (bits : Fin k → Bool) :
+    scaledWordValue (M,List.ofFn bits)=(FairBits.scaledBitInteger M k hM bits).val := by
+  simp only [scaledWordValue,List.length_ofFn,bitValue_eq_word]
+  rfl
+
+/-- Every finite input yields the prescribed bounded integer. -/
+theorem scaledWordValue_lt (M : ℕ) (hM : 0<M) (bits : List Bool) :
+    scaledWordValue (M,bits)<M := by
+  let w : Fin bits.length → Bool := fun i => bits[i]
+  have he : List.ofFn w=bits := List.ofFn_getElem
+  rw [←he,scaledWordValue_ofFn M bits.length hM w]
+  exact (FairBits.scaledBitInteger M bits.length hM w).isLt
+
+end ContingencyTables.ProfilePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScheduledCountInput.lean

@@ -0,0 +1,233 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.OriginalOuterVector
+import OAI.Combinatorics.ContingencyTables.Sampling.UnitOuterVector
+import OAI.Combinatorics.ContingencyTables.Sampling.AllSamplingProgram
+import OAI.Combinatorics.ContingencyTables.Sampling.ProfileScheduleSemantics
+import OAI.Combinatorics.ContingencyTables.Transport.UnaryMarkers
+
+namespace OAI
+
+/-! # Supplying the finite count evaluator from the public sampling parameters -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms Polynomial
+
+attribute [local irreducible] initialCheck marginPadding parameterDimension parameterAccuracy
+  parameterCompletionWidth parameterSteps parameterProposalWidth hasLargeRectangle parameterTrials
+  profileBoxIndex outerVector UnitCountPrograms.outerVector
+
+/-- The same cache parameters used by the executed approximate sampler. -/
+def scheduledCacheParameters (z : SamplingParameters) : TransitionCacheParameters :=
+  (((initialCheck z.1,marginPadding z.1),(parameterDimension z,parameterAccuracy z)),
+    parameterCompletionWidth z)
+
+def scheduledCacheParametersRealizer : Realizer scheduledCacheParameters :=
+  pair (pair (pair (composition (f := fun z : SamplingParameters => z.1) (g := initialCheck) first initialCheckRealizer)
+    (composition (f := fun z : SamplingParameters => z.1) (g := marginPadding) first marginPaddingRealizer))
+    (pair parameterDimensionRealizer parameterAccuracyRealizer)) parameterCompletionWidthRealizer
+
+lemma polynomial_scheduledCacheParameters : PolynomialTime scheduledCacheParametersRealizer :=
+  polynomial_pair (polynomial_pair (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_initialCheck)
+    (polynomial_composition polynomial_first polynomial_marginPadding))
+    (polynomial_pair polynomial_parameterDimension polynomial_parameterAccuracy))
+    polynomial_parameterCompletionWidth
+
+def scheduledDenseWidth (z : SamplingParameters) : ℕ :=
+  parameterSteps z*(parameterProposalWidth z+parameterCompletionWidth z)+parameterCompletionWidth z
+
+def scheduledDenseWidthRealizer : Realizer scheduledDenseWidth :=
+  composition (f := fun z : SamplingParameters =>
+    (parameterSteps z*(parameterProposalWidth z+parameterCompletionWidth z),parameterCompletionWidth z))
+    (g := fun p : ℕ×ℕ => p.1+p.2)
+    (pair (composition (f := fun z : SamplingParameters =>
+      (parameterSteps z,parameterProposalWidth z+parameterCompletionWidth z))
+      (g := fun p : ℕ×ℕ => p.1*p.2)
+      (pair parameterStepsRealizer (composition
+        (f := fun z : SamplingParameters => (parameterProposalWidth z,parameterCompletionWidth z))
+        (g := fun p : ℕ×ℕ => p.1+p.2)
+        (pair parameterProposalWidthRealizer parameterCompletionWidthRealizer) add)) multiply)
+      parameterCompletionWidthRealizer) add
+
+lemma polynomial_scheduledDenseWidth : PolynomialTime scheduledDenseWidthRealizer :=
+  polynomial_composition (polynomial_pair (polynomial_composition
+    (polynomial_pair polynomial_parameterSteps (polynomial_composition
+      (polynomial_pair polynomial_parameterProposalWidth polynomial_parameterCompletionWidth)
+      polynomial_add)) polynomial_multiply) polynomial_parameterCompletionWidth) polynomial_add
+
+def scheduledUnitWidth (z : SamplingParameters) : ℕ := parameterSteps z*parameterProposalWidth z
+
+def scheduledUnitWidthRealizer : Realizer scheduledUnitWidth :=
+  composition (f := fun z : SamplingParameters => (parameterSteps z,parameterProposalWidth z))
+    (g := fun p : ℕ×ℕ => p.1*p.2) (pair parameterStepsRealizer parameterProposalWidthRealizer) multiply
+
+lemma polynomial_scheduledUnitWidth : PolynomialTime scheduledUnitWidthRealizer :=
+  polynomial_composition (polynomial_pair polynomial_parameterSteps polynomial_parameterProposalWidth)
+    polynomial_multiply
+
+attribute [local irreducible] scheduledDenseWidth scheduledUnitWidth
+
+/-- The all-small branch uses only the proposal bits of each walk. -/
+def scheduledTrialWidth (z : SamplingParameters) : ℕ :=
+  if hasLargeRectangle z then scheduledDenseWidth z else scheduledUnitWidth z
+
+def scheduledTrialWidthRealizer : Realizer scheduledTrialWidth :=
+  choose hasLargeRectangleRealizer scheduledDenseWidthRealizer scheduledUnitWidthRealizer
+
+lemma polynomial_scheduledTrialWidth : PolynomialTime scheduledTrialWidthRealizer :=
+  polynomial_choose polynomial_hasLargeRectangle polynomial_scheduledDenseWidth polynomial_scheduledUnitWidth
+
+attribute [local irreducible] scheduledTrialWidth
+
+/-- Numeric loop lengths are charged explicitly, in addition to binary input size. -/
+def scheduledCountInputMeasure (z : SamplingParameters) : ℕ :=
+  parameterSteps z+parameterTrials z+parameterProposalWidth z+scheduledTrialWidth z+weight z
+
+lemma weight_le_scheduledCountInputMeasure (z : SamplingParameters) :
+    weight z ≤ X.eval (scheduledCountInputMeasure z) := by
+  simp only [eval_X,scheduledCountInputMeasure]
+  omega
+
+def scheduledMatrixParameters (z : SamplingParameters) : MatrixParameters :=
+  (scheduledCacheParameters z,unaryMarkers (parameterProposalWidth z))
+
+def scheduledMatrixParametersRealizer : Realizer scheduledMatrixParameters :=
+  pair scheduledCacheParametersRealizer
+    (composition (f := parameterProposalWidth) (g := unaryMarkers)
+      parameterProposalWidthRealizer unaryMarkersRealizer)
+
+attribute [local irreducible] scheduledMatrixParameters
+
+lemma work_scheduledMatrixParameters :
+    WorkBound scheduledMatrixParametersRealizer scheduledCountInputMeasure := by
+  unfold scheduledMatrixParametersRealizer scheduledMatrixParameters
+  have hm : WorkBound (composition parameterProposalWidthRealizer unaryMarkersRealizer)
+      scheduledCountInputMeasure := by
+    apply work_composition (work_of_polynomial polynomial_parameterProposalWidth X
+      weight_le_scheduledCountInputMeasure) work_unaryMarkers X
+    intro z
+    simp only [id_eq,eval_X,scheduledCountInputMeasure]
+    omega
+  exact work_pair (work_of_polynomial polynomial_scheduledCacheParameters X
+    weight_le_scheduledCountInputMeasure) hm X weight_le_scheduledCountInputMeasure
+
+def scheduledStartIndex (z : SamplingParameters) : ℕ := profileBoxIndex (initialCheck z.1)
+
+def scheduledStartIndexRealizer : Realizer scheduledStartIndex :=
+  composition (composition (f := fun z : SamplingParameters => z.1) (g := initialCheck) first initialCheckRealizer) profileBoxIndexRealizer
+
+lemma polynomial_scheduledStartIndex : PolynomialTime scheduledStartIndexRealizer :=
+  polynomial_composition (polynomial_composition polynomial_first polynomial_initialCheck)
+    polynomial_profileBoxIndex
+
+def scheduledWalkInput (z : SamplingParameters) : WalkCountInput :=
+  (scheduledMatrixParameters z,(parameterSteps z,scheduledStartIndex z))
+
+def scheduledWalkInputRealizer : Realizer scheduledWalkInput :=
+  pair scheduledMatrixParametersRealizer (pair parameterStepsRealizer scheduledStartIndexRealizer)
+
+attribute [local irreducible] scheduledWalkInput
+
+lemma work_scheduledWalkInput : WorkBound scheduledWalkInputRealizer scheduledCountInputMeasure := by
+  unfold scheduledWalkInputRealizer scheduledWalkInput
+  exact work_pair work_scheduledMatrixParameters
+    (work_of_polynomial (polynomial_pair polynomial_parameterSteps polynomial_scheduledStartIndex)
+      X weight_le_scheduledCountInputMeasure) X weight_le_scheduledCountInputMeasure
+
+def scheduledTrialInput (z : SamplingParameters) : TrialVectorInput := (scheduledWalkInput z,z.1)
+
+def scheduledTrialInputRealizer : Realizer scheduledTrialInput := pair scheduledWalkInputRealizer first
+
+attribute [local irreducible] scheduledTrialInput
+
+lemma work_scheduledTrialInput : WorkBound scheduledTrialInputRealizer scheduledCountInputMeasure := by
+  unfold scheduledTrialInputRealizer scheduledTrialInput
+  exact work_pair work_scheduledWalkInput (work_of_polynomial polynomial_first X
+    weight_le_scheduledCountInputMeasure) X weight_le_scheduledCountInputMeasure
+
+def scheduledTrialDenominator (z : SamplingParameters) : ℕ :=
+  BinaryPowerPrograms.power (2,scheduledTrialWidth z)
+
+def scheduledTrialDenominatorRealizer : Realizer scheduledTrialDenominator :=
+  composition (f := fun z : SamplingParameters => (2,scheduledTrialWidth z))
+    (g := BinaryPowerPrograms.power)
+    (pair (constant 2) scheduledTrialWidthRealizer) BinaryPowerPrograms.powerRealizer
+
+attribute [local irreducible] scheduledTrialDenominator
+
+lemma work_scheduledTrialDenominator :
+    WorkBound scheduledTrialDenominatorRealizer scheduledCountInputMeasure := by
+  unfold scheduledTrialDenominatorRealizer scheduledTrialDenominator
+  apply work_composition (work_of_polynomial
+    (polynomial_pair (polynomial_constant 2) polynomial_scheduledTrialWidth)
+      X weight_le_scheduledCountInputMeasure) BinaryPowerPrograms.work_power (X+C (weight (2:ℕ)))
+  intro z
+  simp only [eval_add,eval_X,eval_C,scheduledCountInputMeasure]
+  omega
+
+def scheduledOuterInput (z : SamplingParameters) : OuterVectorInput :=
+  (scheduledTrialInput z,((unaryMarkers (parameterTrials z),scheduledTrialDenominator z),
+    GreedyFeasibleTable.listMatrix z.1.1 z.1.2))
+
+def scheduledOuterInputRealizer : Realizer scheduledOuterInput :=
+  pair scheduledTrialInputRealizer
+    (pair (pair (composition (f := parameterTrials) (g := unaryMarkers)
+      parameterTrialsRealizer unaryMarkersRealizer) scheduledTrialDenominatorRealizer)
+      (composition (f := fun z : SamplingParameters => z.1)
+        (g := fun p => GreedyFeasibleTable.listMatrix p.1 p.2) first GreedyFeasibleTable.tableRealizer))
+
+attribute [local irreducible] scheduledOuterInput
+
+lemma work_scheduledOuterInput : WorkBound scheduledOuterInputRealizer scheduledCountInputMeasure := by
+  unfold scheduledOuterInputRealizer scheduledOuterInput
+  have hm : WorkBound (composition parameterTrialsRealizer unaryMarkersRealizer)
+      scheduledCountInputMeasure := by
+    apply work_composition (work_of_polynomial polynomial_parameterTrials X
+      weight_le_scheduledCountInputMeasure) work_unaryMarkers X
+    intro z
+    simp only [id_eq,eval_X,scheduledCountInputMeasure]
+    omega
+  exact work_pair work_scheduledTrialInput
+    (work_pair (work_pair hm work_scheduledTrialDenominator X weight_le_scheduledCountInputMeasure)
+      (work_of_polynomial (polynomial_composition polynomial_first GreedyFeasibleTable.polynomial_table)
+        X weight_le_scheduledCountInputMeasure) X weight_le_scheduledCountInputMeasure)
+    X weight_le_scheduledCountInputMeasure
+
+/-- All first-success numerators, computed from the public binary margins. -/
+def scheduledCounts (z : SamplingParameters) : List ℕ :=
+  if hasLargeRectangle z then outerVector (scheduledOuterInput z)
+  else UnitCountPrograms.outerVector (scheduledOuterInput z)
+
+def scheduledCountsRealizer : Realizer scheduledCounts :=
+  choose hasLargeRectangleRealizer
+    (composition (f := scheduledOuterInput) (g := outerVector)
+      scheduledOuterInputRealizer outerVectorRealizer)
+    (composition (f := scheduledOuterInput) (g := UnitCountPrograms.outerVector)
+      scheduledOuterInputRealizer UnitCountPrograms.outerVectorRealizer)
+
+attribute [local irreducible] scheduledCounts
+
+def scheduledCountsMeasure (z : SamplingParameters) : ℕ := scheduledCountInputMeasure z+
+  outerVectorMeasure (scheduledOuterInput z)+UnitCountPrograms.outerVectorMeasure (scheduledOuterInput z)
+
+lemma work_scheduledCounts : WorkBound scheduledCountsRealizer scheduledCountsMeasure := by
+  have hi (z : SamplingParameters) : scheduledCountInputMeasure z ≤ X.eval (scheduledCountsMeasure z) := by
+    simp only [eval_X,scheduledCountsMeasure]
+    omega
+  have hb := work_remeasure work_scheduledOuterInput X hi
+  have hw (z : SamplingParameters) : weight z ≤ X.eval (scheduledCountsMeasure z) :=
+    (weight_le_scheduledCountInputMeasure z).trans (by simpa only [eval_X] using hi z)
+  unfold scheduledCountsRealizer scheduledCounts
+  apply work_choose (work_of_polynomial polynomial_hasLargeRectangle X hw)
+  · apply work_composition hb work_outerVector X
+    intro z
+    simp only [eval_X,scheduledCountsMeasure]
+    omega
+  · apply work_composition hb UnitCountPrograms.work_outerVector X
+    intro z
+    simp only [eval_X,scheduledCountsMeasure]
+    omega
+  · exact hw
+
+end ContingencyTables.ProfilePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScheduledCountSemantics.lean

@@ -0,0 +1,151 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ScheduledCountInput
+import OAI.Combinatorics.ContingencyTables.Sampling.OriginalBoxPush
+import OAI.Combinatorics.ContingencyTables.Sampling.AllSamplingAccuracy
+
+namespace OAI
+
+/-! # The scheduled executable numerator vector is the public sampler's law -/
+
+namespace ContingencyTables.SmallGraphProfiles
+open ProfilePrograms DensePrograms PhysicalCompletionFibres FirstPaperPhysicalMarginal
+open SmallContextCoordinates CompletionCounts OriginalTableBox ResidualMixture FirstSuccess
+open scoped BigOperators Classical
+noncomputable section
+attribute [local irreducible] scheduledTrialDenominator scheduledTrialWidth
+  scheduledCounts scheduledOuterInput listedOuterCounts unitOuterCounts matrixInput
+  scheduledTableDraw listedOuterDraw unitCodeOuterDraw
+
+private lemma dyadic_trialDenom (N s f : ℕ) :
+    (2:ℕ)^(N*(s+f)+f)=(2^(s+f))^N*2^f := by
+  rw [pow_add,←pow_mul]
+  congr 2
+  exact Nat.mul_comm _ _
+
+
+variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+local notation "d" => dimensionAllowance (I := Fin m) (J := Fin n)
+local notation "b" => smallBinaryLength r c
+local notation "s" => smallProposalBits (I := Fin m) (J := Fin n)
+
+lemma scheduledTrialDenominator_dense (k : ℕ)
+    (hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)=true) :
+    scheduledTrialDenominator ((List.ofFn r,List.ofFn c),k)=
+      (2^(s+25*(d+b+outerAccuracy d b k+1)^62))^(outerSteps d b k)*
+        2^(25*(d+b+outerAccuracy d b k+1)^62) := by
+  rw [scheduledTrialDenominator,BinaryPowerPrograms.power_eq,scheduledTrialWidth,hlarge]
+  simp only [ite_true,scheduledDenseWidth,parameterSteps_ofFn,parameterProposalWidth_ofFn,parameterCompletionWidth_ofFn]
+  exact dyadic_trialDenom _ _ _
+
+lemma scheduledTrialDenominator_unit (k : ℕ)
+    (hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)≠true) :
+    scheduledTrialDenominator ((List.ofFn r,List.ofFn c),k)=(2^s)^(outerSteps d b k) := by
+  rw [scheduledTrialDenominator,BinaryPowerPrograms.power_eq,scheduledTrialWidth,ite_eq_right hlarge]
+  rw [scheduledUnitWidth,parameterSteps_ofFn,parameterProposalWidth_ofFn,←pow_mul,Nat.mul_comm]
+
+lemma scheduledTrialDenominator_pos (z : SamplingParameters) : 0<scheduledTrialDenominator z := by
+  rw [scheduledTrialDenominator,BinaryPowerPrograms.power_eq]
+  positivity
+
+lemma scheduledOuterInput_code (htotal : ∑ i,r i=∑ j,c j) (k : ℕ) :
+    scheduledOuterInput ((List.ofFn r,List.ofFn c),k)=
+      (((matrixInput r c (computedCellEquiv r c) b (outerAccuracy d b k)
+        (tableState r c (GreedyFeasibleTable.table r c htotal)) (unaryMarkers s),
+        (outerSteps d b k,(profileIndex r c (computedCellEquiv r c)
+          (tableState r c (GreedyFeasibleTable.table r c htotal))).val)),
+        (List.ofFn r,List.ofFn c)),
+        ((unaryMarkers (outerTrials d k),scheduledTrialDenominator ((List.ofFn r,List.ofFn c),k)),
+          matrixCode (GreedyFeasibleTable.table r c htotal).val)) := by
+  unfold scheduledOuterInput scheduledTrialInput scheduledWalkInput scheduledMatrixParameters
+    scheduledCacheParameters scheduledStartIndex
+  rw [initialCheck_code r c htotal,marginPadding_ofFn,parameterDimension_ofFn,
+    parameterAccuracy_ofFn,parameterCompletionWidth_ofFn,parameterProposalWidth_ofFn,
+    parameterSteps_ofFn,profileBoxIndex_actual,parameterTrials_ofFn,GreedyFeasibleTable.listMatrix_ofFn]
+  unfold matrixInput
+  rfl
+
+/-- No extra table oracle: this is the integer law of the ordinary public branch. -/
+def scheduledCountsLaw (htotal : ∑ i,r i=∑ j,c j) (k : ℕ) :
+    IntegerLaw (Table r c)
+      ((scheduledTrialDenominator ((List.ofFn r,List.ofFn c),k))^(outerTrials d k)) :=
+  if hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)=true then
+    (listedOuterCounts r c (computedCellEquiv r c)
+      ((hasLargeRectangle_spec r c k).mp hlarge).1 ((hasLargeRectangle_spec r c k).mp hlarge).2
+      b (outerAccuracy d b k) (smallBinaryLength_parameters r c).1
+      (tableState r c (GreedyFeasibleTable.table r c htotal)) (outerSteps d b k) (outerTrials d k)
+      (GreedyFeasibleTable.table r c htotal)).rebase
+      (congrArg (fun Q => Q^(outerTrials d k)) (scheduledTrialDenominator_dense r c k hlarge).symm)
+  else
+    (unitOuterCounts r c (computedCellEquiv r c) (allSmall_of_no_large r c k hlarge)
+      (tableState r c (GreedyFeasibleTable.table r c htotal)) (outerSteps d b k) (outerTrials d k)
+      (GreedyFeasibleTable.table r c htotal)).rebase
+      (congrArg (fun Q => Q^(outerTrials d k)) (scheduledTrialDenominator_unit r c k hlarge).symm)
+
+lemma scheduledDraw_dense (htotal : ∑ i,r i=∑ j,c j) (k : ℕ)
+    (hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)=true) :
+    scheduledTableDraw r c htotal k=
+      listedOuterDraw r c (computedCellEquiv r c)
+        ((hasLargeRectangle_spec r c k).mp hlarge).1 ((hasLargeRectangle_spec r c k).mp hlarge).2
+        b (outerAccuracy d b k) (smallBinaryLength_parameters r c).1
+        (tableState r c (GreedyFeasibleTable.table r c htotal)) (outerSteps d b k) (outerTrials d k)
+        (GreedyFeasibleTable.table r c htotal) := by
+  funext bits
+  unfold scheduledTableDraw
+  rw [dite_eq_left hlarge]
+
+lemma scheduledDraw_unit (htotal : ∑ i,r i=∑ j,c j) (k : ℕ)
+    (hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)≠true) :
+    scheduledTableDraw r c htotal k=fun bits =>
+      unitCodeOuterDraw r c (computedCellEquiv r c) (allSmallFibre r c (allSmall_of_no_large r c k hlarge))
+        (tableState r c (GreedyFeasibleTable.table r c htotal)) (outerSteps d b k) (outerTrials d k)
+        (GreedyFeasibleTable.table r c htotal) (prefixWord (unitCodeBits_le r c k) bits) := by
+  funext bits
+  unfold scheduledTableDraw
+  rw [dite_eq_right hlarge]
+
+lemma scheduledCountsLaw_law (htotal : ∑ i,r i=∑ j,c j) (k : ℕ) :
+    (scheduledCountsLaw r c htotal k).toRational
+      (pow_pos (scheduledTrialDenominator_pos _) _)=
+      mapLaw (uniformLaw (α := Fin (finiteSamplerBits r c k) → Bool))
+        (scheduledTableDraw r c htotal k) := by
+  unfold scheduledCountsLaw
+  split_ifs with hlarge
+  · rw [scheduledDraw_dense r c htotal k hlarge]
+    exact (IntegerLaw.toRational_rebase _ _ (by positivity) _).trans
+      (listedOuterCounts_law r c _ _ _ _ _ _ htotal _ _ _ _)
+  · rw [scheduledDraw_unit r c htotal k hlarge]
+    exact (IntegerLaw.toRational_rebase _ _ (by positivity) _).trans
+      ((unitOuterCounts_law r c _ htotal _ _ _ _ _).trans
+        (padded_draw_law (unitCodeBits_le r c k) _).symm)
+
+/-- Every literal vector entry equals the corresponding embedded table count,
+including zero at infeasible matrices in the original bounding box. -/
+lemma scheduledCounts_actual (htotal : ∑ i,r i=∑ j,c j) (k : ℕ) :
+    scheduledCounts ((List.ofFn r,List.ofFn c),k)=
+      List.ofFn (((scheduledCountsLaw r c htotal k).push (index r c le_rfl)).count) := by
+  unfold scheduledCounts
+  by_cases hlarge : hasLargeRectangle ((List.ofFn r,List.ofFn c),k)=true
+  · rw [ite_eq_left hlarge,scheduledOuterInput_code r c htotal]
+    conv_lhs => rw [scheduledTrialDenominator_dense r c k hlarge]
+    rw [outerVector_actual r c (computedCellEquiv r c)
+      ((hasLargeRectangle_spec r c k).mp hlarge).1 ((hasLargeRectangle_spec r c k).mp hlarge).2
+      b (outerAccuracy d b k) (smallBinaryLength_parameters r c).1 htotal _ _
+        (unaryMarkers_length _) _ _ _]
+    apply congrArg List.ofFn
+    funext j
+    rw [OriginalBoxLaw.retry_count_some,OriginalBoxLaw.push_count]
+    simp only [scheduledCountsLaw,dite_eq_left hlarge,IntegerLaw.rebase,listedOuterCounts]
+    simp only [IntegerLaw.retry,unaryMarkers_length]
+  · rw [ite_eq_right hlarge,scheduledOuterInput_code r c htotal]
+    conv_lhs => rw [scheduledTrialDenominator_unit r c k hlarge]
+    rw [unit_outerVector_actual r c (computedCellEquiv r c) b (outerAccuracy d b k)
+      (allSmall_of_no_large r c k hlarge) htotal _ _ (unaryMarkers_length _) _ _ _]
+    apply congrArg List.ofFn
+    funext j
+    rw [OriginalBoxLaw.retry_count_some,OriginalBoxLaw.push_count]
+    simp only [scheduledCountsLaw,dite_eq_right hlarge,IntegerLaw.rebase,unitOuterCounts]
+    simp only [IntegerLaw.retry,unaryMarkers_length]
+
+end
+end ContingencyTables.SmallGraphProfiles
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScheduledResidualLaw.lean

@@ -0,0 +1,68 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ScheduledCountSemantics
+import OAI.Combinatorics.ContingencyTables.Machines.ScheduledResidualProgram
+import OAI.Combinatorics.ContingencyTables.Sampling.CompiledResidualCorrection
+
+namespace OAI
+
+/-! # Correctness and positivity of the executed correction vector -/
+
+namespace ContingencyTables.SmallGraphProfiles
+open ProfilePrograms DensePrograms OriginalTableBox ResidualMixture FirstSuccess CompletionCounts
+open scoped BigOperators Classical
+noncomputable section
+
+variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+local notation "d" => dimensionAllowance (I := Fin m) (J := Fin n)
+local notation "D" => correctionPrecision r c
+local notation "q" => largeTailCount r (d^20)*largeTailCount c (d^20)
+
+lemma scheduledCounts_domination
+    (hPL : PublishedInputs.FiniteBoxPrekopaLeindler q)
+    (hCheeger : PublishedInputs.FiniteCheeger (GridBoundary.Grid (I := Fin q) (4*d^8)))
+    (htotal : (∑ i,r i)=∑ j,c j) :
+    let _ : Nonempty (Table r c) := ⟨GreedyFeasibleTable.table r c htotal⟩
+    ∀ X,(1-1/((2^D:ℕ):ℚ))*
+      ((scheduledCountsLaw r c htotal (2*D)).toRational
+        (pow_pos (scheduledTrialDenominator_pos _) _)).mass X≤uniformMass (α := Table r c) := by
+  let : Nonempty (Table r c) := ⟨GreedyFeasibleTable.table r c htotal⟩
+  dsimp only
+  rw [scheduledCountsLaw_law]
+  obtain ⟨residual,hr⟩ := scheduled_residual_correction r c hPL hCheeger htotal
+  intro X
+  have hn : 0≤(1/(2:ℚ)^D)*residual.mass X :=
+    mul_nonneg (by positivity) (residual.nonnegative X)
+  simp only [Nat.cast_pow,Nat.cast_ofNat]
+  linarith [hr X]
+
+/-- The explicit correction vector is the embedded integer residual law. -/
+theorem scheduledResidualCounts_actual
+    (hPL : PublishedInputs.FiniteBoxPrekopaLeindler q)
+    (hCheeger : PublishedInputs.FiniteCheeger (GridBoundary.Grid (I := Fin q) (4*d^8)))
+    (htotal : (∑ i,r i)=∑ j,c j) :
+    let _ : Nonempty (Table r c) := ⟨GreedyFeasibleTable.table r c htotal⟩
+    scheduledResidualCounts (((List.ofFn r,List.ofFn c),2*D),2^D)=
+      List.ofFn ((IntegerResidualCorrection.law (scheduledCountsLaw r c htotal (2*D)) (2^D)
+        (pow_pos (scheduledTrialDenominator_pos _) _) (by positivity)
+        (scheduledCounts_domination r c hPL hCheeger htotal)).push (index r c le_rfl)).count := by
+  let : Nonempty (Table r c) := ⟨GreedyFeasibleTable.table r c htotal⟩
+  dsimp only
+  unfold scheduledResidualCounts cachedResidualCounts cachedResidualInput scheduledResidualCache
+  rw [scheduledCounts_actual r c htotal,List.sum_ofFn,(IntegerLaw.push _ _).total]
+  exact OriginalBoxLaw.residualVector_law r c _ (GreedyFeasibleTable.table r c htotal) _
+    (pow_pos (scheduledTrialDenominator_pos _) _) (by positivity)
+    (scheduledCounts_domination r c hPL hCheeger htotal)
+
+/-- Positive total weight makes the exact weighted rejection loop applicable. -/
+theorem scheduledResidualCounts_sum
+    (hPL : PublishedInputs.FiniteBoxPrekopaLeindler q)
+    (hCheeger : PublishedInputs.FiniteCheeger (GridBoundary.Grid (I := Fin q) (4*d^8)))
+    (htotal : (∑ i,r i)=∑ j,c j) :
+    0<(scheduledResidualCounts (((List.ofFn r,List.ofFn c),2*D),2^D)).sum := by
+  let : Nonempty (Table r c) := ⟨GreedyFeasibleTable.table r c htotal⟩
+  rw [scheduledResidualCounts_actual r c hPL hCheeger htotal,List.sum_ofFn,(IntegerLaw.push _ _).total]
+  exact Nat.mul_pos Fintype.card_pos (pow_pos (scheduledTrialDenominator_pos _) _)
+
+end
+end ContingencyTables.SmallGraphProfiles
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScheduledResidualProgram.lean

@@ -0,0 +1,112 @@
+import OAI.Combinatorics.ContingencyTables.Machines.ScheduledCountInput
+import OAI.Combinatorics.ContingencyTables.Sampling.OriginalResidualVector
+
+namespace OAI
+
+/-! # Executing residual weights from margins, precision, and branch denominator -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms Polynomial
+
+attribute [local irreducible] scheduledCounts residualVector originalCandidates originalCardinality
+
+/-- Ordinary count vector, original margins, and reciprocal branch probability. -/
+abbrev ScheduledResidualCache := List ℕ×(CompletionMargins×ℕ)
+
+def scheduledResidualCache (z : SamplingParameters×ℕ) : ScheduledResidualCache :=
+  (scheduledCounts z.1,(z.1.1,z.2))
+
+def scheduledResidualCacheRealizer : Realizer scheduledResidualCache :=
+  pair (composition (f := fun z : SamplingParameters×ℕ => z.1) (g := scheduledCounts)
+    first scheduledCountsRealizer) (pair (composition first first) second)
+
+def scheduledResidualMeasure (z : SamplingParameters×ℕ) : ℕ :=
+  scheduledCountsMeasure z.1+originalEnumerationMeasure z.1.1+weight z
+
+lemma work_scheduledResidualCache :
+    WorkBound scheduledResidualCacheRealizer scheduledResidualMeasure := by
+  have hi (z : SamplingParameters×ℕ) : weight z ≤ X.eval (scheduledResidualMeasure z) := by
+    simp only [eval_X,scheduledResidualMeasure]
+    omega
+  have hc : WorkBound (composition (first (B := ℕ)) scheduledCountsRealizer)
+      scheduledResidualMeasure := by
+    apply work_composition (work_of_polynomial polynomial_first X hi) work_scheduledCounts X
+    intro z
+    simp only [eval_X,scheduledResidualMeasure]
+    omega
+  exact work_pair hc (work_of_polynomial (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second) X hi) X hi
+
+def cachedResidualInput (z : ScheduledResidualCache) : ResidualVectorCache :=
+  ((originalCandidates z.2.1,z.1),((z.1.sum,z.2.2),originalCardinality z.2.1))
+
+def cachedResidualInputRealizer : Realizer cachedResidualInput :=
+  pair (pair (composition (f := fun z : ScheduledResidualCache => z.2.1) (g := originalCandidates)
+    (composition second first) originalCandidatesRealizer) first)
+    (pair (pair (composition first listSum) (composition second second))
+      (composition (f := fun z : ScheduledResidualCache => z.2.1) (g := originalCardinality)
+        (composition second first) originalCardinalityRealizer))
+
+def cachedResidualMeasure (z : ScheduledResidualCache) : ℕ :=
+  originalEnumerationMeasure z.2.1+weight z
+
+lemma work_cachedResidualInput : WorkBound cachedResidualInputRealizer cachedResidualMeasure := by
+  have hi (z : ScheduledResidualCache) : weight z ≤ X.eval (cachedResidualMeasure z) := by
+    simp only [eval_X,cachedResidualMeasure]
+    omega
+  have he : WorkBound (composition (composition (second (A := List ℕ)) first)
+      originalCandidatesRealizer) cachedResidualMeasure := by
+    apply work_composition (work_of_polynomial (polynomial_composition polynomial_second polynomial_first)
+      X hi) work_originalCandidates X
+    intro z
+    simp only [eval_X,cachedResidualMeasure,Function.comp_apply]
+    omega
+  have hn : WorkBound (composition (composition (second (A := List ℕ)) first)
+      originalCardinalityRealizer) cachedResidualMeasure := by
+    apply work_composition (work_of_polynomial (polynomial_composition polynomial_second polynomial_first)
+      X hi) work_originalCardinality X
+    intro z
+    simp only [eval_X,cachedResidualMeasure,Function.comp_apply]
+    omega
+  exact work_pair (work_pair he (work_of_polynomial polynomial_first X hi) X hi)
+    (work_pair (work_of_polynomial (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_listSum)
+      (polynomial_composition polynomial_second polynomial_second)) X hi) hn X hi) X hi
+
+def cachedResidualCounts (z : ScheduledResidualCache) : List ℕ :=
+  residualVector (cachedResidualInput z)
+
+def cachedResidualCountsRealizer : Realizer cachedResidualCounts :=
+  composition (f := cachedResidualInput) (g := residualVector)
+    cachedResidualInputRealizer residualVectorRealizer
+
+lemma work_cachedResidualCounts : WorkBound cachedResidualCountsRealizer cachedResidualMeasure :=
+  work_then_polynomial work_cachedResidualInput polynomial_residualVector
+
+attribute [local irreducible] scheduledResidualCache cachedResidualCounts
+
+/-- This computes the complete correction vector; it asks for no probability oracle. -/
+def scheduledResidualCounts (z : SamplingParameters×ℕ) : List ℕ :=
+  cachedResidualCounts (scheduledResidualCache z)
+
+def scheduledResidualCountsRealizer : Realizer scheduledResidualCounts :=
+  composition (f := scheduledResidualCache) (g := cachedResidualCounts)
+    scheduledResidualCacheRealizer cachedResidualCountsRealizer
+
+lemma work_scheduledResidualCounts :
+    WorkBound scheduledResidualCountsRealizer scheduledResidualMeasure := by
+  unfold scheduledResidualCountsRealizer scheduledResidualCounts
+  obtain ⟨p,hp⟩ := work_scheduledResidualCache
+  apply work_composition ⟨p,hp⟩ work_cachedResidualCounts (X+p)
+  intro z
+  have hw := hp z
+  simp only [scheduledResidualCache] at hw
+  simp only [eval_add,eval_X,cachedResidualMeasure,scheduledResidualCache]
+  have hm : originalEnumerationMeasure z.1.1 ≤ scheduledResidualMeasure z := by
+    unfold scheduledResidualMeasure
+    omega
+  omega
+
+end ContingencyTables.ProfilePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/ScheduledScalarBounds.lean

@@ -0,0 +1,137 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.ExactInputBounds
+import OAI.Combinatorics.ContingencyTables.Machines.ScheduledCountInput
+
+namespace OAI
+
+/-! # Charging scalar tabulation loops to the ordinary sampler's word -/
+
+namespace ContingencyTables.ProfilePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms Polynomial
+
+lemma parameterDimension_pos (z : SamplingParameters) : 0 < parameterDimension z := by
+  unfold parameterDimension marginDimension
+  omega
+
+lemma parameterBinaryLength_pos (z : SamplingParameters) : 0 < parameterBinaryLength z := by
+  have h := parameterDimension_pos z
+  unfold parameterBinaryLength marginBinaryLength parameterDimension at *
+  omega
+
+lemma parameterSteps_pos (z : SamplingParameters) : 0 < parameterSteps z := by
+  unfold parameterSteps
+  exact Nat.mul_pos (pow_pos (parameterDimension_pos z) _)
+    (pow_pos (by have := parameterBinaryLength_pos z; omega) _)
+
+lemma parameterTrials_pos (z : SamplingParameters) : 0 < parameterTrials z := by
+  unfold parameterTrials
+  exact Nat.mul_pos (pow_pos (parameterDimension_pos z) _) (by omega)
+
+lemma parameterCompletionWidth_pos (z : SamplingParameters) : 0 < parameterCompletionWidth z := by
+  unfold parameterCompletionWidth
+  exact Nat.mul_pos (by decide) (pow_pos (by omega) _)
+
+lemma parameterDimension_le_steps (z : SamplingParameters) :
+    parameterDimension z ≤ parameterSteps z := by
+  have hd : 1 ≤ parameterDimension z := parameterDimension_pos z
+  have hb : 1 ≤ z.2+parameterBinaryLength z := by have := parameterBinaryLength_pos z; omega
+  exact (Nat.le_self_pow (by decide : 200 ≠ 0) _).trans (by
+    unfold parameterSteps
+    simpa only [Nat.mul_one] using Nat.mul_le_mul_left ((parameterDimension z)^200)
+      (one_le_pow₀ hb : 1 ≤ (z.2+parameterBinaryLength z)^2))
+
+lemma parameterBinaryLength_le_steps (z : SamplingParameters) :
+    parameterBinaryLength z ≤ parameterSteps z := by
+  have hd : 1 ≤ (parameterDimension z)^200 := one_le_pow₀ (parameterDimension_pos z)
+  have hb : parameterBinaryLength z ≤ (z.2+parameterBinaryLength z)^2 :=
+    (Nat.le_add_left _ _).trans (Nat.le_self_pow (by decide) _)
+  unfold parameterSteps
+  exact hb.trans (by simpa only [Nat.one_mul] using
+    Nat.mul_le_mul_right ((z.2+parameterBinaryLength z)^2) hd)
+
+lemma parameterAccuracy_le_steps (z : SamplingParameters) :
+    parameterAccuracy z ≤ parameterSteps z := by
+  unfold parameterAccuracy parameterSteps
+  exact Nat.mul_le_mul_right _ (Nat.pow_le_pow_right (parameterDimension_pos z) (by decide))
+
+theorem schedule_numeric_polynomial : ∃ p : Polynomial ℕ,∀ z,
+    parameterDimension z+parameterAccuracy z+parameterCompletionWidth z ≤
+      p.eval (scheduledCountInputMeasure z) := by
+  refine ⟨2*X+25*(3*X+1)^62,?_⟩
+  intro z
+  let M := scheduledCountInputMeasure z
+  have hs : parameterSteps z ≤ M := by unfold M scheduledCountInputMeasure; omega
+  have hd := (parameterDimension_le_steps z).trans hs
+  have hb := (parameterBinaryLength_le_steps z).trans hs
+  have ha := (parameterAccuracy_le_steps z).trans hs
+  have hf : parameterCompletionWidth z ≤ 25*(3*M+1)^62 := by
+    unfold parameterCompletionWidth
+    exact Nat.mul_le_mul_left _ (Nat.pow_le_pow_left (by omega) _)
+  simp only [eval_add,eval_mul,eval_pow,eval_ofNat,eval_X,eval_one]
+  change _ ≤ 2*M+25*(3*M+1)^62
+  omega
+
+lemma scheduledCountInputMeasure_le (z : SamplingParameters) :
+    scheduledCountInputMeasure z ≤ 4*parameterWordCount z+weight z := by
+  let N := parameterSteps z
+  let J := parameterTrials z
+  let P := parameterProposalWidth z
+  let F := parameterCompletionWidth z
+  let A := N*(P+F)+F
+  have hN : 1 ≤ N := parameterSteps_pos z
+  have hJ : 1 ≤ J := parameterTrials_pos z
+  have hF : 1 ≤ F := parameterCompletionWidth_pos z
+  have hNF : N ≤ N*(P+F) := by
+    simpa only [Nat.mul_one] using Nat.mul_le_mul_left N (show 1 ≤ P+F by omega)
+  have hPF : P+F ≤ N*(P+F) := by
+    simpa only [Nat.one_mul] using Nat.mul_le_mul_right (P+F) hN
+  have hA : 1 ≤ A := by unfold A; omega
+  have hAW : A ≤ J*A := by
+    simpa only [Nat.one_mul] using Nat.mul_le_mul_right A hJ
+  have hJW : J ≤ J*A := by
+    simpa only [Nat.mul_one] using Nat.mul_le_mul_left J hA
+  have hT : scheduledTrialWidth z ≤ A := by
+    unfold scheduledTrialWidth scheduledDenseWidth scheduledUnitWidth
+    change (if hasLargeRectangle z then N*(P+F)+F else N*P) ≤ A
+    split_ifs
+    · exact le_rfl
+    · unfold A
+      exact (Nat.mul_le_mul_left N (Nat.le_add_right P F)).trans (Nat.le_add_right _ _)
+  change N+J+P+scheduledTrialWidth z+weight z ≤ 4*(J*A)+weight z
+  have hNA : N ≤ A := by unfold A; omega
+  have hPA : P ≤ A := by unfold A; omega
+  have hnw := hNA.trans hAW
+  have hpw := hPA.trans hAW
+  have htw := hT.trans hAW
+  omega
+
+end ContingencyTables.ProfilePrograms
+
+namespace ContingencyTables.SmallGraphProfiles
+open MatchingFPRAS MatchingFPRAS.TreeTyped ProfilePrograms DensePrograms Polynomial
+open scoped BigOperators Classical
+noncomputable section
+
+theorem exact_count_input_measure_polynomial : ∃ p : Polynomial ℕ,
+    ∀ (m n : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ),
+      (∑ i,r i)=∑ j,c j →
+      scheduledCountInputMeasure (exactSamplingParameters (List.ofFn r,List.ofFn c)) ≤
+        p.eval (Algorithms.samplingSize n r 0) := by
+  obtain ⟨p,hp⟩ := exact_ordinary_bits_polynomial
+  obtain ⟨q,hq⟩ := exact_margin_weight_polynomial
+  obtain ⟨u,hu⟩ := polynomial_exactSamplingParameters
+  refine ⟨4*p+u.comp q,?_⟩
+  intro m n r c htotal
+  have hw : weight (exactSamplingParameters (List.ofFn r,List.ofFn c)) ≤
+      u.eval (q.eval (Algorithms.samplingSize n r 0)) :=
+    (Nat.le_add_left _ _).trans ((hu (List.ofFn r,List.ofFn c)).trans
+    (polynomial_eval_monotone u (hq m n r c htotal)))
+  have hb : parameterWordCount (exactSamplingParameters (List.ofFn r,List.ofFn c)) ≤
+      p.eval (Algorithms.samplingSize n r 0) := hp m n r c
+  have hs := scheduledCountInputMeasure_le (exactSamplingParameters (List.ofFn r,List.ofFn c))
+  simp only [eval_add,eval_mul,eval_ofNat,eval_comp]
+  omega
+
+end
+end ContingencyTables.SmallGraphProfiles
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/SignedFloorProgram.lean

@@ -0,0 +1,148 @@
+import OAI.Combinatorics.ContingencyTables.Machines.SignedPairProgram
+import OAI.Combinatorics.MatchingCount.Machines.TreeFiniteOps
+import Mathlib.Data.Rat.Floor
+
+namespace OAI
+
+/-! # Binary floor of a signed rational
+
+Two natural quotients and the comparison of their remainders compute
+the exact floor. No loop depends on the numeric numerator or denominator.
+-/
+
+namespace ContingencyTables.SignedFloorProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped SignedPairProgram
+
+abbrev Input := Signed×ℕ
+
+def numeratorQuotient (z : Input) : ℕ := z.1.1/z.2
+def numeratorQuotientRealizer : Realizer numeratorQuotient :=
+  composition (pair (composition first first) second) quotient
+lemma polynomial_numeratorQuotient : PolynomialTime numeratorQuotientRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+    polynomial_quotient
+
+def negativeQuotient (z : Input) : ℕ := z.1.2/z.2
+def negativeQuotientRealizer : Realizer negativeQuotient :=
+  composition (pair (composition first second) second) quotient
+lemma polynomial_negativeQuotient : PolynomialTime negativeQuotientRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition polynomial_first polynomial_second) polynomial_second)
+    polynomial_quotient
+
+def carry (z : Input) : Bool := decide (z.1.1%z.2<z.1.2%z.2)
+def carryRealizer : Realizer carry :=
+  composition (pair
+    (composition (pair (composition first first) second) remainder)
+    (composition (pair (composition first second) second) remainder)) less
+lemma polynomial_carry : PolynomialTime carryRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+      polynomial_remainder)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_second) polynomial_second)
+      polynomial_remainder)) polynomial_less
+
+def carryValue (z : Input) : ℕ := if carry z then 1 else 0
+def carryValueRealizer : Realizer carryValue :=
+  choose carryRealizer (constant 1) (constant 0)
+lemma polynomial_carryValue : PolynomialTime carryValueRealizer :=
+  polynomial_choose polynomial_carry (polynomial_constant 1) (polynomial_constant 0)
+
+def raw (z : Input) : Signed := (numeratorQuotient z,negativeQuotient z+carryValue z)
+def rawRealizer : Realizer raw := pair numeratorQuotientRealizer
+  (composition (pair negativeQuotientRealizer carryValueRealizer) add)
+lemma polynomial_raw : PolynomialTime rawRealizer :=
+  polynomial_pair polynomial_numeratorQuotient
+    (polynomial_composition (polynomial_pair polynomial_negativeQuotient polynomial_carryValue)
+      polynomial_add)
+
+def floorCode (z : Input) : Signed := if z.2=0 then (0,0) else raw z
+def floorCodeRealizer : Realizer floorCode :=
+  (choose (composition (pair second (constant 0)) natEqual) (constant (0,0))
+    rawRealizer).congr (fun z=>by simp only [floorCode,Function.comp_apply,decide_eq_true_eq])
+theorem polynomial_floorCode : PolynomialTime floorCodeRealizer :=
+  polynomial_congr _ (polynomial_choose
+    (polynomial_composition (polynomial_pair polynomial_second (polynomial_constant 0))
+      polynomial_natEqual) (polynomial_constant (0,0)) polynomial_raw)
+
+lemma raw_value (p n d : ℕ) (hd : 0<d) :
+    value (raw ((p,n),d))=⌊((p:ℚ)-n)/d⌋ := by
+  have hdQ: (0:ℚ)<d:=by exact_mod_cast hd
+  have hp: ((p%d:ℕ):ℚ)+(d:ℚ)*((p/d:ℕ):ℚ)=(p:ℚ):=by
+    exact_mod_cast Nat.mod_add_div p d
+  have hn: ((n%d:ℕ):ℚ)+(d:ℚ)*((n/d:ℕ):ℚ)=(n:ℚ):=by
+    exact_mod_cast Nat.mod_add_div n d
+  have hpr: ((p%d:ℕ):ℚ)<d:=by exact_mod_cast Nat.mod_lt p hd
+  have hnr: ((n%d:ℕ):ℚ)<d:=by exact_mod_cast Nat.mod_lt n hd
+  have hp0: (0:ℚ)≤((p%d:ℕ):ℚ):=Nat.cast_nonneg _
+  have hn0: (0:ℚ)≤((n%d:ℕ):ℚ):=Nat.cast_nonneg _
+  symm
+  apply Int.floor_eq_iff.mpr
+  by_cases h: p%d<n%d
+  · have hr: ((p%d:ℕ):ℚ)<((n%d:ℕ):ℚ):=by exact_mod_cast h
+    simp only [raw,numeratorQuotient,negativeQuotient,carryValue,carry,h,decide_true,
+      ite_true,value,Nat.cast_add,Nat.cast_one,Int.cast_sub,
+      Int.cast_add,Int.cast_one,Int.cast_natCast]
+    constructor
+    · rw [le_div_iff₀ hdQ]
+      nlinarith
+    · rw [div_lt_iff₀ hdQ]
+      nlinarith
+  · have hr: ((n%d:ℕ):ℚ)≤((p%d:ℕ):ℚ):=by exact_mod_cast (Nat.le_of_not_gt h)
+    simp only [raw,numeratorQuotient,negativeQuotient,carryValue,carry,h,decide_false,
+      Bool.false_eq_true,ite_false,Nat.add_zero,value,Int.cast_sub,Int.cast_natCast]
+    constructor
+    · rw [le_div_iff₀ hdQ]
+      nlinarith
+    · rw [div_lt_iff₀ hdQ]
+      nlinarith
+
+theorem floorCode_value (p n d : ℕ) :
+    value (floorCode ((p,n),d))=⌊((p:ℚ)-n)/d⌋ := by
+  by_cases hd: d=0
+  · simp [floorCode,hd,value]
+  · simp only [floorCode,hd,ite_false]
+    exact raw_value p n d (Nat.pos_of_ne_zero hd)
+
+abbrev ScaledInput := Input×List Bool
+
+def scale (z : ScaledInput) : Input :=
+  ((z.2.length*z.1.1.1,z.2.length*z.1.1.2),z.1.2)
+def scaleRealizer : Realizer scale :=
+  pair (pair
+    (composition (pair (composition second listLength)
+      (composition (composition first first) first)) multiply)
+    (composition (pair (composition second listLength)
+      (composition (composition first first) second)) multiply)) (composition first second)
+lemma polynomial_scale : PolynomialTime scaleRealizer :=
+  polynomial_pair (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_second polynomial_listLength)
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_first)) polynomial_multiply)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_second polynomial_listLength)
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_second)) polynomial_multiply))
+    (polynomial_composition polynomial_first polynomial_second)
+
+def scaledFloor (z : ScaledInput) : Signed := floorCode (scale z)
+def scaledFloorRealizer : Realizer scaledFloor := composition scaleRealizer floorCodeRealizer
+theorem polynomial_scaledFloor : PolynomialTime scaledFloorRealizer :=
+  polynomial_composition polynomial_scale polynomial_floorCode
+
+theorem scaledFloor_value (p n d : ℕ) (xs : List Bool) :
+    value (scaledFloor (((p,n),d),xs))=
+      ⌊(xs.length:ℚ)*(((p:ℚ)-n)/d)⌋ := by
+  rw [scaledFloor,scale,floorCode_value]
+  congr 1
+  push_cast
+  ring
+
+end ContingencyTables.SignedFloorProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/SignedPairProgram.lean

@@ -0,0 +1,133 @@
+import OAI.Combinatorics.ContingencyTables.Rooted.ForestAffineProgram
+
+namespace OAI
+
+/-! # Binary signed arithmetic used to prepare the forest evaluator
+
+A pair stores a difference of naturals. Arithmetic never iterates through
+the represented integer value, and normalization returns the exact
+positive/negative parts expected by the affine penalty program.
+-/
+
+namespace ContingencyTables.SignedPairProgram
+
+open MatchingFPRAS.TreeTyped
+open scoped BigOperators
+
+abbrev Signed := ℕ×ℕ
+
+def value (a : Signed) : ℤ := (a.1:ℤ)-a.2
+
+def plus (z : Signed×Signed) : Signed := (z.1.1+z.2.1,z.1.2+z.2.2)
+def neg (a : Signed) : Signed := (a.2,a.1)
+def minus (z : Signed×Signed) : Signed := plus (z.1,neg z.2)
+def times (z : Signed×Signed) : Signed :=
+  (z.1.1*z.2.1+z.1.2*z.2.2,z.1.1*z.2.2+z.1.2*z.2.1)
+def normalize (a : Signed) : Signed := (a.1-a.2,a.2-a.1)
+
+lemma value_plus (a b : Signed) : value (plus (a,b))=value a+value b := by
+  simp only [value,plus,Nat.cast_add]
+  ring
+
+lemma value_neg (a : Signed) : value (neg a)= -value a := by
+  unfold value neg
+  ring
+
+lemma value_minus (a b : Signed) : value (minus (a,b))=value a-value b := by
+  rw [minus,value_plus,value_neg]
+  ring
+
+lemma value_times (a b : Signed) : value (times (a,b))=value a*value b := by
+  simp only [value,times,Nat.cast_add,Nat.cast_mul]
+  ring
+
+lemma normalize_eq (a : Signed) : normalize a=ForestAffineProgram.signedParts (value a) := by
+  rcases a with ⟨p,q⟩
+  apply Prod.ext <;> simp only [normalize,ForestAffineProgram.signedParts,value]
+  · omega
+  · omega
+
+lemma value_normalize (a : Signed) : value (normalize a)=value a := by
+  rw [normalize_eq]
+  exact ForestAffineProgram.signedParts_sub (value a)
+
+def plusRealizer : Realizer plus :=
+  pair
+    (composition (pair (composition first first) (composition second first)) add)
+    (composition (pair (composition first second) (composition second second)) add)
+
+def negRealizer : Realizer neg := pair second first
+
+def minusRealizer : Realizer minus :=
+  composition (pair first (composition second negRealizer)) plusRealizer
+
+def timesRealizer : Realizer times :=
+  pair
+    (composition (pair
+      (composition (pair (composition first first) (composition second first)) multiply)
+      (composition (pair (composition first second) (composition second second)) multiply)) add)
+    (composition (pair
+      (composition (pair (composition first first) (composition second second)) multiply)
+      (composition (pair (composition first second) (composition second first)) multiply)) add)
+
+def normalizeRealizer : Realizer normalize :=
+  pair subtract (composition (pair second first) subtract)
+
+lemma polynomial_plus : PolynomialTime plusRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_first)
+      (polynomial_composition polynomial_second polynomial_first)) polynomial_add)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition polynomial_first polynomial_second)
+      (polynomial_composition polynomial_second polynomial_second)) polynomial_add)
+
+lemma polynomial_neg : PolynomialTime negRealizer :=
+  polynomial_pair polynomial_second polynomial_first
+
+lemma polynomial_minus : PolynomialTime minusRealizer :=
+  polynomial_composition (polynomial_pair polynomial_first
+    (polynomial_composition polynomial_second polynomial_neg)) polynomial_plus
+
+lemma polynomial_times : PolynomialTime timesRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_first polynomial_first)
+        (polynomial_composition polynomial_second polynomial_first)) polynomial_multiply)
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_first polynomial_second)
+        (polynomial_composition polynomial_second polynomial_second)) polynomial_multiply)) polynomial_add)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_first polynomial_first)
+        (polynomial_composition polynomial_second polynomial_second)) polynomial_multiply)
+      (polynomial_composition (polynomial_pair
+        (polynomial_composition polynomial_first polynomial_second)
+        (polynomial_composition polynomial_second polynomial_first)) polynomial_multiply)) polynomial_add)
+
+lemma polynomial_normalize : PolynomialTime normalizeRealizer :=
+  polynomial_pair polynomial_subtract
+    (polynomial_composition (polynomial_pair polynomial_second polynomial_first) polynomial_subtract)
+
+def sum (xs : List Signed) : Signed := ((xs.map Prod.fst).sum,(xs.map Prod.snd).sum)
+
+def sumRealizer : Realizer sum :=
+  pair (composition (map first) listSum) (composition (map second) listSum)
+
+lemma polynomial_sum : PolynomialTime sumRealizer :=
+  polynomial_pair
+    (polynomial_composition (polynomial_map polynomial_first) polynomial_listSum)
+    (polynomial_composition (polynomial_map polynomial_second) polynomial_listSum)
+
+lemma value_sum (xs : List Signed) : value (sum xs)=(xs.map value).sum := by
+  induction xs with
+  | nil => simp [sum,value]
+  | cons a xs ih =>
+    simp only [sum,List.map_cons,List.sum_cons,value,Nat.cast_add] at *
+    rw [←ih]
+    ring
+
+end ContingencyTables.SignedPairProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/SparseViewMatrixProgram.lean

@@ -0,0 +1,73 @@
+import OAI.Combinatorics.ContingencyTables.Sampling.SmallViewLookupProgram
+import OAI.Combinatorics.ContingencyTables.Dense.DenseIntegerProgram
+import OAI.Combinatorics.ContingencyTables.Transport.DirectedBFSCode
+import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialGrid
+
+namespace OAI
+
+/-! # Materializing a sparse retained-cell view in a rectangular matrix -/
+
+namespace ContingencyTables.SparseViewMatrixProgram
+
+open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial ProfilePrograms DensePrograms
+
+abbrev Input := (List ℕ × List ℕ) × (List (ℕ × ℕ) × List ℕ)
+abbrev RowInput := Input × ℕ
+
+def entry (z : RowInput × ℕ) : ℕ := lookupView (z.1.1.2,(z.1.2,z.2))
+def entryRealizer : Realizer entry :=
+  composition (f := fun z : RowInput × ℕ => (z.1.1.2,(z.1.2,z.2))) (g := lookupView)
+    (pair (composition (composition first first) second)
+      (pair (composition first second) second)) lookupViewRealizer
+lemma polynomial_entry : PolynomialTime entryRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+    (polynomial_pair (polynomial_composition polynomial_first polynomial_second) polynomial_second))
+    polynomial_lookupView
+
+def columns (z : RowInput) : List ℕ := List.range z.1.1.2.length
+def columnsRealizer : Realizer columns :=
+  composition (composition (composition (composition first first) second) listLength) range
+lemma polynomial_columns : PolynomialTime columnsRealizer := by
+  apply polynomial_boundedRange (polynomial_composition
+    (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+      polynomial_second) polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using (list_length_le_weight z.1.1.2).trans
+    ((weight_snd z.1.1).trans ((weight_fst z.1).trans (weight_fst z)))
+
+def row (z : RowInput) : List ℕ := (columns z).map (fun j => entry (z,j))
+def rowRealizer : Realizer row :=
+  composition (pair identity columnsRealizer) (mapWith entryRealizer)
+lemma polynomial_row : PolynomialTime rowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_columns)
+    (polynomial_mapWith polynomial_entry)
+
+def rowIndices (z : Input) : List ℕ := List.range z.1.1.length
+def rowIndicesRealizer : Realizer rowIndices :=
+  composition (composition (composition first first) listLength) range
+lemma polynomial_rowIndices : PolynomialTime rowIndicesRealizer := by
+  apply polynomial_boundedRange (polynomial_composition
+    (polynomial_composition polynomial_first polynomial_first) polynomial_listLength) X
+  intro z
+  simpa only [Function.comp_apply,eval_X] using (list_length_le_weight z.1.1).trans
+    ((weight_fst z.1).trans (weight_fst z))
+
+def matrix (z : Input) : MatrixCode := (rowIndices z).map (fun i => row (z,i))
+def matrixRealizer : Realizer matrix :=
+  composition (pair identity rowIndicesRealizer) (mapWith rowRealizer)
+theorem polynomial_matrix : PolynomialTime matrixRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_rowIndices)
+    (polynomial_mapWith polynomial_row)
+
+theorem matrix_ofFn {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
+    (catalog : List (ℕ × ℕ)) (values : List ℕ) :
+    matrix ((List.ofFn r,List.ofFn c),(catalog,values))=
+      matrixCode (fun i : Fin m => fun j : Fin n =>
+        lookupView ((catalog,values),(i.val,j.val))) := by
+  simp only [matrix,rowIndices,row,columns,List.length_ofFn,DirectedBFSCode.range_eq_map,
+    ←List.ofFn_eq_map,List.map_ofFn,Function.comp_def,entry,matrixCode]
+
+end ContingencyTables.SparseViewMatrixProgram
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/TableIndexProgram.lean

@@ -0,0 +1,73 @@
+import OAI.Combinatorics.ContingencyTables.Dense.DenseTableCoordinates
+import OAI.Combinatorics.ContingencyTables.Dense.GridIndexProgram
+import OAI.Combinatorics.ContingencyTables.Transport.IndexedTableLaw
+
+namespace OAI
+
+/-! # Computing the position of a table in the completion enumeration -/
+
+namespace ContingencyTables.DensePrograms
+open MatchingFPRAS MatchingFPRAS.TreeTyped
+open scoped BigOperators Classical
+
+def tableFreeCoordinates (z : ExponentData) : List ℕ :=
+  (tableFreeCells z).map (fun ij => tableFreeValue (z,ij))
+
+def tableFreeCoordinatesRealizer : Realizer tableFreeCoordinates :=
+  composition (pair identity tableFreeCellsRealizer) (mapWith tableFreeValueRealizer)
+
+lemma polynomial_tableFreeCoordinates : PolynomialTime tableFreeCoordinatesRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity polynomial_tableFreeCells)
+    (polynomial_mapWith polynomial_tableFreeValue)
+
+lemma tableFreeCoordinates_code {m n : ℕ} (R : Option (Fin m) → ℕ)
+    (P : Option (Fin n) → ℕ) (d : ℕ) (X : Table R P) :
+    tableFreeCoordinates (tableCoordinatesCode R P d X)=
+      List.ofFn (fun k : Fin (m*n) =>
+        X.val (some (finProdFinEquiv.symm k).1) (some (finProdFinEquiv.symm k).2)) := by
+  rw [tableFreeCoordinates,tableFreeCells_code,List.map_ofFn]
+  apply congrArg List.ofFn
+  funext k
+  exact tableFreeValue_code R P d X _ _
+
+def tableIndexInput (z : CompletionData) : GridIndexData :=
+  (tableFreeCoordinates (z,0),z.1.1.sum+1)
+
+def tableIndexInputRealizer : Realizer tableIndexInput :=
+  pair (composition (pair identity (constant 0)) tableFreeCoordinatesRealizer)
+    (composition (composition (composition first first) listSum) successor)
+
+lemma polynomial_tableIndexInput : PolynomialTime tableIndexInputRealizer :=
+  polynomial_pair (polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_constant 0)) polynomial_tableFreeCoordinates)
+    (polynomial_composition (polynomial_composition
+      (polynomial_composition polynomial_first polynomial_first) polynomial_listSum)
+      polynomial_successor)
+
+def tableIndex (z : CompletionData) : ℕ := gridIndex (tableIndexInput z)
+
+def tableIndexRealizer : Realizer tableIndex :=
+  composition tableIndexInputRealizer gridIndexRealizer
+
+theorem polynomial_tableIndex : PolynomialTime tableIndexRealizer :=
+  polynomial_composition polynomial_tableIndexInput polynomial_gridIndex
+
+theorem tableIndex_actual {m n : ℕ} (R : Option (Fin m) → ℕ)
+    (P : Option (Fin n) → ℕ) (X : Table R P) :
+    tableIndex ((marginCode R,marginCode P),tableOutput X)=
+      (IndexedTableLaw.index R P (le_refl (∑ i,R i)) X).val := by
+  unfold tableIndex tableIndexInput
+  change gridIndex (tableFreeCoordinates (tableCoordinatesCode R P 0 X),
+    (marginCode R).sum+1)=_
+  rw [tableFreeCoordinates_code]
+  have hsum : (marginCode R).sum=∑ i,R i := by
+    simp only [marginCode,List.sum_cons,List.sum_ofFn,Fintype.sum_option]
+  rw [hsum]
+  change gridIndex (List.ofFn (fun k =>
+    (BoxCompletion.encode R P (le_refl (∑ i,R i)) X k).val),(∑ i,R i)+1)=_
+  rw [gridIndex_ofFn]
+  rfl
+
+end ContingencyTables.DensePrograms
+
+end OAI

lean/OAI/Combinatorics/ContingencyTables/Machines/TightenedInputProgram.lean

@@ -0,0 +1,228 @@
+import OAI.Combinatorics.ContingencyTables.Machines.EndpointMatrixProgram
+import OAI.Combinatorics.ContingencyTables.Transport.ComputedTableTightening
+import OAI.Combinatorics.ContingencyTables.Machines.NetworkTableProgram
+
+namespace OAI
+
+/-! # Executed endpoint translation and a feasible tightened baseline
+
+The lower and upper matrices are computed by the endpoint scans. Binary
+subtraction updates the capacities and both margins, then the same proved
+flow program produces a baseline table in the translated instance.
+-/
+
+namespace ContingencyTables.TightenedInputProgram
+
+open MatchingFPRAS.TreeTyped Polynomial ResidualGraphProgram NetworkVertexCode
+open scoped BigOperators Classical
+
+abbrev TranslationInput := Input×NatMatrix
+abbrev MarginInput := TranslationInput×ℕ
+abbrev CellInput := MarginInput×ℕ
+
+def rowValue (z : MarginInput) : ℕ :=
+  z.1.1.1.1.getD z.2 0-(z.1.1.2.getD z.2 []).sum
+def rowValueRealizer : Realizer rowValue :=
+  composition (pair
+    (composition (pair (composition (composition (composition first first) first) first) second)
+      (getDFast 0))
+    (composition (composition (pair (composition (composition first first) second) second)
+      (getDFast [])) listSum)) subtract
+lemma polynomial_rowValue : PolynomialTime rowValueRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition (polynomial_composition
+        polynomial_first polynomial_first) polynomial_first) polynomial_first)
+      polynomial_second) (polynomial_getDFast 0))
+    (polynomial_composition (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
+        polynomial_second) polynomial_second) (polynomial_getDFast [])) polynomial_listSum))
+    polynomial_subtract
+
+def columnValue (z : MarginInput) : ℕ :=
+  z.1.1.1.2.getD z.2 0-(BoundedComplementProgram.columnValues (z.1.1,z.2)).sum
+def columnValueRealizer : Realizer columnValue :=
+  composition (pair
+    (composition (pair (composition (composition (composition first first) first) second) second)
+      (getDFast 0))
+    (composition (composition
+      (pair (composition first first) second) BoundedComplementProgram.columnValuesRealizer)
+      listSum)) subtract
+lemma polynomial_columnValue : PolynomialTime columnValueRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition (polynomial_composition
+        polynomial_first polynomial_first) polynomial_first) polynomial_second)
+      polynomial_second) (polynomial_getDFast 0))
+    (polynomial_composition (polynomial_composition
+      (polynomial_pair (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+      BoundedComplementProgram.polynomial_columnValues) polynomial_listSum)) polynomial_subtract
+
+def position (z : CellInput) : ℕ×ℕ := (z.1.2,z.2)
+def positionRealizer : Realizer position := pair (composition first second) second
+lemma polynomial_position : PolynomialTime positionRealizer :=
+  polynomial_pair (polynomial_composition polynomial_first polynomial_second) polynomial_second
+
+def cellValue (z : CellInput) : ℕ :=
+  capacityEntry (z.1.1.2,position z)-capacityEntry (z.1.1.1.2,position z)
+def cellValueRealizer : Realizer cellValue :=
+  composition (pair
+    (composition (pair (composition (composition first first) second) positionRealizer)
+      capacityEntryRealizer)
+    (composition (pair (composition (composition (composition first first) first) second)
+      positionRealizer) capacityEntryRealizer)) subtract
+lemma polynomial_cellValue : PolynomialTime cellValueRealizer :=
+  polynomial_composition (polynomial_pair
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second)
+      polynomial_position) polynomial_capacityEntry)
+    (polynomial_composition (polynomial_pair
+      (polynomial_composition (polynomial_composition (polynomial_composition
+        polynomial_first polynomial_first) polynomial_first) polynomial_second)
+      polynomial_position) polynomial_capacityEntry)) polynomial_subtract
+
+def rowIndices (z : TranslationInput) : List ℕ := BoundedComplementProgram.rowIndices z.1
+def rowIndicesRealizer : Realizer rowIndices :=
+  composition first BoundedComplementProgram.rowIndicesRealizer
+lemma polynomial_rowIndices : PolynomialTime rowIndicesRealizer :=
+  polynomial_composition polynomial_first BoundedComplementProgram.polynomial_rowIndices
+
+def columnIndices (z : TranslationInput) : List ℕ := BoundedComplementProgram.columnIndices z.1
+def columnIndicesRealizer : Realizer columnIndices :=
+  composition first BoundedComplementProgram.columnIndicesRealizer
+lemma polynomial_columnIndices : PolynomialTime columnIndicesRealizer :=
+  polynomial_composition polynomial_first BoundedComplementProgram.polynomial_columnIndices
+
+def capacityRow (z : MarginInput) : List ℕ :=
+  (columnIndices z.1).map (fun j=>cellValue (z,j))
+def capacityRowRealizer : Realizer capacityRow :=
+  composition (pair identity (composition first columnIndicesRealizer)) (mapWith cellValueRealizer)
+lemma polynomial_capacityRow : PolynomialTime capacityRowRealizer :=
+  polynomial_composition (polynomial_pair polynomial_identity
+    (polynomial_composition polynomial_first polynomial_columnIndices))
+    (polynomial_mapWith polynomial_cellValue)
+
+def translate (z : TranslationInput) : Input :=
+  (((rowIndices z).map (fun i=>rowValue (z,i)),
+    (columnIndices z).map (fun j=>columnValue (z,j))),
+    (rowIndices z).map (fun i=>capacityRow (z,i)))
+def translateRealizer : Realizer translate :=
+  pair (pair
+    (composition (pair identity rowIndicesRealizer) (mapWith rowValueRealizer))
+    (composition (pair identity columnIndicesRealizer) (mapWith columnValueRealizer)))
+    (composition (pair identity rowIndicesRealizer) (mapWith capacityRowRealizer))
+lemma polynomial_translate : PolynomialTime translateRealizer :=
+  polynomial_pair (polynomial_pair
+    (polynomial_composition (polynomial_pair polynomial_identity polynomial_rowIndices)
+      (polynomial_mapWith polynomial_rowValue))
+    (polynomial_composition (polynomial_pair polynomial_identity polynomial_columnIndices)
+      (polynomial_mapWith polynomial_columnValue)))
+    (polynomial_composition (polynomial_pair polynomial_identity polynomial_rowIndices)
+      (polynomial_mapWith polynomial_capacityRow))
+
+lemma rowValue_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (l u : Fin m→Fin n→ℕ) (i : Fin m) :
+    rowValue ((data r c l,natCode u),i.val)=TableTightening.rows r l i := by
+  simp only [rowValue,data,natCode,List.getD_eq_getElem?_getD,List.getElem?_ofFn,
+    i.isLt,dite_true,Option.getD_some,Fin.eta,List.sum_ofFn,TableTightening.rows]
+
+lemma columnValue_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (l u : Fin m→Fin n→ℕ) (j : Fin n) :
+    columnValue ((data r c l,natCode u),j.val)=TableTightening.columns c l j := by
+  simp only [columnValue,BoundedComplementProgram.columnValues,data,natCode,List.map_ofFn,
+    Function.comp_def,List.getD_eq_getElem?_getD,List.getElem?_ofFn,
+    j.isLt,dite_true,Option.getD_some,Fin.eta,List.sum_ofFn,TableTightening.columns]
+
+lemma cellValue_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (l u : Fin m→Fin n→ℕ)
+    (i : Fin m) (j : Fin n) :
+    cellValue (((data r c l,natCode u),i.val),j.val)=TableTightening.bounds l u i j := by
+  change capacityEntry (natCode u,(i.val,j.val))-capacityEntry (natCode l,(i.val,j.val))=_
+  rw [capacityEntry_code,capacityEntry_code]
+  rfl
+
+lemma translate_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (l u : Fin m→Fin n→ℕ) :
+    translate (data r c l,natCode u)=data (TableTightening.rows r l)
+      (TableTightening.columns c l) (TableTightening.bounds l u) := by
+  unfold translate
+  apply Prod.ext
+  · apply Prod.ext
+    · simp only [rowIndices,BoundedComplementProgram.rowIndices,data,List.length_ofFn,
+        DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn]
+      apply congrArg List.ofFn
+      funext i
+      exact rowValue_code r c l u i
+    · simp only [columnIndices,BoundedComplementProgram.columnIndices,data,List.length_ofFn,
+        DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn]
+      apply congrArg List.ofFn
+      funext j
+      exact columnValue_code r c l u j
+  · simp only [rowIndices,BoundedComplementProgram.rowIndices,data,List.length_ofFn,
+      DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn,natCode]
+    apply congrArg List.ofFn
+    funext i
+    dsimp only [Function.comp_apply]
+    simp only [capacityRow,columnIndices,BoundedComplementProgram.columnIndices,List.length_ofFn,
+      DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,List.map_ofFn]
+    apply congrArg List.ofFn
+    funext j
+    exact cellValue_code r c l u i j
+
+def prepare (z : Input) : TranslationInput :=
+  ((z.1,EndpointMatrixProgram.lowerMatrix z),EndpointMatrixProgram.upperMatrix z)
+def prepareRealizer : Realizer prepare :=
+  pair (pair first EndpointMatrixProgram.lowerMatrixRealizer) EndpointMatrixProgram.upperMatrixRealizer
+lemma polynomial_prepare : PolynomialTime prepareRealizer :=
+  polynomial_pair (polynomial_pair polynomial_first EndpointMatrixProgram.polynomial_lowerMatrix)
+    EndpointMatrixProgram.polynomial_upperMatrix
+
+def compute (z : Input) : Input := translate (prepare z)
+def computeRealizer : Realizer compute :=
+  composition (f:=prepare) (g:=translate) prepareRealizer translateRealizer
+lemma polynomial_compute : PolynomialTime computeRealizer :=
+  polynomial_composition polynomial_prepare polynomial_translate
+
+lemma compute_code {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) :
+    compute (data r c b)=data (ComputedTableTightening.newRows r c b)
+      (ComputedTableTightening.newColumns r c b) (ComputedTableTightening.newBounds r c b) := by
+  unfold compute prepare
+  rw [EndpointMatrixProgram.lowerMatrix_code,EndpointMatrixProgram.upperMatrix_code]
+  exact translate_code r c (ComputedTableTightening.lower r c b) (ComputedTableTightening.upper r c b)
+
+def baseline (z : Input) : NatMatrix := NetworkTableProgram.output (compute z)
+def baselineRealizer : Realizer baseline :=
+  composition (f:=compute) (g:=NetworkTableProgram.output) computeRealizer NetworkTableProgram.outputRealizer
+lemma polynomial_baseline : PolynomialTime baselineRealizer :=
+  polynomial_composition polynomial_compute NetworkTableProgram.polynomial_output
+
+/-- Endpoint translation preserves a concrete feasible witness. -/
+theorem translated_nonempty {m n : ℕ} (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1)
+    (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ)
+    (hne : ∃ X,TableTightening.Feasible r c b X) :
+    ∃ Y,HasMargins Y (ComputedTableTightening.newRows r c b)
+      (ComputedTableTightening.newColumns r c b) ∧
+      ∀ i j,Y i j≤ComputedTableTightening.newBounds r c b i j := by
+  obtain ⟨X,hX⟩ := hne
+  let x : BoundedTable r c b := ⟨⟨X,hX.1⟩,hX.2⟩
+  let y := ComputedTableTightening.tighten hEK r c b ⟨X,hX⟩ x
+  exact ⟨y.val.val,y.val.property,y.property⟩
+
+/-- The stored baseline comes from the executed flow decoder, with all
+its margin and capacity obligations discharged by endpoint translation. -/
+theorem baseline_correct {m n : ℕ} (hEK : PublishedEdmondsKarp.EdmondsKarp1972Theorem1)
+    (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ)
+    (hne : ∃ X,TableTightening.Feasible r c b X) :
+    ∃ Y,baseline (data r c b)=natCode Y ∧
+      HasMargins Y (ComputedTableTightening.newRows r c b)
+        (ComputedTableTightening.newColumns r c b) ∧
+      ∀ i j,Y i j≤ComputedTableTightening.newBounds r c b i j := by
+  have ht := (NetworkFeasibilityProgram.test_correct hEK
+    (ComputedTableTightening.newRows r c b)
+    (ComputedTableTightening.newColumns r c b)
+    (ComputedTableTightening.newBounds r c b)).mpr (translated_nonempty hEK r c b hne)
+  have h := NetworkTableProgram.output_correct hEK
+    (ComputedTableTightening.newRows r c b)
+    (ComputedTableTightening.newColumns r c b)
+    (ComputedTableTightening.newBounds r c b) ht
+  simpa only [baseline,compute_code] using h
+
+end ContingencyTables.TightenedInputProgram
+
+end OAI