| import OAI.MathematicalPhysics.NavierStokes.Material.History |
|
|
| namespace OAI |
|
|
| namespace Alternating.Memory |
| open scoped Topology |
|
|
| noncomputable def periodicDecoder (a b x : ℝ) : ℝ := |
| Int.fract x - Real.smoothTransition ((Int.fract x - a) / (b - a)) |
|
|
| theorem periodicDecoder_periodic (a b : ℝ) : Function.Periodic (periodicDecoder a b) 1 := by |
| intro x |
| simp only [periodicDecoder, Int.fract_add_one] |
|
|
| theorem periodicDecoder_on_unit {a b x : ℝ} (hx : x ∈ Set.Ico 0 1) : |
| periodicDecoder a b x = x - Real.smoothTransition ((x - a) / (b - a)) := by |
| simp only [periodicDecoder, Int.fract_eq_self.2 hx] |
|
|
| theorem periodicDecoder_on_safe {a b m : ℝ} (hab : a < b) (hbm : b < 1) (hma : m < a) |
| {x : ℝ} (hx : x ∈ Set.Icc 0 m) : periodicDecoder a b x = x := by |
| rw [periodicDecoder_on_unit ⟨hx.1, by linarith [hx.2]⟩, |
| Real.smoothTransition.zero_of_nonpos (div_nonpos_of_nonpos_of_nonneg |
| (by linarith [hx.2]) (by linarith)), sub_zero] |
|
|
| theorem periodicDecoder_near_zero {a b : ℝ} (ha : 0 < a) (hab : a < b) (hb : b < 1) |
| {x : ℝ} (hx : x ∈ Set.Ioo (b - 1) a) : periodicDecoder a b x = x := by |
| have hba : 0 < b - a := sub_pos.2 hab |
| by_cases hx0 : 0 ≤ x |
| · rw [periodicDecoder_on_unit ⟨hx0, hx.2.trans (hab.trans hb)⟩, |
| Real.smoothTransition.zero_of_nonpos |
| (div_nonpos_of_nonpos_of_nonneg (sub_nonpos.2 hx.2.le) hba.le), sub_zero] |
| · have hneg : x < 0 := lt_of_not_ge hx0 |
| have hfloor : ⌊x⌋ = (-1 : ℤ) := Int.floor_eq_iff.2 ⟨by norm_num; linarith [hx.1], by simpa⟩ |
| have hfract : Int.fract x = x + 1 := by simp [Int.fract, hfloor] |
| have hstep : 1 ≤ (x + 1 - a) / (b - a) := (le_div_iff₀ hba).2 (by linarith [hx.1]) |
| simp [periodicDecoder, hfract, Real.smoothTransition.one_of_one_le hstep] |
|
|
| theorem periodicDecoder_smooth {a b : ℝ} (ha : 0 < a) (hab : a < b) (hb : b < 1) : |
| ContDiff ℝ (⊤ : ℕ∞) (periodicDecoder a b) := by |
| apply contDiff_iff_contDiffAt.2 |
| intro x |
| let k : ℤ := ⌊x⌋ |
| by_cases hx : x = (k : ℝ) |
| · have hlocal : periodicDecoder a b =ᶠ[𝓝 x] (fun y : ℝ => y - (k : ℝ)) := by |
| filter_upwards [Ioo_mem_nhds (a := (k : ℝ) + b - 1) (b := (k : ℝ) + a) |
| (by rw [hx]; linarith) (by rw [hx]; linarith)] with y hy |
| have hi := ((periodicDecoder_periodic a b).int_mul (-k)) y |
| have heq : periodicDecoder a b y = periodicDecoder a b (y - k) := by |
| simpa [sub_eq_add_neg] using hi.symm |
| rw [heq] |
| exact periodicDecoder_near_zero ha hab hb ⟨by linarith [hy.1], by linarith [hy.2]⟩ |
| exact (contDiffAt_id.sub contDiffAt_const).congr_of_eventuallyEq hlocal |
| · have hlow : (k : ℝ) < x := (Int.floor_le x).lt_of_ne (Ne.symm hx) |
| have hupp : x < (k : ℝ) + 1 := Int.lt_floor_add_one x |
| have hlocal : periodicDecoder a b =ᶠ[𝓝 x] |
| (fun y : ℝ => (y - k) - Real.smoothTransition (((y - k) - a) / (b - a))) := by |
| filter_upwards [Ioo_mem_nhds hlow hupp] with y hy |
| have hfloor : ⌊y⌋ = k := Int.floor_eq_iff.2 ⟨hy.1.le, hy.2⟩ |
| simp only [periodicDecoder, Int.fract, hfloor] |
| apply ContDiffAt.congr_of_eventuallyEq (hg := hlocal) |
| apply (show ContDiff ℝ (⊤ : ℕ∞) |
| (fun y : ℝ => (y - k) - Real.smoothTransition (((y - k) - a) / (b - a))) from ?_).contDiffAt |
| fun_prop |
|
|
| theorem periodic_iteratedDeriv {P : ℝ → ℝ} (hP : Function.Periodic P 1) (n : ℕ) : |
| Function.Periodic (iteratedDeriv n P) 1 := by |
| have heq : (fun x => P (x + 1)) = P := funext hP |
| have h := iteratedDeriv_comp_add_const n P 1 |
| rw [heq] at h |
| exact fun x => (congr_fun h x).symm |
|
|
| theorem periodicDecoder_derivatives_bounded {a b : ℝ} |
| (ha : 0 < a) (hab : a < b) (hb : b < 1) (n : ℕ) : |
| ∃ M : ℝ, 0 < M ∧ ∀ x : ℝ, |iteratedDeriv n (periodicDecoder a b) x| ≤ M := by |
| have hp := periodic_iteratedDeriv (periodicDecoder_periodic a b) n |
| have hc := (periodicDecoder_smooth ha hab hb).continuous_iteratedDeriv n (by exact_mod_cast (le_top : (n : ℕ∞) ≤ ⊤)) |
| obtain ⟨M, hM, hbound⟩ := |
| (hp.isBounded_of_continuous (by norm_num : (1 : ℝ) ≠ 0) hc).exists_pos_norm_le |
| exact ⟨M, hM, fun x => by simpa using hbound _ ⟨x, rfl⟩⟩ |
|
|
| end Alternating.Memory |
|
|
| namespace Alternating.Memory |
| open scoped BigOperators |
| open Finset |
|
|
| noncomputable def safeDecoder (b : ℕ) : ℝ → ℝ := |
| periodicDecoder ((2 * tailBound b + 1) / 3) ((tailBound b + 2) / 3) |
|
|
| theorem safeDecoder_smooth {b : ℕ} (hb : 2 ≤ b) : |
| ContDiff ℝ (⊤ : ℕ∞) (safeDecoder b) := by |
| have hm0 := tailBound_nonneg hb |
| have hm1 := tailBound_lt_one hb |
| exact periodicDecoder_smooth (by linarith) (by linarith) (by linarith) |
|
|
| theorem safeDecoder_periodic (b : ℕ) : Function.Periodic (safeDecoder b) 1 := |
| periodicDecoder_periodic _ _ |
|
|
| theorem safeDecoder_on_safe {b : ℕ} (hb : 2 ≤ b) {x : ℝ} |
| (hx : x ∈ Set.Icc 0 (tailBound b)) : safeDecoder b x = x := by |
| have hm1 := tailBound_lt_one hb |
| exact periodicDecoder_on_safe (by linarith) (by linarith) (by linarith) hx |
|
|
| theorem safeDecoder_derivatives_bounded {b : ℕ} (hb : 2 ≤ b) (n : ℕ) : |
| ∃ M : ℝ, 0 < M ∧ ∀ x : ℝ, |iteratedDeriv n (safeDecoder b) x| ≤ M := by |
| have hm0 := tailBound_nonneg hb |
| have hm1 := tailBound_lt_one hb |
| exact periodicDecoder_derivatives_bounded (by linarith) (by linarith) (by linarith) n |
|
|
| theorem safe_read_exact {b N : ℕ} (hb : 2 ≤ b) (C : ∀ n, Block b (width N n)) (n : ℕ) : |
| safeDecoder b ((b : ℝ) ^ scale N n * donor b N C n) = (C n).code ∧ |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1 + width N n) * donor b N C n) = (C n).rightCode ∧ |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1) * donor b N C n) - |
| (b : ℝ)⁻¹ ^ width N n * |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1 + width N n) * donor b N C n) = (C n).leftCode := |
| read_exact hb C (safeDecoder_periodic b) (fun _ hx => safeDecoder_on_safe hb hx) n |
|
|
| theorem history_nonneg {b N : ℕ} (hb : 0 < b) |
| (C : ∀ n, Block b (width N n)) (parity n : ℕ) : |
| 0 ≤ history b N C parity n := by |
| apply sum_nonneg |
| intro j _hj |
| exact mul_nonneg (epsilon_nonneg hb N j) (C j).code_nonneg |
|
|
| theorem history_le {b N : ℕ} (hb : 2 ≤ b) |
| (C : ∀ n, Block b (width N n)) (parity n : ℕ) : |
| history b N C parity n ≤ ∑ j ∈ range (n + 1), epsilon b N j := by |
| calc |
| history b N C parity n ≤ |
| ∑ j ∈ (range (n + 1)).filter (fun j => j % 2 = parity), epsilon b N j := by |
| apply sum_le_sum |
| intro j _hj |
| apply mul_le_of_le_one_right (epsilon_nonneg (by omega) N j) |
| exact ((C j).code_le hb).trans (tailBound_lt_one hb).le |
| _ ≤ ∑ j ∈ range (n + 1), epsilon b N j := by |
| apply sum_le_sum_of_subset_of_nonneg (filter_subset _ _) |
| intro j _hj _ |
| exact epsilon_nonneg (by omega) N j |
|
|
| theorem history_small {b N : ℕ} (hb : 4 ≤ b) |
| (C : ∀ n, Block b (width N n)) (parity n : ℕ) : |
| history b N C parity n < 1 / 4 := |
| ((history_le (by omega) C parity n).trans (epsilon_sum_range_le (by omega) N (n + 1))).trans_lt |
| (initial_epsilon_small hb N) |
|
|
| theorem history_succ {b N : ℕ} (C : ∀ n, Block b (width N n)) (parity n : ℕ) : |
| history b N C parity (n + 1) = history b N C parity n + |
| if (n + 1) % 2 = parity then epsilon b N (n + 1) * (C (n + 1)).code else 0 := by |
| simp only [history] |
| rw [range_add_one, filter_insert] |
| by_cases h : (n + 1) % 2 = parity |
| · simp [h, add_comm] |
| · simp [h] |
|
|
| theorem alternating_histories_step {b N : ℕ} (C : ∀ n, Block b (width N n)) (n : ℕ) : |
| history b N C (n % 2) (n + 1) = donor b N C n ∧ |
| history b N C ((n + 1) % 2) (n + 1) = history b N C ((n + 1) % 2) n + |
| epsilon b N (n + 1) * (C (n + 1)).code := by |
| have hparity : (n + 1) % 2 ≠ n % 2 := by omega |
| simp [history_succ, hparity, donor] |
|
|
| theorem history_interpolation_mem {b N : ℕ} (hb : 4 ≤ b) |
| (C : ∀ n, Block b (width N n)) (parity n : ℕ) {u : ℝ} (hu : u ∈ Set.Icc 0 1) : |
| (1 - u) * history b N C parity n + u * history b N C parity (n + 1) ∈ |
| Set.Ico 0 (1 / 4 : ℝ) := by |
| have ha0 := history_nonneg (by omega : 0 < b) C parity n |
| have hb0 := history_nonneg (by omega : 0 < b) C parity (n + 1) |
| have ha1 := history_small hb C parity n |
| have hb1 := history_small hb C parity (n + 1) |
| refine ⟨add_nonneg (mul_nonneg (by linarith [hu.2]) ha0) (mul_nonneg hu.1 hb0), ?_⟩ |
| have h : (1 - u) * ((1 / 4 : ℝ) - history b N C parity n) + |
| u * ((1 / 4 : ℝ) - history b N C parity (n + 1)) > 0 := by |
| rcases hu.1.eq_or_lt with h | h |
| · rw [← h] |
| simp |
| linarith |
| · exact add_pos_of_nonneg_of_pos |
| (mul_nonneg (by linarith [hu.2]) (by linarith)) (mul_pos h (by linarith)) |
| linarith |
|
|
| end Alternating.Memory |
|
|
| end OAI |
|
|
