File size: 6,292 Bytes
92416a2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 | import OAI.Dynamics.ConditionalShuffle.ResetReverse
namespace OAI
noncomputable section
open scoped BigOperators Classical
open Filter Topology
namespace Thorp.Conditional.Reset
abbrev Injection (D b : ℕ) := Fin b ↪ Position D
def act {α ι : Type*} (g : Equiv.Perm α) (x : ι ↪ α) : ι ↪ α := x.trans g.toEmbedding
@[simp] lemma act_apply {α ι : Type*} (g : Equiv.Perm α) (x : ι ↪ α) (i : ι) :
act g x i = g (x i) := rfl
@[simp] lemma act_mul {α ι : Type*} (g h : Equiv.Perm α) (x : ι ↪ α) :
act (g*h) x = act g (act h x) := rfl
@[simp] lemma act_one {α ι : Type*} (x : ι ↪ α) : act (1 : Equiv.Perm α) x = x := rfl
lemma act_eq_iff {α ι : Type*} (g : Equiv.Perm α) (x y : ι ↪ α) :
act g x = y ↔ x = act g⁻¹ y := by
constructor
· intro h; rw [← h, ← act_mul, inv_mul_cancel, act_one]
· intro h; rw [h, ← act_mul, mul_inv_cancel, act_one]
def actEquiv {α ι : Type*} (g : Equiv.Perm α) : (ι ↪ α) ≃ (ι ↪ α) where
toFun := act g
invFun := act g⁻¹
left_inv x := by rw [← act_mul, inv_mul_cancel, act_one]
right_inv x := by rw [← act_mul, mul_inv_cancel, act_one]
lemma uniform_injection {α ι : Type*} [Fintype α] [Fintype ι] [DecidableEq α]
(e : ι ↪ α) : fairMass (fun g : Equiv.Perm α => act g e) =
fun _ => (Fintype.card (ι ↪ α) : ℝ)⁻¹ := by
funext y
rw [fairMass_eq_mean, show (fun g : Equiv.Perm α => if act g e = y then (1:ℝ) else 0) =
(fun g => (fun z : ι ↪ α => if z = y then (1:ℝ) else 0) (e.trans g.toEmbedding)) from rfl,
mean_perm_embedding e (fun z : ι ↪ α => if z = y then (1:ℝ) else 0)]
simp [mean]
def kernel (D b t : ℕ) (x y : Injection D b) : ℝ :=
fairMass (fun ω : History D t => act (run D t ω) x) y
lemma kernel_nonneg (D b t : ℕ) (x y : Injection D b) : 0 ≤ kernel D b t x y :=
fairMass_nonneg _ _
lemma kernel_row_sum (D b t : ℕ) (x : Injection D b) : ∑ y, kernel D b t x y = 1 :=
fairMass_sum _
lemma kernel_column_sum (D b t : ℕ) (y : Injection D b) : ∑ x, kernel D b t x y = 1 := by
unfold kernel
simp only [fairMass_eq_mean]
rw [← mean_sum]
have he (ω : History D t) : (∑ x : Injection D b, if act (run D t ω) x = y then (1:ℝ) else 0) = 1 := by
simp_rw [act_eq_iff]; simp
simp only [he, mean_const]
def toInjection {α ι : Type*} (e : ι ↪ α) (f : ι → α) : ι ↪ α :=
if h : Function.Injective f then ⟨f,h⟩ else e
@[simp] lemma toInjection_coe {α ι : Type*} (e x : ι ↪ α) : toInjection e x = x := by
simp only [toInjection, dite_eq_left x.injective]; rfl
lemma injection_tv_le {α ι Ω Ω' : Type*} [Fintype α] [Fintype ι] [Fintype Ω] [Fintype Ω'] [DecidableEq ι]
(e : ι ↪ α) (a : Ω → ι ↪ α) (b : Ω' → ι ↪ α) :
tv (fairMass a) (fairMass b) ≤
tv (fairMass (fun ω => (a ω : ι → α))) (fairMass (fun ω => (b ω : ι → α))) := by
have hh := Trim.tv_push_le (fairMass (fun ω => (a ω : ι → α)))
(fairMass (fun ω => (b ω : ι → α))) (toInjection e)
rw [Trim.push_fairMass, Trim.push_fairMass] at hh
simpa only [Function.comp_def, toInjection_coe] using hh
lemma kernel_row_bound (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) :
∀ᶠ d : ℕ in atTop, ∀ (b : ℕ), (b : ℝ) ≤ (1-ρ)*(2^(d+2) : ℝ) →
∀ x : Injection (d+2) b,
tv (kernel (d+2) b (2*resetS ρ*(d+2)) x)
(fun _ => (Fintype.card (Injection (d+2) b) : ℝ)⁻¹) ≤ (1/2 : ℝ)^(8*(d+2)) := by
filter_upwards [reset_partial_mixing ρ hρ hρ₁] with d hd
intro b hb x
rw [← uniform_injection x]
exact (injection_tv_le x (fun ω : History (d+2) (2*resetS ρ*(d+2)) =>
act (run (d+2) (2*resetS ρ*(d+2)) ω) x) (fun g : State (d+2) => act g x)).trans
(hd b x x.injective hb)
lemma reflection_column (d b t : ℕ) (x y : Injection (d+1) b) :
kernel (d+1) b t x y =
kernel (d+1) b t (act (reversePosition (d+1)) y) (act (reversePosition (d+1)) x) := by
unfold kernel
rw [fairMass_eq_mean, fairMass_eq_mean]
rw [← mean_equiv (reverseHistory d t)]
apply mean_congr; intro ω
dsimp only [Function.comp_def]
rw [reverse_run]
have hr : reversePosition (d+1) * reversePosition (d+1) = 1 := by
apply Equiv.ext; exact reversePosition_involutive (d+1)
have iff : act (reversePosition (d+1) * (run (d+1) t ω)⁻¹ * reversePosition (d+1)) x = y ↔
act (run (d+1) t ω) (act (reversePosition (d+1)) y) = act (reversePosition (d+1)) x := by
rw [act_eq_iff, mul_inv_rev, mul_inv_rev]
have hi : (reversePosition (d+1))⁻¹ = reversePosition (d+1) := by
apply inv_eq_of_mul_eq_one_left; exact hr
rw [hi, act_mul, act_mul, inv_inv]
have hre (z : Injection (d+1) b) : act (reversePosition (d+1)) (act (reversePosition (d+1)) z) = z := by
rw [← act_mul, hr, act_one]
constructor
· intro h; rw [h, hre]
· intro h; rw [h, hre]
simp only [iff]
lemma kernel_column_bound (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) :
∀ᶠ d : ℕ in atTop, ∀ (b : ℕ), (b : ℝ) ≤ (1-ρ)*(2^(d+2) : ℝ) →
∀ y : Injection (d+2) b,
tv (fun x => kernel (d+2) b (2*resetS ρ*(d+2)) x y)
(fun _ => (Fintype.card (Injection (d+2) b) : ℝ)⁻¹) ≤ (1/2 : ℝ)^(8*(d+2)) := by
filter_upwards [kernel_row_bound ρ hρ hρ₁] with d hd
intro b hb y
have hh := hd b hb (act (reversePosition (d+2)) y)
have hsum :
(∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) x y - (Fintype.card (Injection (d+2) b) : ℝ)⁻¹|) =
∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y) x -
(Fintype.card (Injection (d+2) b) : ℝ)⁻¹| := by
calc
_ = ∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y)
(act (reversePosition (d+2)) x) - (Fintype.card (Injection (d+2) b) : ℝ)⁻¹| := by
apply Finset.sum_congr rfl; intro x _
rw [reflection_column (d+1) b (2*resetS ρ*(d+2)) x y]
_ = _ := (actEquiv (ι := Fin b) (reversePosition (d+2))).sum_comp
(fun x => |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y) x -
(Fintype.card (Injection (d+2) b) : ℝ)⁻¹|)
unfold tv at *; rwa [hsum]
end Thorp.Conditional.Reset
end
end OAI
|