| import Mathlib |
| import OAI.Probability.BinarySweep.Processes.PointMassOne |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace BinaryCoordinateSweeps |
| section IndependentLaw |
| variable {G Ω Ξ : Type*} [Fintype G] [Group G] [Fintype Ω] [Fintype Ξ] |
|
|
| def independentHistory (f : Ω → G) (n : ℕ) (c : Fin n → Ω) : G := |
| (List.ofFn (fun i => f (c i))).reverse.prod |
|
|
| omit [Fintype G] [Fintype Ω] in |
| lemma independentHistory_succ (f : Ω → G) (n : ℕ) (a : Ω) (c : Fin n → Ω) : |
| independentHistory f (n + 1) (Fin.snoc c a) = f a * independentHistory f n c := by |
| unfold independentHistory |
| rw [List.ofFn_succ'] |
| simp |
|
|
| lemma finiteLaw_independentHistory [Nonempty Ω] (f : Ω → G) (n : ℕ) : |
| finiteLaw (independentHistory f n) = convolutionPower (finiteLaw f) n := by |
| induction n with |
| | zero => |
| classical |
| funext g |
| simp [finiteLaw, independentHistory, convolutionPower, pointMassOne, eq_comm] |
| | succ n ih => |
| let e : Ω × (Fin n → Ω) ≃ (Fin (n + 1) → Ω) := Fin.snocEquiv (fun _ => Ω) |
| rw [← finiteLaw_reindex e] |
| have he : (independentHistory f (n + 1)) ∘ e = |
| fun a : Ω × (Fin n → Ω) => f a.1 * independentHistory f n a.2 := by |
| funext a |
| exact independentHistory_succ f n a.1 a.2 |
| rw [he, finiteLaw_independent_mul, ih] |
| rfl |
|
|
| end IndependentLaw |
|
|
| section Assignments |
| attribute [local instance] Classical.propDecidable |
| variable {X I : Type*} [Fintype X] [Fintype I] |
|
|
| def Assigns (A B : I ↪ X) (σ : Equiv.Perm X) : Prop := ∀ i, σ (A i) = B i |
|
|
| lemma card_assignment_completions (A B : I ↪ X) : |
| Fintype.card {σ : Equiv.Perm X // Assigns A B σ} = |
| (Fintype.card X - Fintype.card I).factorial := by |
| classical |
| let eA := Equiv.ofInjective A A.injective |
| let eB := Equiv.ofInjective B B.injective |
| let e₀ : Set.range A ≃ Set.range B := eA.symm.trans eB |
| have ha : Fintype.card (Set.range A) = Fintype.card I := Fintype.card_congr eA.symm |
| have hb : Fintype.card (Set.range B) = Fintype.card I := Fintype.card_congr eB.symm |
| let e : {σ : Equiv.Perm X // Assigns A B σ} ≃ |
| {σ : X ≃ X // ∀ x : Set.range A, σ x = e₀ x} := |
| Equiv.subtypeEquiv (Equiv.refl _) (by |
| intro σ |
| constructor |
| · intro h x |
| obtain ⟨i, hi⟩ := x.property |
| have hx : x = eA i := Subtype.ext hi.symm |
| rw [hx] |
| simpa [e₀, eA, eB] using h i |
| · intro h i |
| simpa [e₀, eA, eB] using h (eA i)) |
| let c : ↥((Set.range A)ᶜ) ≃ ↥((Set.range B)ᶜ) := Fintype.equivOfCardEq (by |
| change Fintype.card {x : X // x ∉ Set.range A} = Fintype.card {x : X // x ∉ Set.range B} |
| rw [Fintype.card_subtype_compl, Fintype.card_subtype_compl, ha, hb]) |
| rw [Fintype.card_congr (e.trans (Equiv.Set.compl e₀)), Fintype.card_equiv c] |
| change (Fintype.card {x : X // x ∉ Set.range A}).factorial = _ |
| rw [Fintype.card_subtype_compl, ha] |
|
|
| lemma uniform_assignment_probability (A B : I ↪ X) : |
| (∑ σ : Equiv.Perm X, if Assigns A B σ then |
| (Fintype.card (Equiv.Perm X) : ℝ)⁻¹ else 0) = |
| (Nat.descFactorial (Fintype.card X) (Fintype.card I) : ℝ)⁻¹ := by |
| classical |
| have hn : Fintype.card I ≤ Fintype.card X := Fintype.card_le_of_injective A A.injective |
| have hcard : (Fintype.card {σ : Equiv.Perm X // Assigns A B σ} : ℝ) = |
| ((Fintype.card X - Fintype.card I).factorial : ℝ) := by |
| exact_mod_cast card_assignment_completions A B |
| have hsum : (∑ σ : Equiv.Perm X, if Assigns A B σ then |
| (Fintype.card (Equiv.Perm X) : ℝ)⁻¹ else 0) = |
| (Fintype.card {σ : Equiv.Perm X // Assigns A B σ} : ℝ) * |
| (Fintype.card (Equiv.Perm X) : ℝ)⁻¹ := by |
| simp [Fintype.card_subtype, Finset.sum_ite] |
| rw [hsum, hcard, Fintype.card_perm, |
| ← Nat.factorial_mul_descFactorial hn, Nat.cast_mul, mul_inv_rev] |
| have hf : (((Fintype.card X - Fintype.card I).factorial : ℕ) : ℝ) ≠ 0 := by |
| exact_mod_cast (Nat.factorial_ne_zero (Fintype.card X - Fintype.card I)) |
| field_simp |
|
|
| end Assignments |
|
|
| lemma physicalLaw_eq_convolutionPower (d t : ℕ) : |
| physicalLaw d t = convolutionPower (finiteLaw (physical d)) t := |
| finiteLaw_independentHistory (physical d) t |
|
|
| def sweepHistory (d t : ℕ) (coins : Fin t → SweepCoins d) : Equiv.Perm (Slot d) := |
| independentHistory (binarySweep d) t coins |
|
|
| lemma sweepLaw_eq_finiteLaw (d t : ℕ) : sweepLaw d t = finiteLaw (sweepHistory d t) := |
| (finiteLaw_independentHistory (binarySweep d) t).symm |
|
|
| def fromInitial {G : Type*} [Group G] (p : G → ℝ) (initial : G) : G → ℝ := |
| fun g => p (g * initial⁻¹) |
|
|
| lemma totalVariation_fromInitial {G : Type*} [Fintype G] [Group G] |
| (p : G → ℝ) (initial : G) : |
| totalVariation (fromInitial p initial) (uniformLaw G) = totalVariation p (uniformLaw G) := by |
| unfold totalVariation fromInitial uniformLaw |
| congr 1 |
| exact Equiv.sum_comp (Equiv.mulRight initial⁻¹) |
| (fun g => |p g - (Fintype.card G : ℝ)⁻¹|) |
|
|
| theorem fixed_dimension_sweep_convergence_fromInitial (d : ℕ) |
| (initial : Equiv.Perm (Slot d)) : |
| Filter.Tendsto (fun t => totalVariation (fromInitial (sweepLaw d t) initial) |
| (uniformLaw (Equiv.Perm (Slot d)))) Filter.atTop (nhds 0) := by |
| simp only [totalVariation_fromInitial] |
| exact fixed_dimension_sweep_convergence d |
|
|
| def ConstantSweepMixingTarget : Prop := |
| ∃ w : ℕ, ∀ ε : ℝ, 0 < ε → ∃ d₀ : ℕ, ∀ d ≥ d₀, |
| ∀ initial : Equiv.Perm (Slot d), |
| totalVariation (fromInitial (sweepLaw d w) initial) |
| (uniformLaw (Equiv.Perm (Slot d))) < ε |
|
|
| def fallingCost (m u : ℕ) : ℝ := Real.log ((m : ℝ) ^ u / (m.descFactorial u : ℝ)) |
|
|
| lemma fallingCost_sum {m u : ℕ} (hm : 0 < m) (hu : u ≤ m) : |
| fallingCost m u = ∑ j ∈ Finset.range u, Real.log ((m : ℝ) / (m - j : ℕ)) := by |
| have hmp : (0 : ℝ) < m := by exact_mod_cast hm |
| have hdf : (0 : ℝ) < m.descFactorial u := by exact_mod_cast (Nat.descFactorial_pos.mpr hu) |
| have hdiff (j : ℕ) (hj : j ∈ Finset.range u) : (m - j : ℕ) ≠ 0 := by |
| simp only [Finset.mem_range] at hj |
| omega |
| have hlog (j : ℕ) (hj : j ∈ Finset.range u) : |
| Real.log ((m : ℝ) / (m - j : ℕ)) = Real.log m - Real.log (m - j : ℕ) := |
| Real.log_div hmp.ne' (by exact_mod_cast hdiff j hj) |
| rw [fallingCost, Real.log_div (pow_ne_zero _ hmp.ne') hdf.ne', Real.log_pow, |
| Nat.descFactorial_eq_prod_range, Nat.cast_prod, Real.log_prod (fun j hj => by exact_mod_cast hdiff j hj)] |
| rw [Finset.sum_congr rfl hlog, Finset.sum_sub_distrib] |
| simp |
|
|
| lemma fallingCost_nonneg {m u : ℕ} (hm : 0 < m) (hu : u ≤ m) : 0 ≤ fallingCost m u := by |
| rw [fallingCost_sum hm hu] |
| apply Finset.sum_nonneg |
| intro j hj |
| have hdiff : (0 : ℝ) < (m - j : ℕ) := by |
| exact_mod_cast (Nat.sub_pos_of_lt ((Finset.mem_range.mp hj).trans_le hu)) |
| apply Real.log_nonneg |
| exact (le_div_iff₀ hdiff).mpr (by simp) |
|
|
| lemma prefix_sum_le_of_full_sum_le {m u : ℕ} (hm : 0 < m) (hu : u ≤ m) (f : ℕ → ℝ) |
| (hf : ∀ i < u, ∀ j, u ≤ j → j < m → f i ≤ f j) |
| (hfull : ∑ j ∈ Finset.range m, f j ≤ m) : |
| ∑ j ∈ Finset.range u, f j ≤ u := by |
| have hc : ((m : ℝ) - u) * (∑ i ∈ Finset.range u, f i) ≤ |
| (u : ℝ) * ∑ j ∈ Finset.Ico u m, f j := by |
| calc |
| _ = ∑ i ∈ Finset.range u, ∑ _j ∈ Finset.Ico u m, f i := by |
| simp [Nat.cast_sub hu, Finset.mul_sum] |
| _ ≤ ∑ i ∈ Finset.range u, ∑ j ∈ Finset.Ico u m, f j := by |
| apply Finset.sum_le_sum |
| intro i hi |
| apply Finset.sum_le_sum |
| intro j hj |
| exact hf i (Finset.mem_range.mp hi) j (Finset.mem_Ico.mp hj).1 (Finset.mem_Ico.mp hj).2 |
| _ = _ := by simp |
| have hsplit := Finset.sum_range_add_sum_Ico f hu |
| have hmp : (0 : ℝ) < m := by exact_mod_cast hm |
| have hu0 : (0 : ℝ) ≤ u := by positivity |
| nlinarith |
|
|
| lemma fallingCost_le {m u : ℕ} (hm : 0 < m) (hu : u ≤ m) : fallingCost m u ≤ u := by |
| have hmp : (0 : ℝ) < m := by exact_mod_cast hm |
| have hfull : fallingCost m m ≤ m := by |
| have hst := Stirling.le_log_factorial_stirling hm.ne' |
| have hlog : 0 ≤ Real.log (m : ℝ) := Real.log_nonneg (by exact_mod_cast hm) |
| have hpi : 0 ≤ Real.log (2 * Real.pi) := Real.log_nonneg (by linarith [Real.pi_gt_three]) |
| rw [fallingCost, Nat.descFactorial_self, Real.log_div (pow_ne_zero _ hmp.ne') (by positivity), Real.log_pow] |
| linarith |
| rw [fallingCost_sum hm hu] |
| apply prefix_sum_le_of_full_sum_le hm hu |
| · intro i hi j huj hjm |
| apply Real.log_le_log |
| · exact div_pos hmp (by exact_mod_cast Nat.sub_pos_of_lt (hi.trans_le hu)) |
| · apply div_le_div_of_nonneg_left hmp.le |
| · exact_mod_cast Nat.sub_pos_of_lt hjm |
| · exact_mod_cast Nat.sub_le_sub_left (hi.le.trans huj) m |
| · rwa [← fallingCost_sum hm le_rfl] |
|
|
| attribute [local instance] Classical.propDecidable |
| variable {X I J : Type*} [Fintype X] [Fintype I] [Fintype J] |
|
|
| end BinaryCoordinateSweeps |
| end |
|
|
| end OAI |
|
|
