| import OAI.Combinatorics.ContingencyTables.Transport.DyadicRootBisection |
| import OAI.Combinatorics.ContingencyTables.Machines.BinaryPowerProgram |
| import OAI.Combinatorics.MatchingCount.Machines.TreeFiniteOps |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolyTactic |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| The root degree is the length of a supplied allowance list. One fixed |
| depth list controls the outer loop. Thus both natural-power evaluation |
| and the bisection loop have polynomial cost in the supplied binary data |
| and the two explicit allowances. |
| -/ |
|
|
| namespace ContingencyTables.DyadicRootProgram |
|
|
| open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial |
|
|
| def powerInput (z : ℕ×List Bool) : ℕ×ℕ := (z.1,z.2.length) |
| def powerInputRealizer : Realizer powerInput := pair first (composition second listLength) |
| lemma polynomial_powerInput : PolynomialTime powerInputRealizer := by |
| unfold powerInputRealizer |
| exact polynomial_pair polynomial_first |
| (polynomial_composition polynomial_second polynomial_listLength) |
|
|
| def markedPower (z : ℕ×List Bool) : ℕ := BinaryPowerPrograms.power (powerInput z) |
| def markedPowerRealizer : Realizer markedPower := |
| composition powerInputRealizer BinaryPowerPrograms.powerRealizer |
|
|
| lemma polynomial_markedPower : PolynomialTime markedPowerRealizer := by |
| apply work_composition polynomial_powerInput BinaryPowerPrograms.work_power X |
| intro z |
| have hl:=list_length_le_weight z.2 |
| simp only [powerInput,eval_X] |
| rw [←Prod.eta z,weight_prod] |
| dsimp only |
| omega |
|
|
| lemma markedPower_eq (a : ℕ) (xs : List Bool) : markedPower (a,xs)=a^xs.length := |
| BinaryPowerPrograms.power_eq a xs.length |
|
|
| abbrev Parameters := TreeFraction.Fraction×List Bool |
| abbrev State := Parameters×DyadicRootBisection.State |
|
|
| private def lowRealizer : Realizer (fun z : State=>z.2.1.1) := |
| composition (composition second first) first |
| private def highRealizer : Realizer (fun z : State=>z.2.1.2) := |
| composition (composition second first) second |
| private def denominatorRealizer : Realizer (fun z : State=>z.2.2) := composition second second |
| private def numeratorRealizer : Realizer (fun z : State=>z.1.1.1) := |
| composition (composition first first) first |
| private def targetDenominatorRealizer : Realizer (fun z : State=>z.1.1.2) := |
| composition (composition first first) second |
| private def allowanceRealizer : Realizer (fun z : State=>z.1.2) := composition first second |
|
|
| private lemma polynomial_low : PolynomialTime lowRealizer := by unfold lowRealizer; tree_poly |
| private lemma polynomial_high : PolynomialTime highRealizer := by unfold highRealizer; tree_poly |
| private lemma polynomial_denominator : PolynomialTime denominatorRealizer := by |
| unfold denominatorRealizer; tree_poly |
| private lemma polynomial_numerator : PolynomialTime numeratorRealizer := by |
| unfold numeratorRealizer; tree_poly |
| private lemma polynomial_targetDenominator : PolynomialTime targetDenominatorRealizer := by |
| unfold targetDenominatorRealizer; tree_poly |
| private lemma polynomial_allowance : PolynomialTime allowanceRealizer := by |
| unfold allowanceRealizer; tree_poly |
|
|
| def mid (z : State) : ℕ := z.2.1.1+z.2.1.2 |
| def midRealizer : Realizer mid := composition (pair lowRealizer highRealizer) add |
| lemma polynomial_mid : PolynomialTime midRealizer := |
| polynomial_composition (polynomial_pair polynomial_low polynomial_high) polynomial_add |
|
|
| def twiceDenominator (z : State) : ℕ := 2*z.2.2 |
| def twiceDenominatorRealizer : Realizer twiceDenominator := |
| composition (f:=fun z : State=>(2,z.2.2)) (g:=fun p : ℕ×ℕ=>p.1*p.2) |
| (pair (constant 2) denominatorRealizer) multiply |
| lemma polynomial_twiceDenominator : PolynomialTime twiceDenominatorRealizer := |
| polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_denominator) |
| polynomial_multiply |
|
|
| def leftProduct (z : State) : ℕ := markedPower (mid z,z.1.2)*z.1.1.2 |
| def leftProductRealizer : Realizer leftProduct := |
| composition (pair |
| (composition (pair midRealizer allowanceRealizer) markedPowerRealizer) |
| targetDenominatorRealizer) multiply |
| lemma polynomial_leftProduct : PolynomialTime leftProductRealizer := |
| polynomial_composition (polynomial_pair |
| (polynomial_composition (polynomial_pair polynomial_mid polynomial_allowance) |
| polynomial_markedPower) polynomial_targetDenominator) polynomial_multiply |
|
|
| def rightProduct (z : State) : ℕ := z.1.1.1*markedPower (twiceDenominator z,z.1.2) |
| def rightProductRealizer : Realizer rightProduct := |
| composition (pair numeratorRealizer |
| (composition (pair twiceDenominatorRealizer allowanceRealizer) markedPowerRealizer)) multiply |
| lemma polynomial_rightProduct : PolynomialTime rightProductRealizer := |
| polynomial_composition (polynomial_pair polynomial_numerator |
| (polynomial_composition (polynomial_pair polynomial_twiceDenominator polynomial_allowance) |
| polynomial_markedPower)) polynomial_multiply |
|
|
| def test (z : State) : Bool := decide (leftProduct z≤rightProduct z) |
| def testRealizer : Realizer test := composition (pair leftProductRealizer rightProductRealizer) leNat |
| lemma polynomial_test : PolynomialTime testRealizer := |
| polynomial_composition (polynomial_pair polynomial_leftProduct polynomial_rightProduct) |
| polynomial_leNat |
|
|
| private def lowerBranchRealizer : Realizer (fun z : State=> |
| ((mid z,2*z.2.1.2),twiceDenominator z)) := |
| pair (pair midRealizer (composition |
| (f:=fun z : State=>(2,z.2.1.2)) (g:=fun p : ℕ×ℕ=>p.1*p.2) |
| (pair (constant 2) highRealizer) multiply)) |
| twiceDenominatorRealizer |
| private def upperBranchRealizer : Realizer (fun z : State=> |
| ((2*z.2.1.1,mid z),twiceDenominator z)) := |
| pair (pair (composition |
| (f:=fun z : State=>(2,z.2.1.1)) (g:=fun p : ℕ×ℕ=>p.1*p.2) |
| (pair (constant 2) lowRealizer) multiply) midRealizer) |
| twiceDenominatorRealizer |
|
|
| def next (z : State) : State := |
| (z.1,if test z then ((mid z,2*z.2.1.2),twiceDenominator z) |
| else ((2*z.2.1.1,mid z),twiceDenominator z)) |
| def nextRealizer : Realizer next := |
| pair first (choose testRealizer lowerBranchRealizer upperBranchRealizer) |
|
|
| lemma polynomial_next : PolynomialTime nextRealizer := by |
| apply polynomial_pair polynomial_first |
| apply polynomial_choose polynomial_test |
| · exact polynomial_pair (polynomial_pair polynomial_mid |
| (polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_high) |
| polynomial_multiply)) polynomial_twiceDenominator |
| · exact polynomial_pair (polynomial_pair |
| (polynomial_composition (polynomial_pair (polynomial_constant 2) polynomial_low) |
| polynomial_multiply) polynomial_mid) polynomial_twiceDenominator |
|
|
| lemma next_eq (z : State) : |
| next z=(z.1,DyadicRootBisection.advance z.1.1 z.1.2.length z.2) := by |
| simp only [next,test,leftProduct,rightProduct,markedPower_eq,mid,twiceDenominator, |
| DyadicRootBisection.advance,decide_eq_true_eq] |
|
|
| def height (z : DyadicRootBisection.State) : ℕ := max (max z.1.1.size z.1.2.size) z.2.size |
|
|
| private lemma size_double (a : ℕ) : (2*a).size≤a.size+1 := by |
| simpa only [two_mul,max_self] using nat_size_add a a |
|
|
| lemma height_advance (c : TreeFraction.Fraction) (s : ℕ) (z : DyadicRootBisection.State) : |
| height (DyadicRootBisection.advance c s z)≤height z+1 := by |
| have hm:=nat_size_add z.1.1 z.1.2 |
| have ha:=size_double z.1.1 |
| have hb:=size_double z.1.2 |
| have hd:=size_double z.2 |
| unfold DyadicRootBisection.advance height |
| split_ifs <;> dsimp only <;> omega |
|
|
| def advance (z : Bool×State) : State := next z.2 |
| def advanceRealizer : Realizer advance := composition second nextRealizer |
| lemma polynomial_advance : PolynomialTime advanceRealizer := |
| polynomial_composition polynomial_second polynomial_next |
|
|
| lemma fold_parameters (xs : List Bool) (z : State) : |
| (xs.foldl (fun z a=>advance (a,z)) z).1=z.1 := by |
| induction xs generalizing z with |
| | nil=>rfl |
| | cons a xs ih=>exact ih (next z) |
|
|
| lemma fold_height (xs : List Bool) (z : State) : |
| height (xs.foldl (fun z a=>advance (a,z)) z).2≤height z.2+xs.length := by |
| induction xs generalizing z with |
| | nil=>simp only [List.foldl_nil,List.length_nil,Nat.add_zero,le_refl] |
| | cons a xs ih=> |
| have hh:=height_advance z.1.1 z.1.2.length z.2 |
| have ht:=ih (next z) |
| have hn: height (next z).2≤height z.2+1 := by |
| rw [next_eq] |
| exact hh |
| change height (xs.foldl (fun z a=>advance (a,z)) (next z)).2≤ |
| height z.2+(xs.length+1) |
| omega |
|
|
| lemma height_le_weight (z : DyadicRootBisection.State) : height z≤weight z := by |
| have ha: z.1.1.size≤weight z := |
| (size_le_weight _).trans ((weight_fst z.1).trans (weight_fst z)) |
| have hb: z.1.2.size≤weight z := |
| (size_le_weight _).trans ((weight_snd z.1).trans (weight_fst z)) |
| have hd: z.2.size≤weight z := (size_le_weight _).trans (weight_snd z) |
| exact max_le (max_le ha hb) hd |
|
|
| lemma polynomial_loop : PolynomialTime (fold advanceRealizer) := by |
| apply polynomial_fold polynomial_advance (30*(X+1)) |
| intro xs z pre post he |
| let S:=weight (xs,z) |
| let out:=pre.foldl (fun z a=>advance (a,z)) z |
| have hz: weight z≤S:=weight_snd (xs,z) |
| have hp: weight z.1≤S:=(weight_fst z).trans hz |
| have hs: height z.2≤S:=(height_le_weight z.2).trans ((weight_snd z).trans hz) |
| have hl: pre.length≤S:=(list_length_le_weight pre).trans |
| ((weight_prefix he).trans (weight_fst (xs,z))) |
| have hh:=fold_height pre z |
| change height out.2≤height z.2+pre.length at hh |
| have hctx: out.1=z.1:=fold_parameters pre z |
| have h1:=weight_nat_le out.2.1.1 |
| have h2:=weight_nat_le out.2.1.2 |
| have h3:=weight_nat_le out.2.2 |
| have hs1: out.2.1.1.size≤height out.2:= |
| (le_max_left _ _).trans (le_max_left _ _) |
| have hs2: out.2.1.2.size≤height out.2:= |
| (le_max_right _ _).trans (le_max_left _ _) |
| have hs3: out.2.2.size≤height out.2:=le_max_right _ _ |
| have hw: weight out=weight out.1+weight out.2.1.1+weight out.2.1.2+weight out.2.2+3 := by |
| change weight (out.1,((out.2.1.1,out.2.1.2),out.2.2))=_ |
| simp only [weight_prod] |
| omega |
| simp only [eval_mul,eval_ofNat,eval_add,eval_X,eval_one] |
| change weight out≤30*(S+1) |
| rw [hw,hctx] |
| omega |
|
|
| abbrev Input := Parameters×List Bool |
| def prepare (z : Input) : List Bool×State := (z.2,(z.1,((0,8),1))) |
| def prepareRealizer : Realizer prepare := pair second (pair first (constant ((0,8),1))) |
| lemma polynomial_prepare : PolynomialTime prepareRealizer := by |
| unfold prepareRealizer |
| exact polynomial_pair polynomial_second |
| (polynomial_pair polynomial_first (polynomial_constant ((0,8),1))) |
|
|
| def execute (z : Input) : State := z.2.foldl (fun s a=>advance (a,s)) (z.1,((0,8),1)) |
| def executeRealizer : Realizer execute := composition prepareRealizer (fold advanceRealizer) |
| lemma polynomial_execute : PolynomialTime executeRealizer := |
| polynomial_composition polynomial_prepare polynomial_loop |
|
|
| def finish (z : State) : TreeFraction.Fraction := |
| TreeFraction.normalize (mid z,twiceDenominator z) |
| def finishRealizer : Realizer finish := |
| composition (pair midRealizer twiceDenominatorRealizer) TreeFraction.normalizeRealizer |
| lemma polynomial_finish : PolynomialTime finishRealizer := |
| polynomial_composition (polynomial_pair polynomial_mid polynomial_twiceDenominator) |
| TreeFraction.polynomial_normalize |
|
|
| def output (z : Input) : TreeFraction.Fraction := finish (execute z) |
| def outputRealizer : Realizer output := composition executeRealizer finishRealizer |
| theorem polynomial_output : PolynomialTime outputRealizer := |
| polynomial_composition polynomial_execute polynomial_finish |
|
|
| lemma fold_eq (xs : List Bool) (p : Parameters) (z : DyadicRootBisection.State) : |
| xs.foldl (fun z a=>advance (a,z)) (p,z)= |
| (p,(DyadicRootBisection.advance p.1 p.2.length)^[xs.length] z) := by |
| induction xs generalizing z with |
| | nil=>rfl |
| | cons a xs ih=> |
| rw [List.foldl_cons] |
| change xs.foldl (fun z a=>advance (a,z)) (next (p,z))=_ |
| rw [next_eq,ih] |
| simp only [List.length_cons,Function.iterate_succ_apply] |
|
|
| theorem output_eq (c : TreeFraction.Fraction) (degree depth : List Bool) : |
| output ((c,degree),depth)=DyadicRootBisection.output c degree.length depth.length := by |
| have hr (k : ℕ) : |
| (DyadicRootBisection.advance c degree.length)^[k] ((0,8),1)= |
| DyadicRootBisection.run c degree.length k := by |
| induction k with |
| | zero=>rfl |
| | succ k ih=>rw [Function.iterate_succ_apply',ih,DyadicRootBisection.run] |
| simp only [output,execute,fold_eq,hr,finish,mid,twiceDenominator,DyadicRootBisection.output] |
| |
| theorem output_value (c : TreeFraction.Fraction) (hc : 0<c.2) (degree depth : List Bool) : |
| TreeFraction.val (output ((c,degree),depth))= |
| RationalRootBisection.midpoint (TreeFraction.val c) degree.length depth.length := by |
| rw [output_eq] |
| exact DyadicRootBisection.output_value c hc _ _ |
| |
| end ContingencyTables.DyadicRootProgram |
| |
| end OAI |
| |
