| 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 |
|
|
