Download data/lean/OAI/Computability/BinPacking/Information/SharedProfiles.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/Information/SharedProfiles.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/BinPacking/Information/SharedProfiles.lean
-
curl -L -o SharedProfiles.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/Information/SharedProfiles.lean
19.2 kB
| import Mathlib.Analysis.SpecificLimits.Basic | |
| import Mathlib.Data.Fintype.Sum | |
| import OAI.Computability.BinPacking.Games.Reindexing | |
| import OAI.Computability.BinPacking.Information.TraceLaw | |
| namespace OAI | |
| noncomputable section | |
| namespace BinPackingGames.Foundations.CorrelatedSampling | |
| section | |
| variable {Ξ± : Type*} [Fintype Ξ±] | |
| private theorem sum_div_const {ΞΉ : Type*} [Fintype ΞΉ] (f : ΞΉ β β) (c : β) : | |
| (β i, f i) / c = β i, f i / c := by | |
| simp only [div_eq_mul_inv, Finset.sum_mul] | |
| abbrev RectangleSeed (thresholds : List β) (Ξ± : Type*) := | |
| Ξ± Γ Fin (thresholdPartition thresholds).length | |
| def rectangleWeight (thresholds : List β) (seed : RectangleSeed thresholds Ξ±) : β := | |
| ((thresholdPartition thresholds)[seed.2].hi - (thresholdPartition thresholds)[seed.2].lo) / | |
| (Fintype.card Ξ± : β) | |
| def rectangleAccept (thresholds : List β) (density : Ξ± β β) | |
| (seed : RectangleSeed thresholds Ξ±) : Bool := | |
| decide ((thresholdPartition thresholds)[seed.2].lo < density seed.1) | |
| theorem rectangleWeight_nonnegative (thresholds : List β) (seed : RectangleSeed thresholds Ξ±) : | |
| 0 β€ rectangleWeight thresholds seed := | |
| div_nonneg (sub_nonneg.mpr ((thresholdPartition thresholds)[seed.2].valid)) (by positivity) | |
| theorem rectangleWeight_normalized [Nonempty Ξ±] (thresholds : List β) : | |
| β seed : RectangleSeed thresholds Ξ±, rectangleWeight thresholds seed = 1 := by | |
| rw [Fintype.sum_prod_type] | |
| have hrow (a : Ξ±) : (β i, rectangleWeight thresholds (a, i)) = | |
| 1 / (Fintype.card Ξ± : β) := by | |
| unfold rectangleWeight | |
| rw [β sum_div_const, sum_interval_get (fun I => I.hi - I.lo), partition_total_mass] | |
| simp_rw [hrow] | |
| have hc : (Fintype.card Ξ± : β) β 0 := by exact_mod_cast Fintype.card_ne_zero | |
| simp [hc] | |
| def rectangleDistribution [Nonempty Ξ±] (thresholds : List β) : | |
| Games.FiniteDistribution (RectangleSeed thresholds Ξ±) where | |
| weight := rectangleWeight thresholds | |
| nonnegative := rectangleWeight_nonnegative thresholds | |
| normalized := rectangleWeight_normalized thresholds | |
| theorem rectangle_row_mass (thresholds : List β) (density : Ξ± β β) (a : Ξ±) | |
| (hm : density a β thresholds) (h0 : 0 β€ density a) (h1 : density a β€ 1) : | |
| (β i, if rectangleAccept thresholds density (a, i) then | |
| rectangleWeight thresholds (a, i) else 0) = density a / (Fintype.card Ξ± : β) := by | |
| calc | |
| _ = (β i : Fin (thresholdPartition thresholds).length, | |
| if (thresholdPartition thresholds)[i].lo < density a then | |
| (thresholdPartition thresholds)[i].hi - (thresholdPartition thresholds)[i].lo else 0) / | |
| (Fintype.card Ξ± : β) := by | |
| rw [sum_div_const] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| simp [rectangleAccept, rectangleWeight, ite_div] | |
| _ = density a / (Fintype.card Ξ± : β) := by | |
| rw [sum_interval_get (fun I => if I.lo < density a then I.hi - I.lo else 0), | |
| partition_acceptance_mass thresholds (density a) hm h0 h1] | |
| theorem rectangle_acceptance_mass (thresholds : List β) (density : Ξ± β β) | |
| (hm : β a, density a β thresholds) (h0 : β a, 0 β€ density a) | |
| (h1 : β a, density a β€ 1) : | |
| eventMass (rectangleWeight thresholds) (rectangleAccept thresholds density) = | |
| (β a, density a) / (Fintype.card Ξ± : β) := by | |
| unfold eventMass | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [rectangle_row_mass thresholds density _ (hm _) (h0 _) (h1 _)] | |
| rw [sum_div_const] | |
| theorem rectangle_label_mass [DecidableEq Ξ±] (thresholds : List β) (density : Ξ± β β) (a : Ξ±) | |
| (hm : β x, density x β thresholds) (h0 : β x, 0 β€ density x) | |
| (h1 : β x, density x β€ 1) : | |
| eventMass (rectangleWeight thresholds) | |
| (fun seed => rectangleAccept thresholds density seed && decide (seed.1 = a)) = | |
| density a / (Fintype.card Ξ± : β) := by | |
| unfold eventMass | |
| rw [Fintype.sum_prod_type] | |
| calc | |
| _ = β x : Ξ±, if x = a then density x / (Fintype.card Ξ± : β) else 0 := by | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| by_cases hx : x = a | |
| Β· simpa [hx] using rectangle_row_mass thresholds density x (hm x) (h0 x) (h1 x) | |
| Β· simp [hx] | |
| _ = density a / (Fintype.card Ξ± : β) := by simp | |
| omit [Fintype Ξ±] in theorem rectangle_and (thresholds : List β) (p q : Ξ± β β) : | |
| (fun seed => rectangleAccept thresholds p seed && rectangleAccept thresholds q seed) = | |
| rectangleAccept thresholds (fun a => min (p a) (q a)) := by | |
| funext seed | |
| simp [rectangleAccept] | |
| omit [Fintype Ξ±] in theorem rectangle_or (thresholds : List β) (p q : Ξ± β β) : | |
| (fun seed => rectangleAccept thresholds p seed || rectangleAccept thresholds q seed) = | |
| rectangleAccept thresholds (fun a => max (p a) (q a)) := by | |
| funext seed | |
| simp [rectangleAccept] | |
| theorem min_mem_thresholds (thresholds : List β) {x y : β} (hx : x β thresholds) | |
| (hy : y β thresholds) : min x y β thresholds := by | |
| by_cases h : x β€ y <;> simp [min_def, h, hx, hy] | |
| theorem max_mem_thresholds (thresholds : List β) {x y : β} (hx : x β thresholds) | |
| (hy : y β thresholds) : max x y β thresholds := by | |
| by_cases h : x β€ y <;> simp [max_def, h, hx, hy] | |
| theorem rectangle_union_mass (thresholds : List β) (p q : Ξ± β β) | |
| (hpm : β a, p a β thresholds) (hqm : β a, q a β thresholds) | |
| (hp0 : β a, 0 β€ p a) (_hq0 : β a, 0 β€ q a) | |
| (hp1 : β a, p a β€ 1) (hq1 : β a, q a β€ 1) : | |
| eventMass (rectangleWeight thresholds) | |
| (fun seed => rectangleAccept thresholds p seed || rectangleAccept thresholds q seed) = | |
| unionMass p q / (Fintype.card Ξ± : β) := by | |
| rw [rectangle_or] | |
| exact rectangle_acceptance_mass thresholds _ | |
| (fun a => max_mem_thresholds thresholds (hpm a) (hqm a)) | |
| (fun a => (hp0 a).trans (le_max_left _ _)) (fun a => max_le (hp1 a) (hq1 a)) | |
| theorem rectangle_common_label_mass [DecidableEq Ξ±] (thresholds : List β) | |
| (p q : Ξ± β β) (a : Ξ±) | |
| (hpm : β x, p x β thresholds) (hqm : β x, q x β thresholds) | |
| (hp0 : β x, 0 β€ p x) (hq0 : β x, 0 β€ q x) | |
| (hp1 : β x, p x β€ 1) (_hq1 : β x, q x β€ 1) : | |
| eventMass (rectangleWeight thresholds) | |
| (fun seed => (rectangleAccept thresholds p seed && rectangleAccept thresholds q seed) && | |
| decide (seed.1 = a)) = min (p a) (q a) / (Fintype.card Ξ± : β) := by | |
| have hand := congrFun (rectangle_and thresholds p q) | |
| simp_rw [hand] | |
| exact rectangle_label_mass thresholds _ a | |
| (fun x => min_mem_thresholds thresholds (hpm x) (hqm x)) | |
| (fun x => le_min (hp0 x) (hq0 x)) (fun x => (min_le_left _ _).trans (hp1 x)) | |
| end | |
| section | |
| variable {Ο Ξ± : Type*} [Fintype Ο] [DecidableEq Ο] [DecidableEq Ξ±] | |
| def localSample (accept : Ο β Bool) (decode : Ο β Ξ±) (fallback : Ξ±) | |
| (proposals : List Ο) : Ξ± := | |
| ((firstAccepted accept proposals).map decode).getD fallback | |
| def localDiagonal (left right : Ο β Bool) (decode : Ο β Ξ±) (fallback a : Ξ±) | |
| (proposals : List Ο) : β := | |
| if localSample left decode fallback proposals = a β§ | |
| localSample right decode fallback proposals = a then 1 else 0 | |
| def goodLabel (left right : Ο β Bool) (decode : Ο β Ξ±) (a : Ξ±) (s : Ο) : Bool := | |
| (left s && right s) && decide (decode s = a) | |
| omit [Fintype Ο] [DecidableEq Ο] in | |
| theorem common_first_label_lower (left right : Ο β Bool) (decode : Ο β Ξ±) | |
| (fallback a : Ξ±) (proposals : List Ο) : | |
| goodFirstIndicator (fun s => left s || right s) (goodLabel left right decode a) proposals β€ | |
| localDiagonal left right decode fallback a proposals := by | |
| cases hfirst : firstAccepted (fun s => left s || right s) proposals with | |
| | none => | |
| simp only [goodFirstIndicator, hfirst] | |
| unfold localDiagonal | |
| split_ifs <;> norm_num | |
| | some s => | |
| by_cases hc : goodLabel left right decode a s = true | |
| Β· have hparts : (left s = true β§ right s = true) β§ decode s = a := by | |
| simpa [goodLabel] using hc | |
| have h := first_union_common left right proposals s hfirst hparts.1.1 hparts.1.2 | |
| simp [goodFirstIndicator, hfirst, hc, localDiagonal, localSample, h.1, h.2, hparts.2] | |
| Β· have hn : 0 β€ localDiagonal left right decode fallback a proposals := by | |
| unfold localDiagonal | |
| split_ifs <;> norm_num | |
| simpa [goodFirstIndicator, hfirst, hc] using hn | |
| omit [DecidableEq Ο] in theorem union_goodLabel_mass | |
| (w : Ο β β) (left right : Ο β Bool) (decode : Ο β Ξ±) (a : Ξ±) : | |
| eventMass w (fun s => (left s || right s) && goodLabel left right decode a s) = | |
| eventMass w (goodLabel left right decode a) := by | |
| unfold eventMass | |
| apply Finset.sum_congr rfl | |
| intro s _ | |
| cases hl : left s <;> cases hr : right s <;> simp [goodLabel, hl, hr] | |
| theorem finite_label_diagonal_bound (w : Ο β β) (left right : Ο β Bool) | |
| (decode : Ο β Ξ±) (fallback a : Ξ±) (hw : β s, 0 β€ w s) | |
| (hw_sum : β s, w s = 1) (hu : 0 < eventMass w (fun s => left s || right s)) (n : Nat) : | |
| eventMass w (goodLabel left right decode a) / eventMass w (fun s => left s || right s) * | |
| (1 - eventMass w (fun s => !(left s || right s)) ^ n) β€ | |
| traceAverage w n (localDiagonal left right decode fallback a) := by | |
| have h := traceAverage_mono w hw n _ _ (common_first_label_lower left right decode fallback a) | |
| rw [goodFirstIndicator_law w _ _ hw_sum n, | |
| goodFirstMass_exact w _ _ hw_sum (ne_of_gt hu) n, | |
| union_goodLabel_mass] at h | |
| exact h | |
| variable [Fintype Ξ±] [Nonempty Ξ±] | |
| theorem rectangle_label_diagonal_bound (thresholds : List β) (p q : Ξ± β β) | |
| (fallback a : Ξ±) | |
| (hpm : β x, p x β thresholds) (hqm : β x, q x β thresholds) | |
| (hp0 : β x, 0 β€ p x) (hq0 : β x, 0 β€ q x) | |
| (hp1 : β x, p x β€ 1) (hq1 : β x, q x β€ 1) | |
| (hpsum : β x, p x = 1) (hqsum : β x, q x = 1) (n : Nat) : | |
| min (p a) (q a) / (1 + totalVariation p q) * | |
| (1 - eventMass (rectangleWeight thresholds) | |
| (fun s => !(rectangleAccept thresholds p s || rectangleAccept thresholds q s)) ^ n) β€ | |
| traceAverage (rectangleWeight thresholds) n | |
| (localDiagonal (rectangleAccept thresholds p) (rectangleAccept thresholds q) | |
| Prod.fst fallback a) := by | |
| have hc : 0 < (Fintype.card Ξ± : β) := by exact_mod_cast Fintype.card_pos | |
| have hU : 0 < unionMass p q := by | |
| rw [unionMass_eq p q hpsum hqsum] | |
| linarith [totalVariation_nonneg p q] | |
| have hmass := rectangle_union_mass thresholds p q hpm hqm hp0 hq0 hp1 hq1 | |
| have hu : 0 < eventMass (rectangleWeight thresholds) | |
| (fun s => rectangleAccept thresholds p s || rectangleAccept thresholds q s) := by | |
| rw [hmass] | |
| exact div_pos hU hc | |
| have h := finite_label_diagonal_bound (rectangleWeight thresholds) | |
| (rectangleAccept thresholds p) (rectangleAccept thresholds q) Prod.fst fallback a | |
| (rectangleWeight_nonnegative thresholds) (rectangleWeight_normalized thresholds) hu n | |
| unfold goodLabel at h | |
| rw [rectangle_common_label_mass thresholds p q a hpm hqm hp0 hq0 hp1 hq1, hmass] at h | |
| have hratio : (min (p a) (q a) / (Fintype.card Ξ± : β)) / | |
| (unionMass p q / (Fintype.card Ξ± : β)) = min (p a) (q a) / unionMass p q := by | |
| field_simp | |
| rw [hratio, unionMass_eq p q hpsum hqsum] at h | |
| exact h | |
| end | |
| open scoped BigOperators | |
| def profileThresholds {ΞΊ S : Type*} [Fintype ΞΊ] [Fintype S] | |
| (P : ΞΊ β S β β) : List β := by | |
| classical | |
| exact (Finset.univ.toList : List (ΞΊ Γ S)).map (fun ks => P ks.1 ks.2) | |
| theorem mem_profileThresholds {ΞΊ S : Type*} [Fintype ΞΊ] [Fintype S] | |
| (P : ΞΊ β S β β) (k : ΞΊ) (s : S) : P k s β profileThresholds P := by | |
| classical | |
| exact List.mem_map.mpr β¨(k, s), by simp, rflβ© | |
| theorem distribution_weight_le_one {S : Type*} [Fintype S] | |
| (ΞΌ : Games.FiniteDistribution S) (s : S) : ΞΌ.weight s β€ 1 := by | |
| calc | |
| ΞΌ.weight s β€ β t, ΞΌ.weight t := | |
| Finset.single_le_sum (fun t _ => ΞΌ.nonnegative t) (Finset.mem_univ s) | |
| _ = 1 := ΞΌ.normalized | |
| variable {Qβ Qβ S : Type*} [Fintype Qβ] [Fintype Qβ] [Fintype S] | |
| def sharedProfileThresholds (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) : List β := | |
| profileThresholds (fun (k : Qβ β Qβ) s => (Sum.elim L R k).weight s) | |
| theorem left_mem_sharedProfileThresholds (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) (x : Qβ) (s : S) : | |
| (L x).weight s β sharedProfileThresholds L R := by | |
| exact mem_profileThresholds _ (Sum.inl x) s | |
| theorem right_mem_sharedProfileThresholds (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) (y : Qβ) (s : S) : | |
| (R y).weight s β sharedProfileThresholds L R := by | |
| exact mem_profileThresholds _ (Sum.inr y) s | |
| abbrev SharedProfileSeed (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) := | |
| RectangleSeed (sharedProfileThresholds L R) S | |
| def sharedProfileLeft (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) (x : Qβ) : SharedProfileSeed L R β Bool := | |
| rectangleAccept (sharedProfileThresholds L R) (L x).weight | |
| def sharedProfileRight (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) (y : Qβ) : SharedProfileSeed L R β Bool := | |
| rectangleAccept (sharedProfileThresholds L R) (R y).weight | |
| def sharedProfileReject (L : Qβ β Games.FiniteDistribution S) | |
| (R : Qβ β Games.FiniteDistribution S) (x : Qβ) (y : Qβ) : β := | |
| eventMass (rectangleWeight (sharedProfileThresholds L R)) | |
| (fun s => !(sharedProfileLeft L R x s || sharedProfileRight L R y s)) | |
| def uniformRejectionRate (S : Type*) [Fintype S] : β := | |
| 1 - 1 / (Fintype.card S : β) | |
| theorem uniformRejectionRate_nonnegative (S : Type*) [Fintype S] [Nonempty S] : | |
| 0 β€ uniformRejectionRate S := by | |
| have hc : (0 : β) < Fintype.card S := by | |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card S) | |
| have hcβ : (1 : β) β€ Fintype.card S := by | |
| exact_mod_cast (Nat.succ_le_of_lt (Fintype.card_pos : 0 < Fintype.card S)) | |
| apply sub_nonneg.mpr | |
| exact (div_le_iffβ hc).2 (by simpa using hcβ) | |
| theorem uniformRejectionRate_lt_one (S : Type*) [Fintype S] [Nonempty S] : | |
| uniformRejectionRate S < 1 := by | |
| have hc : (0 : β) < Fintype.card S := by | |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card S) | |
| have hp : (0 : β) < 1 / (Fintype.card S : β) := div_pos (by norm_num) hc | |
| dsimp [uniformRejectionRate] | |
| linarith | |
| theorem sharedProfileReject_nonnegative [Nonempty S] | |
| (L : Qβ β Games.FiniteDistribution S) (R : Qβ β Games.FiniteDistribution S) | |
| (x : Qβ) (y : Qβ) : 0 β€ sharedProfileReject L R x y := by | |
| exact eventMass_nonneg _ _ | |
| (rectangleDistribution (Ξ± := S) (sharedProfileThresholds L R)).nonnegative | |
| theorem sharedProfile_reject_le_rate [Nonempty S] | |
| (L : Qβ β Games.FiniteDistribution S) (R : Qβ β Games.FiniteDistribution S) | |
| (x : Qβ) (y : Qβ) : sharedProfileReject L R x y β€ uniformRejectionRate S := by | |
| let thresholds := sharedProfileThresholds L R | |
| have hsum : (β s : RectangleSeed thresholds S, rectangleWeight thresholds s) = 1 := | |
| (rectangleDistribution (Ξ± := S) thresholds).normalized | |
| have hcomp := eventMass_complement (rectangleWeight thresholds) | |
| (fun s => sharedProfileLeft L R x s || sharedProfileRight L R y s) hsum | |
| have hu : eventMass (rectangleWeight thresholds) | |
| (fun s => sharedProfileLeft L R x s || sharedProfileRight L R y s) = | |
| (1 + totalVariation (L x).weight (R y).weight) / (Fintype.card S : β) := by | |
| change eventMass (rectangleWeight thresholds) | |
| (fun s => rectangleAccept thresholds (L x).weight s || | |
| rectangleAccept thresholds (R y).weight s) = _ | |
| rw [rectangle_union_mass thresholds (L x).weight (R y).weight | |
| (left_mem_sharedProfileThresholds L R x) | |
| (right_mem_sharedProfileThresholds L R y) | |
| (L x).nonnegative (R y).nonnegative | |
| (distribution_weight_le_one (L x)) (distribution_weight_le_one (R y))] | |
| rw [unionMass_eq (L x).weight (R y).weight (L x).normalized (R y).normalized] | |
| have hc : (0 : β) < Fintype.card S := by | |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card S) | |
| have htv := totalVariation_nonneg (L x).weight (R y).weight | |
| have hquot : 1 / (Fintype.card S : β) β€ | |
| (1 + totalVariation (L x).weight (R y).weight) / (Fintype.card S : β) := | |
| (div_le_div_iff_of_pos_right hc).2 (by linarith) | |
| rw [hu] at hcomp | |
| change eventMass (rectangleWeight thresholds) | |
| (fun s => !(sharedProfileLeft L R x s || sharedProfileRight L R y s)) β€ | |
| 1 - 1 / (Fintype.card S : β) | |
| linarith | |
| private theorem nonnegative_powers_mono (a b : β) (ha : 0 β€ a) (hab : a β€ b) | |
| (n : β) : a ^ n β€ b ^ n := by | |
| have hb : 0 β€ b := le_trans ha hab | |
| induction n with | |
| | zero => simp | |
| | succ n ih => | |
| rw [pow_succ, pow_succ] | |
| exact mul_le_mul ih hab ha (pow_nonneg hb n) | |
| theorem sharedProfile_label_diagonal_bound [Nonempty S] [DecidableEq S] | |
| (L : Qβ β Games.FiniteDistribution S) (R : Qβ β Games.FiniteDistribution S) | |
| (x : Qβ) (y : Qβ) (fallback a : S) (n : β) : | |
| min ((L x).weight a) ((R y).weight a) / | |
| (1 + totalVariation (L x).weight (R y).weight) * | |
| (1 - uniformRejectionRate S ^ n) β€ | |
| traceAverage (rectangleWeight (sharedProfileThresholds L R)) n | |
| (localDiagonal (sharedProfileLeft L R x) (sharedProfileRight L R y) | |
| Prod.fst fallback a) := by | |
| have hp := nonnegative_powers_mono (sharedProfileReject L R x y) | |
| (uniformRejectionRate S) (sharedProfileReject_nonnegative L R x y) | |
| (sharedProfile_reject_le_rate L R x y) n | |
| have htv := totalVariation_nonneg (L x).weight (R y).weight | |
| have hm : 0 β€ min ((L x).weight a) ((R y).weight a) / | |
| (1 + totalVariation (L x).weight (R y).weight) := | |
| div_nonneg (le_min ((L x).nonnegative a) ((R y).nonnegative a)) (by linarith) | |
| have hsurv : | |
| min ((L x).weight a) ((R y).weight a) / | |
| (1 + totalVariation (L x).weight (R y).weight) * | |
| (1 - uniformRejectionRate S ^ n) β€ | |
| min ((L x).weight a) ((R y).weight a) / | |
| (1 + totalVariation (L x).weight (R y).weight) * | |
| (1 - sharedProfileReject L R x y ^ n) := | |
| mul_le_mul_of_nonneg_left (by linarith) hm | |
| refine hsurv.trans ?_ | |
| simpa only [sharedProfileReject, sharedProfileLeft, sharedProfileRight] using | |
| rectangle_label_diagonal_bound (sharedProfileThresholds L R) | |
| (L x).weight (R y).weight fallback a | |
| (left_mem_sharedProfileThresholds L R x) | |
| (right_mem_sharedProfileThresholds L R y) | |
| (L x).nonnegative (R y).nonnegative | |
| (distribution_weight_le_one (L x)) (distribution_weight_le_one (R y)) | |
| (L x).normalized (R y).normalized n | |
| theorem exists_uniformRejectionRate_pow_lt (S : Type*) [Fintype S] [Nonempty S] | |
| (Ξ· : β) (hΞ· : 0 < Ξ·) : β n : β, uniformRejectionRate S ^ n < Ξ· := by | |
| have ht := tendsto_pow_atTop_nhds_zero_of_lt_one | |
| (uniformRejectionRate_nonnegative S) (uniformRejectionRate_lt_one S) | |
| exact (ht.eventually (gt_mem_nhds hΞ·)).exists | |
| end BinPackingGames.Foundations.CorrelatedSampling | |
| end | |
| end OAI | |