| import OAI.Combinatorics.ContingencyTables.Sampling.ExactTablePrefix |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| namespace ContingencyTables.ExactPublicPrefix |
| open MatchingFPRAS MatchingFPRAS.PhysicalStream MatchingFPRAS.PhysicalPost Turing |
| open DensePrograms |
| open scoped Classical |
| noncomputable section |
|
|
| /-- These two finite programs are independent of dimensions and margins. -/ |
| def middle : Program := ExactPhysicalProgram.program.seq LiteralProgram.post |
| def program : Program := LiteralProgram.pack.seq middle |
|
|
| def machine : RandomMachine := program.machine |
|
|
| variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) |
|
|
| def word (X : Table r c) : List Symbol := GreedyFeasibleTable.printMatrix (matrixCode X.val) |
|
|
| lemma word_eq (X : Table r c) : word r c X=Algorithms.encodeMatrix X.val := |
| GreedyFeasibleTable.printMatrix_ofFn X.val |
|
|
| def middleOutput : Option (Table r c) → Cfg Symbol middle.State |
| | none => leftCfg LiteralProgram.post.entry (ExactTablePrefix.output r c none) |
| | some X => rightCfg (LiteralProgram.post.final (Tape.mk₁ (word r c X))) |
|
|
| def output (o : Option (Table r c)) : Cfg Symbol program.State := rightCfg (middleOutput r c o) |
|
|
| lemma middle_prefix (htotal : (∑ i,r i)=∑ j,c j) (N : ℕ) : |
| ∃ p,Implements middle.table (middleOutput r c) |
| (middle.initial (Tape.mk₁ (TreePost.packed (ExactTablePrefix.input r c)))) p ∧ |
| ∀ g : Option (Table r c) → ℚ,p.mean g=(ExactTablePrefix.experiment r c N).mean g := by |
| obtain ⟨p,hp,hpm⟩ := ExactTablePrefix.physical_prefix r c htotal N |
| obtain ⟨q,hq,hqm,_⟩ := PhysicalPartialSequence.left_prefix_injective |
| ExactPhysicalProgram.program.table LiteralProgram.post.table LiteralProgram.post.entry |
| (ExactTablePrefix.output r c) (ExactTablePrefix.output_injective r c) _ p hp |
| have next (o : Option (Table r c)) : ∃ u, |
| Implements middle.table (middleOutput r c) |
| (leftCfg LiteralProgram.post.entry (ExactTablePrefix.output r c o)) u ∧ |
| ∀ g : Option (Table r c) → ℚ,u.mean g=g o := by |
| cases o with |
| | none => exact ⟨.done none,.done none,fun _ => rfl⟩ |
| | some X => |
| obtain ⟨u,hu,hum,_⟩ := LiteralProgram.post_realizes (word r c X) |
| (ProfilePrograms.printMatrix_alphabet _) |
| have hu' := hu.right (M := ExactPhysicalProgram.program.table) LiteralProgram.post.entry |
| have hall : u.All (fun T => T=Tape.mk₁ (word r c X)) := |
| Experiment.all_of_mean_eq hum _ rfl |
| refine ⟨u.map (fun _ => some X),?_,?_⟩ |
| · have hv := hu'.map_all (fun _ => some X) (middleOutput r c) |
| (hall.mono (by intro T hT; rw [hT]; rfl)) |
| simpa only [middle,Program.seq,ExactTablePrefix.output,ExactTablePrefix.code,Option.map_some, |
| ExactPhysicalProgram.output_some,word,leftCfg,Program.final,Program.initial, |
| Option.elim_none,rightCfg,Option.map_some] using hv |
| · intro g |
| rw [Experiment.mean_map,PhysicalPartialSequence.mean_const] |
| choose u hu hum using next |
| refine ⟨q.bind u,hq.bind u _ hu,?_⟩ |
| intro g |
| rw [Experiment.mean_bind] |
| simp_rw [hum] |
| exact (hqm g).trans (hpm g) |
| |
| theorem prefix_correct (htotal : (∑ i,r i)=∑ j,c j) (N : ℕ) : |
| ∃ p,Implements program.table (output r c) |
| (program.initial (Tape.mk₁ (ExactTablePrefix.input r c))) p ∧ |
| ∀ g : Option (Table r c) → ℚ,p.mean g=(ExactTablePrefix.experiment r c N).mean g := by |
| obtain ⟨p,hp,hpm⟩ := middle_prefix r c htotal N |
| have hi : ∀ a∈ExactTablePrefix.input r c,a≠0 := by |
| intro a ha |
| exact GreedyFeasibleTable.encodeMargins_nonzero r c a ha |
| obtain ⟨u,hu,hum,_⟩ := LiteralProgram.pack_realizes (ExactTablePrefix.input r c) hi |
| obtain ⟨v,hv,hvm,_⟩ := PhysicalPartialSequence.left_prefix LiteralProgram.pack.table middle.table |
| middle.entry LiteralProgram.pack.final _ u hu |
| have hall : v.All (fun x => x=LiteralProgram.pack.final |
| (Tape.mk₁ (TreePost.packed (ExactTablePrefix.input r c)))) := by |
| rw [Experiment.all_indicator,hvm,hum] |
| simp only [Experiment.mean,ite_true] |
| have hp' := hp.right (M := LiteralProgram.pack.table) middle.entry |
| refine ⟨v.bind (fun _ => p),?_,?_⟩ |
| · apply hv.bind_all (fun _ => p) (output r c) |
| exact hall.mono (by intro x hx; rw [hx]; exact hp') |
| · intro g |
| rw [Experiment.mean_bind,PhysicalPartialSequence.mean_const] |
| exact hpm g |
| |
| lemma output_none_live : (output r c none).state≠none := by |
| change (some _ : Option program.State)≠none |
| exact Option.some_ne_none _ |
|
|
| lemma output_halted (X : Table r c) : (output r c (some X)).state=none := rfl |
|
|
| lemma output_tape (X : Table r c) : |
| (output r c (some X)).tape.right₀=ListBlank.mk (Algorithms.encodeMatrix X.val) := by |
| change (Tape.mk₁ (word r c X)).right₀=_ |
| rw [word_eq] |
| simp only [Tape.mk₁,Tape.mk₂,Tape.mk'_right₀] |
|
|
| end |
| end ContingencyTables.ExactPublicPrefix |
|
|
| end OAI |
|
|
