| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.DiscreteLadderSteps |
| import OAI.Combinatorics.MatchingCount.Machines.TreeSum |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeTyped |
| variable {A : Type} [Codec A] |
| def Realizer.addNat {f g : A→ℕ} (F : Realizer f) (G : Realizer g) : |
| Realizer (fun a=>f a+g a) := composition (pair F G) add |
| def Realizer.mulNat {f g : A→ℕ} (F : Realizer f) (G : Realizer g) : |
| Realizer (fun a=>f a*g a) := composition (pair F G) multiply |
| lemma polynomial_addNat {f g : A→ℕ} {F : Realizer f} {G : Realizer g} |
| (hF : PolynomialTime F) (hG : PolynomialTime G) : PolynomialTime (F.addNat G) := |
| polynomial_composition (polynomial_pair hF hG) polynomial_add |
| lemma polynomial_mulNat {f g : A→ℕ} {F : Realizer f} {G : Realizer g} |
| (hF : PolynomialTime F) (hG : PolynomialTime G) : PolynomialTime (F.mulNat G) := |
| polynomial_composition (polynomial_pair hF hG) polynomial_multiply |
|
|
| def fixedPower : (k : ℕ)→Realizer (fun n : ℕ=>n^k) |
| | 0 => (constant 1).congr (by intro n; simp) |
| | k+1 => ((fixedPower k).mulNat identity).congr (by intro n; simp [pow_succ]) |
| lemma polynomial_fixedPower (k : ℕ) : PolynomialTime (fixedPower k) := by |
| induction k with |
| | zero => exact polynomial_congr _ (polynomial_constant 1) |
| | succ k ih => exact polynomial_congr _ (polynomial_mulNat ih polynomial_identity) |
| lemma clog_two_size_pred (n : ℕ) : Nat.clog 2 n=Nat.size (n-1) := by |
| apply Nat.le_antisymm |
| · apply Nat.clog_le_of_le_pow |
| have hp:=Nat.lt_size_self (n-1) |
| omega |
| · apply Nat.size_le.mpr |
| have hp:=Nat.le_pow_clog (by decide : 1<2) n |
| have hpos:=Nat.two_pow_pos (Nat.clog 2 n) |
| omega |
| def clogTwo : Realizer (Nat.clog 2) := |
| (composition predecessor bitSize).congr (fun n=>(clog_two_size_pred n).symm) |
| lemma polynomial_clogTwo : PolynomialTime clogTwo := |
| polynomial_congr _ (polynomial_composition polynomial_predecessor polynomial_bitSize) |
| end MatchingFPRAS.TreeTyped |
|
|
| namespace MatchingFPRAS.OnlineSchedule |
| open TreeTyped Transport |
|
|
| def lRealizer : Realizer (fun x : ℕ×ℕ=>ladderL x.1 x.2) := |
| (composition (((constant (10^4)).mulNat first).mulNat second) (fixedPower 100)).congr (fun _=>rfl) |
| lemma polynomial_l : PolynomialTime lRealizer := by |
| unfold lRealizer |
| apply polynomial_congr |
| exact polynomial_composition (polynomial_mulNat (polynomial_mulNat (polynomial_constant _) polynomial_first) |
| polynomial_second) (polynomial_fixedPower _) |
| def qRealizer : Realizer (fun x : ℕ×ℕ=>ladderQ x.1 x.2) := |
| ((constant 32).mulNat lRealizer).congr (fun _=>rfl) |
| lemma polynomial_q : PolynomialTime qRealizer := |
| polynomial_congr _ (polynomial_mulNat (polynomial_constant _) polynomial_l) |
|
|
| abbrev ScanInput := ((ℕ×ℕ)×(ℕ×ℕ))×ℕ |
|
|
| def mRealizer : Realizer (fun x : (ℕ×ℕ)×ℕ=>ladderM x.1.1 x.1.2 x.2) := |
| ((second.mulNat (composition (composition first qRealizer) (fixedPower 2))).addNat |
| (composition first qRealizer)).congr (fun _=>rfl) |
| lemma polynomial_m : PolynomialTime mRealizer := by |
| unfold mRealizer |
| apply polynomial_congr |
| exact polynomial_addNat (polynomial_mulNat polynomial_second |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_q) (polynomial_fixedPower 2))) |
| (polynomial_composition polynomial_first polynomial_q) |
| def lambdaRealizer : Realizer (fun x : (ℕ×ℕ)×(ℕ×ℕ)=>ladderLambda x.1.1 x.1.2 x.2.1 x.2.2) := |
| (((((constant 10).mulNat first.fst).mulNat (composition first qRealizer)).mulNat |
| (second.snd.addNat (constant 1))).mulNat |
| ((second.fst.addNat (composition ((first.fst.mulNat first.snd).addNat (constant 2)) clogTwo)).addNat (constant 1))).congr |
| (fun _=>rfl) |
| lemma polynomial_lambda : PolynomialTime lambdaRealizer := by |
| unfold lambdaRealizer |
| apply polynomial_congr |
| exact polynomial_mulNat |
| (polynomial_mulNat |
| (polynomial_mulNat (polynomial_mulNat (polynomial_constant _) (polynomial_fst polynomial_first)) |
| (polynomial_composition polynomial_first polynomial_q)) |
| (polynomial_addNat (polynomial_snd polynomial_second) (polynomial_constant _))) |
| (polynomial_addNat |
| (polynomial_addNat (polynomial_fst polynomial_second) |
| (polynomial_composition |
| (polynomial_addNat (polynomial_mulNat (polynomial_fst polynomial_first) |
| (polynomial_snd polynomial_first)) (polynomial_constant _)) polynomial_clogTwo)) |
| (polynomial_constant _)) |
|
|
| def scansRealizer : Realizer (fun x : ScanInput=>discreteLadderSteps x.1.1.1 x.1.1.2 x.1.2.1 x.1.2.2 x.2) := |
| ((((constant 20).mulNat (composition first.fst lRealizer)).mulNat |
| (composition (pair first.fst first.snd.snd) mRealizer)).mulNat |
| (((composition first lambdaRealizer).addNat (composition second clogTwo)).addNat (constant 1))).congr |
| (fun _=>rfl) |
| lemma polynomial_scans : PolynomialTime scansRealizer := by |
| unfold scansRealizer |
| apply polynomial_congr |
| exact polynomial_mulNat |
| (polynomial_mulNat |
| (polynomial_mulNat (polynomial_constant _) |
| (polynomial_composition (polynomial_fst polynomial_first) polynomial_l)) |
| (polynomial_composition |
| (polynomial_pair (polynomial_fst polynomial_first) (polynomial_snd (polynomial_snd polynomial_first))) |
| polynomial_m)) |
| (polynomial_addNat |
| (polynomial_addNat (polynomial_composition polynomial_first polynomial_lambda) |
| (polynomial_composition polynomial_second polynomial_clogTwo)) |
| (polynomial_constant _)) |
|
|
| end MatchingFPRAS.OnlineSchedule |
|
|
| end OAI |
|
|
