| import OAI.Dynamics.ConditionalShuffle.OverlayConditioning |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
| open Filter Topology |
| namespace Thorp.Conditional |
| theorem halfDensity_after_step_rho (d : ℕ) (v : RawState (d + 1)) |
| (c : Coins (d + 1)) (h : Bool) |
| (ρ : ℝ) (hm : ρ * Fintype.card (Position (d + 1)) ≤ freeCount v.free) |
| (hc : freeCount v.free ≤ 4 * pairHalfCount (v.free ∘ (splitPosition d).symm) c h) : |
| (ρ / 2) ≤ startHalfDensity d (rawNext d v c) h := by |
| unfold startHalfDensity |
| rw [halfCount_after_step] |
| have hn : Fintype.card (Position (d + 1)) = 2 * Fintype.card (Position d) := by |
| simp [Fintype.card_pi, Fintype.card_bool, Fintype.card_fin, pow_succ, Nat.mul_comm] |
| rw [hn, Nat.cast_mul, Nat.cast_ofNat] at hm |
| have hc' : (freeCount v.free : ℝ) ≤ |
| 4 * (pairHalfCount (v.free ∘ (splitPosition d).symm) c h : ℝ) := by exact_mod_cast hc |
| apply (le_div_iff₀ (by exact_mod_cast Fintype.card_pos (α := Position d))).mpr |
| nlinarith |
|
|
| theorem expectedNoise_dimension_rho (d : ℕ) (v : CenteredState (d + 2)) |
| (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) |
| (hm : ρ * Fintype.card (Position (d + 2)) ≤ freeCount v.free) : |
| expectedNoise (d + 1) v (d + 2) ≤ (1 - ρ / 2) * expectedEnergy (d + 1) v (d + 2) + |
| 2 * (9 / 10 : ℝ) ^ freeCount v.free := by |
| let B := v.free ∘ (splitPosition (d + 1)).symm |
| let bad (c : Coins (d + 2)) : Prop := |
| 4 * pairHalfCount B c false < pairFreeCount B ∨ |
| 4 * pairHalfCount B c true < pairFreeCount B |
| have hlocal (c : Coins (d + 2)) : |
| expectedNoise (d + 1) (nextState (d + 1) v c) (d + 1) ≤ |
| (1 - ρ / 2) * expectedEnergy (d + 1) (nextState (d + 1) v c) (d + 1) + |
| (if bad c then 1 else 0) := by |
| by_cases hc : bad c |
| · rw [ite_eq_left hc] |
| have hle := expectedNoise_le_energy (d + 1) (nextState (d + 1) v c) (d + 1) |
| have hone := expectedEnergy_le_one (d + 1) (nextState (d + 1) v c) (d + 1) |
| have hnon := expectedEnergy_nonneg (d + 1) (nextState (d + 1) v c) (d + 1) |
| nlinarith |
| · rw [ite_eq_right hc, add_zero] |
| have hb (h : Bool) : (ρ / 2) ≤ |
| startHalfDensity (d + 1) (nextState (d + 1) v c).raw h := by |
| apply halfDensity_after_step_rho (d + 1) v.raw c h ρ hm |
| have hf : ¬ 4 * pairHalfCount B c false < freeCount v.free := by |
| simpa only [B, pairFreeCount_physical] using not_or.mp hc |>.1 |
| have ht : ¬ 4 * pairHalfCount B c true < freeCount v.free := by |
| simpa only [B, pairFreeCount_physical] using not_or.mp hc |>.2 |
| change freeCount v.free ≤ 4 * pairHalfCount B c h |
| cases h |
| · exact Nat.le_of_not_gt hf |
| · exact Nat.le_of_not_gt ht |
| convert noise_bound_balanced_state d (nextState (d + 1) v c) (ρ / 2) hb using 1 |
| have hmean := mean_le_mean hlocal |
| rw [mean_add, mean_const_mul, ← expectedNoise_first, ← expectedEnergy_first] at hmean |
| have hbad := pair_both_half_balance B |
| have hbad' : mean (fun c : Coins (d + 2) => if bad c then (1 : ℝ) else 0) ≤ |
| 2 * (9 / 10 : ℝ) ^ freeCount v.free := by |
| change mean (fun c : Position (d + 1) → Bool => if bad c then (1 : ℝ) else 0) ≤ _ |
| simpa only [bad, B, pairFreeCount_physical] using hbad |
| exact hmean.trans (add_le_add (le_refl _) hbad') |
|
|
| theorem expectedNoise_bound_rho (d : ℕ) (v : CenteredState (d + 2)) |
| (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) |
| (hm : ρ * Fintype.card (Position (d + 2)) ≤ freeCount v.free) |
| (s : ℕ) (hs : d + 2 ≤ s) : |
| expectedNoise (d + 1) v s ≤ (1 - ρ / 2) * expectedEnergy (d + 1) v s + |
| 2 * (9 / 10 : ℝ) ^ freeCount v.free := by |
| obtain ⟨a, rfl⟩ := Nat.exists_eq_add_of_le hs |
| rw [Nat.add_comm (d + 2) a, expectedNoise_add, expectedEnergy_add] |
| have he := mean_le_mean (fun ω : History (d + 2) a => |
| expectedNoise_dimension_rho d (iterateState (d + 1) v a ω) ρ hρ hρ₁ |
| (by simpa only [iterateState_freeCount] using hm)) |
| simpa only [iterateState_freeCount, mean_add, mean_const_mul, mean_const] using he |
|
|
| theorem expectedEnergy_decay_rho (d : ℕ) (v : CenteredState (d + 2)) |
| (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) |
| (hm : ρ * Fintype.card (Position (d + 2)) ≤ freeCount v.free) (t : ℕ) : |
| expectedEnergy (d + 1) v t ≤ |
| (1 - ρ / 4) ^ t / (1 - ρ / 4) ^ (2 * (d + 2)) + |
| (4 / ρ) * (9 / 10 : ℝ) ^ freeCount v.free := by |
| have he := scalar_decay (d + 2) (expectedEnergy (d + 1) v) |
| (expectedNoise (d + 1) v) (ρ / 2) (1 - ρ / 4) |
| (2 * (9 / 10 : ℝ) ^ freeCount v.free) |
| (by linarith) (by linarith) (by linarith) (by linarith) |
| (by linarith) (by positivity) (expectedEnergy_le_one (d + 1) v) |
| (expectedEnergy_recurrence (d + 1) v) |
| (by intro s hs; exact expectedNoise_bound_rho d v ρ hρ hρ₁ hm s hs) t |
| convert he using 1 ; ring |
|
|
| def resetS (ρ : ℝ) : ℕ := ⌈320 / ρ⌉₊ |
|
|
| lemma resetS_large (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) : 2 ≤ resetS ρ := by |
| have hh := Nat.le_ceil (320 / ρ) |
| have hdiv : (320 : ℝ) ≤ 320 / ρ := (le_div_iff₀ hρ).mpr (by nlinarith) |
| have : (2 : ℝ) ≤ (resetS ρ : ℝ) := by dsimp [resetS]; linarith |
| exact_mod_cast this |
|
|
| lemma reset_gamma_power (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) : |
| (1 - ρ / 4) ^ (2 * resetS ρ - 2) ≤ (1/2 : ℝ)^32 := by |
| have hs := resetS_large ρ hρ hρ₁ |
| have hc : (320 : ℝ) ≤ ρ * (resetS ρ : ℝ) := by |
| have := (div_le_iff₀ hρ).mp (Nat.le_ceil (320 / ρ)) |
| dsimp [resetS]; nlinarith |
| have hcast : ((2 * resetS ρ - 2 : ℕ) : ℝ) = 2 * (resetS ρ : ℝ) - 2 := by |
| rw [Nat.cast_sub (by omega), Nat.cast_mul]; norm_num |
| have hbase : 1 - ρ / 4 ≤ Real.exp (-ρ / 4) := by |
| convert Real.add_one_le_exp (-ρ / 4) using 1 ; ring |
| have ht : -(ρ / 4) * (2 * (resetS ρ : ℝ) - 2) ≤ -32 := by nlinarith |
| have he : Real.exp (-1) ≤ (1/2 : ℝ) := by |
| rw [Real.exp_neg] |
| apply (inv_le_comm₀ (Real.exp_pos _) (by norm_num)).mpr |
| have := Real.add_one_le_exp (1 : ℝ) |
| norm_num at this ⊢ |
| exact this |
| calc |
| _ ≤ Real.exp (-ρ / 4) ^ (2 * resetS ρ - 2) := |
| pow_le_pow_left₀ (by linarith) hbase _ |
| _ = Real.exp (-(ρ / 4) * (2 * (resetS ρ : ℝ) - 2)) := by |
| rw [← Real.exp_nat_mul, hcast]; congr 1; ring |
| _ ≤ Real.exp (-32) := Real.exp_le_exp.mpr ht |
| _ = Real.exp (-1) ^ 32 := by rw [← Real.exp_nat_mul]; norm_num |
| _ ≤ _ := pow_le_pow_left₀ (Real.exp_pos _).le he _ |
|
|
| lemma reset_energy_bound (d : ℕ) (v : CenteredState (d + 2)) |
| (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) |
| (hm : ρ * Fintype.card (Position (d + 2)) ≤ freeCount v.free) : |
| expectedEnergy (d + 1) v (2 * resetS ρ * (d + 2)) ≤ |
| (1/2 : ℝ)^(32*(d+2)) + (4 / ρ) * ((9/10 : ℝ)^ρ)^((2 : ℕ)^(d+2)) := by |
| have hγ : 0 < 1 - ρ / 4 := by linarith |
| have hs := resetS_large ρ hρ hρ₁ |
| have he := expectedEnergy_decay_rho d v ρ hρ hρ₁ hm (2 * resetS ρ * (d+2)) |
| have hp : (1-ρ/4)^(2*resetS ρ*(d+2)) / (1-ρ/4)^(2*(d+2)) = |
| ((1-ρ/4)^(2*resetS ρ-2))^(d+2) := by |
| rw [← pow_mul] |
| have hn : 2*resetS ρ*(d+2) = (2*resetS ρ-2)*(d+2)+2*(d+2) := by |
| rw [← Nat.add_mul]; congr 1; omega |
| rw [hn, pow_add, mul_div_cancel_right₀ _ (ne_of_gt (pow_pos hγ _))] |
| rw [hp] at he |
| have hpow := pow_le_pow_left₀ (pow_nonneg hγ.le _) (reset_gamma_power ρ hρ hρ₁) (d+2) |
| rw [pow_mul] |
| apply he.trans (add_le_add hpow (mul_le_mul_of_nonneg_left ?_ (by positivity))) |
| rw [← Real.rpow_natCast (9/10 : ℝ), ← Real.rpow_natCast ((9/10 : ℝ)^ρ), ← Real.rpow_mul (by norm_num : (0 : ℝ) ≤ 9/10)] |
| apply Real.rpow_le_rpow_of_exponent_ge (by norm_num) (by norm_num) |
| simpa only [card_position] using hm |
|
|
| lemma reset_noise_scaled_tendsto (ρ : ℝ) (hρ : 0 < ρ) : |
| Tendsto (fun D : ℕ => (2^D : ℝ)^20 * |
| ((4/ρ) * ((9/10 : ℝ)^ρ)^((2 : ℕ)^D))) atTop (nhds 0) := by |
| have ha : 0 ≤ (9/10 : ℝ)^ρ := Real.rpow_nonneg (by norm_num) _ |
| have ha₁ : (9/10 : ℝ)^ρ < 1 := Real.rpow_lt_one (by norm_num) (by norm_num) hρ |
| have hh := ((tendsto_pow_const_mul_const_pow_of_lt_one 20 ha ha₁).comp |
| (tendsto_pow_atTop_atTop_of_one_lt (by norm_num : (1 : ℕ) < 2))).const_mul (4/ρ) |
| simpa only [Function.comp_def, Nat.cast_pow, Nat.cast_ofNat, mul_zero, |
| mul_left_comm] using hh |
|
|
| lemma reset_energy_eventually (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) : |
| ∀ᶠ d : ℕ in atTop, ∀ v : CenteredState (d+2), |
| ρ * Fintype.card (Position (d+2)) ≤ freeCount v.free → |
| expectedEnergy (d+1) v (2*resetS ρ*(d+2)) ≤ (1/2 : ℝ)^(20*(d+2)) := by |
| obtain ⟨D, hD⟩ := eventually_atTop.mp |
| ((tendsto_order.mp (reset_noise_scaled_tendsto ρ hρ)).2 (1/2) (by norm_num)) |
| filter_upwards [eventually_ge_atTop D] with d hd |
| intro v hm |
| have hn := (hD (d+2) (by omega)).le |
| have hlead : (2^(d+2) : ℝ)^20 * (1/2 : ℝ)^(32*(d+2)) ≤ 1/2 := by |
| have he : (2^(d+2) : ℝ)^20 * (1/2 : ℝ)^(32*(d+2)) = (1/2 : ℝ)^(12*(d+2)) := by |
| rw [← pow_mul, Nat.mul_comm (d+2) 20, pow_mul, pow_mul, ← mul_pow, pow_mul] |
| norm_num |
| rw [he] |
| simpa only [pow_one] using pow_le_pow_of_le_one (by norm_num : (0 : ℝ) ≤ 1/2) |
| (by norm_num : (1/2 : ℝ) ≤ 1) (show 1 ≤ 12*(d+2) by omega) |
| have he := mul_le_mul_of_nonneg_left (reset_energy_bound d v ρ hρ hρ₁ hm) |
| (by positivity : (0 : ℝ) ≤ (2^(d+2) : ℝ)^20) |
| have hone : (2^(d+2) : ℝ)^20 * (1/2 : ℝ)^(20*(d+2)) = 1 := by |
| rw [← pow_mul, Nat.mul_comm (d+2) 20, pow_mul, pow_mul, ← mul_pow] |
| norm_num |
| apply (mul_le_mul_iff_right₀ (by positivity : (0 : ℝ) < (2^(d+2) : ℝ)^20)).mp |
| rw [hone]; nlinarith |
|
|
| end Thorp.Conditional |
|
|
| end |
|
|
| end OAI |
|
|
