Download data/lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/BalancedPartitions.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 16.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/BalancedPartitions.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/BalancedPartitions.lean
-
curl -L -o BalancedPartitions.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/BalancedPartitions.lean
16.6 kB
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorFamilies | |
| import OAI.Combinatorics.MatchingPSD.TypeProbabilities | |
| namespace OAI | |
| /-! | |
| # Survival under balanced labeled partitions | |
| The three category profiles in the survival proof are as balanced as possible. | |
| Their multinomial coefficients are therefore maximal, giving bounds on the | |
| number of prescribed labeled partitions. | |
| -/ | |
| namespace LowSpaceSubsetSum | |
| open scoped BigOperators | |
| variable {K : Type*} [Fintype K] [DecidableEq K] | |
| /-- Counts differ by at most one across all labeled blocks. -/ | |
| def BalancedProfile (t : K β β) : Prop := β i j, t i β€ t j + 1 | |
| private theorem poisson_mass_at_adjacent_mode (q j t : β) (ht : t = q β¨ t = q + 1) : | |
| ((q + 1 : β) : β) ^ j / j.factorial β€ | |
| ((q + 1 : β) : β) ^ t / t.factorial := by | |
| have h := MatchingSmoothing.poisson_mass_le_integer_mode (q + 1) j | |
| rcases ht with rfl | rfl | |
| Β· convert h using 1 | |
| push_cast | |
| rw [pow_succ, Nat.factorial_succ, Nat.cast_mul, Nat.cast_add, Nat.cast_one] | |
| field_simp | |
| Β· exact h | |
| omit [DecidableEq K] in | |
| theorem balanced_multinomial_max [Nonempty K] (t k : K β β) | |
| (ht : BalancedProfile t) (hsum : β i, k i = β i, t i) : | |
| Nat.multinomial Finset.univ k β€ Nat.multinomial Finset.univ t := by | |
| classical | |
| obtain β¨j, _, hjβ© := Finset.exists_min_image Finset.univ t Finset.univ_nonempty | |
| have hnear (i : K) : t i = t j β¨ t i = t j + 1 := by | |
| have hl := hj i (Finset.mem_univ i) | |
| have hu := ht i j | |
| omega | |
| have hmass := Finset.prod_le_prodβ | |
| (fun i (_ : i β (Finset.univ : Finset K)) => | |
| by positivity : β i β (Finset.univ : Finset K), | |
| 0 β€ (((t j + 1 : β) : β) ^ k i / (k i).factorial)) | |
| (fun i (_ : i β (Finset.univ : Finset K)) => | |
| poisson_mass_at_adjacent_mode (t j) (k i) (t i) (hnear i)) | |
| have hprod := mul_le_mul_of_nonneg_left hmass | |
| (by positivity : (0 : β) β€ (β i, t i).factorial) | |
| have hk := MatchingSmoothing.multinomial_term_eq Finset.univ k | |
| (fun _ => ((t j + 1 : β) : β)) | |
| have ht' := MatchingSmoothing.multinomial_term_eq Finset.univ t | |
| (fun _ => ((t j + 1 : β) : β)) | |
| rw [hsum] at hk | |
| rw [β hk, β ht', Finset.prod_pow_eq_pow_sum, Finset.prod_pow_eq_pow_sum, hsum] at hprod | |
| have hp : 0 < (((t j + 1 : β) : β) ^ (β i, t i)) := by positivity | |
| exact_mod_cast (mul_le_mul_iff_leftβ hp).mp hprod | |
| /-- A balanced profile receives at least the average multinomial mass. | |
| There are at most `(n+1)^|K|` profiles. -/ | |
| theorem balanced_multinomial_lower [Nonempty K] (t : K β β) (n : β) | |
| (ht : BalancedProfile t) (hsum : β i, t i = n) : | |
| (Fintype.card K : β) ^ n β€ (n + 1 : β) ^ Fintype.card K * | |
| Nat.multinomial Finset.univ t := by | |
| classical | |
| have heq : (Fintype.card K : β) ^ n = | |
| β k β Finset.piAntidiag (Finset.univ : Finset K) n, | |
| (Nat.multinomial Finset.univ k : β) := by | |
| simpa using Finset.sum_pow_eq_sum_piAntidiag (Finset.univ : Finset K) | |
| (fun _ : K => (1 : β)) n | |
| rw [heq] | |
| calc | |
| _ β€ β _k β Finset.piAntidiag (Finset.univ : Finset K) n, | |
| (Nat.multinomial Finset.univ t : β) := by | |
| apply Finset.sum_le_sum | |
| intro k hk | |
| exact_mod_cast balanced_multinomial_max t k ht | |
| ((Finset.mem_piAntidiag.mp hk).1.trans hsum.symm) | |
| _ = ((Finset.piAntidiag (Finset.univ : Finset K) n).card : β) * | |
| Nat.multinomial Finset.univ t := by simp | |
| _ β€ _ := mul_le_mul_of_nonneg_right | |
| (by exact_mod_cast MatchingSmoothing.card_piAntidiag_univ_le (ΞΉ := K) n) | |
| (Nat.cast_nonneg _) | |
| private def sigma_fst_fiber_equiv (t : K β β) (i : K) : | |
| {x : (Ξ£ j, Fin (t j)) // x.1 = i} β Fin (t i) where | |
| toFun x := x.2 βΈ x.1.2 | |
| invFun x := β¨β¨i, xβ©, rflβ© | |
| left_inv := by rintro β¨β¨j, xβ©, hβ©; dsimp at h; subst j; rfl | |
| right_inv := by intro x; rfl | |
| theorem exists_coloring_of_sum (A : Type*) [Fintype A] (t : K β β) | |
| (ht : β i, t i = Fintype.card A) : | |
| β f : A β K, MatchingSmoothing.histogram f = t := by | |
| classical | |
| let e : A β (Ξ£ i, Fin (t i)) := Fintype.equivOfCardEq (by | |
| simpa only [Fintype.card_sigma, Fintype.card_fin] using ht.symm) | |
| refine β¨fun a => (e a).1, ?_β© | |
| funext i | |
| unfold MatchingSmoothing.histogram | |
| let e' : {a : A // (e a).1 = i} β {x : (Ξ£ j, Fin (t j)) // x.1 = i} := | |
| e.subtypeEquivOfSubtype (p := fun x : (Ξ£ j, Fin (t j)) => x.1 = i) | |
| exact (Fintype.card_congr (e'.trans (sigma_fst_fiber_equiv t i))).trans | |
| (Fintype.card_fin (t i)) | |
| theorem card_colorings_of_sum (A : Type*) [Fintype A] (t : K β β) | |
| (ht : β i, t i = Fintype.card A) : | |
| Fintype.card (MatchingSmoothing.Colorings A K t) = Nat.multinomial Finset.univ t := by | |
| obtain β¨f, hfβ© := exists_coloring_of_sum A t ht | |
| rw [β hf] | |
| exact MatchingSmoothing.card_colorings_eq_multinomial f | |
| /-- The domain is the disjoint union of the three categories in the paper. -/ | |
| abbrev CategoryDomain (C : Fin 3 β Type*) := Ξ£ a, C a | |
| abbrev PrescribedLabelings (C : Fin 3 β Type*) [β a, Fintype (C a)] (q : Fin 3 β K β β) := | |
| {f : CategoryDomain C β K // β a, | |
| MatchingSmoothing.histogram (fun x : C a => f β¨a, xβ©) = q a} | |
| noncomputable instance prescribedLabelingsFintype (C : Fin 3 β Type*) | |
| [β a, Fintype (C a)] (q : Fin 3 β K β β) : Fintype (PrescribedLabelings C q) := | |
| Fintype.ofFinite _ | |
| theorem card_prescribedLabelings (C : Fin 3 β Type*) [β a, Fintype (C a)] | |
| (q : Fin 3 β K β β) (hrows : β a, β i, q a i = Fintype.card (C a)) : | |
| Fintype.card (PrescribedLabelings C q) = β a, Nat.multinomial Finset.univ (q a) := by | |
| classical | |
| let e : PrescribedLabelings C q β | |
| ((a : Fin 3) β MatchingSmoothing.Colorings (C a) K (q a)) := | |
| { toFun := fun f a => β¨fun x => f.1 β¨a, xβ©, f.2 aβ© | |
| invFun := fun f => β¨fun x => (f x.1).1 x.2, fun a => (f a).2β© | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| rw [Fintype.card_congr e, Fintype.card_pi] | |
| exact Finset.prod_congr rfl (fun a _ => card_colorings_of_sum (C a) (q a) (hrows a)) | |
| omit [Fintype K] in | |
| theorem histogram_categoryDomain (C : Fin 3 β Type*) [β a, Fintype (C a)] | |
| (f : CategoryDomain C β K) (i : K) : | |
| MatchingSmoothing.histogram f i = | |
| β a, MatchingSmoothing.histogram (fun x : C a => f β¨a, xβ©) i := by | |
| classical | |
| let e : {x : CategoryDomain C // f x = i} β (Ξ£ a, {x : C a // f β¨a, xβ© = i}) := | |
| { toFun := fun x => β¨x.1.1, β¨x.1.2, x.2β©β© | |
| invFun := fun x => β¨β¨x.1, x.2.1β©, x.2.2β© | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| unfold MatchingSmoothing.histogram | |
| exact (Fintype.card_congr e).trans Fintype.card_sigma | |
| omit [Fintype K] in | |
| theorem prescribedLabelings_fill_blocks (C : Fin 3 β Type*) [β a, Fintype (C a)] | |
| (q : Fin 3 β K β β) (b : β) (hcols : β i, β a, q a i = b) | |
| (f : PrescribedLabelings C q) : MatchingSmoothing.histogram f.val = fun _ => b := by | |
| funext i | |
| rw [histogram_categoryDomain] | |
| simp_rw [f.property] | |
| exact hcols i | |
| /-- Exact favorable/total counting formula, before applying the balanced bounds. -/ | |
| theorem prescribed_partition_probability_eq | |
| (C : Fin 3 β Type*) [β a, Fintype (C a)] (q : Fin 3 β K β β) (b : β) | |
| (hrows : β a, β i, q a i = Fintype.card (C a)) | |
| (hcols : β i, β a, q a i = b) : | |
| finiteUniformProbability | |
| (fun f : MatchingSmoothing.Colorings (CategoryDomain C) K (fun _ => b) => | |
| β a, MatchingSmoothing.histogram (fun x : C a => f.val β¨a, xβ©) = q a) = | |
| (β a, (Nat.multinomial Finset.univ (q a) : β)) / | |
| Nat.multinomial (Finset.univ : Finset K) (fun _ => b) := by | |
| classical | |
| let Part := MatchingSmoothing.Colorings (CategoryDomain C) K (fun _ => b) | |
| let P : Part β Prop := fun f => | |
| β a, MatchingSmoothing.histogram (fun x : C a => f.val β¨a, xβ©) = q a | |
| let : DecidablePred P := fun _ => Classical.propDecidable _ | |
| let e : {f : Part // P f} β PrescribedLabelings C q := | |
| { toFun := fun f => β¨f.1.1, f.2β© | |
| invFun := fun f => β¨β¨f.1, prescribedLabelings_fill_blocks C q b hcols fβ©, f.2β© | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| have hgood : Fintype.card {f : Part // P f} = Fintype.card (PrescribedLabelings C q) := | |
| Fintype.card_congr e | |
| have hsum : β i : K, b = Fintype.card (CategoryDomain C) := by | |
| calc | |
| _ = β i, β a, q a i := Finset.sum_congr rfl (fun i _ => (hcols i).symm) | |
| _ = β a, β i, q a i := Finset.sum_comm | |
| _ = _ := by simp only [hrows, Fintype.card_sigma] | |
| have hpart : Fintype.card Part = Nat.multinomial Finset.univ (fun _ : K => b) := | |
| card_colorings_of_sum (CategoryDomain C) (fun _ => b) hsum | |
| change finiteUniformProbability P = _ | |
| unfold finiteUniformProbability | |
| rw [hgood, card_prescribedLabelings C q hrows, hpart, Nat.cast_prod] | |
| theorem balanced_category_count_lower [Nonempty K] | |
| (C : Fin 3 β Type*) [β a, Fintype (C a)] (q : Fin 3 β K β β) | |
| (hrows : β a, β i, q a i = Fintype.card (C a)) (hbal : β a, BalancedProfile (q a)) : | |
| (Fintype.card K : β) ^ Fintype.card (CategoryDomain C) β€ | |
| (Fintype.card (CategoryDomain C) + 1 : β) ^ (3 * Fintype.card K) * | |
| Fintype.card (PrescribedLabelings C q) := by | |
| classical | |
| have hsize (a : Fin 3) : Fintype.card (C a) β€ Fintype.card (CategoryDomain C) := by | |
| rw [Fintype.card_sigma] | |
| exact Finset.single_le_sum (f := fun a : Fin 3 => Fintype.card (C a)) | |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ a) | |
| have hrow (a : Fin 3) : (Fintype.card K : β) ^ Fintype.card (C a) β€ | |
| (Fintype.card (CategoryDomain C) + 1 : β) ^ Fintype.card K * | |
| Nat.multinomial Finset.univ (q a) := by | |
| apply (balanced_multinomial_lower (q a) _ (hbal a) (hrows a)).trans | |
| apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg _) | |
| apply pow_le_pow_leftβ (by positivity) | |
| exact_mod_cast Nat.add_le_add_right (hsize a) 1 | |
| have hprod := Finset.prod_le_prodβ | |
| (fun a (_ : a β (Finset.univ : Finset (Fin 3))) => | |
| by positivity : β a β (Finset.univ : Finset (Fin 3)), | |
| 0 β€ (Fintype.card K : β) ^ Fintype.card (C a)) | |
| (fun a _ => hrow a) | |
| rw [Finset.prod_pow_eq_pow_sum, β Fintype.card_sigma] at hprod | |
| rw [Finset.prod_mul_distrib, Finset.prod_const, Finset.card_univ, Fintype.card_fin] at hprod | |
| rw [β pow_mul, Nat.mul_comm] at hprod | |
| rw [card_prescribedLabelings C q hrows, Nat.cast_prod] | |
| exact hprod | |
| /-- Uniform labeled equal-size partitions preserve all three balanced | |
| category prescriptions with the paper's inverse-polynomial probability. -/ | |
| theorem balanced_partition_probability [Nonempty K] | |
| (C : Fin 3 β Type*) [β a, Fintype (C a)] (q : Fin 3 β K β β) (b : β) | |
| (hrows : β a, β i, q a i = Fintype.card (C a)) | |
| (hcols : β i, β a, q a i = b) (hbal : β a, BalancedProfile (q a)) : | |
| 1 / (Fintype.card (CategoryDomain C) + 1 : β) ^ (3 * Fintype.card K) β€ | |
| finiteUniformProbability | |
| (fun f : MatchingSmoothing.Colorings (CategoryDomain C) K (fun _ => b) => | |
| β a, MatchingSmoothing.histogram (fun x : C a => f.val β¨a, xβ©) = q a) := by | |
| classical | |
| let Part := MatchingSmoothing.Colorings (CategoryDomain C) K (fun _ => b) | |
| let P : Part β Prop := fun f => | |
| β a, MatchingSmoothing.histogram (fun x : C a => f.val β¨a, xβ©) = q a | |
| let : DecidablePred P := fun _ => Classical.propDecidable _ | |
| let e : {f : Part // P f} β PrescribedLabelings C q := | |
| { toFun := fun f => β¨f.1.1, f.2β© | |
| invFun := fun f => β¨β¨f.1, prescribedLabelings_fill_blocks C q b hcols fβ©, f.2β© | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| have hgood : Fintype.card {f : Part // P f} = Fintype.card (PrescribedLabelings C q) := | |
| Fintype.card_congr e | |
| have hpos : 0 < Fintype.card (PrescribedLabelings C q) := by | |
| rw [card_prescribedLabelings C q hrows] | |
| exact Finset.prod_pos (fun _ _ => Nat.multinomial_pos _ _) | |
| have hle : Fintype.card (PrescribedLabelings C q) β€ Fintype.card Part := by | |
| rw [β hgood] | |
| exact Fintype.card_subtype_le P | |
| have hden : (0 : β) < Fintype.card Part := by exact_mod_cast lt_of_lt_of_le hpos hle | |
| have hall : (Fintype.card Part : β) β€ | |
| (Fintype.card K : β) ^ Fintype.card (CategoryDomain C) := by | |
| have h := Fintype.card_subtype_le | |
| (fun f : CategoryDomain C β K => MatchingSmoothing.histogram f = fun _ => b) | |
| rw [Fintype.card_fun] at h | |
| exact_mod_cast h | |
| have hbound := hall.trans (balanced_category_count_lower C q hrows hbal) | |
| change 1 / _ β€ finiteUniformProbability P | |
| unfold finiteUniformProbability | |
| apply (div_le_div_iffβ (by positivity) hden).mpr | |
| rw [one_mul] | |
| rw [hgood] | |
| simpa only [mul_comm] using hbound | |
| /-- The only two arities used by the algorithm: top blocks (`l=4`) and | |
| local blocks (`l=2`). -/ | |
| theorem balanced_partition_probability_two_or_four (l b : β) (hl : l = 2 β¨ l = 4) | |
| (C : Fin 3 β Type*) [β a, Fintype (C a)] (q : Fin 3 β Fin l β β) | |
| (hrows : β a, β i, q a i = Fintype.card (C a)) | |
| (hcols : β i, β a, q a i = b) (hbal : β a, BalancedProfile (q a)) : | |
| 1 / (Fintype.card (CategoryDomain C) + 1 : β) ^ (3 * l) β€ | |
| finiteUniformProbability | |
| (fun f : MatchingSmoothing.Colorings (CategoryDomain C) (Fin l) (fun _ => b) => | |
| β a, MatchingSmoothing.histogram (fun x : C a => f.val β¨a, xβ©) = q a) := by | |
| have : Nonempty (Fin l) := β¨β¨0, by omegaβ©β© | |
| simpa only [Fintype.card_fin] using balanced_partition_probability C q b hrows hcols hbal | |
| /-- A bounded surviving fraction has a polynomially likely substantial value. -/ | |
| theorem surviving_fraction_probability {Ξ© : Type*} [Fintype Ξ©] [Nonempty Ξ©] | |
| (Z : Ξ© β β) {p : β} (_hZ0 : β Ο, 0 β€ Z Ο) (hZ1 : β Ο, Z Ο β€ 1) | |
| (hp : p β€ (β Ο, Z Ο) / Fintype.card Ξ©) : | |
| p / 2 β€ finiteUniformProbability (fun Ο => p / 2 β€ Z Ο) := by | |
| classical | |
| by_cases hp0 : p β€ 0 | |
| Β· exact (by linarith : p / 2 β€ 0).trans (finiteUniformProbability_nonneg _) | |
| have hcard : (0 : β) < Fintype.card Ξ© := by exact_mod_cast Fintype.card_pos | |
| have hpoint (Ο : Ξ©) : Z Ο β€ p / 2 + if p / 2 β€ Z Ο then (1 : β) else 0 := by | |
| split_ifs with h | |
| Β· linarith [hZ1 Ο] | |
| Β· linarith | |
| have hsum := Finset.sum_le_sum (s := Finset.univ) (fun Ο _ => hpoint Ο) | |
| simp only [Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ, nsmul_eq_mul] at hsum | |
| have hevent : (β Ο, if p / 2 β€ Z Ο then (1 : β) else 0) = | |
| (Fintype.card {Ο // p / 2 β€ Z Ο} : β) := by | |
| rw [Fintype.card_subtype] | |
| simp only [β Finset.sum_filter, Finset.sum_const, nsmul_eq_mul, mul_one] | |
| rw [hevent] at hsum | |
| unfold finiteUniformProbability | |
| apply (le_div_iffβ hcard).mpr | |
| have hmean := (le_div_iffβ hcard).mp hp | |
| nlinarith | |
| theorem finiteUniformProbability_eq_indicator_mean {Ξ© : Type*} [Fintype Ξ©] | |
| (P : Ξ© β Prop) [DecidablePred P] : finiteUniformProbability P = | |
| (β Ο, if P Ο then (1 : β) else 0) / Fintype.card Ξ© := by | |
| classical | |
| unfold finiteUniformProbability | |
| congr 1 | |
| rw [Fintype.card_subtype] | |
| simp only [β Finset.sum_filter, Finset.sum_const, nsmul_eq_mul, mul_one] | |
| /-- Pointwise survival gives a likely partition retaining at least half the | |
| expected fraction of an arbitrary finite representative family. -/ | |
| theorem surviving_representative_family {Ξ© R : Type*} | |
| [Fintype Ξ©] [Nonempty Ξ©] [Fintype R] [Nonempty R] | |
| (keeps : Ξ© β R β Prop) {p : β} | |
| (hp : β r, p β€ finiteUniformProbability (fun Ο => keeps Ο r)) : | |
| p / 2 β€ finiteUniformProbability | |
| (fun Ο => p / 2 β€ finiteUniformProbability (keeps Ο)) := by | |
| classical | |
| apply surviving_fraction_probability (fun Ο => finiteUniformProbability (keeps Ο)) | |
| (fun Ο => finiteUniformProbability_nonneg (keeps Ο)) | |
| (fun Ο => finiteUniformProbability_le_one (keeps Ο)) | |
| have hcard : (0 : β) < Fintype.card R := by exact_mod_cast Fintype.card_pos | |
| have hsum := Finset.sum_le_sum (s := Finset.univ) (fun r _ => hp r) | |
| simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul] at hsum | |
| have havg : p β€ (β r, finiteUniformProbability (fun Ο => keeps Ο r)) / | |
| Fintype.card R := (le_div_iffβ hcard).mpr (by simpa only [mul_comm] using hsum) | |
| convert havg using 1 | |
| simp_rw [finiteUniformProbability_eq_indicator_mean] | |
| rw [β Finset.sum_div, β Finset.sum_div, div_div, div_div, Finset.sum_comm, mul_comm] | |
| end LowSpaceSubsetSum | |
| end OAI | |