File size: 6,555 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 139 140 141 142 143 144 | import OAI.Dynamics.ConditionalShuffle.PrepEnergy
namespace OAI
noncomputable section
open scoped Classical
namespace Thorp.Conditional
lemma mean_fintype_irrel {Ω : Type*} (A B : Fintype Ω) (f : Ω → ℝ) :
@mean Ω A f = @mean Ω B f := by
have h : A = B := Subsingleton.elim _ _
cases h
rfl
lemma rawPermute_mass {d : ℕ} (v : RawState d) (g : State d) :
(∑ x, (rawPermute v g).weight x) = ∑ x, v.weight x := Equiv.sum_comp g.symm v.weight
lemma rawPermute_support {d : ℕ} (v : RawState d)
(hw : ∀ x, v.free x = false → v.weight x = 0) (g : State d) :
∀ x, (rawPermute v g).free x = false → (rawPermute v g).weight x = 0 :=
fun x hx => hw (g.symm x) hx
lemma rawPermute_count {d : ℕ} (v : RawState d) (g : State d) :
freeCount (rawPermute v g).free = freeCount v.free := freeCount_comp_equiv v.free g.symm
lemma rawIterate_mass (d : ℕ) (v : RawState (d+1)) (t : ℕ) (ω : SweepHistory d t) :
(∑ x, (rawIterate d v t ω).weight x) = ∑ x, v.weight x := by
induction t with
| zero => rfl
| succ t ih => exact (physicalFlow_sum d _ _ _).trans (ih (Fin.init ω))
lemma rawIterate_support (d : ℕ) (v : RawState (d+1))
(hw : ∀ x, v.free x = false → v.weight x = 0) (t : ℕ) (ω : SweepHistory d t) :
∀ x, (rawIterate d v t ω).free x = false → (rawIterate d v t ω).weight x = 0 := by
induction t with
| zero => exact hw
| succ t ih => exact physicalFlow_support d _ _ (ih (Fin.init ω)) _
lemma rawIterate_count (d : ℕ) (v : RawState (d+1)) (t : ℕ) (ω : SweepHistory d t) :
freeCount (rawIterate d v t ω).free = freeCount v.free := by
have hf : (rawIterate d v t ω).free = v.free ∘ (run (d+1) t ω).symm := by
funext x; exact rawIterate_free d v t ω x
rw [hf]
exact freeCount_comp_equiv _ _
namespace OverlayEnergy
abbrev Bits (g : ℕ) := Position (g+2) → Bool
abbrev Prep9 (g : ℕ) := Fin (9*(g+3)) → Bits g
abbrev Prep200 (g : ℕ) := Fin (200*(g+3)) → Bits g
abbrev Active (g : ℕ) := Fin (g+3) → Bits g
abbrev CycleCoins (g : ℕ) := (Prep9 g × Prep200 g) × Active g
def cycle (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) : RawState (g+3) :=
rawIterate (g+2)
(rawPermute (rawPermute v (run (g+3) (9*(g+3)) ω.1.1))
(run (g+3) (200*(g+3)) ω.1.2)) (g+3) ω.2
def cyclePerm (g : ℕ) (ω : CycleCoins g) : State (g+3) :=
run (g+3) (g+3) ω.2 * run (g+3) (200*(g+3)) ω.1.2 * run (g+3) (9*(g+3)) ω.1.1
lemma cycle_free (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) (y) :
(cycle g v ω).free y = v.free ((cyclePerm g ω).symm y) := by
unfold cycle
erw [rawIterate_free]
simp only [cyclePerm, ← Equiv.Perm.inv_def, mul_inv_rev, Equiv.Perm.coe_mul, Function.comp_apply, rawPermute]
lemma cycle_count (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) :
freeCount (cycle g v ω).free = freeCount v.free := by
exact (rawIterate_count (g+2) _ _ _).trans
((rawPermute_count _ _).trans (rawPermute_count v _))
lemma cycle_mass (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) :
(∑ x, (cycle g v ω).weight x) = ∑ x, v.weight x := by
unfold cycle
rw [rawIterate_mass, rawPermute_mass, rawPermute_mass]
lemma cycle_support (g : ℕ) (v : RawState (g+3))
(hw : ∀ x, v.free x = false → v.weight x = 0) (ω : CycleCoins g) :
∀ x, (cycle g v ω).free x = false → (cycle g v ω).weight x = 0 :=
rawIterate_support (g+2) _ (rawPermute_support _ (rawPermute_support _ hw _) _) _ _
lemma cycle_energy_le (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) :
rawEnergy (cycle g v ω) ≤ rawEnergy v := by
refine (rawIterate_energy_le (g+2) _ _ _).trans_eq ?_
rw [rawPermute_energy, rawPermute_energy]
def coefficient (g : ℕ) : ℝ := (255/256 : ℝ)^(g+3) + (2^g : ℝ) *
Real.sqrt ((Fintype.card (Position (g+3)) : ℝ) *
((1/2 : ℝ)^(8*(g+3)) + 32*(9/10 : ℝ)^(2^g)) )
lemma coefficient_nonneg (g : ℕ) : 0 ≤ coefficient g := by unfold coefficient; positivity
lemma cycle_expected_energy (g : ℕ) (v : RawState (g+3))
(hw : ∀ x, v.free x = false → v.weight x = 0) (hz : ∑ x, v.weight x = 0)
(hf : Fintype.card (Position (g+3)) ≤ 64 * freeCount v.free)
(hk : freeCount v.free ≤ 2^g)
(hs : 256*(g+4) ≤ Fintype.card (Position (g+3))) :
mean (fun ω : CycleCoins g => rawEnergy (cycle g v ω)) ≤
rawEnergy v * coefficient g := by
rw [mean_prod]
change mean (fun ω : Prep9 g × Prep200 g => mean (fun η : Active g =>
rawEnergy (cycle g v (ω,η)))) ≤ _
rw [mean_prod]
apply mean_le_const; intro ω
let u := rawPermute v (run (g+3) (9*(g+3)) ω)
have hN : Fintype.card (Position (g+3)) = 8*2^g := by simp [pow_add]; omega
have hh := prep_sweep_energy (g+1) (2^g) (g+3) (by omega) u
(rawPermute_support v hw _) ((rawPermute_mass v _).trans hz)
(by simpa only [show g+1+2 = g+3 by omega, hN] using (le_refl (8*2^g)))
(by rw [rawPermute_count, hN]; omega)
(by rwa [rawPermute_count]) hs
have he : rawEnergy u = rawEnergy v := rawPermute_energy _ _
have hc : (freeCount u.free : ℝ) ≤ (2^g : ℝ) := by
rw [rawPermute_count]; exact_mod_cast hk
have hE := rawEnergy_nonneg v
have hr : 0 ≤ Real.sqrt ((Fintype.card (Position (g+3)) : ℝ) *
((1/2 : ℝ)^(8*(g+3)) + 32*(9/10 : ℝ)^(2^g))) := Real.sqrt_nonneg _
change mean (fun c : Prep200 g => mean (fun η : Active g =>
rawEnergy (rawIterate (g+2) (rawPermute u (run (g+3) (200*(g+3)) c)) (g+3) η))) ≤ _
change _ ≤ rawEnergy v * ((255/256 : ℝ)^(g+3) + (2^g : ℝ) * _)
have hh' : mean (fun c : Prep200 g => mean (fun η : Active g =>
rawEnergy (rawIterate (g+2) (rawPermute u (run (g+3) (200*(g+3)) c)) (g+3) η))) ≤
rawEnergy v * ((255/256 : ℝ)^(g+3) + (freeCount u.free : ℝ)*
Real.sqrt ((Fintype.card (Position (g+3)) : ℝ) *
((1/2 : ℝ)^(8*(g+3)) + 32*(9/10 : ℝ)^(2^g)))) := by
have heq : mean (fun c : Prep200 g => mean (fun η : Active g =>
rawEnergy (rawIterate (g+2) (rawPermute u (run (g+3) (200*(g+3)) c)) (g+3) η))) =
mean (fun c : History (g+1+2) (200*(g+1+2)) =>
mean (fun η : SweepHistory (g+1+1) (g+3) =>
rawEnergy (rawIterate (g+1+1) (rawPermute u (run (g+1+2) (200*(g+1+2)) c)) (g+3) η))) := by
exact mean_fintype_irrel _ _ _
rw [heq]
simpa only [show g+1+2 = g+3 by omega, he] using hh
exact hh'.trans (mul_le_mul_of_nonneg_left
(add_le_add_right (mul_le_mul_of_nonneg_right hc hr) _) hE)
end OverlayEnergy
end Thorp.Conditional
end
end OAI
|