| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Algorithm.TreeNumericStatisticsCorrect |
| import OAI.Combinatorics.MatchingCount.Arithmetic.TreeAdaptiveArithmetic |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.NumericMarking |
| open TreeTyped TreeFraction TreeTyped.Numbered ExecutableStatistics ExecutableLadder ExecutableEstimator |
|
|
| abbrev Summaries := (Fraction×Fraction)×List (ℕ×Fraction) |
|
|
| def rawProbe (x : (Reweights×List (ExecutableMarking.Marks ℕ))×ℕ) : ℕ×Fraction := |
| (x.2,averageProbe reweight ((x.1.1,x.2),x.1.2)) |
| def rawProbeRealizer : Realizer rawProbe := (pair second |
| (composition (pair (pair first.fst second) first.snd) (averageProbeRealizer reweightRealizer natEqual))).congr (fun _=>rfl) |
| lemma polynomial_rawProbe : PolynomialTime rawProbeRealizer := by |
| unfold rawProbeRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| have := polynomial_averageProbe polynomial_reweight polynomial_natEqual |
| tree_cost |
|
|
| def summaries (x : Inputs) : Summaries := |
| ((ratio (averageA x.2,averageD reweight (x.1.1,x.2)),averageD reweight (x.1.1,x.2)), |
| x.1.2.2.map (fun e=>rawProbe ((x.1.1,x.2),e))) |
| def summariesRealizer : Realizer summaries := |
| (pair (pair (composition (pair (composition second averageARealizer) |
| (composition (pair first.fst second) (averageDRealizer reweightRealizer))) ratioRealizer) |
| (composition (pair first.fst second) (averageDRealizer reweightRealizer))) |
| (composition (pair (pair first.fst second) first.snd.snd) (mapWith rawProbeRealizer))).congr (fun _=>rfl) |
| lemma polynomial_summaries : PolynomialTime summariesRealizer := by |
| unfold summariesRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| have := polynomial_averageA (E:=ℕ) |
| have := polynomial_averageD polynomial_reweight |
| have := polynomial_ratio |
| have := polynomial_rawProbe |
| tree_cost |
|
|
| lemma summaries_rep {E : Type} [Fintype E] [LinearOrder E] {S : ℕ} |
| (s : Fin S→Finset E) (m : Fin S→E→Fin 3) |
| (r : E→ℚ) (hr : ∀ e,0≤r e) (D : ℕ) (keys : List E) : |
| summaries ((reweightsRep r,(D,keys.map index)),List.ofFn (fun i=>numericMarks (s i) (m i)))= |
| ((TreeFraction.repr (Counting.ratioEstimate ((∑ i,scalarA s m i)/(S:ℚ)) |
| ((∑ i,scalarD s m r i)/(S:ℚ))),TreeFraction.repr ((∑ i,scalarD s m r i)/(S:ℚ))), |
| keys.map (fun e=>(index e,TreeFraction.repr ((∑ i,scalarProbe s m r e i)/(S:ℚ))))) := by |
| have hs : List.ofFn (fun i=>numericMarks (s i) (m i))= |
| sampleRep (fun i=>Numbered.set (s i)) (fun i=>extend 0 (m i)) := by |
| simp only [sampleRep,numericMarks_eq] |
| rw [summaries,hs] |
| dsimp only |
| rw [averageA_rep,averageD_rep _ _ reweight (reweightsRep r) (extend 1 r) |
| (extend_nonneg r hr) (reweight_rep r)] |
| simp only [scalarA_numbered,scalarD_numbered] |
| have ha (i : Fin S) : 0 ≤ scalarA s m i := by |
| unfold scalarA; split_ifs <;> norm_num |
| have hd (i : Fin S) : 0 ≤ scalarD s m r i := by |
| unfold scalarD; split_ifs |
| · exact Finset.prod_nonneg (fun e _=>hr e) |
| · exact le_rfl |
| rw [ratio_rep _ _ (div_nonneg (Finset.sum_nonneg (fun i _=>ha i)) (Nat.cast_nonneg _)) |
| (div_nonneg (Finset.sum_nonneg (fun i _=>hd i)) (Nat.cast_nonneg _))] |
| congr 1 |
| rw [List.map_map] |
| apply List.map_congr_left |
| intro e _he |
| unfold rawProbe |
| dsimp only [Function.comp_def] |
| rw [averageProbe_rep _ _ reweight (reweightsRep r) (extend 1 r) |
| (extend_nonneg r hr) (reweight_rep r)] |
| simp only [scalarProbe_numbered] |
|
|
| abbrev Bindings := List ((ℕ×ℕ)×ℕ) |
| def logicalProbes (x : Bindings×List (ℕ×Fraction)) : ExecutableAdaptive.ProbeTable := |
| x.1.map (fun z=>(z.1,lookup (0,1) (x.2,z.2))) |
| def logicalProbesRealizer : Realizer logicalProbes := (composition (pair second first) |
| (mapWith (pair second.fst (composition (pair first second.snd) (lookupRealizer (0,1) natEqual))))).congr (fun _=>rfl) |
| lemma polynomial_logicalProbes : PolynomialTime logicalProbesRealizer := by |
| unfold logicalProbesRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| have := polynomial_lookup ((0,1) : Fraction) polynomial_natEqual |
| tree_cost |
|
|
| lemma logicalProbes_rep {E : Type} [Fintype E] [LinearOrder E] {n : ℕ} |
| (c : Enlargement.LogicalEdge (Fin n)→E) (keys : List E) (hk : ∀ e,e∈keys) (z : E→ℚ) : |
| logicalProbes ((List.ofFn (UnitRefresh.orderedEnum (Enlargement.LogicalEdge (Fin n)))).map |
| (fun e=>(ExecutableSource.logicalRepr e,index (c e))), |
| keys.map (fun e=>(index e,TreeFraction.repr (z e))))= |
| (List.ofFn (UnitRefresh.orderedEnum (Enlargement.LogicalEdge (Fin n)))).map |
| (fun e=>(ExecutableSource.logicalRepr e,TreeFraction.repr (z (c e)))) := by |
| unfold logicalProbes |
| rw [List.map_map] |
| apply List.map_congr_left |
| intro e _he |
| dsimp only [Function.comp_def] |
| rw [lookup_image (0,1) keys index (fun e=>TreeFraction.repr (z e)) index_injective (c e) (hk _)] |
|
|
| abbrev UpdateConfig := (ℕ×List ℕ)×(Bindings×ExecutableScaling.Vector) |
| def finishUpdate (x : UpdateConfig×Summaries) : Fraction×ExecutableScaling.Vector := |
| (x.2.1.1,ExecutableAdaptive.updateVector |
| (ExecutableAdaptive.estimateMatrix (((x.1.1.1,x.2.1.2),logicalProbes (x.1.2.1,x.2.2)),x.1.1.2),x.1.2.2)) |
| def finishUpdateRealizer : Realizer finishUpdate := (pair second.fst.fst |
| (composition (pair (composition (pair (pair (pair first.fst.fst second.fst.snd) |
| (composition (pair first.snd.fst second.snd) logicalProbesRealizer)) first.fst.snd) |
| ExecutableAdaptive.estimateMatrixRealizer) first.snd.snd) ExecutableAdaptive.updateVectorRealizer)).congr (fun _=>rfl) |
| lemma polynomial_finishUpdate : PolynomialTime finishUpdateRealizer := by |
| unfold finishUpdateRealizer Realizer.fst Realizer.snd |
| apply polynomial_congr |
| have := polynomial_logicalProbes |
| have := ExecutableAdaptive.polynomial_estimateMatrix |
| have := ExecutableAdaptive.polynomial_updateVector |
| tree_cost |
|
|
| end MatchingFPRAS.NumericMarking |
|
|
| end OAI |
|
|
