| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeUnitAssemble |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeFastUnit |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.ExecutableUnit |
| open TreeTyped ExecutableDP Polynomial |
|
|
| def assembleAtFast : Realizer assembleAt := by |
| let n : Realizer (fun x : (Frame×Result)×ℕ=>x.1.1.1) := first.fst.fst |
| let b : Realizer (fun x : (Frame×Result)×ℕ=>x.1.1.2.1) := first.fst.snd.fst |
| let c : Realizer (fun x : (Frame×Result)×ℕ=>x.1.1.2.2) := first.fst.snd.snd |
| let i : Realizer (fun x : (Frame×Result)×ℕ=>x.2) := second |
| let a := composition n successor |
| let j := composition (pair i b) unskipRealizer |
| let z := composition (pair first.snd j) (getDFast (0,0)) |
| let r := pair (composition (pair z.fst b) skipFast) z.snd |
| exact (choose (composition (pair i a) natEqual) (pair b c) |
| (choose (composition (pair i b) natEqual) (pair a c) r)).congr (by intro x; simp [assembleAt]) |
| lemma polynomial_assembleAtFast : PolynomialTime assembleAtFast := by |
| unfold assembleAtFast Realizer.fst Realizer.snd |
| dsimp only |
| apply polynomial_congr |
| have : PolynomialTime unskipRealizer := by |
| unfold unskipRealizer |
| apply polynomial_congr |
| exact polynomial_choose polynomial_less polynomial_first (polynomial_composition polynomial_first polynomial_predecessor) |
| have := polynomial_successor |
| have := polynomial_getDFast ((0,0) : ℕ×ℕ) |
| have := polynomial_skipFast |
| tree_poly |
|
|
| def capacity (x : Context) : ℕ := x.1.1.length+x.1.2.length+2 |
| def capacityRealizer : Realizer capacity := |
| (composition (pair (composition (pair (composition first.fst listLength) |
| (composition first.snd listLength)) add) (constant 2)) add).congr (fun _=>rfl) |
| lemma polynomial_capacity : PolynomialTime capacityRealizer := by |
| unfold capacityRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| tree_poly |
|
|
| def clippedAt (x : (Context×(Frame×Result))×ℕ) : ℕ×ℕ := |
| let r:=assembleAt (x.1.2,x.2) |
| (min r.1 (capacity x.1.1),min r.2 (capacity x.1.1)) |
| def clippedAtRealizer : Realizer clippedAt := by |
| let r : Realizer (fun x : (Context×(Frame×Result))×ℕ=>assembleAt (x.1.2,x.2)) := (composition (pair first.snd second) assembleAtFast).congr (fun _=>rfl) |
| let cap : Realizer (fun x : (Context×(Frame×Result))×ℕ=>capacity x.1.1) := (composition first.fst capacityRealizer).congr (fun _=>rfl) |
| exact (pair (composition (pair r.fst cap) minNat) (composition (pair r.snd cap) minNat)).congr (fun _=>rfl) |
| lemma polynomial_clippedAt : PolynomialTime clippedAtRealizer := by |
| unfold clippedAtRealizer Realizer.fst Realizer.snd |
| dsimp only |
| apply polynomial_congr |
| have := polynomial_assembleAtFast |
| have := polynomial_capacity |
| have := polynomial_minNat |
| tree_poly |
|
|
| def clippedAssemble (x : Context×(Frame×Result)) : Result := |
| (List.range (min (x.2.1.1+2) (x.1.1.1.length+2))).map (fun i=>clippedAt (x,i)) |
| def clippedAssembleRealizer : Realizer clippedAssemble := by |
| let n : Realizer (fun x : Context×(Frame×Result)=>x.2.1.1+2) := (composition (pair second.fst.fst (constant 2)) add).congr (fun _=>rfl) |
| let m : Realizer (fun x : Context×(Frame×Result)=>x.1.1.1.length+2) := (composition (pair (composition first.fst.fst listLength) (constant 2)) add).congr (fun _=>rfl) |
| let rs := composition (composition (pair n m) minNat) range |
| exact (composition (pair identity rs) (mapWith clippedAtRealizer)).congr (fun _=>rfl) |
| lemma polynomial_clippedAssemble : PolynomialTime clippedAssembleRealizer := by |
| unfold clippedAssembleRealizer Realizer.fst |
| dsimp only |
| apply polynomial_congr |
| apply polynomial_composition _ (polynomial_mapWith polynomial_clippedAt) |
| apply polynomial_pair polynomial_identity |
| apply polynomial_boundedRange (by have := polynomial_minNat; tree_poly) (X+2) |
| intro x |
| simpa only [Function.comp_apply,Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_ofNat] using |
| (min_le_right (x.2.1.1+2) (x.1.1.1.length+2)).trans |
| (Nat.add_le_add_right ((list_length_le_weight _).trans ((weight_fst x.1.1).trans ((weight_fst x.1).trans (weight_fst x)))) 2) |
| lemma clippedAssemble_weight (ctx : Context) (f : Frame) (r : Result) : |
| weight (clippedAssemble (ctx,(f,r)))≤64*(weight ctx+1)^2 := by |
| have hh :=weight_map_bound (as:=List.range (min (f.1+2) (ctx.1.1.length+2))) |
| (f:=fun i=>clippedAt ((ctx,(f,r)),i)) (N:=8*capacity ctx+3) (by |
| intro i hi |
| let z:=assembleAt ((f,r),i) |
| have h1:=weight_nat_numeric (min z.1 (capacity ctx)) |
| have h2:=weight_nat_numeric (min z.2 (capacity ctx)) |
| have h3:=min_le_right z.1 (capacity ctx) |
| have h4:=min_le_right z.2 (capacity ctx) |
| change weight (min z.1 (capacity ctx),min z.2 (capacity ctx))≤_ |
| rw [weight_prod] |
| omega) |
| have hn : ctx.1.1.length≤weight ctx := (list_length_le_weight _).trans ((weight_fst ctx.1).trans (weight_fst ctx)) |
| have hm : ctx.1.2.length≤weight ctx := (list_length_le_weight _).trans ((weight_snd ctx.1).trans (weight_fst ctx)) |
| have hc : capacity ctx≤2*weight ctx+2 := by unfold capacity; omega |
| have hl : min (f.1+2) (ctx.1.1.length+2)≤weight ctx+2 := (min_le_right _ _).trans (by omega) |
| simp only [List.length_range] at hh |
| have hp :=Nat.mul_le_mul hl (show 8*capacity ctx+3+1≤16*weight ctx+20 by omega) |
| change weight (clippedAssemble (ctx,(f,r)))≤_ at hh |
| nlinarith |
|
|
| def assemblyFoldStep (x : Frame×(Context×Result)) : Context×Result := |
| (x.2.1,clippedAssemble (x.2.1,(x.1,x.2.2))) |
| def assemblyFoldStepRealizer : Realizer assemblyFoldStep := |
| (pair second.fst (composition (pair second.fst (pair first second.snd)) clippedAssembleRealizer)).congr (fun _=>rfl) |
| lemma polynomial_assemblyFoldStep : PolynomialTime assemblyFoldStepRealizer := by |
| unfold assemblyFoldStepRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| have := polynomial_clippedAssemble |
| tree_poly |
| lemma assemblyFold_fst (pre : List Frame) (ctx : Context) (r : Result) : |
| (pre.foldl (fun z f=>assemblyFoldStep (f,z)) (ctx,r)).1=ctx := by |
| induction pre generalizing r with |
| | nil => rfl |
| | cons f pre ih => exact ih _ |
| lemma assemblyFold_weight (pre : List Frame) (ctx : Context) (r : Result) : |
| weight (pre.foldl (fun z f=>assemblyFoldStep (f,z)) (ctx,r)).2 ≤ |
| weight r+pre.length*(64*(weight ctx+1)^2) := by |
| induction pre generalizing r with |
| | nil => simp |
| | cons f pre ih => |
| have hh:=ih (clippedAssemble (ctx,(f,r))) |
| have hw:=clippedAssemble_weight ctx f r |
| change weight (pre.foldl _ (ctx,clippedAssemble (ctx,(f,r)))).2≤_ |
| simp only [List.length_cons] |
| nlinarith |
| lemma polynomial_assemblyFold : PolynomialTime (fold assemblyFoldStepRealizer) := by |
| apply polynomial_fold polynomial_assemblyFoldStep (70*(X+1)^3) |
| rintro fs ⟨ctx,r⟩ pre post he |
| let S:=weight (fs,(ctx,r)) |
| have hp:pre.length≤S := (list_length_le_weight _).trans ((weight_prefix he).trans (weight_fst (fs,(ctx,r)))) |
| have hc:weight ctx≤S := (weight_fst (ctx,r)).trans (weight_snd (fs,(ctx,r))) |
| have hr:weight r≤S := (weight_snd (ctx,r)).trans (weight_snd (fs,(ctx,r))) |
| have hh:=assemblyFold_weight pre ctx r |
| have hf:=assemblyFold_fst pre ctx r |
| rw [←Prod.eta (pre.foldl (fun z f=>assemblyFoldStep (f,z)) (ctx,r)),weight_prod,hf] |
| have hm:= Nat.mul_le_mul hp (show 64*(weight ctx+1)^2 ≤64*(S+1)^2 by gcongr) |
| simp only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_pow,Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one] |
| change _≤70*(S+1)^3 |
| nlinarith |
|
|
| lemma resultRep_mem {n m : ℕ} {bags : Fin n → Finset (Fin m)} |
| (p : UnitRefresh.ColoredPairing bags) {z : ℕ×ℕ} (hz : z∈resultRep p) : z.1 < n ∧ z.2 < m := by |
| simp only [resultRep,List.mem_ofFn] at hz |
| obtain ⟨i,rfl⟩:=hz |
| exact ⟨(p.pair.mate i).isLt,(p.color i).isLt⟩ |
|
|
| lemma clippedAssemble_eq {n m : ℕ} (ctx : Context) (hn : n+2≤ctx.1.1.length) (hm : m≤ctx.1.2.length) |
| (bags : Fin (n+2) → Finset (Fin m)) |
| (c : UnitRefresh.Partner bags (Fin.last (n+1))) |
| (p : UnitRefresh.ColoredPairing (fun i=>bags (UnitRefresh.removePairEquiv (Fin.last (n+1)) c.val.1 c.property.1 i).val)) : |
| clippedAssemble (ctx,((n,(c.val.1.val,c.val.2.val)),resultRep p))= |
| resultRep ((UnitRefresh.ColoredPairing.map (UnitRefresh.residualBags bags (Fin.last (n+1)) c.val.1) |
| (UnitRefresh.removePairEquiv (Fin.last (n+1)) c.val.1 c.property.1) p).insert (Fin.last (n+1)) c) := by |
| let f : Frame := (n,(c.val.1.val,c.val.2.val)) |
| have he :=assemble_eq bags c p |
| change assemble (f,resultRep p)=_ at he |
| unfold clippedAssemble |
| dsimp only |
| rw [min_eq_left (show n+2 ≤ ctx.1.1.length+2 by omega)] |
| trans assemble (f,resultRep p) |
| · unfold assemble |
| apply List.map_congr_left |
| intro i hi |
| have hz : assembleAt ((f,resultRep p),i)∈assemble (f,resultRep p) := List.mem_map.mpr ⟨i,hi,rfl⟩ |
| rw [he] at hz |
| obtain ⟨h1,h2⟩:=resultRep_mem _ hz |
| have hc1 :(assembleAt ((f,resultRep p),i)).1≤capacity ctx := by unfold capacity; omega |
| have hc2 :(assembleAt ((f,resultRep p),i)).2≤capacity ctx := by unfold capacity; omega |
| exact Prod.ext (min_eq_left hc1) (min_eq_left hc2) |
| · exact he |
| end MatchingFPRAS.ExecutableUnit |
|
|
| end OAI |
|
|
