openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionBinIntervals.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionOracleJointLaw | |
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteScaledDraw | |
| import OAI.Combinatorics.ContingencyTables.Transport.RationalMapProducts | |
| namespace OAI | |
| /-! # Explicit integer intervals inside the companion evaluator bins -/ | |
| namespace ContingencyTables.CompanionOracleDensity | |
| open CompanionFactorialApplication ForestAssignmentSplit GridBoundary ResidualMixture FirstSuccess | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| variable {I J : Type*} [Fintype I] [Fintype J] | |
| def intervalSize (K N beta : ℕ) : ℕ := | |
| FairBits.endpoint K N (beta+1)-FairBits.endpoint K N beta | |
| /-- Each offset is sent to its integer by adding the exact lower ceiling | |
| endpoint. This is the actual source interval, not a cardinality-only choice. -/ | |
| def intervalEquiv (K N beta : ℕ) (hK : 0 < K) (hN : 0 < N) (hb : beta < K) : | |
| Fin (intervalSize K N beta) ≃ {z : ℕ // z∈FairBits.fiber K N beta} where | |
| toFun x := ⟨FairBits.endpoint K N beta+x.val,by | |
| rw [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] | |
| have hh := x.isLt | |
| unfold intervalSize at hh | |
| omega⟩ | |
| invFun x := ⟨x.val-FairBits.endpoint K N beta,by | |
| have hx : FairBits.endpoint K N beta ≤ x.val ∧ | |
| x.val < FairBits.endpoint K N (beta+1) := by | |
| simpa only [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] using x.property | |
| unfold intervalSize | |
| omega⟩ | |
| left_inv x := by apply Fin.ext; simp | |
| right_inv x := by | |
| apply Subtype.ext | |
| have hx : FairBits.endpoint K N beta ≤ x.val ∧ | |
| x.val < FairBits.endpoint K N (beta+1) := by | |
| simpa only [FairBits.fiber_eq_interval hK hN hb,Finset.mem_Ico] using x.property | |
| dsimp only | |
| omega | |
| def binSize (A : Instance I J) (K : ℕ) (v : Grid (I := Fin (dimension A)) K) | |
| (i : Fin (dimension A)) : ℕ := | |
| intervalSize K (freeRange A (index A i)) (naturalBin A v (index A i)) | |
| theorem binSize_positive (A : Instance I J) (K : ℕ) (hK : 0 < K) | |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) (i : Fin (dimension A)) : | |
| 0 < binSize A K v i := by | |
| have hp := CompanionBinPopulation.coordinate_nonempty K (freeRange A (index A i)) A.d | |
| (naturalBin A v (index A i)) hK A.hd (by | |
| have hb := (A.hlarge (index A i).val.1 (index A i).val.2 (index A i).property.1).1 | |
| unfold freeRange | |
| omega) (naturalBin_lt A v (index A i)) | |
| have hc := Finset.card_pos.mpr hp | |
| have hN : 0 < freeRange A (index A i) := Nat.succ_pos _ | |
| rw [FairBits.fiber_card hK hN (naturalBin_lt A v (index A i))] at hc | |
| exact hc | |
| def binOffsetsEquiv (A : Instance I J) (K : ℕ) (hK : 0 < K) | |
| (v : Grid (I := Fin (dimension A)) K) : | |
| ((i : Fin (dimension A)) → Fin (binSize A K v i)) ≃ {f // f∈integerFiber A K hK v} := | |
| (Equiv.piCongrRight (fun i => intervalEquiv K (freeRange A (index A i)) | |
| (naturalBin A v (index A i)) hK (Nat.succ_pos _) (naturalBin_lt A v (index A i)))).trans | |
| ((Equiv.piCongrLeft (fun t : FreeCell A.small A.T => | |
| {z : ℕ // z∈FairBits.fiber K (freeRange A t) (naturalBin A v t)}) (index A)).trans | |
| (integerFiberEquiv A K hK v).symm) | |
| def binOffsetValue (A : Instance I J) (K : ℕ) (hK : 0 < K) | |
| (v : Grid (I := Fin (dimension A)) K) | |
| (x : (i : Fin (dimension A)) → Fin (binSize A K v i)) : FreeIndex A.small A.T A.b := | |
| (binOffsetsEquiv A K hK v x).val | |
| lemma binOffsetValue_mem (A : Instance I J) (K : ℕ) (hK : 0 < K) | |
| (v : Grid (I := Fin (dimension A)) K) | |
| (x : (i : Fin (dimension A)) → Fin (binSize A K v i)) : | |
| binOffsetValue A K hK v x∈integerFiber A K hK v := (binOffsetsEquiv A K hK v x).property | |
| def exactBinLaw (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W) | |
| (v : Grid (I := Fin (dimension A)) K) : RationalLaw (FreeIndex A.small A.T A.b) := | |
| mapLaw (piLaw (fun i => FairBits.uniformIntLaw (binSize A K v i) (binSize_positive A K hK hW v i))) | |
| (binOffsetValue A K hK v) | |
| def approximateBinLaw (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W) | |
| (v : Grid (I := Fin (dimension A)) K) (h : ℕ) : RationalLaw (FreeIndex A.small A.T A.b) := | |
| mapLaw (piLaw (fun i => FairBits.scaledLaw (binSize A K v i) | |
| (FairBits.offsetBitLength (binSize A K v i) h A.d) (binSize_positive A K hK hW v i))) | |
| (binOffsetValue A K hK v) | |
| theorem exactBinLaw_mass (A : Instance I J) (K : ℕ) (hK : 0 < K) (hW : 100*A.d*K ≤ A.W) | |
| (v : Grid (I := Fin (dimension A)) K) (f : FreeIndex A.small A.T A.b) : | |
| (exactBinLaw A K hK hW v).mass f= | |
| if integerBin A K hK f=v then 1/((integerFiber A K hK v).card:ℚ) else 0 := by | |
| let : ∀ i : Fin (dimension A),Nonempty (Fin (binSize A K v i)) := | |
| fun i => ⟨⟨0,binSize_positive A K hK hW v i⟩⟩ | |
| let : Nonempty {f // f∈integerFiber A K hK v} := | |
| ⟨⟨(integerFiber_nonempty A K hK hW v).choose,(integerFiber_nonempty A K hK hW v).choose_spec⟩⟩ | |
| have hi (i : Fin (dimension A)) : | |
| FairBits.uniformIntLaw (binSize A K v i) (binSize_positive A K hK hW v i)= | |
| uniformLaw (α := Fin (binSize A K v i)) := by | |
| apply RationalLaw.ext | |
| funext x | |
| simp only [FairBits.uniformIntLaw,uniformLaw,uniformMass,Fintype.card_fin] | |
| unfold exactBinLaw | |
| simp_rw [hi] | |
| rw [pi_uniformLaw] | |
| change (mapLaw (uniformLaw (α := (i : Fin (dimension A)) → Fin (binSize A K v i))) | |
| (fun x => (binOffsetsEquiv A K hK v x).val)).mass f=_ | |
| rw [←FairBits.map_equiv (binOffsetsEquiv A K hK v),FairBits.uniform_equiv] | |
| change (∑ x : {g // g∈integerFiber A K hK v}, | |
| if x.val=f then (1:ℚ)/Fintype.card {g // g∈integerFiber A K hK v} else 0)=_ | |
| rw [Fintype.card_coe] | |
| by_cases hf : integerBin A K hK f=v | |
| · rw [ite_eq_left hf] | |
| let g : {g // g∈integerFiber A K hK v} := ⟨f,by simp only [integerFiber,Finset.mem_filter, | |
| Finset.mem_univ,true_and,hf]⟩ | |
| have he (x : {g // g∈integerFiber A K hK v}) : x.val=f ↔ x=g := by | |
| exact ⟨fun h => Subtype.ext h,fun h => congrArg Subtype.val h⟩ | |
| simp_rw [he] | |
| simp | |
| · rw [ite_eq_right hf] | |
| apply Finset.sum_eq_zero | |
| intro x _ | |
| have hxf : x.val≠f := by | |
| intro he | |
| have hx := (Finset.mem_filter.mp x.property).2 | |
| rw [he] at hx | |
| exact hf hx | |
| simp only [hxf,ite_false] | |
| /-- The explicitly shifted bounded quotient draws have a uniform error | |
| bound for every bin, including the case of no free coordinates. -/ | |
| theorem approximateBinLaw_variation (A : Instance I J) (K : ℕ) (hK : 0 < K) | |
| (hW : 100*A.d*K ≤ A.W) (v : Grid (I := Fin (dimension A)) K) (h : ℕ) : | |
| variation (approximateBinLaw A K hK hW v h) (exactBinLaw A K hK hW v) ≤ | |
| (A.d:ℚ)/(2:ℚ)^(4*(h+A.d)) := by | |
| apply (variation_map _ _ (binOffsetValue A K hK v)).trans | |
| exact FairBits.dense_offset_product_variation (dimension A) h A.d (binSize A K v) | |
| (binSize_positive A K hK hW v) (ForestScaledPenalty.free_card_le A) | |
| end | |
| end ContingencyTables.CompanionOracleDensity | |
| end OAI | |