| import OAI.Combinatorics.ContingencyTables.Dense.DenseIndexedCounts |
| import OAI.Combinatorics.ContingencyTables.Machines.TableIndexProgram |
| import OAI.Combinatorics.ContingencyTables.Dense.DenseReservedWord |
|
|
| namespace OAI |
|
|
| /-! # Computing the full integer law of an initialized dense draw -/ |
|
|
| namespace ContingencyTables.DensePrograms |
| open MatchingFPRAS MatchingFPRAS.TreeTyped ProfilePrograms GridBoundary |
| open scoped BigOperators Classical |
|
|
| def rawDrawParameters (z : CanonicalParameters) : DenseDrawParameters := |
| (((z.1,zeroGrid z.1),z.2.1),z.2.2) |
|
|
| def rawDrawParametersRealizer : Realizer rawDrawParameters := by |
| let margins : Realizer (fun z : CanonicalParameters => z.1) := first |
| let grid := composition margins zeroGridRealizer |
| let result := pair (pair (pair margins grid) (composition second first)) |
| (composition second second) |
| exact result |
|
|
| lemma polynomial_rawDrawParameters : PolynomialTime rawDrawParametersRealizer := by |
| unfold rawDrawParametersRealizer |
| exact polynomial_pair (polynomial_pair (polynomial_pair polynomial_first |
| (polynomial_composition polynomial_first polynomial_zeroGrid)) |
| (polynomial_composition polynomial_second polynomial_first)) |
| (polynomial_composition polynomial_second polynomial_second) |
|
|
| def rawTrialBits (z : CanonicalParameters) : ℕ := trialWidth (rawDrawParameters z) |
|
|
| def rawTrialBitsRealizer : Realizer rawTrialBits := |
| composition rawDrawParametersRealizer trialWidthRealizer |
|
|
| lemma polynomial_rawTrialBits : PolynomialTime rawTrialBitsRealizer := |
| polynomial_composition polynomial_rawDrawParameters polynomial_trialWidth |
|
|
| def rawRepeat (z : CanonicalParameters) : ℕ := z.2.1^4*(z.2.2+1) |
|
|
| def rawRepeatRealizer : Realizer rawRepeat := by |
| let d : Realizer (fun z : CanonicalParameters => z.2.1) := composition second first |
| let h : Realizer (fun z : CanonicalParameters => z.2.2) := composition second second |
| let result := composition (pair (composition d fourthPower) |
| (composition h successor)) multiply |
| exact result |
|
|
| lemma polynomial_rawRepeat : PolynomialTime rawRepeatRealizer := by |
| unfold rawRepeatRealizer |
| exact polynomial_composition (polynomial_pair |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_first) |
| polynomial_fourthPower) |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_second) |
| polynomial_successor)) polynomial_multiply |
|
|
| def rawCountContext (z : CanonicalParameters) : TrialCountContext := |
| ((tabulateDenseWalk z,unaryMarkers (rawTrialBits z)),z) |
|
|
| def rawCountContextRealizer : Realizer rawCountContext := by |
| let cap := composition rawTrialBitsRealizer unaryMarkersRealizer |
| let result := pair (pair tabulateDenseWalkRealizer cap) identity |
| exact result |
|
|
| def rawFallbackIndex (z : CanonicalParameters) : ℕ := |
| tableIndex (z.1,GreedyFeasibleTable.listMatrix z.1.1 z.1.2) |
|
|
| def rawFallbackIndexRealizer : Realizer rawFallbackIndex := |
| composition (pair first (composition first GreedyFeasibleTable.tableRealizer)) tableIndexRealizer |
|
|
| lemma polynomial_rawFallbackIndex : PolynomialTime rawFallbackIndexRealizer := |
| polynomial_composition (polynomial_pair polynomial_first |
| (polynomial_composition polynomial_first GreedyFeasibleTable.polynomial_table)) polynomial_tableIndex |
|
|
| def rawVectorInput (z : CanonicalParameters) : VectorRetryPrograms.Input := |
| ((unaryMarkers (rawRepeat z),BinaryPowerPrograms.power (2,rawTrialBits z)), |
| (candidateCounts (rawCountContext z),rawFallbackIndex z)) |
|
|
| def rawVectorInputRealizer : Realizer rawVectorInput := by |
| let markers := composition rawRepeatRealizer unaryMarkersRealizer |
| let denominator := composition (pair (constant 2) rawTrialBitsRealizer) |
| BinaryPowerPrograms.powerRealizer |
| let counts := composition rawCountContextRealizer candidateCountsRealizer |
| let result := pair (pair markers denominator) (pair counts rawFallbackIndexRealizer) |
| exact result |
|
|
| def rawDrawCounts (z : CanonicalParameters) : List ℕ := |
| VectorRetryPrograms.counts (rawVectorInput z) |
|
|
| def rawDrawCountsRealizer : Realizer rawDrawCounts := |
| composition rawVectorInputRealizer VectorRetryPrograms.countsRealizer |
|
|
| def rawTabulationMeasure (z : CanonicalParameters) : ℕ := |
| tabulationMeasure z+gridStateCount (completionEnumerationData z.1)+rawTrialBits z+rawRepeat z |
|
|
| private lemma weight_le_rawMeasure (z : CanonicalParameters) : weight z≤rawTabulationMeasure z := by |
| unfold rawTabulationMeasure tabulationMeasure |
| omega |
|
|
| private lemma polynomial_work {A : Type} [Codec A] {f : CanonicalParameters → A} |
| {F : Realizer f} (hF : PolynomialTime F) : WorkBound F rawTabulationMeasure := |
| work_of_polynomial hF Polynomial.X (fun z => by simpa using weight_le_rawMeasure z) |
|
|
| private lemma paired_work {A B : Type} [Codec A] [Codec B] |
| {f : CanonicalParameters → A} {g : CanonicalParameters → B} |
| {F : Realizer f} {G : Realizer g} |
| (hF : WorkBound F rawTabulationMeasure) (hG : WorkBound G rawTabulationMeasure) : |
| WorkBound (pair F G) rawTabulationMeasure := |
| work_pair hF hG Polynomial.X (fun z => by simpa using weight_le_rawMeasure z) |
|
|
| lemma work_rawCountContext : WorkBound rawCountContextRealizer rawTabulationMeasure := by |
| have hw : WorkBound tabulateDenseWalkRealizer rawTabulationMeasure := by |
| obtain ⟨p,hp⟩ := work_tabulateDenseWalk |
| refine ⟨p,fun z => (hp z).trans ?_⟩ |
| apply polynomial_eval_monotone |
| unfold rawTabulationMeasure |
| omega |
| have hc : WorkBound (composition rawTrialBitsRealizer unaryMarkersRealizer) |
| rawTabulationMeasure := by |
| apply work_composition (polynomial_work polynomial_rawTrialBits) work_unaryMarkers Polynomial.X |
| intro z |
| simp only [id_eq,Polynomial.eval_X,rawTabulationMeasure] |
| omega |
| unfold rawCountContextRealizer |
| exact paired_work (paired_work hw hc) (polynomial_work polynomial_identity) |
|
|
| lemma work_rawCandidateCounts : WorkBound |
| (composition rawCountContextRealizer candidateCountsRealizer) rawTabulationMeasure := by |
| obtain ⟨p,hp⟩ := work_rawCountContext |
| apply work_composition ⟨p,hp⟩ work_candidateCounts (Polynomial.X+p) |
| intro z |
| have hw := hp z |
| simp only [candidateCountMeasure,rawCountContext,Polynomial.eval_add,Polynomial.eval_X] |
| change _≤p.eval (rawTabulationMeasure z) at hw |
| dsimp only [rawCountContext] at hw |
| unfold rawTabulationMeasure at * |
| omega |
|
|
| lemma work_rawVectorInput : WorkBound rawVectorInputRealizer rawTabulationMeasure := by |
| have hj : WorkBound (composition rawRepeatRealizer unaryMarkersRealizer) |
| rawTabulationMeasure := by |
| apply work_composition (polynomial_work polynomial_rawRepeat) work_unaryMarkers Polynomial.X |
| intro z |
| simp only [id_eq,Polynomial.eval_X,rawTabulationMeasure] |
| omega |
| have hq : WorkBound (composition (pair (constant 2) rawTrialBitsRealizer) |
| BinaryPowerPrograms.powerRealizer) rawTabulationMeasure := by |
| apply work_composition (polynomial_work (polynomial_pair (polynomial_constant 2) |
| polynomial_rawTrialBits)) BinaryPowerPrograms.work_power (Polynomial.X+9) |
| intro z |
| have htwo : weight (2:ℕ)≤9 := by decide |
| simp only [Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_ofNat,rawTabulationMeasure] |
| omega |
| unfold rawVectorInputRealizer |
| exact paired_work (paired_work hj hq) |
| (paired_work work_rawCandidateCounts (polynomial_work polynomial_rawFallbackIndex)) |
|
|
| section |
| attribute [local irreducible] rawVectorInputRealizer VectorRetryPrograms.countsRealizer |
|
|
| /-- Full draw-law tabulation is polynomial in the finite box and grid |
| sizes and in the numerical precision schedules. -/ |
| theorem work_rawDrawCounts : WorkBound rawDrawCountsRealizer rawTabulationMeasure := by |
| obtain ⟨p,hp⟩ := work_rawVectorInput |
| obtain ⟨q,hq⟩ := VectorRetryPrograms.polynomial_counts |
| refine ⟨p+q.comp p,fun z => ?_⟩ |
| have h1 := hp z |
| have h2 := hq (rawVectorInput z) |
| have h3 := polynomial_eval_monotone q |
| ((Nat.le_add_left _ _).trans h1) |
| dsimp only at h3 |
| simp only [Polynomial.eval_add,Polynomial.eval_comp] |
| change rawVectorInputRealizer.cost z+ |
| VectorRetryPrograms.countsRealizer.cost (rawVectorInput z)+ |
| weight (VectorRetryPrograms.counts (rawVectorInput z))≤_ |
| omega |
|
|
| end |
|
|
| lemma rawTrialBits_code {m n d : ℕ} (R : Option (Fin m) → ℕ) |
| (P : Option (Fin n) → ℕ) (hd : 0<d) (h : ℕ) : |
| rawTrialBits ((marginCode R,marginCode P),(d,h))= |
| denseTrialBits R P d finProdFinEquiv h := by |
| unfold rawTrialBits rawDrawParameters |
| rw [zeroGrid_code R P hd] |
| exact trialWidth_code R P h _ |
|
|
| theorem rawDrawCounts_actual {m n d : ℕ} (R : Option (Fin m) → ℕ) |
| (P : Option (Fin n) → ℕ) (hd : 14≤d) (hq : m*n≤d) |
| (hR : ∀ i,d^12≤R i) (hP : ∀ j,d^12≤P j) (htotal : ∑ i,R i=∑ j,P j) (h : ℕ) : |
| rawDrawCounts ((marginCode R,marginCode P),(d,h))= |
| List.ofFn (((IndexedTableLaw.law R P (le_refl (∑ i,R i)) |
| ((denseTrialCounts R P d hd hR hP finProdFinEquiv h |
| (canonicalOrigin (m*n) d (by omega))).push |
| (trialSuccess R P d finProdFinEquiv htotal))).retry |
| (IndexedTableLaw.index R P (le_refl (∑ i,R i)) (canonicalFallback R P htotal)) |
| (d^4*(h+1))).count) := by |
| have hd0 : 0<d := by omega |
| have hbits := rawTrialBits_code R P hd0 h |
| have hc : ∀ j : Fin (m*n),FairBits.offsetBitLength |
| (integerWidth R P d (finProdFinEquiv.symm j)) h d≤ |
| (unaryMarkers (denseTrialBits R P d finProdFinEquiv h)).length := by |
| intro j |
| rw [unaryMarkers_length] |
| have hs : FairBits.offsetBitLength (integerWidth R P d (finProdFinEquiv.symm j)) h d≤ |
| ∑ k : Fin (m*n),FairBits.offsetBitLength |
| (integerWidth R P d (finProdFinEquiv.symm k)) h d := |
| Finset.single_le_sum |
| (f := fun k : Fin (m*n) => FairBits.offsetBitLength |
| (integerWidth R P d (finProdFinEquiv.symm k)) h d) |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ j) |
| exact hs.trans (by unfold denseTrialBits; omega) |
| unfold rawDrawCounts rawVectorInput rawCountContext rawFallbackIndex |
| rw [hbits,BinaryPowerPrograms.power_eq, |
| ←canonicalFallback_output R P htotal, |
| tableIndex_actual] |
| have he := denseRetryVector_actual R P hd hq hR hP htotal h |
| (unaryMarkers (denseTrialBits R P d finProdFinEquiv h)) |
| (unaryMarkers (rawRepeat ((marginCode R,marginCode P),(d,h)))) |
| hc (canonicalFallback R P htotal) |
| rw [unaryMarkers_length] at he |
| simpa only [rawRepeat] using he |
|
|
| /-- Looking up a feasible table returns its exact numerator in the |
| implemented finite Boolean dense draw. -/ |
| theorem rawDrawCounts_at {m n d : ℕ} (R : Option (Fin m) → ℕ) |
| (P : Option (Fin n) → ℕ) (hd : 14≤d) (hq : m*n≤d) |
| (hR : ∀ i,d^12≤R i) (hP : ∀ j,d^12≤P j) (htotal : ∑ i,R i=∑ j,P j) |
| (h : ℕ) (X : Table R P) : |
| (rawDrawCounts ((marginCode R,marginCode P),(d,h))).getD |
| (tableIndex ((marginCode R,marginCode P),tableOutput X)) 0= |
| (denseDrawCounts R P d hd hR hP finProdFinEquiv htotal h |
| (canonicalOrigin (m*n) d (by omega)) (canonicalFallback R P htotal)).count X := by |
| rw [rawDrawCounts_actual R P hd hq hR hP htotal,tableIndex_actual] |
| simp only [List.getD_eq_getElem?_getD,List.getElem?_ofFn,Fin.isLt,dite_true, |
| Option.getD_some,Fin.eta] |
| exact IndexedTableLaw.retry_count_index R P htotal (le_refl (∑ i,R i)) _ |
| (canonicalFallback R P htotal) X (d^4*(h+1)) |
|
|
| end ContingencyTables.DensePrograms |
|
|
| end OAI |
|
|
