openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionEstimatorWords.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionEstimatorConfidence | |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionEstimatorRange | |
| namespace OAI | |
| /-! # A single Boolean word for the literal companion weight estimator -/ | |
| namespace ContingencyTables.CompanionOracleDensity | |
| open CompanionFactorialApplication ForestAssignmentSplit GridBoundary ResidualMixture FirstSuccess | |
| open CommonBasesFPRAS FiniteIndependentAverages FairBits | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| variable {I J : Type*} [Fintype I] [Fintype J] | |
| /-- The complete input length, with one independent walk for each ratio | |
| sample and one walk plus integer-bin draw for each correction sample. -/ | |
| def estimatorWordBits (A : Instance I J) (C K j : ℕ) (delta failure : ℚ) : ℕ := | |
| j*(sampleCount j delta failure * | |
| (oracleTime A C K 1 delta * oracleStepBits A C)) + | |
| sampleCount j delta failure * | |
| oracleIntegerBits A C (oracleTime A C K 1 (correctionTheta delta)) (offsetAccuracy A delta) | |
| lemma estimatorWordBits_eq (A : Instance I J) (C K j : ℕ) (delta failure : ℚ) : | |
| estimatorWordBits A C K j delta failure = sampleCount j delta failure * | |
| (j*oracleTime A C K 1 delta*oracleStepBits A C + | |
| oracleTime A C K 1 (correctionTheta delta)*oracleStepBits A C + | |
| binWordBits A (offsetAccuracy A delta)) := by | |
| unfold estimatorWordBits oracleIntegerBits | |
| ring | |
| def ratioBlockWordEquiv (A : Instance I J) (C K j : ℕ) (delta failure : ℚ) : | |
| (Fin (sampleCount j delta failure * | |
| (oracleTime A C K 1 delta * oracleStepBits A C)) → Bool) ≃ | |
| RatioBlock A C K j delta failure := | |
| (oracleWalkWordEquiv (sampleCount j delta failure) | |
| (oracleTime A C K 1 delta * oracleStepBits A C)).trans | |
| (Equiv.piCongrRight (fun _ => | |
| oracleWalkWordEquiv (oracleTime A C K 1 delta) (oracleStepBits A C))) | |
| /-- This equivalence partitions, rather than reuses, the random bits of | |
| all the individual experiments in the estimator. -/ | |
| def estimatorWordEquiv (A : Instance I J) (C K j : ℕ) (delta failure : ℚ) : | |
| (Fin (estimatorWordBits A C K j delta failure) → Bool) ≃ | |
| EstimatorInput A C K j delta failure := | |
| (splitWordEquiv _ _).trans (Equiv.prodCongr | |
| ((oracleWalkWordEquiv j (sampleCount j delta failure * | |
| (oracleTime A C K 1 delta * oracleStepBits A C))).trans | |
| (Equiv.piCongrRight (fun _ => ratioBlockWordEquiv A C K j delta failure))) | |
| (oracleWalkWordEquiv (sampleCount j delta failure) | |
| (oracleIntegerBits A C (oracleTime A C K 1 (correctionTheta delta)) (offsetAccuracy A delta)))) | |
| def wordEstimate (A : Instance I J) (C : ℕ) (z : View A → ℕ) | |
| (K : ℕ) (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) (j : ℕ) (epsilon failure : ℚ) | |
| (v : Grid (I := Fin (dimension A)) K) | |
| (bits : Fin (estimatorWordBits A C K j (innerTolerance epsilon j) failure) → Bool) : ℚ := | |
| estimateValue A C z K hK hW j (innerTolerance epsilon j) failure v | |
| (estimatorWordEquiv A C K j (innerTolerance epsilon j) failure bits) | |
| /-- The single fixed-length word has exactly the independent-product law. -/ | |
| theorem wordEstimate_failure (A : Instance I J) (C : ℕ) (hC : 0 < C) (z : View A → ℕ) | |
| (hz : BalancedBox.InBox (bounds A) z) (K : ℕ) (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) | |
| (hB : (K:ℝ)=binWidth A C) (j : ℕ) (hj : j ≤ rationalHeight A C) | |
| (epsilon failure : ℚ) (he0 : 0 < epsilon) (he1 : epsilon < 1) (hf : 0 < failure) | |
| (hPL : PublishedInputs.FiniteBoxPrekopaLeindler (dimension A)) | |
| (hCheeger : PublishedInputs.FiniteCheeger (Grid (I := Fin (dimension A)) K)) | |
| (v : Grid (I := Fin (dimension A)) K) : | |
| uniformAverage (fun bits : Fin (estimatorWordBits A C K j (innerTolerance epsilon j) failure) → Bool => | |
| if (wordEstimate A C z K hK hW j epsilon failure v bits:ℝ) < | |
| (1-(epsilon:ℝ))*h A ((j:ℝ)*C/height A C) z ∨ | |
| (1+(epsilon:ℝ))*h A ((j:ℝ)*C/height A C) z < | |
| (wordEstimate A C z K hK hW j epsilon failure v bits:ℝ) | |
| then (1:ℝ) else 0) ≤ (failure:ℝ)/4 := by | |
| let test := fun draws : EstimatorInput A C K j (innerTolerance epsilon j) failure => | |
| if (estimateValue A C z K hK hW j (innerTolerance epsilon j) failure v draws:ℝ) < | |
| (1-(epsilon:ℝ))*h A ((j:ℝ)*C/height A C) z ∨ | |
| (1+(epsilon:ℝ))*h A ((j:ℝ)*C/height A C) z < | |
| (estimateValue A C z K hK hW j (innerTolerance epsilon j) failure v draws:ℝ) | |
| then (1:ℝ) else 0 | |
| have he := uniformAverage_equiv | |
| (estimatorWordEquiv A C K j (innerTolerance epsilon j) failure) test | |
| change uniformAverage (fun bits => test | |
| (estimatorWordEquiv A C K j (innerTolerance epsilon j) failure bits)) ≤ _ | |
| exact he.trans_le | |
| (estimateValue_failure A C hC z hz K hK hW hB j hj epsilon failure he0 he1 hf hPL hCheeger v) | |
| theorem wordEstimate_range (A : Instance I J) (C : ℕ) (hC : 0 < C) (z : View A → ℕ) | |
| (hz : BalancedBox.InBox (bounds A) z) (K : ℕ) (hK : 1 ≤ K) (hW : 100*A.d*K ≤ A.W) | |
| (hB : (K:ℝ)=binWidth A C) (j : ℕ) (hj : j ≤ rationalHeight A C) | |
| (epsilon failure : ℚ) (he0 : 0 < epsilon) (he1 : epsilon < 1) (hf : 0 < failure) | |
| (v : Grid (I := Fin (dimension A)) K) | |
| (bits : Fin (estimatorWordBits A C K j (innerTolerance epsilon j) failure) → Bool) : | |
| (assignmentCount A:ℝ)*(1/2:ℝ)^j/16 ≤ | |
| (wordEstimate A C z K hK hW j epsilon failure v bits:ℝ) ∧ | |
| (wordEstimate A C z K hK hW j epsilon failure v bits:ℝ) ≤ 8*assignmentCount A := | |
| estimateValue_range A C hC z hz K hK hW hB j hj (innerTolerance epsilon j) failure | |
| (innerTolerance_pos epsilon j he0) (innerTolerance_lt_one epsilon j he1) hf v _ | |
| end | |
| end ContingencyTables.CompanionOracleDensity | |
| end OAI | |