Download data/lean/OAI/Combinatorics/ContingencyTables/Counting/CompanionBinIntervals.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.94 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/ContingencyTables/Counting/CompanionBinIntervals.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/ContingencyTables/Counting/CompanionBinIntervals.lean
-
curl -L -o CompanionBinIntervals.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/ContingencyTables/Counting/CompanionBinIntervals.lean
6.94 kB
| 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 | |