| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.TreeBuild |
| import OAI.Combinatorics.MatchingCount.Algorithm.OnlineCoolingSchedule |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.OnlineSchedule |
| open TreeTyped TreeFraction Polynomial ExecutableSource Transport Enlargement |
|
|
| abbrev LadderInput := (ℕ×ℕ)×ℕ |
|
|
| def vertexNumber (x : ℕ×ℕ) : ℕ := |
| (vertices (List.range x.1,List.replicate (2*x.2+2) false)).length |
| def vertexNumberRealizer : Realizer vertexNumber := |
| composition (composition (pair (composition first range) |
| (composition (((constant 2).mulNat second).addNat (constant 2)) fuelRealizer)) verticesRealizer) listLength |
| lemma vertexNumber_eq (n K : ℕ) : vertexNumber (n,K)=Fintype.card (SourceVertex (Fin n) K) := by |
| unfold vertexNumber |
| rw [vertices_eq_ofFn_length n _ (4*(2*K+2)) (by simp),List.length_ofFn] |
| lemma vertexNumber_bound (n K : ℕ) : vertexNumber (n,K)≤n+n^2*(4*(2*K+2)) := by |
| have hprod {A B : Type} (a : List A) (b : List B) : |
| (a.product b).length=a.length*b.length := List.length_product a b |
| unfold vertexNumber vertices internalCount |
| simp only [List.length_append,List.length_map,hprod,List.length_range,List.length_replicate] |
| have h : (logicalEdges (List.range n)).length≤n*n := by |
| simpa only [logicalEdges,hprod,List.length_range] using |
| List.length_filter_le (fun e : ℕ×ℕ=>decide (e.1<e.2)) ((List.range n).product (List.range n)) |
| simpa only [pow_two] using Nat.add_le_add_left (Nat.mul_le_mul_right (4*(2*K+2)) h) n |
|
|
| def distortion (x : ℕ×ℕ) : ℕ := 100*x.2^2*(100000000*(x.1+1)^4) |
| def distortionRealizer : Realizer distortion := |
| (((constant 100).mulNat (composition second (fixedPower 2))).mulNat |
| ((constant 100000000).mulNat (composition (composition first successor) (fixedPower 4)))).congr (fun _=>rfl) |
| lemma polynomial_distortion : PolynomialTime distortionRealizer := by |
| unfold distortionRealizer;apply polynomial_congr |
| have := polynomial_fixedPower 2 |
| have := polynomial_fixedPower 4 |
| have := polynomial_successor |
| simp only [Realizer.mulNat]; tree_cost |
| lemma distortion_source {G : GraphInput} [Nontrivial (Fin G.n)] (K : ℕ) : |
| distortion (G.n,vertexNumber (G.n,K))=FiniteTrial.sourceD (G:=G) K := by |
| simp only [distortion,vertexNumber_eq,FiniteTrial.sourceD] |
|
|
| def tierBoundRealizer : Realizer (fun x : LadderInput=>tierBound x.1.1 x.1.2 x.2) := |
| ((composition first.fst (fixedPower 2)).mulNat |
| (((composition first.snd clogTwo).addNat ((constant 2).mulNat second)).addNat (constant 2))).congr (fun _=>rfl) |
| lemma polynomial_tierBound : PolynomialTime tierBoundRealizer := by |
| unfold tierBoundRealizer;apply polynomial_congr |
| dsimp only [Realizer.fst, Realizer.snd] |
| have := polynomial_fixedPower 2 |
| have := polynomial_clogTwo |
| simp only [Realizer.mulNat,Realizer.addNat]; tree_cost |
|
|
| def ladderPowerPlan (x : (ℕ×ℕ)×List Bool) : Fraction×Fraction := |
| (TreeFraction.add ((1,1),TreeFraction.div ((1,1),(x.1.1^2,1))), |
| TreeFraction.maximum ((x.1.2,1),TreeFraction.mul ((3,1),fuelPower ((4,1),x.2)))) |
| def ladderPowerPlanRealizer : Realizer ladderPowerPlan := |
| (pair (composition (pair (constant (1,1)) |
| (composition (pair (constant (1,1)) (pair (composition first.fst (fixedPower 2)) (constant 1))) divRealizer)) addRealizer) |
| (composition (pair (pair first.snd (constant 1)) |
| (composition (pair (constant (3,1)) (composition (pair (constant (4,1)) second) fuelPowerRealizer)) mulRealizer)) maximumRealizer)).congr (fun _=>rfl) |
| lemma polynomial_ladderPowerPlan : PolynomialTime ladderPowerPlanRealizer := by |
| unfold ladderPowerPlanRealizer; apply polynomial_congr |
| dsimp only [Realizer.fst, Realizer.snd] |
| have := polynomial_div |
| have := polynomial_mul |
| have := TreeFraction.polynomial_add |
| have := TreeFraction.polynomial_maximum |
| have := polynomial_fuelPower |
| have := polynomial_fixedPower 2 |
| tree_cost |
| lemma ladderPowerPlan_repr (N D : ℕ) (fuel : List Bool) : |
| ladderPowerPlan ((N,D),fuel)= |
| (TreeFraction.repr (rationalBase N),TreeFraction.repr (max (D:ℚ) (3*4^fuel.length))) := by |
| unfold ladderPowerPlan |
| rw [←repr_nat (N^2),←repr_nat D, |
| show ((1,1) : Fraction)=TreeFraction.repr (1:ℚ) from rfl, |
| show ((3,1) : Fraction)=TreeFraction.repr (3:ℚ) from rfl, |
| show ((4,1) : Fraction)=TreeFraction.repr (4:ℚ) from rfl, |
| div_repr (by decide) (by positivity),add_repr (by decide) (by positivity), |
| fuelPower_repr _ (by positivity),mul_repr (by decide) (by positivity), |
| maximum_repr (by positivity) (by positivity)] |
| simp only [rationalBase,Nat.cast_pow,one_div] |
|
|
| def ladderSearchInput (x : LadderInput) : PowerSearchInput := |
| (ladderPowerPlan (x.1,List.replicate x.2 false),List.replicate (tierBound x.1.1 x.1.2 x.2) false) |
| def ladderSearchInputRealizer : Realizer ladderSearchInput := |
| pair (composition (pair first (composition second fuelRealizer)) ladderPowerPlanRealizer) |
| (composition tierBoundRealizer fuelRealizer) |
| def ladderSchedule (x : LadderInput) : ℕ := findPower (ladderSearchInput x) |
| def ladderScheduleRealizer : Realizer ladderSchedule := composition ladderSearchInputRealizer findPowerRealizer |
| lemma ladderSchedule_eq (N D K : ℕ) (hN : 0<N) : |
| ladderSchedule ((N,D),K)=endpoint N D K hN := by |
| unfold ladderSchedule ladderSearchInput |
| rw [ladderPowerPlan_repr,List.length_replicate] |
| exact findPower_endpoint N D K hN _ (by simp) |
| end MatchingFPRAS.OnlineSchedule |
|
|
| end OAI |
|
|
