math / data /lean /OAI /Analysis /FiniteFactor /Truncation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
7.25 kB
import OAI.Analysis.FiniteFactor.Polynomial
import OAI.Analysis.FiniteFactor.Convolution
import Mathlib.Data.Int.Interval
namespace OAI
namespace FiniteFactor
open scoped ComplexConjugate
/-- Sum a row of the Laurent coefficient double sum using its unique possible
second exponent. -/
theorem laurent_row_eq (K : ℕ) (A B : ℤ → ℂ) (r v : ℤ) :
(∑ j : Fin (2*K+1), if v + ((j.val : ℤ)-K) = r then
A v * B ((j.val : ℤ)-K) else 0) =
if -(K : ℤ) ≤ r-v ∧ r-v ≤ K then A v * B (r-v) else 0 := by
classical
by_cases hv : -(K : ℤ) ≤ r-v ∧ r-v ≤ K
· rw [ite_eq_left hv]
let j : Fin (2*K+1) := ⟨(r-v+K).toNat, by omega⟩
have hj : (j.val : ℤ)-K = r-v := by dsimp [j]; omega
rw [Finset.sum_eq_single j]
· rw [hj, ite_eq_left (by omega)]
· intro b _ hb
apply ite_eq_right
intro he
apply hb
apply Fin.ext
have := b.isLt
omega
· simp
· rw [ite_eq_right hv]
apply Finset.sum_eq_zero
intro j _
apply ite_eq_right
intro he
apply hv
have := j.isLt
omega
/-- A finite subset of ℤ, exactly the two simultaneous coefficient cutoffs. -/
noncomputable def convolutionWindow (K : ℕ) (n : ℤ) : Finset ℤ :=
(Finset.Icc (-(K : ℤ)) K).filter (fun v => -(K : ℤ) ≤ -n-v ∧ -n-v ≤ K)
theorem mem_convolutionWindow (K : ℕ) (n v : ℤ) :
v ∈ convolutionWindow K n ↔ |v| ≤ (K : ℤ) ∧ |n+v| ≤ (K : ℤ) := by
simp only [convolutionWindow, Finset.mem_filter, Finset.mem_Icc, abs_le]
omega
theorem not_mem_convolutionWindow (K : ℕ) (n v : ℤ) :
v ∉ convolutionWindow K n ↔ (K : ℤ) < |v| ∨ (K : ℤ) < |n+v| := by
rw [mem_convolutionWindow]
omega
theorem laurent_coefficient_eq_finite_convolution (K : ℕ) (A B : ℤ → ℂ) (n : ℤ) :
laurentProductCoefficient K A B (-n) =
∑ v ∈ convolutionWindow K n, A v * B (-n-v) := by
classical
simp only [laurentProductCoefficient, laurent_row_eq]
rw [convolutionWindow, Finset.sum_filter]
apply Finset.sum_bij (fun i _ => (i.val : ℤ)-K)
· intro i _
simp only [Finset.mem_Icc]
have := i.isLt
omega
· intro i _ j _ hij
apply Fin.ext
omega
· intro v hv
simp only [Finset.mem_Icc] at hv
refine ⟨⟨(v+K).toNat, by omega⟩, Finset.mem_univ _, ?_⟩
dsimp
omega
· intro i _
rfl
/-- A zero absolutely convergent convolution forces the exact finite Laurent
coefficient to be the negative complementary tail. -/
theorem laurent_coefficient_eq_neg_tail (K : ℕ) (A B : ℤ → ℂ) (n : ℤ)
(hs : Summable (fun v => A v * B (-n-v)))
(hz : ∑' v, A v * B (-n-v) = 0) :
laurentProductCoefficient K A B (-n) =
-(∑' v : {v : ℤ // v ∉ convolutionWindow K n}, A v * B (-n-v)) := by
rw [laurent_coefficient_eq_finite_convolution]
exact finite_part_eq_neg_tail hs hz _
/-- The corresponding absolute tail bound used in error-pointwise. -/
theorem laurent_coefficient_norm_le_tail (K : ℕ) (A B : ℤ → ℂ) (n : ℤ)
(hs : Summable (fun v => ‖A v * B (-n-v)‖))
(hz : ∑' v, A v * B (-n-v) = 0) :
‖laurentProductCoefficient K A B (-n)‖ ≤
∑' v : {v : ℤ // v ∉ convolutionWindow K n}, ‖A v * B (-n-v)‖ := by
rw [laurent_coefficient_eq_finite_convolution]
exact finite_part_norm_le_tail hs hz _
/-- The full pointwise error estimate. The two exceptional masks remain
separate and each is summed over all of ℤ; no union bound is introduced. -/
theorem laurent_error_pointwise (K : ℕ) (n : ℤ)
(ξ γ : lp (fun _ : ℤ => ℂ) 2) {F G : ℤ → ℝ}
(hF : ∀ k, 0 < F k) (hG : ∀ k, 0 < G k)
(hFa : Antitone F) (hGa : Antitone G) (hGF : ∀ k, G k ≤ F k)
(hn : 0 ≤ n) {H₁ H₂ : Set ℤ} {ε : ℝ} (hε : 0 ≤ ε)
(hz : ∑' v, leftCoefficient F ξ v * rightCoefficient G γ (-n-v) = 0)
(hR : ∀ v, v ∉ convolutionWindow K n →
G (n+v) / F v ≤ ε + H₁.indicator (fun _ => 1) v +
H₂.indicator (fun _ => 1) v) :
‖laurentProductCoefficient K (leftCoefficient F ξ) (rightCoefficient G γ) (-n)‖ ≤
ε * (‖ξ‖ * ‖γ‖) +
(∑' v, H₁.indicator (fun v => ‖ξ v‖ * ‖γ (n+v)‖) v) +
(∑' v, H₂.indicator (fun v => ‖ξ v‖ * ‖γ (n+v)‖) v) := by
classical
let p : ℤ → ℝ := fun v => ‖ξ v‖ * ‖γ (n+v)‖
have hp0 : ∀ v, 0 ≤ p v := fun v => mul_nonneg (norm_nonneg _) (norm_nonneg _)
obtain ⟨hp, hpbound⟩ := shifted_l2_norm_product ξ γ n
change Summable p at hp
change (∑' v, p v) ≤ ‖ξ‖ * ‖γ‖ at hpbound
have hmask : ∀ H : Set ℤ, Summable (H.indicator p) := by
intro H
apply hp.of_nonneg_of_le
· intro v
by_cases hv : v ∈ H <;> simp [hv, hp0]
· intro v
by_cases hv : v ∈ H <;> simp [hv, hp0]
let b : ℤ → ℝ := fun v => ε * p v + H₁.indicator p v + H₂.indicator p v
have hb : Summable b := ((hp.mul_left ε).add (hmask H₁)).add (hmask H₂)
have hb0 : ∀ v, 0 ≤ b v := by
intro v
dsimp [b]
have h₁ : 0 ≤ H₁.indicator p v := by by_cases hv : v ∈ H₁ <;> simp [hv, hp0]
have h₂ : 0 ≤ H₂.indicator p v := by by_cases hv : v ∈ H₂ <;> simp [hv, hp0]
exact add_nonneg (add_nonneg (mul_nonneg hε (hp0 v)) h₁) h₂
have hterm : ∀ v, v ∉ convolutionWindow K n →
‖leftCoefficient F ξ v * rightCoefficient G γ (-n-v)‖ ≤ b v := by
intro v hv
rw [cocycle_convolution_term_eq]
have hr : 0 ≤ G (n+v) / F v := (div_pos (hG _) (hF _)).le
simp only [norm_mul, RCLike.norm_conj, Complex.norm_real, Real.norm_eq_abs,
abs_of_nonneg hr]
calc
G (n+v) / F v * ‖ξ v‖ * ‖γ (n+v)‖ = (G (n+v) / F v) * p v := by dsimp [p]; ring
_ ≤ (ε + H₁.indicator (fun _ => 1) v + H₂.indicator (fun _ => 1) v) * p v :=
mul_le_mul_of_nonneg_right (hR v hv) (hp0 v)
_ = b v := by
dsimp [b]
by_cases h₁ : v ∈ H₁ <;> by_cases h₂ : v ∈ H₂ <;> simp [h₁, h₂] <;> ring
have hs := (cocycle_convolution_absolute_convergence ξ γ hF hG hFa hGa hGF hn).1
calc
‖laurentProductCoefficient K (leftCoefficient F ξ) (rightCoefficient G γ) (-n)‖ ≤
∑' v : {v : ℤ // v ∉ convolutionWindow K n},
‖leftCoefficient F ξ v * rightCoefficient G γ (-n-v)‖ :=
laurent_coefficient_norm_le_tail K _ _ n hs hz
_ ≤ ∑' v : {v : ℤ // v ∉ convolutionWindow K n}, b v :=
(hs.subtype _).tsum_le_tsum (fun v => hterm v v.property) (hb.subtype _)
_ ≤ ∑' v, b v := hb.tsum_subtype_le _ _ hb0
_ = ε * (∑' v, p v) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v) := by
change (∑' v, (ε * p v + H₁.indicator p v + H₂.indicator p v)) = _
rw [Summable.tsum_add ((hp.mul_left ε).add (hmask H₁)) (hmask H₂),
Summable.tsum_add (hp.mul_left ε) (hmask H₁), tsum_mul_left]
_ ≤ _ := by
change ε * (∑' v, p v) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v) ≤
ε * (‖ξ‖ * ‖γ‖) + (∑' v, H₁.indicator p v) + (∑' v, H₂.indicator p v)
linarith [mul_le_mul_of_nonneg_left hpbound hε]
end FiniteFactor
end OAI