openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /BinarySearchProgram.lean
| import OAI.Combinatorics.ContingencyTables.Machines.BoundedBinarySearch | |
| import OAI.Combinatorics.ContingencyTables.Machines.NetworkFeasibilityProgram | |
| namespace OAI | |
| /-! # A polynomial binary program for monotone endpoint search | |
| The supplied test is a realized binary predicate. The loop | |
| performs one midpoint test per bit of the upper bound and keeps the | |
| unchanged test data throughout. | |
| -/ | |
| namespace ContingencyTables.BinarySearchProgram | |
| open MatchingFPRAS.TreeTyped Polynomial BoundedBinarySearch | |
| def midpointRealizer : Realizer midpoint := | |
| composition (pair first (composition (pair | |
| (composition (composition (pair second first) subtract) successor) (constant 2)) quotient)) add | |
| lemma polynomial_midpoint : PolynomialTime midpointRealizer := | |
| polynomial_composition (polynomial_pair polynomial_first | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_first) | |
| polynomial_subtract) polynomial_successor) (polynomial_constant 2)) | |
| polynomial_quotient)) polynomial_add | |
| variable {A : Type} [Codec A] | |
| variable (test : A×ℕ→Bool) (T : Realizer test) | |
| abbrev State (A : Type) := A×Window | |
| def advance (z : ℕ×State A) : State A := | |
| (z.2.1,step (fun t=>test (z.2.1,t)) z.2.2) | |
| def advanceRealizer : Realizer (advance test) := by | |
| let M : Realizer (fun z : ℕ×State A=>midpoint z.2.2) := | |
| composition (composition second second) midpointRealizer | |
| let P : Realizer (fun z : ℕ×State A=>test (z.2.1,midpoint z.2.2)) := | |
| composition (f := fun z : ℕ×State A=>(z.2.1,midpoint z.2.2)) (g := test) | |
| (pair (composition second first) M) T | |
| let yes : Realizer (fun z : ℕ×State A=>(midpoint z.2.2,z.2.2.2)) := | |
| pair M (composition (composition second second) second) | |
| let no : Realizer (fun z : ℕ×State A=>(z.2.2.1,midpoint z.2.2-1)) := | |
| pair (composition (composition second second) first) (composition M predecessor) | |
| exact pair (composition second first) (choose P yes no) | |
| lemma polynomial_advance (hT : PolynomialTime T) : PolynomialTime (advanceRealizer test T) := by | |
| unfold advanceRealizer | |
| apply polynomial_pair | |
| · exact polynomial_composition polynomial_second polynomial_first | |
| · apply polynomial_choose | |
| · exact polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_second polynomial_first) | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) | |
| polynomial_midpoint)) hT | |
| · exact polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) | |
| polynomial_midpoint) | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) | |
| polynomial_second) | |
| · exact polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) | |
| polynomial_first) | |
| (polynomial_composition | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) | |
| polynomial_midpoint) polynomial_predecessor) | |
| lemma midpoint_le_max (p : Window) : midpoint p≤ max p.1 p.2 := by | |
| rcases p with ⟨lo,hi⟩ | |
| unfold BoundedBinarySearch.midpoint | |
| omega | |
| lemma step_le_max (f : ℕ→Bool) (p : Window) : | |
| (step f p).1≤ max p.1 p.2 ∧ (step f p).2≤ max p.1 p.2 := by | |
| have h := midpoint_le_max p | |
| unfold step | |
| split_ifs <;> dsimp only <;> constructor <;> omega | |
| omit [Codec A] in | |
| lemma fold_context (xs : List ℕ) (s : State A) : | |
| (xs.foldl (fun s i=>advance test (i,s)) s).1=s.1 := by | |
| induction xs generalizing s with | |
| | nil => rfl | |
| | cons i xs ih => exact ih (advance test (i,s)) | |
| omit [Codec A] in | |
| lemma fold_bounds (xs : List ℕ) (s : State A) (M : ℕ) | |
| (h1 : s.2.1≤M) (h2 : s.2.2≤M) : | |
| (xs.foldl (fun s i=>advance test (i,s)) s).2.1≤M ∧ | |
| (xs.foldl (fun s i=>advance test (i,s)) s).2.2≤M := by | |
| induction xs generalizing s with | |
| | nil => exact ⟨h1,h2⟩ | |
| | cons i xs ih => | |
| have h := step_le_max (fun t=>test (s.1,t)) s.2 | |
| have hm : max s.2.1 s.2.2≤M := max_le h1 h2 | |
| exact ih (advance test (i,s)) (h.1.trans hm) (h.2.trans hm) | |
| lemma polynomial_loop (hT : PolynomialTime T) : | |
| PolynomialTime (fold (advanceRealizer test T)) := by | |
| apply polynomial_fold (polynomial_advance test T hT) (20*(X+1)) | |
| intro xs s pre _post _he | |
| let S := weight (xs,s) | |
| let out := pre.foldl (fun s i=>advance test (i,s)) s | |
| have hs : weight s≤S := weight_snd (xs,s) | |
| have ha : weight s.1≤S := (weight_fst s).trans hs | |
| have hp : weight s.2≤S := (weight_snd s).trans hs | |
| have hM : weight (max s.2.1 s.2.2)≤S := by | |
| rcases le_total s.2.1 s.2.2 with h | h | |
| · rw [max_eq_right h] | |
| exact (weight_snd s.2).trans hp | |
| · rw [max_eq_left h] | |
| exact (weight_fst s.2).trans hp | |
| have hb := fold_bounds test pre s (max s.2.1 s.2.2) (le_max_left _ _) (le_max_right _ _) | |
| have h1 := weight_nat_small hb.1 | |
| have h2 := weight_nat_small hb.2 | |
| change weight out.2.1≤4*weight (max s.2.1 s.2.2)+1 at h1 | |
| change weight out.2.2≤4*weight (max s.2.1 s.2.2)+1 at h2 | |
| have hc : out.1=s.1 := fold_context test pre s | |
| have ho : weight out=weight out.1+weight out.2.1+weight out.2.2+2 := by | |
| change weight (out.1,(out.2.1,out.2.2))=_ | |
| simp only [weight_prod] | |
| omega | |
| simp only [eval_mul,eval_ofNat,eval_add,eval_X,eval_one] | |
| change weight out≤20*(S+1) | |
| rw [ho,hc] | |
| omega | |
| def steps (z : A×ℕ) : List ℕ := List.range z.2.size | |
| def stepsRealizer : Realizer (steps (A := A)) := | |
| composition (composition second bitSize) range | |
| lemma polynomial_steps : PolynomialTime (stepsRealizer (A := A)) := by | |
| apply polynomial_boundedRange (polynomial_composition polynomial_second polynomial_bitSize) X | |
| intro z | |
| simp only [Function.comp_apply,eval_X] | |
| exact (size_le_weight z.2).trans (weight_snd z) | |
| def prepare (z : A×ℕ) : List ℕ×State A := (steps z,(z.1,(0,z.2))) | |
| def prepareRealizer : Realizer (prepare (A := A)) := | |
| pair stepsRealizer (pair first (pair (constant 0) second)) | |
| lemma polynomial_prepare : PolynomialTime (prepareRealizer (A := A)) := | |
| polynomial_pair polynomial_steps | |
| (polynomial_pair polynomial_first (polynomial_pair (polynomial_constant 0) polynomial_second)) | |
| def execute (z : A×ℕ) : State A := | |
| (steps z).foldl (fun s i=>advance test (i,s)) (z.1,(0,z.2)) | |
| def executeRealizer : Realizer (execute test) := | |
| composition (f := prepare (A := A)) | |
| (g := fun z : List ℕ×State A=>z.1.foldl (fun s i=>advance test (i,s)) z.2) | |
| prepareRealizer (fold (advanceRealizer test T)) | |
| lemma polynomial_execute (hT : PolynomialTime T) : PolynomialTime (executeRealizer test T) := | |
| polynomial_composition polynomial_prepare (polynomial_loop test T hT) | |
| def search (z : A×ℕ) : ℕ := (execute test z).2.1 | |
| def searchRealizer : Realizer (search test) := | |
| composition (f := execute test) (g := fun s : State A=>s.2.1) | |
| (executeRealizer test T) (composition second first) | |
| lemma polynomial_search (hT : PolynomialTime T) : PolynomialTime (searchRealizer test T) := | |
| polynomial_composition (polynomial_execute test T hT) | |
| (polynomial_composition polynomial_second polynomial_first) | |
| omit [Codec A] in | |
| lemma fold_code (xs : List ℕ) (a : A) (p : Window) : | |
| xs.foldl (fun s i=>advance test (i,s)) (a,p)= | |
| (a,run (fun t=>test (a,t)) xs.length p) := by | |
| induction xs generalizing p with | |
| | nil => rfl | |
| | cons i xs ih => | |
| change xs.foldl (fun s i=>advance test (i,s)) | |
| (a,step (fun t=>test (a,t)) p)=(a,run (fun t=>test (a,t)) (xs.length+1) p) | |
| exact ih _ | |
| omit [Codec A] in | |
| theorem search_eq (a : A) (K U : ℕ) | |
| (ht : ∀ t,test (a,t)=true ↔ t≤K) (hK : K≤U) : search test (a,U)=K := by | |
| unfold search execute | |
| rw [fold_code] | |
| simp only [steps,List.length_range] | |
| exact congrArg Prod.fst (run_eq_cutoff _ K U U.size ht hK (Nat.lt_size_self U)) | |
| end ContingencyTables.BinarySearchProgram | |
| end OAI | |