| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Algorithm.RationalCounts |
| import OAI.Combinatorics.MatchingCount.Algorithm.SortedList |
| import OAI.Combinatorics.MatchingCount.Machines.TreeSlotWeight |
| import OAI.Combinatorics.MatchingCount.Arithmetic.OnlineFractionParam |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.OnlineSchedule |
| open TreeTyped TreeFraction Polynomial |
|
|
| abbrev SigmaInput := (ℕ×ℕ)×Fraction |
|
|
| def sigma (x : SigmaInput) : Fraction := |
| TreeFraction.minimum |
| (TreeFraction.div ((1,100000),(100*x.1.1,1)),TreeFraction.div (x.2,(1000*x.1.2,1))) |
| def sigmaRealizer : Realizer sigma := |
| (composition (pair |
| (composition (pair (constant (1,100000)) (pair ((constant 100).mulNat first.fst) (constant 1))) divRealizer) |
| (composition (pair second (pair ((constant 1000).mulNat first.snd) (constant 1))) divRealizer)) minimumRealizer).congr (fun _=>rfl) |
| lemma polynomial_sigma : PolynomialTime sigmaRealizer := by |
| unfold sigmaRealizer Realizer.fst Realizer.snd; apply polynomial_congr |
| have := polynomial_div |
| have := TreeFraction.polynomial_minimum |
| simp only [Realizer.mulNat] |
| tree_cost |
| lemma sigma_repr (D K : ℕ) (e : ℚ) (he : 0≤e) : |
| sigma ((D,K),TreeFraction.repr e)=TreeFraction.repr (Counting.sigma D K e) := by |
| unfold sigma |
| rw [←repr_nat (100*D),←repr_nat (1000*K), |
| show ((1,100000) : Fraction)=TreeFraction.repr ((1:ℚ)/100000) from by norm_num [TreeFraction.repr], |
| div_repr (by positivity) (by positivity), div_repr he (by positivity), |
| minimum_repr (by positivity) (by positivity)] |
| congr 1 |
| simp only [Counting.sigma,Counting.alpha,Nat.cast_mul,Nat.cast_ofNat] |
|
|
| abbrev SampleCountInput := ℕ×SigmaInput |
|
|
| def invSigma (x : SampleCountInput) : Fraction := inverse (sigma x.2) |
| def reciprocalSigma : Realizer invSigma := |
| composition (f:=sigma ∘ Prod.snd) (g:=inverse) |
| (composition (f:=Prod.snd) (g:=sigma) second sigmaRealizer) inverseRealizer |
| lemma polynomial_reciprocalSigma : PolynomialTime reciprocalSigma := by |
| unfold reciprocalSigma |
| exact polynomial_composition (polynomial_composition polynomial_second polynomial_sigma) polynomial_inverse |
|
|
| def fracProduct {A : Type} [Codec A] {f g : A→Fraction} (F : Realizer f) (G : Realizer g) : |
| Realizer (fun x=>TreeFraction.mul (f x,g x)) := composition (f:=fun x=>(f x,g x)) (g:=TreeFraction.mul) (pair F G) mulRealizer |
| lemma polynomial_fracProduct {A : Type} [Codec A] {f g : A→Fraction} {F : Realizer f} {G : Realizer g} |
| (hF : PolynomialTime F) (hG : PolynomialTime G) : PolynomialTime (fracProduct F G) := |
| polynomial_composition (polynomial_pair hF hG) polynomial_mul |
|
|
| def sampleFactorFn (x : SampleCountInput) : Fraction := TreeFraction.mul ((10,1),TreeFraction.mul (invSigma x,invSigma x)) |
| def sampleFactor : Realizer sampleFactorFn := fracProduct (constant (10,1)) (fracProduct reciprocalSigma reciprocalSigma) |
| lemma polynomial_sampleFactor : PolynomialTime sampleFactor := |
| polynomial_fracProduct (polynomial_constant _) (polynomial_fracProduct polynomial_reciprocalSigma polynomial_reciprocalSigma) |
|
|
| def sampleSumFn (x : SampleCountInput) : Fraction := (x.1+x.2.1.2+1,1) |
| def sampleSum : Realizer sampleSumFn := |
| pair ((first.addNat second.fst.snd).addNat (constant 1)) (constant 1) |
| lemma polynomial_sampleSum : PolynomialTime sampleSum := by |
| exact polynomial_pair (polynomial_addNat (polynomial_addNat polynomial_first |
| (polynomial_snd (polynomial_fst polynomial_second))) (polynomial_constant 1)) (polynomial_constant 1) |
|
|
| def sampleProduct (x : SampleCountInput) : Fraction := TreeFraction.mul (sampleFactorFn x,sampleSumFn x) |
| def sampleProductRealizer : Realizer sampleProduct := fracProduct sampleFactor sampleSum |
| lemma polynomial_sampleProduct : PolynomialTime sampleProductRealizer := |
| polynomial_fracProduct polynomial_sampleFactor polynomial_sampleSum |
|
|
| def sampleCount (x : SampleCountInput) : ℕ := natCeil (sampleProduct x) |
| def sampleCountRealizer : Realizer sampleCount := |
| composition (f:=sampleProduct) (g:=natCeil) sampleProductRealizer natCeilRealizer |
| lemma polynomial_sampleCount : PolynomialTime sampleCountRealizer := |
| polynomial_composition polynomial_sampleProduct polynomial_natCeil |
| lemma sampleCount_repr (n D K : ℕ) (e : ℚ) (he : 0≤e) : |
| sampleCount (n,((D,K),TreeFraction.repr e))= |
| ⌈10*(Counting.sigma D K e)⁻¹^2*((n:ℚ)+K+1)⌉₊ := by |
| have hs := Counting.sigma_nonneg D K e he |
| unfold sampleCount sampleProduct sampleFactorFn sampleSumFn invSigma |
| rw [sigma_repr D K e he,inverse_repr _ (Counting.sigma_nonneg D K e he), |
| show ((10,1) : Fraction)=TreeFraction.repr (10:ℚ) from rfl, |
| ←repr_nat (n+K+1),mul_repr (by positivity) (by positivity), |
| mul_repr (by positivity) (by positivity),mul_repr (by positivity) (by positivity), |
| natCeil_repr _ (by positivity)] |
| congr 1 |
| simp only [Nat.cast_add,Nat.cast_one,pow_two] |
|
|
| variable {G : GraphInput} [Nontrivial (Fin G.n)] |
| omit [Nontrivial (Fin G.n)] in |
| lemma sampleCount_source (p : Trial.Parameters G) : |
| sampleCount (G.n,((FiniteTrial.sourceD (G:=G) p.K,p.K),TreeFraction.repr p.epsilon))=p.S := by |
| rw [sampleCount_repr _ _ _ _ p.epsilon_pos.le] |
| exact FiniteTrial.sampleCount_eq p |
|
|
| def repetitions (x : Fraction) : ℕ := 10*(Nat.clog 2 (natCeil (inverse x))+1)+1 |
| def repetitionsRealizer : Realizer repetitions := |
| (((constant 10).mulNat ((composition (composition inverseRealizer natCeilRealizer) clogTwo).addNat (constant 1))).addNat (constant 1)).congr (fun _=>rfl) |
| lemma polynomial_repetitions : PolynomialTime repetitionsRealizer := by |
| unfold repetitionsRealizer;apply polynomial_congr |
| have := polynomial_clogTwo |
| have := polynomial_natCeil |
| have := polynomial_inverse |
| simp only [Realizer.addNat,Realizer.mulNat] |
| tree_cost |
| lemma repetitions_repr (d : ℚ) (hd : 0≤d) : |
| repetitions (TreeFraction.repr d)=2*Amplification.halfRepetitions d+1 := by |
| unfold repetitions |
| rw [inverse_repr d hd,natCeil_repr _ (by positivity)] |
| unfold Amplification.halfRepetitions |
| omega |
| end MatchingFPRAS.OnlineSchedule |
|
|
| end OAI |
|
|
