Download data/lean/OAI/Dynamics/SmoothObstruction/Sampling.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 22.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/SmoothObstruction/Sampling.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/SmoothObstruction/Sampling.lean
-
curl -L -o Sampling.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/SmoothObstruction/Sampling.lean
22.8 kB
| import Mathlib | |
| namespace OAI | |
| section | |
| open Finset | |
| namespace SmoothObstruction.SymplecticSampling | |
| lemma bit_cases (a : ZMod 2) : a = 0 β¨ a = 1 := by | |
| have h : β a : ZMod 2, a = 0 β¨ a = 1 := by decide | |
| exact h a | |
| lemma bit_one {a : ZMod 2} (h : a β 0) : a = 1 := (bit_cases a).resolve_left h | |
| lemma bit_neg (a : ZMod 2) : -a = a := by | |
| rcases bit_cases a with rfl | rfl <;> decide | |
| variable {V : Type*} [AddCommGroup V] [Module (ZMod 2) V] | |
| lemma add_self (v : V) : v + v = 0 := by | |
| rw [β two_smul (ZMod 2), show (2 : ZMod 2) = 0 by decide, zero_smul] | |
| lemma alt_symm {B : LinearMap.BilinForm (ZMod 2) V} (hB : B.IsAlt) (x y : V) : | |
| B x y = B y x := by | |
| rw [β hB.neg_eq x y, bit_neg] | |
| lemma transvection_preserves {B : LinearMap.BilinForm (ZMod 2) V} | |
| (hB : B.IsAlt) (v x y : V) : | |
| B (LinearEquiv.transvection (hB v) x) (LinearEquiv.transvection (hB v) y) = B x y := by | |
| simp only [LinearEquiv.transvection.apply, map_add, map_smul, LinearMap.add_apply, | |
| LinearMap.smul_apply, smul_eq_mul, hB v, mul_zero, add_zero] | |
| rw [β alt_symm hB x v] | |
| rcases bit_cases (B v x) with hx | hx <;> | |
| rcases bit_cases (B v y) with hy | hy <;> | |
| simp [hx, hy, alt_symm hB x v, add_assoc, | |
| show (1 : ZMod 2) + 1 = 0 by decide] | |
| lemma transvection_moves {B : LinearMap.BilinForm (ZMod 2) V} (hB : B.IsAlt) | |
| {v w : V} (hvw : B v w = 1) : | |
| LinearEquiv.transvection (hB (v + w)) v = w := by | |
| rw [LinearEquiv.transvection.apply, map_add, LinearMap.add_apply, hB v, | |
| alt_symm hB w v, hvw, zero_add, one_smul, β add_assoc, add_self, zero_add] | |
| lemma exists_pairing_one {B : LinearMap.BilinForm (ZMod 2) V} | |
| (hB : B.Nondegenerate) {v : V} (hv : v β 0) : β w, B v w = 1 := by | |
| have h : Β¬ β w, B v w = 0 := fun h => hv (hB.1 v h) | |
| obtain β¨w, hwβ© := not_forall.mp h | |
| exact β¨w, bit_one hwβ© | |
| lemma common_pairing_one {B : LinearMap.BilinForm (ZMod 2) V} | |
| (hB : B.Nondegenerate) {v w : V} (hv : v β 0) (hw : w β 0) : | |
| β z, B v z = 1 β§ B w z = 1 := by | |
| obtain β¨a, haβ© := exists_pairing_one hB hv | |
| obtain β¨b, hbβ© := exists_pairing_one hB hw | |
| rcases bit_cases (B w a) with hwa | hwa | |
| Β· rcases bit_cases (B v b) with hvb | hvb | |
| Β· exact β¨a + b, by simp [ha, hvb], by simp [hwa, hb]β© | |
| Β· exact β¨b, hvb, hbβ© | |
| Β· exact β¨a, ha, hwaβ© | |
| /-- Explicit symplectic transitivity in characteristic two, using at most two | |
| transvections. This proves the uniform one-label marginal input to the actual | |
| sequential word sampling, without assuming a symplectic-basis theorem. -/ | |
| theorem symplectic_transitive {B : LinearMap.BilinForm (ZMod 2) V} | |
| (hB : B.IsAlt) (hnd : B.Nondegenerate) {v w : V} (hv : v β 0) (hw : w β 0) : | |
| β e : V ββ[ZMod 2] V, e v = w β§ β x y, B (e x) (e y) = B x y := by | |
| obtain β¨z, hvz, hwzβ© := common_pairing_one hnd hv hw | |
| let eβ := LinearEquiv.transvection (hB (v + z)) | |
| let eβ := LinearEquiv.transvection (hB (z + w)) | |
| refine β¨eβ.trans eβ, ?_, ?_β© | |
| Β· change eβ (eβ v) = w | |
| rw [show eβ v = z from transvection_moves hB hvz] | |
| exact transvection_moves hB ((alt_symm hB z w).trans hwz) | |
| Β· intro x y | |
| exact (transvection_preserves hB (z + w) (eβ x) (eβ y)).trans | |
| (transvection_preserves hB (v + z) x y) | |
| section Cardinality | |
| variable [Fintype V] [DecidableEq V] | |
| noncomputable local instance {k : β} (f : V ββ[ZMod 2] (Fin k β ZMod 2)) : | |
| Fintype f.ker := Fintype.ofFinite _ | |
| noncomputable def nonzeroKerEquiv {k : β} (f : V ββ[ZMod 2] (Fin k β ZMod 2)) : | |
| {u : f.ker // u β 0} β {v : V // v β 0 β§ f v = 0} where | |
| toFun u := β¨u.val.val, by | |
| constructor | |
| Β· intro h | |
| exact u.property (Subtype.ext h) | |
| Β· exact u.val.propertyβ© | |
| invFun v := β¨β¨v.val, v.property.2β©, by | |
| intro h | |
| exact v.property.1 (congrArg Subtype.val h)β© | |
| left_inv u := rfl | |
| right_inv v := rfl | |
| lemma card_nonzero_ker {k : β} (f : V ββ[ZMod 2] (Fin k β ZMod 2)) : | |
| Fintype.card f.ker = Fintype.card {v : V // v β 0 β§ f v = 0} + 1 := by | |
| have h := Fintype.card_congr (Equiv.optionSubtypeNe (0 : f.ker)) | |
| rw [Fintype.card_option, Fintype.card_congr (nonzeroKerEquiv f)] at h | |
| exact h.symm | |
| /-- At most k linear equations remove at most k binary dimensions, even when | |
| they are dependent. The zero vector is then removed exactly once. -/ | |
| theorem common_kernel_lower {k : β} (f : V ββ[ZMod 2] (Fin k β ZMod 2)) : | |
| 2 ^ (Module.finrank (ZMod 2) V - k) β€ | |
| Fintype.card {v : V // v β 0 β§ f v = 0} + 1 := by | |
| have hr := f.finrank_range_add_finrank_ker | |
| have hk : Module.finrank (ZMod 2) f.range β€ k := by | |
| simpa using (Submodule.finrank_le f.range) | |
| have hdim : Module.finrank (ZMod 2) V - k β€ Module.finrank (ZMod 2) f.ker := by omega | |
| calc | |
| _ β€ 2 ^ Module.finrank (ZMod 2) f.ker := Nat.pow_le_pow_right (by decide) hdim | |
| _ = Fintype.card f.ker := by rw [Module.card_eq_pow_finrank (K := ZMod 2), ZMod.card] | |
| _ = _ := card_nonzero_ker f | |
| /-- The quantitative bound actually used in source (word-choices), with the | |
| original nonzero alphabet and dependent equations allowed. -/ | |
| theorem common_kernel_choices {k : β} (f : V ββ[ZMod 2] (Fin k β ZMod 2)) | |
| (hk : 1 β€ k) (hd : k + 1 β€ Module.finrank (ZMod 2) V) : | |
| Fintype.card {v : V // v β 0} β€ | |
| 2 ^ (2 * k) * Fintype.card {v : V // v β 0 β§ f v = 0} := by | |
| let d := Module.finrank (ZMod 2) V | |
| let c := Fintype.card {v : V // v β 0 β§ f v = 0} | |
| have hlo : 2 ^ (d - k) β€ c + 1 := common_kernel_lower f | |
| have hexp : d - k = (d - k - 1) + 1 := by dsimp [d]; omega | |
| have hpow : 2 ^ (d - k - 1) β€ c := by | |
| rw [hexp, pow_succ] at hlo | |
| have hn : 1 β€ 2 ^ (d - k - 1) := Nat.one_le_pow _ _ (by decide) | |
| omega | |
| have hdim : d β€ 2 * k + (d - k - 1) := by dsimp [d]; omega | |
| have hfull : Fintype.card V β€ 2 ^ (2 * k) * c := calc | |
| _ = 2 ^ d := by rw [Module.card_eq_pow_finrank (K := ZMod 2), ZMod.card] | |
| _ β€ 2 ^ (2 * k + (d - k - 1)) := Nat.pow_le_pow_right (by decide) hdim | |
| _ = 2 ^ (2 * k) * 2 ^ (d - k - 1) := pow_add _ _ _ | |
| _ β€ _ := Nat.mul_le_mul_left _ hpow | |
| exact (Fintype.card_subtype_le _).trans hfull | |
| variable (B : LinearMap.BilinForm (ZMod 2) V) | |
| /-- The exact nonzero choices, not an independent-equations approximation. -/ | |
| noncomputable def allowed {k : β} (u : Fin k β V) : Finset {v : V // v β 0} := | |
| univ.filter (fun v => β j, B (u j) v.val = 0) | |
| noncomputable def equationMap {k : β} (u : Fin k β V) : V ββ[ZMod 2] (Fin k β ZMod 2) := | |
| LinearMap.pi (fun j => B (u j)) | |
| lemma mem_allowed {k : β} (u : Fin k β V) (v : {v : V // v β 0}) : | |
| v β allowed B u β β j, B (u j) v.val = 0 := by | |
| classical | |
| simp [allowed] | |
| lemma allowed_card {k : β} (u : Fin k β V) : | |
| (allowed B u).card = Fintype.card {v : V // v β 0 β§ equationMap B u v = 0} := by | |
| classical | |
| let e : {v // v β allowed B u} β {v : V // v β 0 β§ equationMap B u v = 0} := | |
| { toFun := fun v => β¨v.val.val, v.val.property, by | |
| ext j | |
| exact (mem_allowed B u v.val).mp v.property jβ© | |
| invFun := fun v => β¨β¨v.val, v.property.1β©, (mem_allowed B u _).mpr (fun j => | |
| congrFun v.property.2 j)β© | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| exact (Fintype.card_coe _).symm.trans (Fintype.card_congr e) | |
| lemma allowed_nonempty {k : β} (u : Fin k β V) | |
| (hd : k + 1 β€ Module.finrank (ZMod 2) V) : (allowed B u).Nonempty := by | |
| have h := common_kernel_lower (equationMap B u) | |
| rw [β allowed_card B u] at h | |
| have hpow : 2 β€ 2 ^ (Module.finrank (ZMod 2) V - k) := by | |
| simpa using Nat.pow_le_pow_right (n := 2) (by decide) (show 1 β€ | |
| Module.finrank (ZMod 2) V - k by omega) | |
| exact card_pos.mp (by omega) | |
| /-- Uniform sampling among all allowed nonzero labels. -/ | |
| noncomputable def kernel {k : β} (u : Fin k β V) (v : {v : V // v β 0}) : β := | |
| if v β allowed B u then ((allowed B u).card : β)β»ΒΉ else 0 | |
| lemma kernel_nonneg {k : β} (u : Fin k β V) (v : {v : V // v β 0}) : | |
| 0 β€ kernel B u v := by | |
| unfold kernel | |
| split_ifs <;> positivity | |
| lemma kernel_sum {k : β} (u : Fin k β V) | |
| (hd : k + 1 β€ Module.finrank (ZMod 2) V) : β v, kernel B u v = 1 := by | |
| classical | |
| have hc : ((allowed B u).card : β) β 0 := Nat.cast_ne_zero.mpr | |
| (Finset.card_ne_zero.mpr (allowed_nonempty B u hd)) | |
| simp only [kernel, sum_ite_mem, univ_inter, sum_const, nsmul_eq_mul] | |
| exact mul_inv_cancelβ hc | |
| lemma kernel_upper {k : β} (u : Fin k β V) (v : {v : V // v β 0}) | |
| (hk : 1 β€ k) (hd : k + 1 β€ Module.finrank (ZMod 2) V) : | |
| kernel B u v β€ (2 : β) ^ (2 * k) / Fintype.card {v : V // v β 0} := by | |
| have hN : 0 < (Fintype.card {v : V // v β 0} : β) := by | |
| have : Nonempty {v : V // v β 0} := (allowed_nonempty B u hd).nonempty | |
| exact_mod_cast Fintype.card_pos | |
| have hc : 0 < ((allowed B u).card : β) := by | |
| exact_mod_cast Finset.card_pos.mpr (allowed_nonempty B u hd) | |
| have hb : (Fintype.card {v : V // v β 0} : β) β€ | |
| (2 : β) ^ (2 * k) * (allowed B u).card := by | |
| have h := common_kernel_choices (equationMap B u) hk hd | |
| rw [β allowed_card B u] at h | |
| exact_mod_cast h | |
| unfold kernel | |
| split_ifs | |
| Β· apply (le_div_iffβ hN).mpr | |
| apply (inv_mul_le_iffβ hc).mpr | |
| simpa only [mul_comm] using hb | |
| Β· positivity | |
| noncomputable def nonzeroEquiv (e : V ββ[ZMod 2] V) : | |
| {v : V // v β 0} β {v : V // v β 0} where | |
| toFun v := β¨e v.val, fun h => v.property (e.injective (h.trans e.map_zero.symm))β© | |
| invFun v := β¨e.symm v.val, fun h => v.property (e.symm.injective (h.trans e.symm.map_zero.symm))β© | |
| left_inv v := Subtype.ext (e.symm_apply_apply v.val) | |
| right_inv v := Subtype.ext (e.apply_symm_apply v.val) | |
| lemma allowed_equivariant {k : β} (u : Fin k β V) (e : V ββ[ZMod 2] V) | |
| (he : β x y, B (e x) (e y) = B x y) (v : {v : V // v β 0}) : | |
| nonzeroEquiv e v β allowed B (e β u) β v β allowed B u := by | |
| simp only [mem_allowed, nonzeroEquiv, Equiv.coe_fn_mk, Function.comp_apply, he] | |
| lemma allowed_card_equivariant {k : β} (u : Fin k β V) (e : V ββ[ZMod 2] V) | |
| (he : β x y, B (e x) (e y) = B x y) : | |
| (allowed B (e β u)).card = (allowed B u).card := by | |
| classical | |
| have h := Fintype.card_congr ((nonzeroEquiv e).subtypeEquiv | |
| (fun v => (allowed_equivariant B u e he v).symm)) | |
| simpa only [Fintype.card_coe] using h.symm | |
| lemma kernel_equivariant {k : β} (u : Fin k β V) (e : V ββ[ZMod 2] V) | |
| (he : β x y, B (e x) (e y) = B x y) (v : {v : V // v β 0}) : | |
| kernel B (e β u) (nonzeroEquiv e v) = kernel B u v := by | |
| simp only [kernel, allowed_equivariant B u e he, allowed_card_equivariant B u e he] | |
| end Cardinality | |
| end SmoothObstruction.SymplecticSampling | |
| namespace SmoothObstruction.SequentialLaw | |
| variable {A : Type*} | |
| /-- A finite left-to-right sampling law. The kernel at time k may depend on | |
| all k preceding labels; no independence inside a group is assumed. -/ | |
| def weight (K : (k : β) β (Fin k β A) β A β β) : (n : β) β (Fin n β A) β β | |
| | 0, _ => 1 | |
| | n + 1, w => weight K n (Fin.init w) * K n (Fin.init w) (w (Fin.last n)) | |
| @[simp] lemma weight_zero (K : (k : β) β (Fin k β A) β A β β) (w : Fin 0 β A) : | |
| weight K 0 w = 1 := rfl | |
| @[simp] lemma weight_snoc (K : (k : β) β (Fin k β A) β A β β) | |
| {n : β} (w : Fin n β A) (a : A) : | |
| weight K (n + 1) (Fin.snoc w a) = weight K n w * K n w a := by | |
| simp [weight] | |
| lemma weight_nonneg {K : (k : β) β (Fin k β A) β A β β} | |
| (hK : β k w a, 0 β€ K k w a) : β n w, 0 β€ weight K n w | |
| | 0, _ => by simp | |
| | n + 1, w => mul_nonneg (weight_nonneg hK n _) (hK n _ _) | |
| variable [Fintype A] | |
| omit [Fintype A] in | |
| lemma snoc_equiv_apply {n : β} (p : A Γ (Fin n β A)) : | |
| (Fin.snocEquiv (fun _ : Fin (n + 1) => A)) p = Fin.snoc p.2 p.1 := rfl | |
| lemma sum_weight {K : (k : β) β (Fin k β A) β A β β} | |
| (hK : β k w, β a, K k w a = 1) : β n, β w, weight K n w = 1 := by | |
| intro n | |
| induction n with | |
| | zero => simp | |
| | succ n ih => | |
| rw [β (Fin.snocEquiv (fun _ : Fin (n + 1) => A)).sum_comp] | |
| simp only [snoc_equiv_apply, weight_snoc, Fintype.sum_prod_type] | |
| rw [sum_comm] | |
| simp only [β mul_sum, hK, mul_one] | |
| exact ih | |
| variable [DecidableEq A] | |
| def mark (m : Option A) (a : A) : β := | |
| match m with | |
| | none => 1 | |
| | some b => if a = b then 1 else 0 | |
| def test {n : β} (m : Fin n β Option A) (w : Fin n β A) : β := | |
| β i, mark (m i) (w i) | |
| omit [Fintype A] in | |
| lemma mark_nonneg (m : Option A) (a : A) : 0 β€ mark m a := by | |
| cases m with | |
| | none => norm_num [mark] | |
| | some b => change 0 β€ (if _ = b then (1 : β) else 0); split_ifs <;> norm_num | |
| omit [Fintype A] in | |
| lemma test_nonneg {n : β} (m : Fin n β Option A) (w : Fin n β A) : 0 β€ test m w := | |
| prod_nonneg (fun i _ => mark_nonneg (m i) (w i)) | |
| omit [Fintype A] in | |
| @[simp] lemma test_snoc {n : β} (m : Fin (n + 1) β Option A) (w : Fin n β A) (a : A) : | |
| test m (Fin.snoc w a) = test (Fin.init m) w * mark (m (Fin.last n)) a := by | |
| unfold test | |
| rw [Fin.prod_univ_castSucc] | |
| simp only [Fin.snoc_castSucc, Fin.snoc_last] | |
| rfl | |
| lemma sum_test_succ (K : (k : β) β (Fin k β A) β A β β) | |
| {n : β} (m : Fin (n + 1) β Option A) : | |
| (β w, weight K (n + 1) w * test m w) = | |
| β w, (weight K n w * test (Fin.init m) w) * | |
| (β a, K n w a * mark (m (Fin.last n)) a) := by | |
| rw [β (Fin.snocEquiv (fun _ : Fin (n + 1) => A)).sum_comp] | |
| simp only [snoc_equiv_apply, weight_snoc, test_snoc, Fintype.sum_prod_type] | |
| rw [sum_comm] | |
| apply sum_congr rfl | |
| intro w _ | |
| rw [mul_sum] | |
| apply sum_congr rfl | |
| intro a _ | |
| ring | |
| /-- Any list of specified coordinates has probability at most the product | |
| of the pointwise conditional upper bounds. Unspecified labels are integrated | |
| out, exactly as in (word-raw-sublist). -/ | |
| theorem cylinder_bound {K : (k : β) β (Fin k β A) β A β β} {ΞΆ : β} | |
| (h0 : β k w a, 0 β€ K k w a) (h1 : β k w, β a, K k w a = 1) | |
| (hΞΆ : 0 β€ ΞΆ) (hK : β k w a, K k w a β€ ΞΆ) : | |
| β n (m : Fin n β Option A), (β w, weight K n w * test m w) β€ | |
| β i, (if (m i).isSome then ΞΆ else 1) := by | |
| intro n | |
| induction n with | |
| | zero => intro m; simp [test] | |
| | succ n ih => | |
| intro m | |
| rw [sum_test_succ, Fin.prod_univ_castSucc] | |
| have hstep (w : Fin n β A) : (β a, K n w a * mark (m (Fin.last n)) a) β€ | |
| if (m (Fin.last n)).isSome then ΞΆ else 1 := by | |
| cases hm : m (Fin.last n) with | |
| | none => simp [mark, h1] | |
| | some a => simpa [mark] using hK n w a | |
| calc | |
| _ β€ β w, (weight K n w * test (Fin.init m) w) * | |
| (if (m (Fin.last n)).isSome then ΞΆ else 1) := | |
| sum_le_sum (fun w _ => mul_le_mul_of_nonneg_left (hstep w) | |
| (mul_nonneg (weight_nonneg h0 n w) (test_nonneg _ _))) | |
| _ = (β w, weight K n w * test (Fin.init m) w) * | |
| (if (m (Fin.last n)).isSome then ΞΆ else 1) := by rw [sum_mul] | |
| _ β€ _ := by | |
| apply mul_le_mul_of_nonneg_right (ih (Fin.init m)) | |
| split_ifs <;> positivity | |
| omit [Fintype A] [DecidableEq A] in | |
| lemma weight_equivariant (K : (k : β) β (Fin k β A) β A β β) (e : A β A) | |
| (hK : β k w a, K k (e β w) (e a) = K k w a) : | |
| β n w, weight K n (e β w) = weight K n w := by | |
| intro n | |
| induction n with | |
| | zero => intro w; rfl | |
| | succ n ih => | |
| intro w | |
| simp only [weight] | |
| have hi : Fin.init (e β w) = e β Fin.init w := rfl | |
| rw [hi, ih, Function.comp_apply, hK] | |
| lemma test_eq_indicator {n : β} (m : Fin n β Option A) (w : Fin n β A) : | |
| test m w = if β i a, m i = some a β w i = a then 1 else 0 := by | |
| classical | |
| have hm (i : Fin n) : mark (m i) (w i) = | |
| if β a, m i = some a β w i = a then 1 else 0 := by | |
| cases h : m i <;> simp [mark] | |
| simp only [test, hm, Finset.prod_boole, Finset.mem_univ, forall_const] | |
| lemma test_upper_pow {K : (k : β) β (Fin k β A) β A β β} {ΞΆ : β} | |
| (h0 : β k w a, 0 β€ K k w a) (h1 : β k w, β a, K k w a = 1) | |
| (hΞΆ : 0 β€ ΞΆ) (hK : β k w a, K k w a β€ ΞΆ) | |
| (n : β) (m : Fin n β Option A) : | |
| (β w, weight K n w * test m w) β€ | |
| ΞΆ ^ (univ.filter (fun i => (m i).isSome)).card := by | |
| simpa only [Finset.prod_ite, Finset.prod_const, one_pow, mul_one] | |
| using cylinder_bound h0 h1 hΞΆ hK n m | |
| /-- The unconditioned one-coordinate law; the complete path is summed out. -/ | |
| def marginal (K : (k : β) β (Fin k β A) β A β β) {n : β} (i : Fin n) (a : A) : β := | |
| β w, if w i = a then weight K n w else 0 | |
| lemma sum_marginal {K : (k : β) β (Fin k β A) β A β β} | |
| (hK : β k w, β a, K k w a = 1) {n : β} (i : Fin n) : | |
| β a, marginal K i a = 1 := by | |
| unfold marginal | |
| rw [sum_comm] | |
| simp only [sum_ite_eq, mem_univ, ite_true] | |
| exact sum_weight hK n | |
| lemma marginal_equivariant (K : (k : β) β (Fin k β A) β A β β) (e : A β A) | |
| (hK : β k w a, K k (e β w) (e a) = K k w a) {n : β} (i : Fin n) (a : A) : | |
| marginal K i (e a) = marginal K i a := by | |
| unfold marginal | |
| let E : (Fin n β A) β (Fin n β A) := Equiv.piCongrRight (fun _ => e) | |
| rw [β E.sum_comp] | |
| apply sum_congr rfl | |
| intro w _ | |
| change (if e (w i) = e a then weight K n (e β w) else 0) = _ | |
| simp only [e.injective.eq_iff, weight_equivariant K e hK] | |
| /-- Equivariance under a transitive collection of label permutations gives | |
| exactly uniform marginals, despite arbitrary dependencies between positions. -/ | |
| theorem uniform_marginal [Nonempty A] | |
| {K : (k : β) β (Fin k β A) β A β β} | |
| (h1 : β k w, β a, K k w a = 1) | |
| (htrans : β a b : A, β e : A β A, e a = b β§ | |
| β k w x, K k (e β w) (e x) = K k w x) | |
| {n : β} (i : Fin n) (a : A) : marginal K i a = 1 / Fintype.card A := by | |
| have heq (b : A) : marginal K i b = marginal K i a := by | |
| obtain β¨e, hab, heβ© := htrans a b | |
| rw [β hab] | |
| exact marginal_equivariant K e he i a | |
| have hsum := sum_marginal h1 i | |
| simp_rw [heq] at hsum | |
| simp only [sum_const, card_univ, nsmul_eq_mul] at hsum | |
| have hc : (Fintype.card A : β) β 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero | |
| exact (eq_div_iff hc).mpr (by simpa only [mul_comm] using hsum) | |
| end SmoothObstruction.SequentialLaw | |
| namespace SmoothObstruction.GroupSampler | |
| open Finset SymplecticSampling SequentialLaw | |
| variable {V : Type*} [AddCommGroup V] [Module (ZMod 2) V] | |
| [Fintype V] [DecidableEq V] | |
| variable (B : LinearMap.BilinForm (ZMod 2) V) {K : β} | |
| /-- At time t, at most K earlier positions are constrained. None represents | |
| an absent constraint, whose equation is identically zero. -/ | |
| def previous (back : (t : β) β Fin K β Option (Fin t)) | |
| (t : β) (w : Fin t β {v : V // v β 0}) (j : Fin K) : V := | |
| (back t j).elim 0 (fun r => (w r).val) | |
| noncomputable def step (back : (t : β) β Fin K β Option (Fin t)) | |
| (t : β) (w : Fin t β {v : V // v β 0}) (a : {v : V // v β 0}) : β := | |
| kernel B (previous back t w) a | |
| lemma step_sum (back : (t : β) β Fin K β Option (Fin t)) | |
| (hd : K + 1 β€ Module.finrank (ZMod 2) V) (t : β) (w : Fin t β {v : V // v β 0}) : | |
| β a, step B back t w a = 1 := kernel_sum B _ hd | |
| omit [Fintype V] [DecidableEq V] in | |
| lemma previous_equivariant (back : (t : β) β Fin K β Option (Fin t)) | |
| (e : V ββ[ZMod 2] V) (t : β) (w : Fin t β {v : V // v β 0}) : | |
| previous back t (nonzeroEquiv e β w) = e β previous back t w := by | |
| funext j | |
| cases h : back t j <;> simp [previous, h, nonzeroEquiv] | |
| lemma step_equivariant (back : (t : β) β Fin K β Option (Fin t)) | |
| (e : V ββ[ZMod 2] V) (he : β x y, B (e x) (e y) = B x y) | |
| (t : β) (w : Fin t β {v : V // v β 0}) (a : {v : V // v β 0}) : | |
| step B back t (nonzeroEquiv e β w) (nonzeroEquiv e a) = step B back t w a := by | |
| unfold step | |
| rw [previous_equivariant, kernel_equivariant B _ e he] | |
| /-- The actual sequential sampling has exactly uniform one-position laws. | |
| This is not a product law inside a group. -/ | |
| theorem uniform_position (hB : B.IsAlt) (hnd : B.Nondegenerate) | |
| (back : (t : β) β Fin K β Option (Fin t)) | |
| (hd : K + 1 β€ Module.finrank (ZMod 2) V) | |
| {n : β} (i : Fin n) (a : {v : V // v β 0}) : | |
| marginal (step B back) i a = 1 / Fintype.card {v : V // v β 0} := by | |
| let : Nonempty {v : V // v β 0} := β¨aβ© | |
| apply uniform_marginal (step_sum B back hd) | |
| intro v w | |
| obtain β¨e, he, hpresβ© := symplectic_transitive hB hnd v.property w.property | |
| exact β¨nonzeroEquiv e, Subtype.ext he, step_equivariant B back e hpresβ© | |
| /-- All sublist probabilities have the source bound, even though prior | |
| constraints can be linearly dependent and unobserved labels are integrated out. -/ | |
| theorem raw_sublist (back : (t : β) β Fin K β Option (Fin t)) | |
| (hK : 1 β€ K) (hd : K + 1 β€ Module.finrank (ZMod 2) V) | |
| (n : β) (m : Fin n β Option {v : V // v β 0}) : | |
| (β w, weight (step B back) n w * test m w) β€ | |
| ((2 : β) ^ (2 * K) / Fintype.card {v : V // v β 0}) ^ | |
| (univ.filter (fun i => (m i).isSome)).card := by | |
| apply test_upper_pow | |
| Β· intro t w a; exact kernel_nonneg B _ _ | |
| Β· exact step_sum B back hd | |
| Β· positivity | |
| Β· intro t w a; exact kernel_upper B _ _ hK hd | |
| lemma step_positive_constraint (back : (t : β) β Fin K β Option (Fin t)) | |
| (t : β) (w : Fin t β {v : V // v β 0}) (a : {v : V // v β 0}) | |
| (h : 0 < step B back t w a) {j : Fin K} {r : Fin t} (hr : back t j = some r) : | |
| B (w r).val a.val = 0 := by | |
| have hm : a β allowed B (previous back t w) := by | |
| by_contra hc | |
| simp [step, kernel, hc] at h | |
| have he := (mem_allowed B _ _).mp hm j | |
| simpa [previous, hr] using he | |
| /-- Positively weighted paths satisfy every prescribed relation. -/ | |
| theorem supported_constraints (back : (t : β) β Fin K β Option (Fin t)) : | |
| β n (w : Fin n β {v : V // v β 0}), 0 < weight (step B back) n w β | |
| β (t : Fin n) (j : Fin K) (r : Fin t.val), back t.val j = some r β | |
| B (w β¨r.val, lt_trans r.isLt t.isLtβ©).val (w t).val = 0 := by | |
| intro n | |
| induction n with | |
| | zero => intro w h t; exact Fin.elim0 t | |
| | succ n ih => | |
| intro w hw t j r hr | |
| have hp : 0 < weight (step B back) n (Fin.init w) β§ | |
| 0 < step B back n (Fin.init w) (w (Fin.last n)) := by | |
| rcases mul_pos_iff.mp hw with h | h | |
| Β· exact h | |
| Β· exact False.elim ((not_lt_of_ge (kernel_nonneg B _ _)) h.2) | |
| by_cases ht : t.val < n | |
| Β· exact ih (Fin.init w) hp.1 β¨t.val, htβ© j r hr | |
| Β· have teq : t = Fin.last n := Fin.ext (by simp; omega) | |
| subst t | |
| exact step_positive_constraint B back n (Fin.init w) (w (Fin.last n)) hp.2 hr | |
| end SmoothObstruction.GroupSampler | |
| end | |
| end OAI | |