LeanFun RevOLVER

6.1 Volterra operators and second-kind equations

Proriol polynomials on the triangle represent Volterra kernels. We first compute their action on coefficients, then construct operators on function spaces and prove convergence of finite solves. The coordinate spaces and assumptions are stated in each solve theorem.

Theorem 6.1.1 Proriol marginal integration

✓ 🤖

#

Let \(D_{n,k}\) denote our DLMF-normalized unweighted Proriol polynomial on \(0{\lt}y{\lt}x{\lt}1\), and put \(Q_{n,k}(x,y)=(-1)^{n-k}D_{n,k}(1-x,y)\). This is precisely the normalization of [GO20] on \(0{\lt}y{\lt}1-x\):

\[ Q_{n,k}(x,(1-x)z)=\widetilde P_{n-k}^{(2k+1,0)}(x) (1-x)^k\widetilde P_k^{(0,0)}(z). \]

The linear marginal \(I_yf(x)=\int _0^{1-x}f(x,y)\, dy\) satisfies

\[ I_yQ_{n,k}(x)= \begin{cases} (1-x)\widetilde P_n^{(1,0)}(x),& k=0,\\ 0,& k{\gt}0.\end{cases} \]

Consequently, for every finite expansion,

\[ I_y\! \left(\sum _{n{\lt}N}\sum _{k=0}^n c_{n,k}Q_{n,k}\right)(x) =(1-x)\sum _{n{\lt}N}c_{n,0}\widetilde P_n^{(1,0)}(x). \]

The endpoint factor remains explicit; these identities include \(x=1\) and hold for all real \(x\) with oriented interval integrals.

References: [GO20, Section 3.1]; [Gut22, Section 2.3].

Lean Formalisation

theorem Polynomial.eval_shiftedJacobi_one_sub (α β x : ℝ) (n : ℕ) :
  Polynomial.eval (1 - x) (Polynomial.shiftedJacobi α β n) =
    (-1) ^ n * Polynomial.eval x (Polynomial.shiftedJacobi β α n)

Lean proof

/-- Shifted Jacobi reflection, with the parameter swap (DLMF Table 18.6.1). -/
theorem eval_shiftedJacobi_one_sub (α β x : ℝ) (n : ℕ) :
    (shiftedJacobi α β n).eval (1-x) =
      (-1 : ℝ)^n * (shiftedJacobi β α n).eval x := by
  simp only [eval_shiftedJacobi]
  rw [show 2*(1-x)-1 = -(2*x-1) by ring, eval_jacobi_neg]

9 related Lean declarations

theorem Polynomial.integral_shiftedJacobi_zero_zero (k : ℕ) :
  ∫ (z : ℝ) in 0..1, Polynomial.eval z (Polynomial.shiftedJacobi 0 0 k) = if k = 0 then 1 else 0

Lean proof

/-- The unweighted inner Jacobi modes have unit mass in degree zero and zero
mass otherwise (Gutleb's thesis, derivation of equation (2.7)). -/
theorem integral_shiftedJacobi_zero_zero (k : ℕ) :
    ∫ z in (0 : ℝ)..1, (shiftedJacobi 0 0 k).eval z = if k = 0 then 1 else 0 := by
  by_cases hk : k = 0
  · subst k
    simp [shiftedJacobi]
  · have h := integralInner_shiftedJacobi (0 : ℝ) 0 k 0
      (hi := (hasFiniteMoments_jacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _)
    have hz := integral_mul_jacobi_eq_zero (α := 0) (β := 0) (by norm_num)
      (by norm_num) hk
    simp only [integralInner] at h
    let g : IntegrableInput (unitJacobiMeasure 0 0) := ⟨fun x ↦ (shiftedJacobi 0 0 k).eval x * (shiftedJacobi 0 0 0).eval x, (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _⟩
    have hg : Measurable g.val := by dsimp [g]; fun_prop
    have hd : (∫ x, g.val x ∂unitJacobiMeasure 0 0) = 2 *
        ∫ x in (0 : ℝ)..1, g.val x := by
      rw [integral_unitJacobiMeasure_subtype 0 0 g hg]
      simp only [unitJacobiWeight_apply, zero_add, Real.rpow_one, Real.rpow_zero,
        mul_one]
      rw [integral_const_mul, integral_subtype measurableSet_Ioo g.val,
        restrict_Ioo_eq_restrict_Ioc,
        ← intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
    dsimp only [g] at hd
    rw [hz, hd] at h
    simp [shiftedJacobi, hk] at h ⊢
    linarith

theorem MvPolynomial.eval_proriol_reflected_normalized_scaled (n k : ℕ) (x z : ℝ) :
  (-1) ^ (n - k) * (MvPolynomial.eval ![1 - x, (1 - x) * z]) (MvPolynomial.proriol 0 0 0 n k) =
    Polynomial.eval x (Polynomial.shiftedJacobi (2 * ↑k + 1) 0 (n - k)) * (1 - x) ^ k *
      Polynomial.eval z (Polynomial.shiftedJacobi 0 0 k)

Lean proof

/-- The sign-normalized reflected DLMF polynomial is the separated Proriol
mode used by Gutleb–Olver. No division by the boundary factor is needed. -/
theorem eval_proriol_reflected_normalized_scaled (n k : ℕ) (x z : ℝ) :
    (-1 : ℝ)^(n-k) *
      eval (![1-x,(1-x)*z] : Fin 2 → ℝ) (proriol 0 0 0 n k) =
      (shiftedJacobi (2*k+1) 0 (n-k)).eval x * (1-x)^k *
        (shiftedJacobi 0 0 k).eval z := by
  rw [eval_proriol_scaled, eval_shiftedJacobi_one_sub]
  simp only [zero_add]
  calc
    _ = ((-1 : ℝ)^(n-k) * (-1)^(n-k)) *
        ((shiftedJacobi (2*k+1) 0 (n-k)).eval x * (1-x)^k *
          (shiftedJacobi 0 0 k).eval z) := by ring
    _ = _ := by rw [← mul_pow]; simp

theorem MvPolynomial.integral_proriol_inner (n k : ℕ) (x : ℝ) :
  ∫ (y : ℝ) in 0..x, (MvPolynomial.eval ![x, y]) (MvPolynomial.proriol 0 0 0 n k) =
    if k = 0 then x * Polynomial.eval x (Polynomial.shiftedJacobi 0 1 n) else 0

Lean proof

/-- Integration along the inner coordinate removes every positive inner mode.
This formula also holds at the collapsed edge and for oriented real intervals. -/
theorem integral_proriol_inner (n k : ℕ) (x : ℝ) :
    ∫ y in (0 : ℝ)..x, eval (![x,y] : Fin 2 → ℝ) (proriol 0 0 0 n k) =
      if k = 0 then x * (shiftedJacobi 0 1 n).eval x else 0 := by
  have h := intervalIntegral.smul_integral_comp_mul_left
    (a := (0 : ℝ)) (b := 1)
    (fun y ↦ eval (![x,y] : Fin 2 → ℝ) (proriol 0 0 0 n k)) x
  simp only [mul_zero, mul_one, smul_eq_mul, eval_proriol_scaled] at h
  rw [intervalIntegral.integral_const_mul, integral_shiftedJacobi_zero_zero] at h
  rw [← h]
  split_ifs with hk
  · subst k
    simp
  · simp

theorem MvPolynomial.integral_proriol_reflected (n k : ℕ) (x : ℝ) :
  ∫ (y : ℝ) in 0..1 - x, (MvPolynomial.eval ![1 - x, y]) (MvPolynomial.proriol 0 0 0 n k) =
    if k = 0 then (-1) ^ n * ((1 - x) * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n)) else 0

Lean proof

/-- Reflecting the DLMF triangle introduces the outer Jacobi parity factor.
The endpoint factor is retained explicitly, including at `x = 1`. -/
theorem integral_proriol_reflected (n k : ℕ) (x : ℝ) :
    ∫ y in (0 : ℝ)..(1-x), eval (![1-x,y] : Fin 2 → ℝ) (proriol 0 0 0 n k) =
      if k = 0 then (-1 : ℝ)^n * ((1-x) * (shiftedJacobi 1 0 n).eval x) else 0 := by
  rw [integral_proriol_inner]
  split_ifs
  · rw [eval_shiftedJacobi_one_sub]
    ring
  · rfl

theorem MvPolynomial.integral_proriol_reflected_normalized (n k : ℕ) (x : ℝ) :
  ∫ (y : ℝ) in 0..1 - x, (-1) ^ (n - k) * (MvPolynomial.eval ![1 - x, y]) (MvPolynomial.proriol 0 0 0 n k) =
    if k = 0 then (1 - x) * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n) else 0

Lean proof

/-- In the Gutleb–Olver normalization, the marginal is precisely the outer
shifted Jacobi mode times `1-x`; all positive inner degrees vanish. -/
theorem integral_proriol_reflected_normalized (n k : ℕ) (x : ℝ) :
    ∫ y in (0 : ℝ)..(1-x), (-1 : ℝ)^(n-k) *
      eval (![1-x,y] : Fin 2 → ℝ) (proriol 0 0 0 n k) =
      if k = 0 then (1-x) * (shiftedJacobi 1 0 n).eval x else 0 := by
  rw [intervalIntegral.integral_const_mul, integral_proriol_reflected]
  split_ifs with hk
  · subst k
    rw [Nat.sub_zero, ← mul_assoc, ← mul_pow]
    simp
  · simp

def MvPolynomial.triangleMarginal : MvPolynomial (Fin 2) ℝ →ₗ[ℝ] ℝ → ℝ

Lean definition

/-- The unweighted triangle marginal, with upper endpoint `1-x`.
Its domain is polynomial kernels, so additivity needs no integrability assumptions. -/
def triangleMarginal : MvPolynomial (Fin 2) ℝ →ₗ[ℝ] (ℝ → ℝ) where
  toFun p x := ∫ y in (0 : ℝ)..(1-x), eval (![x,y] : Fin 2 → ℝ) p
  map_add' p q := by
    funext x
    simp only [map_add, Pi.add_apply]
    exact intervalIntegral.integral_add
      (intervalIntegrable_eval_vertical p x 0 (1-x))
      (intervalIntegrable_eval_vertical q x 0 (1-x))
  map_smul' c p := by
    funext x
    simp [smul_eval, intervalIntegral.integral_const_mul]

def MvPolynomial.triangleReflect : MvPolynomial (Fin 2) ℝ →ₐ[ℝ] MvPolynomial (Fin 2) ℝ

Lean definition

/-- Reflecting only the first coordinate transports the DLMF triangle to the
simplex used for Volterra operators. -/
def triangleReflect : MvPolynomial (Fin 2) ℝ →ₐ[ℝ] MvPolynomial (Fin 2) ℝ :=
  aeval ![1-X 0, X 1]

theorem MvPolynomial.triangleMarginal_proriol (n k : ℕ) (x : ℝ) :
  MvPolynomial.triangleMarginal ((-1) ^ (n - k) • MvPolynomial.triangleReflect (MvPolynomial.proriol 0 0 0 n k)) x =
    if k = 0 then (1 - x) * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n) else 0

Lean proof

/-- Marginal entries of the reflected, sign-normalized Proriol modes. -/
theorem triangleMarginal_proriol (n k : ℕ) (x : ℝ) :
    triangleMarginal ((-1 : ℝ)^(n-k) • triangleReflect (proriol 0 0 0 n k)) x =
      if k = 0 then (1-x) * (shiftedJacobi 1 0 n).eval x else 0 := by
  change (∫ y in (0 : ℝ)..(1-x), _) = _
  simp only [smul_eval, eval_triangleReflect]
  exact integral_proriol_reflected_normalized n k x

theorem MvPolynomial.triangleMarginal_sum_proriol (N : ℕ) (c : ℕ → ℕ → ℝ) (x : ℝ) :
  MvPolynomial.triangleMarginal
      (∑ n ∈ Finset.range N,
        ∑ k ∈ Finset.range (n + 1),
          c n k • (-1) ^ (n - k) • MvPolynomial.triangleReflect (MvPolynomial.proriol 0 0 0 n k))
      x =
    (1 - x) * ∑ n ∈ Finset.range N, c n 0 * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n)

Lean proof

/-- Exact coefficient selection for every finite triangular expansion.
Only inner degree zero contributes; the factor `1-x` is not absorbed into the
coefficient normalization (Gutleb's thesis, equation (2.7)). -/
theorem triangleMarginal_sum_proriol (N : ℕ) (c : ℕ → ℕ → ℝ) (x : ℝ) :
    triangleMarginal (∑ n ∈ Finset.range N, ∑ k ∈ Finset.range (n+1),
      c n k • ((-1 : ℝ)^(n-k) • triangleReflect (proriol 0 0 0 n k))) x =
      (1-x) * ∑ n ∈ Finset.range N, c n 0 * (shiftedJacobi 1 0 n).eval x := by
  have hc (n k : ℕ) :
      triangleMarginal (c n k •
        ((-1 : ℝ)^(n-k) • triangleReflect (proriol 0 0 0 n k))) x =
        c n k * (if k = 0 then (1-x) * (shiftedJacobi 1 0 n).eval x else 0) := by
    rw [map_smul, Pi.smul_apply, smul_eq_mul, triangleMarginal_proriol]
  simp only [map_sum, Finset.sum_apply, hc]
  simp only [mul_ite, mul_zero]
  simp only [Finset.sum_ite_eq', Finset.mem_range, Nat.succ_pos, ite_true]
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro n hn
  ring

Theorem 6.1.2 Exact polynomial Volterra assembly

✓ 🤖

#

For a polynomial kernel \(K(x,y)\) and polynomial input \(u\), let \(E_yu(x,y)=u(y)\) and \(\mathcal RK(x,y)=K(1-x,y)\). Then extension, multiplication by the reflected kernel, marginal integration, and output reflection give exactly

\[ [I_y((\mathcal RK)E_yu)](1-x) =\int _0^x K(x,y)u(y)\, dy. \]

This assembly is linear in the input and in the kernel. The formula holds for all real \(x\), including the collapsed interval at zero.

Reference: [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.eval_triangleExtendY (u : Polynomial ℝ) (x y : ℝ) :
  (MvPolynomial.eval ![x, y]) (MvPolynomial.triangleExtendY u) = Polynomial.eval y u

Lean proof

/-- Inner extension evaluates as `u(y)` at every point. -/
theorem eval_triangleExtendY (u : ℝ[X]) (x y : ℝ) :
    eval (![x,y] : Fin 2 → ℝ) (triangleExtendY u) = u.eval y := by
  change eval (![x,y] : Fin 2 → ℝ) (u.eval₂ C (X 1)) = _
  simp [eval_eval₂_C_X]

5 related Lean declarations

def MvPolynomial.triangleExtendY : Polynomial ℝ →ₐ[ℝ] MvPolynomial (Fin 2) ℝ

Lean definition

/-- Extension of a univariate polynomial to the inner triangle coordinate. -/
def triangleExtendY : ℝ[X] →ₐ[ℝ] MvPolynomial (Fin 2) ℝ :=
  Polynomial.aeval (X 1)

def MvPolynomial.volterraPolynomial (K : MvPolynomial (Fin 2) ℝ) : Polynomial ℝ →ₗ[ℝ] ℝ → ℝ

Lean definition

/-- Exact polynomial Volterra assembly: reflect the kernel, extend the input,
multiply, integrate on the simplex, then reflect the output coordinate. -/
def volterraPolynomial (K : MvPolynomial (Fin 2) ℝ) : ℝ[X] →ₗ[ℝ] (ℝ → ℝ) where
  toFun u x := triangleMarginal (triangleReflect K * triangleExtendY u) (1-x)
  map_add' u v := by
    funext x
    simp only [map_add, mul_add, Pi.add_apply]
  map_smul' c u := by
    funext x
    simp only [map_smul, mul_smul_comm, Pi.smul_apply, RingHom.id_apply]

theorem MvPolynomial.volterraPolynomial_apply (K : MvPolynomial (Fin 2) ℝ) (u : Polynomial ℝ) (x : ℝ) :
  K.volterraPolynomial u x = ∫ (y : ℝ) in 0..x, (MvPolynomial.eval ![x, y]) K * Polynomial.eval y u

Lean proof

/-- The assembled operator is exactly the Volterra integral, including `x = 0`.
For negative `x`, the usual oriented interval-integral convention applies. -/
theorem volterraPolynomial_apply (K : MvPolynomial (Fin 2) ℝ) (u : ℝ[X]) (x : ℝ) :
    volterraPolynomial K u x =
      ∫ y in (0 : ℝ)..x, eval (![x,y] : Fin 2 → ℝ) K * u.eval y := by
  change (∫ y in (0 : ℝ)..(1-(1-x)),
    eval (![1-x,y] : Fin 2 → ℝ) (triangleReflect K * triangleExtendY u)) = _
  simp only [map_mul, eval_triangleReflect, eval_triangleExtendY, sub_sub_cancel]

theorem MvPolynomial.volterraPolynomial_add (K L : MvPolynomial (Fin 2) ℝ) :
  (K + L).volterraPolynomial = K.volterraPolynomial + L.volterraPolynomial

Lean proof

/-- Kernel assembly is additive, without any analytic side conditions for
polynomial kernels. -/
theorem volterraPolynomial_add (K L : MvPolynomial (Fin 2) ℝ) :
    volterraPolynomial (K+L) = volterraPolynomial K + volterraPolynomial L := by
  ext u x
  simp [volterraPolynomial, add_mul]

theorem MvPolynomial.volterraPolynomial_smul (c : ℝ) (K : MvPolynomial (Fin 2) ℝ) :
  (c • K).volterraPolynomial = c • K.volterraPolynomial

Lean proof

/-- Scalar multiples of kernels give scalar multiples of Volterra operators. -/
theorem volterraPolynomial_smul (c : ℝ) (K : MvPolynomial (Fin 2) ℝ) :
    volterraPolynomial (c • K) = c • volterraPolynomial K := by
  ext u x
  simp [volterraPolynomial]

The bounded integral operator and its polynomial coefficient realization are given in Theorems 6.1.28 and 6.1.30.

Reference details: Finite Proriol marginal coefficient operator and related results

Theorem 6.1.3 Finite Proriol marginal coefficient operator

✓ 🤖

#

On finitely supported coefficients indexed by \((n,k)\) with \(0\le k\le n\), the normalized Proriol marginal coefficient operator has entries

\[ Q_{j,(n,k)}=\begin{cases} 1,& k=0\text{ and }j=n,\\ 0,& \text{otherwise}.\end{cases} \]

Synthesize its output in \(\widetilde P_n^{(1,0)}\) and multiply by \(1-X\). The resulting univariate polynomial agrees pointwise with the analytic marginal of the synthesized triangle polynomial. Each matrix column has at most one nonzero; no infinite series or infinite matrix multiplication is used.

References: [GO20, Section 3.1]; [Gut22, equation (2.7)].

Lean Formalisation

theorem MvPolynomial.proriolMarginalCoefficients_single (i : (n : ℕ) × Fin (n + 1)) (a : ℝ) :
  MvPolynomial.proriolMarginalCoefficients (Finsupp.single i a) = if i.snd = 0 then Finsupp.single i.fst a else 0

Lean proof

/-- Each column has at most one nonzero, in its own total degree. -/
theorem proriolMarginalCoefficients_single (i : Σ n : ℕ, Fin (n+1)) (a : ℝ) :
    proriolMarginalCoefficients (Finsupp.single i a) =
      if i.2 = 0 then Finsupp.single i.1 a else 0 := by
  classical
  simp [proriolMarginalCoefficients, Finsupp.linearCombination_single, smul_ite]

5 related Lean declarations

def MvPolynomial.proriolVolterraSynthesis : ((n : ℕ) × Fin (n + 1) →₀ ℝ) →ₗ[ℝ] MvPolynomial (Fin 2) ℝ

Lean definition

/-- Synthesis in the reflected and sign-normalized Proriol basis. -/
def proriolVolterraSynthesis : ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) →ₗ[ℝ]
    MvPolynomial (Fin 2) ℝ :=
  Finsupp.linearCombination ℝ (fun i ↦
    (-1 : ℝ)^(i.1-i.2.val) • triangleReflect (proriol 0 0 0 i.1 i.2))

def MvPolynomial.proriolMarginalCoefficients : ((n : ℕ) × Fin (n + 1) →₀ ℝ) →ₗ[ℝ] ℕ →₀ ℝ

Lean definition

/-- The sparse marginal coefficient operator, before multiplication by `1-x`. -/
def proriolMarginalCoefficients : ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) →ₗ[ℝ] (ℕ →₀ ℝ) :=
  Finsupp.linearCombination ℝ (fun i ↦
    if i.2 = 0 then Finsupp.single i.1 1 else 0)

theorem MvPolynomial.proriolMarginalCoefficients_entry (n : ℕ) (i : (n : ℕ) × Fin (n + 1)) :
  (MvPolynomial.proriolMarginalCoefficients (Finsupp.single i 1)) n = if i.snd = 0 ∧ i.fst = n then 1 else 0

Lean proof

/-- Exact entries of the marginal matrix on the valid triangular index set. -/
theorem proriolMarginalCoefficients_entry (n : ℕ) (i : Σ n : ℕ, Fin (n+1)) :
    proriolMarginalCoefficients (Finsupp.single i 1) n =
      if i.2 = 0 ∧ i.1 = n then 1 else 0 := by
  classical
  rw [proriolMarginalCoefficients_single]
  split_ifs <;> simp_all

def MvPolynomial.proriolMarginalPolynomial : ((n : ℕ) × Fin (n + 1) →₀ ℝ) →ₗ[ℝ] Polynomial ℝ

Lean definition

/-- The marginal polynomial retains the explicit endpoint factor. -/
def proriolMarginalPolynomial : ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) →ₗ[ℝ] ℝ[X] :=
  (LinearMap.mulLeft ℝ (1-Polynomial.X)).comp
    ((Finsupp.linearCombination ℝ (shiftedJacobi 1 0)).comp proriolMarginalCoefficients)

theorem MvPolynomial.eval_proriolMarginalPolynomial (c : (n : ℕ) × Fin (n + 1) →₀ ℝ) (x : ℝ) :
  Polynomial.eval x (MvPolynomial.proriolMarginalPolynomial c) =
    MvPolynomial.triangleMarginal (MvPolynomial.proriolVolterraSynthesis c) x

Lean proof

/-- Polynomial coefficient assembly agrees exactly with analytic marginal
integration on every finite coefficient vector. -/
theorem eval_proriolMarginalPolynomial (c : (Σ n : ℕ, Fin (n+1)) →₀ ℝ) (x : ℝ) :
    (proriolMarginalPolynomial c).eval x = triangleMarginal (proriolVolterraSynthesis c) x := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd]
  | single i a =>
    have hm : triangleMarginal (proriolVolterraSynthesis (Finsupp.single i a)) x =
        a * (if i.2.val = 0 then (1-x) * (shiftedJacobi 1 0 i.1).eval x else 0) := by
      rw [proriolVolterraSynthesis, Finsupp.linearCombination_single,
        map_smul, Pi.smul_apply, smul_eq_mul, triangleMarginal_proriol]
    rw [hm]
    simp only [proriolMarginalPolynomial, LinearMap.comp_apply,
      proriolMarginalCoefficients_single, LinearMap.mulLeft_apply]
    by_cases hi : i.2 = 0
    · simp [hi, Finsupp.linearCombination_single, Polynomial.smul_eq_C_mul]
      ring
    · have hz : i.2.val ≠ 0 := fun h ↦ hi (Fin.ext h)
      simp [hi, hz]

Theorem 6.1.4 Jacobi lowering of the second parameter

✓ 🤖

#

Over every commutative \(\mathbb {Q}\)-algebra, for \(n\ge 0\),

\[ (X+1)(P_n^{(\alpha ,\beta )})'+\beta P_n^{(\alpha ,\beta )} =(n+\beta )P_n^{(\alpha +1,\beta -1)}. \]

No parameter factors are divided out, so exceptional parameters are included.

Lean Formalisation

theorem Polynomial.jacobi_lower_beta.{u_1} {R : Type u_1} [CommRing R] [Algebra ℚ R] (α β : R) (n : ℕ) :
  (Polynomial.X + 1) * Polynomial.derivative (Polynomial.jacobi α β n) + Polynomial.C β * Polynomial.jacobi α β n =
    Polynomial.C (↑n + β) * Polynomial.jacobi (α + 1) (β - 1) n

Lean proof

/-- Lowering the second parameter by a first-order differential operator. -/
theorem jacobi_lower_beta (α β : R) (n : ℕ) :
    (X+1) * derivative (jacobi α β n) + C β * jacobi α β n =
      C ((n : R)+β) * jacobi (α+1) (β-1) n := by
  let : HasUniqueDiv R := HasUniqueDiv.of_module_rat R
  let r (α β : R) (n : ℕ) :=
    (X+1) * derivative (jacobi α β n) + C β * jacobi α β n -
      C ((n : R)+β) * jacobi (α+1) (β-1) n
  have hz (α β : R) (n : ℕ) : (r α β n).eval (-1) = 0 := by
    have hp := congrArg (fun p : R[X] ↦ p.eval β)
      ((ascPochhammer_succ_left R n).symm.trans (ascPochhammer_succ_right R n))
    simp only [eval_mul, eval_X, eval_comp, eval_add, eval_one,
      eval_natCast] at hp
    dsimp [r]
    simp only [eval_sub, eval_add, eval_mul, eval_X, eval_one, eval_C,
      neg_add_cancel, zero_mul, zero_add, eval_jacobi_neg_one]
    simp only [sub_add_cancel]
    linear_combination ((-1 : R)^n * algebraMap ℚ R ((n.factorial : ℚ)⁻¹)) * hp
  have hr : ∀ n : ℕ, ∀ α β : R, r α β n = 0 := by
    intro n
    induction n with
    | zero => intro α β; simp [r]
    | succ n ih =>
      intro α β
      have hd : derivative (r α β (n+1)) = 0 := by
        have hi := ih (α+1) (β+1)
        dsimp only [r] at hi ⊢
        simp only [derivative_sub, derivative_add, derivative_mul, derivative_X,
          derivative_one, add_zero, one_mul, derivative_C, zero_mul, zero_add,
          derivative_jacobi_succ]
        simp only [show β-1+1=β by ring, show β+1-1=β by ring] at *
        simp only [Nat.cast_add, Nat.cast_one, map_add, map_sub, map_mul,
          map_natCast, map_one, map_ofNat] at hi ⊢
        linear_combination (C (algebraMap ℚ R (1/2)) * ((n : R[X])+C α+C β+2)) * hi
      have hc := eq_C_of_derivative_eq_zero hd
      have he := congrArg (fun p : R[X] ↦ p.eval (-1)) hc
      rw [hz, eval_C] at he
      rw [hc, ← he, C_0]
  exact sub_eq_zero.mp (hr n α β)

Derived from the Jacobi derivative formula [DLMF, 18.9.15] and endpoint symmetry.

Theorem 6.1.5 Volterra Jacobi extension/marginal diagonal

✓ 🤖

#

For every \(n\ge 0\) and real \(x\),

\[ \int _0^x\widetilde P_n^{(1,0)}(y)\, dy =\frac{x}{n+1}\widetilde P_n^{(0,1)}(x). \]

Consequently extension in \(y\) followed by the simplex marginal satisfies

\[ I_yE_y\widetilde P_n^{(1,0)}(x) =(1-x)\frac{(-1)^n}{n+1}\widetilde P_n^{(1,0)}(x). \]

With the endpoint factor kept outside the coefficient operator, the diagonal is \(D_{nn}=(-1)^n/(n+1)\). This coefficient formula is proved for every finitely supported input, with exact agreement with the analytic marginal. It includes \(n=0\) and the collapsed integration intervals.

References: [GO20, Section 3.1]; [Gut22, Section 2.3], with the displayed one-based diagonal converted to zero-based indexing.

Lean Formalisation

theorem Polynomial.hasDerivAt_mul_shiftedJacobi_zero_one (n : ℕ) (x : ℝ) :
  HasDerivAt (fun t => t * Polynomial.eval t (Polynomial.shiftedJacobi 0 1 n))
    ((↑n + 1) * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n)) x

Lean proof

/-- The endpoint-vanishing primitive underlying the Volterra Jacobi diagonal. -/
theorem hasDerivAt_mul_shiftedJacobi_zero_one (n : ℕ) (x : ℝ) :
    HasDerivAt (fun t ↦ t * (shiftedJacobi 0 1 n).eval t)
      (((n : ℝ)+1) * (shiftedJacobi 1 0 n).eval x) x := by
  have ha : HasDerivAt (fun t : ℝ ↦ 2*t-1) 2 x := by
    convert ((hasDerivAt_id x).const_mul 2).sub_const 1 using 1 <;> simp
  have hd := (hasDerivAt_id x).mul (((jacobi (0 : ℝ) 1 n).hasDerivAt (2*x-1)).comp x ha)
  have hi := congrArg (fun p : ℝ[X] ↦ p.eval (2*x-1)) (jacobi_lower_beta 0 1 n)
  norm_num only [zero_add, sub_self, eval_add, eval_mul, eval_C, eval_X, eval_one] at hi
  convert hd using 1
  · ext t
    simp [eval_shiftedJacobi]
  · simp only [eval_shiftedJacobi, Function.comp_apply, id_eq]
    linear_combination -hi

6 related Lean declarations

theorem Polynomial.integral_shiftedJacobi_one_zero (n : ℕ) (x : ℝ) :
  ∫ (t : ℝ) in 0..x, Polynomial.eval t (Polynomial.shiftedJacobi 1 0 n) =
    x * Polynomial.eval x (Polynomial.shiftedJacobi 0 1 n) / (↑n + 1)

Lean proof

/-- Exact integration of a shifted `(1,0)` mode, including degree zero. -/
theorem integral_shiftedJacobi_one_zero (n : ℕ) (x : ℝ) :
    ∫ t in (0 : ℝ)..x, (shiftedJacobi 1 0 n).eval t =
      x * (shiftedJacobi 0 1 n).eval x / ((n : ℝ)+1) := by
  have h := intervalIntegral.integral_eq_sub_of_hasDerivAt
    (fun t _ ↦ hasDerivAt_mul_shiftedJacobi_zero_one n t)
    (((continuous_const.mul (shiftedJacobi 1 0 n).continuous)).intervalIntegrable 0 x)
  rw [intervalIntegral.integral_const_mul] at h
  simp only [zero_mul, sub_zero] at h
  apply (eq_div_iff (by positivity : (n : ℝ)+1 ≠ 0)).2
  simpa only [mul_comm] using h

theorem MvPolynomial.triangleMarginal_extendY_shiftedJacobi (n : ℕ) (x : ℝ) :
  MvPolynomial.triangleMarginal (MvPolynomial.triangleExtendY (Polynomial.shiftedJacobi 1 0 n)) x =
    (-1) ^ n / (↑n + 1) * ((1 - x) * Polynomial.eval x (Polynomial.shiftedJacobi 1 0 n))

Lean proof

/-- Extension followed by marginal has diagonal `(-1)^n/(n+1)` when the
endpoint factor `1-x` is kept outside the coefficient operator. -/
theorem triangleMarginal_extendY_shiftedJacobi (n : ℕ) (x : ℝ) :
    triangleMarginal (triangleExtendY (shiftedJacobi 1 0 n)) x =
      ((-1 : ℝ)^n / ((n : ℝ)+1)) *
        ((1-x) * (shiftedJacobi 1 0 n).eval x) := by
  change (∫ y in (0 : ℝ)..(1-x), _) = _
  simp only [eval_triangleExtendY]
  rw [integral_shiftedJacobi_one_zero, eval_shiftedJacobi_one_sub]
  ring

theorem MvPolynomial.volterraPolynomial_one_shiftedJacobi (n : ℕ) (x : ℝ) :
  (MvPolynomial.volterraPolynomial 1) (Polynomial.shiftedJacobi 1 0 n) x =
    x * Polynomial.eval x (Polynomial.shiftedJacobi 0 1 n) / (↑n + 1)

Lean proof

/-- The constant-kernel Volterra operator maps a `(1,0)` mode to its anchored
primitive in the `(0,1)` basis. -/
theorem volterraPolynomial_one_shiftedJacobi (n : ℕ) (x : ℝ) :
    volterraPolynomial 1 (shiftedJacobi 1 0 n) x =
      x * (shiftedJacobi 0 1 n).eval x / ((n : ℝ)+1) := by
  rw [volterraPolynomial_apply]
  simp only [map_one, one_mul]
  exact integral_shiftedJacobi_one_zero n x

def MvPolynomial.volterraJacobiDiagonal : (ℕ →₀ ℝ) →ₗ[ℝ] ℕ →₀ ℝ

Lean definition

/-- Extension followed by the endpoint-factor-free marginal, in shifted
Jacobi `(1,0)` coordinates. -/
def volterraJacobiDiagonal : (ℕ →₀ ℝ) →ₗ[ℝ] (ℕ →₀ ℝ) :=
  Finsupp.linearCombination ℝ (fun n ↦ Finsupp.single n
    ((-1 : ℝ)^n / ((n : ℝ)+1)))

theorem MvPolynomial.volterraJacobiDiagonal_single (n : ℕ) (a : ℝ) :
  MvPolynomial.volterraJacobiDiagonal (Finsupp.single n a) = Finsupp.single n (a * ((-1) ^ n / (↑n + 1)))

Lean proof

/-- Exact diagonal columns with zero-based indices. -/
theorem volterraJacobiDiagonal_single (n : ℕ) (a : ℝ) :
    volterraJacobiDiagonal (Finsupp.single n a) =
      Finsupp.single n (a * ((-1 : ℝ)^n / ((n : ℝ)+1))) := by
  simp [volterraJacobiDiagonal, Finsupp.linearCombination_single]

theorem MvPolynomial.triangleMarginal_extendY_linearCombination (c : ℕ →₀ ℝ) (x : ℝ) :
  MvPolynomial.triangleMarginal
      (MvPolynomial.triangleExtendY ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) c)) x =
    (1 - x) *
      Polynomial.eval x
        ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) (MvPolynomial.volterraJacobiDiagonal c))

Lean proof

/-- Diagonal coefficient assembly agrees with the actual extension/marginal
composition for every finitely supported input. -/
theorem triangleMarginal_extendY_linearCombination (c : ℕ →₀ ℝ) (x : ℝ) :
    triangleMarginal (triangleExtendY (Finsupp.linearCombination ℝ
      (shiftedJacobi 1 0) c)) x =
      (1-x) * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
        (volterraJacobiDiagonal c)).eval x := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd, mul_add]
  | single n a =>
    rw [Finsupp.linearCombination_single, map_smul, map_smul, Pi.smul_apply,
      smul_eq_mul, triangleMarginal_extendY_shiftedJacobi,
      volterraJacobiDiagonal_single, Finsupp.linearCombination_single]
    simp only [Polynomial.smul_eq_C_mul, Polynomial.eval_mul, Polynomial.eval_C]
    ring

Theorem 6.1.6 Exact finite Proriol extension coordinates

✓ 🤖

#

For every polynomial \(p\) of degree at most \(N\), construct finitely supported coordinates \(E_Np\) in the signed, reflected Volterra Proriol basis \(Q_{n,k}\). They satisfy

\[ \sum _{n,k}(E_Np)_{n,k}Q_{n,k}(x,y)=p(y),\qquad (E_Np)_{n,k}=0\quad (n{\gt}N). \]

The synthesis identity is a polynomial identity, hence holds for all real \(x,y\). The coordinates are unique, independent of any admissible cutoff \(N\), and additive and homogeneous in \(p\). Applying the existing marginal coefficient operator, including its endpoint factor, gives exactly \(\int _0^{1-x}p(y)\, dy\).

Reference: [GO20, Section 3.1].

Lean Formalisation

theorem MvPolynomial.proriolVolterraSynthesis_transport (N : ℕ) (c : { d // (d.sum fun x e => e) ≤ N } →₀ ℝ) :
  MvPolynomial.proriolVolterraSynthesis ((MvPolynomial.proriolVolterraCoordinateTransport N) c) =
    MvPolynomial.triangleReflect
      ((Finsupp.linearCombination ℝ fun d => MvPolynomial.proriol 0 0 0 (↑d 0 + ↑d 1) (↑d 1)) c)

Lean proof

/-- Transport followed by synthesis is reflection of the original synthesis. -/
theorem proriolVolterraSynthesis_transport (N : ℕ)
    (c : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} →₀ ℝ) :
    proriolVolterraSynthesis (proriolVolterraCoordinateTransport N c) =
      triangleReflect (Finsupp.linearCombination ℝ
        (fun d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} ↦
          proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) c) := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd]
  | single d a =>
    rw [proriolVolterraCoordinateTransport, Finsupp.linearCombination_single,
      map_smul, proriolVolterraSynthesis, Finsupp.linearCombination_single,
      Finsupp.linearCombination_single]
    simp only [Nat.add_sub_cancel, smul_smul, map_smul]
    have hs : (-1 : ℝ)^(d.1 0) * (-1 : ℝ)^(d.1 0) = 1 := by
      rw [← mul_pow]; simp
    rw [hs, mul_one]

13 related Lean declarations

def MvPolynomial.proriolVolterraCoordinateTransport (N : ℕ) :
  ({ d // (d.sum fun x e => e) ≤ N } →₀ ℝ) →ₗ[ℝ] (n : ℕ) × Fin (n + 1) →₀ ℝ

Lean definition

/-- Transport finite DLMF coordinates into reflected, signed Volterra coordinates. -/
def proriolVolterraCoordinateTransport (N : ℕ) :
    ({d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} →₀ ℝ) →ₗ[ℝ]
      ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) :=
  Finsupp.linearCombination ℝ (fun d ↦
    Finsupp.single ⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ ((-1 : ℝ)^(d.1 0)))

theorem MvPolynomial.proriolVolterraCoordinateTransport_eq_zero (N : ℕ) (c : { d // (d.sum fun x e => e) ≤ N } →₀ ℝ)
  (i : (n : ℕ) × Fin (n + 1)) (hi : N < i.fst) : ((MvPolynomial.proriolVolterraCoordinateTransport N) c) i = 0

Lean proof

/-- Coordinate transport introduces no degrees above the finite cutoff. -/
theorem proriolVolterraCoordinateTransport_eq_zero (N : ℕ)
    (c : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} →₀ ℝ)
    (i : Σ n : ℕ, Fin (n+1)) (hi : N < i.1) :
    proriolVolterraCoordinateTransport N c i = 0 := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd]
  | single d a =>
    rw [proriolVolterraCoordinateTransport, Finsupp.linearCombination_single]
    simp only [Finsupp.smul_apply, smul_eq_mul]
    have hn : (⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ : Σ n : ℕ, Fin (n+1)) ≠ i := by
      intro he
      have he' := congrArg Sigma.fst he
      have hd := d.2
      rw [sum_exponents_fin_two] at hd
      dsimp only at he'
      omega
    rw [Finsupp.single_eq_of_ne (Ne.symm hn), mul_zero]

def MvPolynomial.proriolExtensionCoefficients (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N) : (n : ℕ) × Fin (n + 1) →₀ ℝ

Lean definition

/-- Exact coefficients of inner-variable extension through degree `N`. -/
def proriolExtensionCoefficients (N : ℕ) (p : ℝ[X]) (hp : p.natDegree ≤ N) :
    (Σ n : ℕ, Fin (n+1)) →₀ ℝ :=
  proriolVolterraCoordinateTransport N
    ((proriolDegreeBasis (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) N).repr
        ⟨triangleExtendY p, (mem_restrictTotalDegree (Fin 2) N _).mpr
          ((totalDegree_eval₂_C_X_le p (1 : Fin 2)).trans hp)⟩)

theorem MvPolynomial.triangleReflect_extendY (p : Polynomial ℝ) :
  MvPolynomial.triangleReflect (MvPolynomial.triangleExtendY p) = MvPolynomial.triangleExtendY p

Lean proof

/-- Reflection in the outer coordinate leaves an inner-variable extension fixed. -/
theorem triangleReflect_extendY (p : ℝ[X]) :
    triangleReflect (triangleExtendY p) = triangleExtendY p := by
  induction p using Polynomial.induction_on' with
  | add p q hp hq => simp [map_add, hp, hq]
  | monomial n a =>
    simp [triangleExtendY, Polynomial.aeval_def, Polynomial.eval₂_monomial,
      triangleReflect, aeval_def]

theorem MvPolynomial.triangleReflect_involutive : Function.Involutive ⇑MvPolynomial.triangleReflect

Lean proof

/-- Outer reflection is its own inverse on triangle polynomials. -/
theorem triangleReflect_involutive : Function.Involutive triangleReflect := by
  have h0 : triangleReflect (X 0) = 1-X 0 := by simp [triangleReflect, aeval_def]
  have h1 : triangleReflect (X 1) = X 1 := by simp [triangleReflect, aeval_def]
  have h : triangleReflect.comp triangleReflect = AlgHom.id ℝ _ := by
    ext i : 1
    change triangleReflect (triangleReflect (X i)) = X i
    fin_cases i
    · change triangleReflect (triangleReflect (X 0)) = X 0
      rw [h0, map_sub, map_one, h0, sub_sub_cancel]
    · change triangleReflect (triangleReflect (X 1)) = X 1
      rw [h1, h1]
  intro p
  exact congrArg (fun f : MvPolynomial (Fin 2) ℝ →ₐ[ℝ] MvPolynomial (Fin 2) ℝ ↦ f p) h

theorem MvPolynomial.proriolVolterraSynthesis_injective : Function.Injective ⇑MvPolynomial.proriolVolterraSynthesis

Lean proof

/-- Finite expansions in the signed Volterra basis are unique. -/
theorem proriolVolterraSynthesis_injective : Function.Injective proriolVolterraSynthesis := by
  have hv := proriol_linearIndependent (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0)
  have hs := hv.units_smul (fun i : Σ n : ℕ, Fin (n+1) ↦ (-1 : ℝˣ)^(i.1-i.2.val))
  have hm := hs.map' triangleReflect.toLinearMap
    (LinearMap.ker_eq_bot.mpr triangleReflect_involutive.injective)
  have hf : (triangleReflect.toLinearMap ∘
      (fun i : Σ n : ℕ, Fin (n+1) ↦
        (-1 : ℝˣ)^(i.1-i.2.val) • proriol 0 0 0 i.1 i.2)) =
      (fun i : Σ n : ℕ, Fin (n+1) ↦
        (-1 : ℝ)^(i.1-i.2.val) • triangleReflect (proriol 0 0 0 i.1 i.2)) := by
    funext i
    change triangleReflect ((-1 : ℝ)^(i.1-i.2.val) • proriol 0 0 0 i.1 i.2) = _
    rw [map_smul]
  change LinearIndependent ℝ (triangleReflect.toLinearMap ∘
    (fun i : Σ n : ℕ, Fin (n+1) ↦
      (-1 : ℝˣ)^(i.1-i.2.val) • proriol 0 0 0 i.1 i.2)) at hm
  change LinearIndependent ℝ (fun i : Σ n : ℕ, Fin (n+1) ↦
    (-1 : ℝ)^(i.1-i.2.val) • triangleReflect (proriol 0 0 0 i.1 i.2))
  exact hf ▸ hm

theorem MvPolynomial.proriolVolterraSynthesis_extension (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N) :
  MvPolynomial.proriolVolterraSynthesis (MvPolynomial.proriolExtensionCoefficients N p hp) =
    MvPolynomial.triangleExtendY p

Lean proof

/-- Synthesizing all extension coordinates recovers the polynomial exactly. -/
theorem proriolVolterraSynthesis_extension (N : ℕ) (p : ℝ[X]) (hp : p.natDegree ≤ N) :
    proriolVolterraSynthesis (proriolExtensionCoefficients N p hp) = triangleExtendY p := by
  let b := proriolDegreeBasis (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) N
  let q : restrictTotalDegree (Fin 2) ℝ N :=
    ⟨triangleExtendY p, (mem_restrictTotalDegree (Fin 2) N _).mpr
      ((totalDegree_eval₂_C_X_le p (1 : Fin 2)).trans hp)⟩
  have h := congrArg (fun t : restrictTotalDegree (Fin 2) ℝ N ↦
    (t : MvPolynomial (Fin 2) ℝ)) (b.linearCombination_repr q)
  have he : Finsupp.linearCombination ℝ
      (fun d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} ↦
        proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) (b.repr q) = triangleExtendY p := by
    have hf : (fun d ↦ (b d : MvPolynomial (Fin 2) ℝ)) =
        (fun d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} ↦
          proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) := by
      funext d
      exact proriolDegreeBasis_apply _ _ _ N d
    change (↑((b.repr q).sum (fun i a ↦ a • b i)) : MvPolynomial (Fin 2) ℝ) = _ at h
    simp only [Finsupp.sum, Submodule.coe_sum, Submodule.coe_smul] at h
    rw [← hf, Finsupp.linearCombination_apply]
    exact h
  rw [proriolExtensionCoefficients, proriolVolterraSynthesis_transport]
  change triangleReflect (Finsupp.linearCombination ℝ _ (b.repr q)) = _
  rw [he, triangleReflect_extendY]

theorem MvPolynomial.eval_proriolVolterraSynthesis_extension (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N) (x y : ℝ) :
  (MvPolynomial.eval ![x, y])
      (MvPolynomial.proriolVolterraSynthesis (MvPolynomial.proriolExtensionCoefficients N p hp)) =
    Polynomial.eval y p

Lean proof

/-- Pointwise correctness on every real pair, including the triangle boundary. -/
theorem eval_proriolVolterraSynthesis_extension (N : ℕ) (p : ℝ[X])
    (hp : p.natDegree ≤ N) (x y : ℝ) :
    eval (![x,y] : Fin 2 → ℝ)
      (proriolVolterraSynthesis (proriolExtensionCoefficients N p hp)) = p.eval y := by
  rw [proriolVolterraSynthesis_extension, eval_triangleExtendY]

theorem MvPolynomial.proriolExtensionCoefficients_eq_zero (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N)
  (i : (n : ℕ) × Fin (n + 1)) (hi : N < i.fst) : (MvPolynomial.proriolExtensionCoefficients N p hp) i = 0

Lean proof

/-- The complete extension has no coefficients above the input degree bound. -/
theorem proriolExtensionCoefficients_eq_zero (N : ℕ) (p : ℝ[X])
    (hp : p.natDegree ≤ N) (i : Σ n : ℕ, Fin (n+1)) (hi : N < i.1) :
    proriolExtensionCoefficients N p hp i = 0 :=
  proriolVolterraCoordinateTransport_eq_zero N _ i hi

theorem MvPolynomial.eval_proriolMarginalPolynomial_extension (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N) (x : ℝ) :
  Polynomial.eval x (MvPolynomial.proriolMarginalPolynomial (MvPolynomial.proriolExtensionCoefficients N p hp)) =
    ∫ (y : ℝ) in 0..1 - x, Polynomial.eval y p

Lean proof

/-- Extension followed by the finite marginal coefficient operator gives the
actual simplex integral, with the endpoint factor included. -/
theorem eval_proriolMarginalPolynomial_extension (N : ℕ) (p : ℝ[X])
    (hp : p.natDegree ≤ N) (x : ℝ) :
    (proriolMarginalPolynomial (proriolExtensionCoefficients N p hp)).eval x =
      ∫ y in (0 : ℝ)..(1-x), p.eval y := by
  rw [eval_proriolMarginalPolynomial, proriolVolterraSynthesis_extension]
  change (∫ y in (0 : ℝ)..(1-x), eval (![x,y] : Fin 2 → ℝ) (triangleExtendY p)) = _
  simp only [eval_triangleExtendY]

theorem MvPolynomial.proriolExtensionCoefficients_cutoff (N M : ℕ) (p : Polynomial ℝ) (hN : p.natDegree ≤ N)
  (hM : p.natDegree ≤ M) :
  MvPolynomial.proriolExtensionCoefficients N p hN = MvPolynomial.proriolExtensionCoefficients M p hM

Lean proof

/-- The coefficient vector is independent of any larger ambient degree cutoff. -/
theorem proriolExtensionCoefficients_cutoff (N M : ℕ) (p : ℝ[X])
    (hN : p.natDegree ≤ N) (hM : p.natDegree ≤ M) :
    proriolExtensionCoefficients N p hN = proriolExtensionCoefficients M p hM := by
  apply proriolVolterraSynthesis_injective
  rw [proriolVolterraSynthesis_extension, proriolVolterraSynthesis_extension]

theorem MvPolynomial.proriolExtensionCoefficients_add (N : ℕ) (p q : Polynomial ℝ) (hp : p.natDegree ≤ N)
  (hq : q.natDegree ≤ N) :
  MvPolynomial.proriolExtensionCoefficients N (p + q) ⋯ =
    MvPolynomial.proriolExtensionCoefficients N p hp + MvPolynomial.proriolExtensionCoefficients N q hq

Lean proof

/-- Extension coordinates are additive for any common admissible degree cutoff. -/
theorem proriolExtensionCoefficients_add (N : ℕ) (p q : ℝ[X])
    (hp : p.natDegree ≤ N) (hq : q.natDegree ≤ N) :
    proriolExtensionCoefficients N (p+q) (natDegree_add_le_of_degree_le hp hq) =
      proriolExtensionCoefficients N p hp + proriolExtensionCoefficients N q hq := by
  apply proriolVolterraSynthesis_injective
  simp only [map_add, proriolVolterraSynthesis_extension]

theorem MvPolynomial.proriolExtensionCoefficients_smul (N : ℕ) (a : ℝ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N) :
  MvPolynomial.proriolExtensionCoefficients N (a • p) ⋯ = a • MvPolynomial.proriolExtensionCoefficients N p hp

Lean proof

/-- Extension coordinates commute with scalar multiplication. -/
theorem proriolExtensionCoefficients_smul (N : ℕ) (a : ℝ) (p : ℝ[X])
    (hp : p.natDegree ≤ N) :
    proriolExtensionCoefficients N (a • p) ((natDegree_smul_le a p).trans hp) =
      a • proriolExtensionCoefficients N p hp := by
  apply proriolVolterraSynthesis_injective
  simp only [map_smul, proriolVolterraSynthesis_extension]

Explicit rational entries for shifted Jacobi inputs and their sharper total-degree-block support are given in Theorems 6.1.12 and 6.1.11.

The construction uses the finite orthogonal-basis coordinate map.

Theorem 6.1.7 Explicit marginal entries and initial extension columns

✓ 🤖

#

Let \(e^{(n)}\) be the actual Proriol extension coordinates of \(\widetilde P_n^{(1,0)}\). For every \(n,m\ge 0\),

\[ e^{(n)}_{m,0}= \begin{cases} (-1)^n/(n+1),& m=n,\\ 0,& m\ne n.\end{cases} \]

The complete first two columns are

\[ e^{(0)}=\delta _{(0,0)},\qquad e^{(1)}=-\tfrac 12\delta _{(1,0)}+\tfrac 32\delta _{(1,1)}. \]

Here \(\delta _{(n,k)}\) is the coordinate unit vector in the signed, reflected Volterra Proriol basis. These are equalities of the full finitely supported vectors; all unlisted entries in the two initial columns vanish.

Reference: [GO20, Section 3.1]; [Gut22, Section 2.3].

Lean Formalisation

theorem MvPolynomial.proriolMarginalCoefficients_apply (c : (n : ℕ) × Fin (n + 1) →₀ ℝ) (n : ℕ) :
  (MvPolynomial.proriolMarginalCoefficients c) n = c ⟨n, 0⟩

Lean proof

/-- Marginal selection is exactly restriction to inner degree zero. -/
theorem proriolMarginalCoefficients_apply (c : (Σ n : ℕ, Fin (n+1)) →₀ ℝ) (n : ℕ) :
    proriolMarginalCoefficients c n = c ⟨n, 0⟩ := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd]
  | single i a =>
    rw [proriolMarginalCoefficients_single]
    by_cases hi : i.2 = 0
    · by_cases hn : i.1 = n
      · have he : i = ⟨n, 0⟩ := Sigma.ext hn
          ((Fin.heq_ext_iff (congrArg (fun t : ℕ ↦ t+1) hn)).mpr (by simp only [hi, Fin.val_zero]))
        rw [he]
        simp
      · have he : (⟨n, 0⟩ : Σ n : ℕ, Fin (n+1)) ≠ i :=
          fun h ↦ hn (congrArg Sigma.fst h).symm
        simp [hi, Finsupp.single_eq_of_ne (Ne.symm hn), Finsupp.single_eq_of_ne he]
    · have hn : (⟨n, 0⟩ : Σ n : ℕ, Fin (n+1)) ≠ i := by
        intro he
        subst i
        exact hi rfl
      simp [hi, Finsupp.single_eq_of_ne hn]

4 related Lean declarations

theorem MvPolynomial.proriolMarginalCoefficients_extension_shiftedJacobi (n : ℕ) :
  MvPolynomial.proriolMarginalCoefficients
      (MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯) =
    Finsupp.single n ((-1) ^ n / (↑n + 1))

Lean proof

/-- The marginal coefficient vector of one extended Jacobi mode is a single
explicit diagonal entry. This is an equality of actual extension coordinates. -/
theorem proriolMarginalCoefficients_extension_shiftedJacobi (n : ℕ) :
    proriolMarginalCoefficients
      (proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
        (natDegree_shiftedJacobi_le 1 0 n)) =
      Finsupp.single n ((-1 : ℝ)^n / ((n : ℝ)+1)) := by
  let c := proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
    (natDegree_shiftedJacobi_le 1 0 n)
  have h : (1-Polynomial.X) * Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
      (proriolMarginalCoefficients c) =
      (1-Polynomial.X) * Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
        (Finsupp.single n ((-1 : ℝ)^n / ((n : ℝ)+1))) := by
    apply Polynomial.funext
    intro x
    have he := eval_proriolMarginalPolynomial c x
    rw [show proriolVolterraSynthesis c = triangleExtendY (shiftedJacobi 1 0 n) from
      proriolVolterraSynthesis_extension _ _ _, triangleMarginal_extendY_shiftedJacobi] at he
    change ((1-Polynomial.X) * Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
      (proriolMarginalCoefficients c)).eval x = _ at he
    rw [he, Finsupp.linearCombination_single]
    simp only [Polynomial.smul_eq_C_mul, Polynomial.eval_mul, Polynomial.eval_sub,
      Polynomial.eval_one, Polynomial.eval_X, Polynomial.eval_C]
    ring
  have hn : (1-Polynomial.X : ℝ[X]) ≠ 0 := by
    intro hz
    have := congrArg (fun p : ℝ[X] ↦ p.coeff 1) hz
    norm_num [Polynomial.coeff_one] at this
  have he := mul_left_cancel₀ hn h
  exact (shiftedJacobiSequence (by norm_num : (-1 : ℝ) < 1)
    (by norm_num : (-1 : ℝ) < 0)).linearIndependent he

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_inner_zero (n m : ℕ) :
  (MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯) ⟨m, 0⟩ =
    if n = m then (-1) ^ n / (↑n + 1) else 0

Lean proof

/-- All inner-degree-zero entries, including the off-degree zeros. -/
theorem proriolExtensionCoefficients_shiftedJacobi_inner_zero (n m : ℕ) :
    proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
      (natDegree_shiftedJacobi_le 1 0 n) ⟨m, 0⟩ =
      if n = m then (-1 : ℝ)^n / ((n : ℝ)+1) else 0 := by
  classical
  rw [← proriolMarginalCoefficients_apply, proriolMarginalCoefficients_extension_shiftedJacobi,
    Finsupp.single_apply]

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_zero :
  MvPolynomial.proriolExtensionCoefficients 0 (Polynomial.shiftedJacobi 1 0 0) ⋯ = Finsupp.single ⟨0, 0⟩ 1

Lean proof

/-- The complete constant-input extension column. -/
theorem proriolExtensionCoefficients_shiftedJacobi_zero :
    proriolExtensionCoefficients 0 (shiftedJacobi 1 0 0)
      (natDegree_shiftedJacobi_le 1 0 0) = Finsupp.single ⟨0, 0⟩ 1 := by
  apply proriolVolterraSynthesis_injective
  rw [proriolVolterraSynthesis_extension, proriolVolterraSynthesis,
    Finsupp.linearCombination_single]
  simp [proriol_zero_zero, shiftedJacobi]

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_one :
  MvPolynomial.proriolExtensionCoefficients 1 (Polynomial.shiftedJacobi 1 0 1) ⋯ =
    Finsupp.single ⟨1, 0⟩ (-(1 / 2)) + Finsupp.single ⟨1, 1⟩ (3 / 2)

Lean proof

/-- The complete linear-input column in the signed Volterra normalization. -/
theorem proriolExtensionCoefficients_shiftedJacobi_one :
    proriolExtensionCoefficients 1 (shiftedJacobi 1 0 1)
      (natDegree_shiftedJacobi_le 1 0 1) =
      Finsupp.single ⟨1, 0⟩ (-(1/2)) + Finsupp.single ⟨1, 1⟩ (3/2) := by
  apply proriolVolterraSynthesis_injective
  rw [proriolVolterraSynthesis_extension, map_add]
  simp only [proriolVolterraSynthesis, Finsupp.linearCombination_single]
  apply MvPolynomial.funext
  intro v
  have hv : v = ![v 0, v 1] := by
    funext i
    fin_cases i <;> rfl
  rw [hv, eval_triangleExtendY]
  simp only [map_add, smul_eval, eval_triangleReflect]
  norm_num only [Fin.val_zero, Fin.val_one]
  rw [proriol_one_zero, proriol_one_one]
  norm_num [shiftedJacobi, jacobi_one, map_ofNat]
  ring

The formula for arbitrary positive inner degree is not asserted here.

Theorem 6.1.8 Finite polynomial moments on the Proriol triangle

✓ 🤖

#

For a polynomial \(q(x,y)=\sum _{a,b}q_{ab}x^ay^b\), define the finite sum

\[ \mathcal M(q)=\sum _{a,b}\frac{q_{ab}}{(b+1)(a+b+2)}. \]

Then \(\mathcal M(q)=\int _0^1\int _0^x q(x,y)\, dy\, dx\). Consequently polynomial pairings and squared norms in the unweighted DLMF triangle are \(\mathcal M(pq)\) and \(\mathcal M(p^2)\). For every degree cutoff \(N\), coordinates of a polynomial of total degree at most \(N\) in the canonical unweighted Proriol basis with parameters \((0,0,0)\) are the corresponding moment quotient, and the squared-norm denominators of the basis members are strictly positive. Reference: [DLMF, 18.37.8] at zero weight parameters.

Lean Formalisation

theorem MvPolynomial.integral_monomial_proriolMeasure_zero (d : Fin 2 →₀ ℕ) (a : ℝ) :
  ∫ (v : Fin 2 → ℝ), (MvPolynomial.eval v) ((MvPolynomial.monomial d) a) ∂MvPolynomial.proriolMeasure 0 0 0 =
    a / ((↑(d 1) + 1) * (↑(d 0) + ↑(d 1) + 2))

Lean proof

/-- Exact integration of a monomial on the unweighted DLMF triangle. -/
theorem integral_monomial_proriolMeasure_zero (d : Fin 2 →₀ ℕ) (a : ℝ) :
    (∫ v, eval v (monomial d a) ∂proriolMeasure 0 0 0) =
      a / (((d 1 : ℝ)+1)*((d 0 : ℝ)+d 1+2)) := by
  rw [integral_proriolMeasure_density (by norm_num) (by norm_num) (by norm_num)]
  simp only [Real.rpow_zero, one_mul, eval_monomial]
  have he (x y : ℝ) : d.prod (fun i n ↦ (![x,y] : Fin 2 → ℝ) i ^ n) =
      x^(d 0)*y^(d 1) := by
    rw [Finsupp.prod_fintype]
    · simp
    · simp
  simp_rw [he, ← mul_assoc]
  have heq (x : Set.Ioo (0 : ℝ) 1) :
      (∫ y : Set.Ioo (0 : ℝ) (x : ℝ), a*(x : ℝ)^(d 0)*(y : ℝ)^(d 1)) =
      ∫ y in (0 : ℝ)..(x : ℝ), a*(x : ℝ)^(d 0)*y^(d 1) := by
    rw [integral_subtype measurableSet_Ioo (fun y : ℝ ↦ a*(x : ℝ)^(d 0)*y^(d 1)),
      restrict_Ioo_eq_restrict_Ioc, intervalIntegral.integral_of_le x.property.1.le]
  simp_rw [heq]
  rw [integral_subtype measurableSet_Ioo
    (fun x : ℝ ↦ ∫ y in (0 : ℝ)..x, a*x^(d 0)*y^(d 1)),
    restrict_Ioo_eq_restrict_Ioc,
    ← intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
  simp_rw [intervalIntegral.integral_const_mul, integral_pow]
  simp only [zero_pow (Nat.succ_ne_zero _), sub_zero]
  calc
    _ = a / ((d 1 : ℝ)+1) * ∫ x in (0 : ℝ)..1, x^(d 0+d 1+1) := by
      rw [← intervalIntegral.integral_const_mul]
      apply intervalIntegral.integral_congr
      intro x _
      simp only [pow_add, pow_one]
      ring
    _ = _ := by
      rw [integral_pow]
      simp only [one_pow, zero_pow (Nat.succ_ne_zero _), sub_zero, Nat.cast_add, Nat.cast_one, div_eq_mul_inv, mul_inv_rev]
      ring

6 related Lean declarations

def MvPolynomial.proriolTriangleMoment (p : MvPolynomial (Fin 2) ℝ) : ℝ

Lean definition

/-- Finite coefficient formula for the integral, with no analytic operation. -/
def proriolTriangleMoment (p : MvPolynomial (Fin 2) ℝ) : ℝ :=
  ∑ d ∈ p.support, p.coeff d / (((d 1 : ℝ)+1)*((d 0 : ℝ)+d 1+2))

theorem MvPolynomial.integral_eval_proriolMeasure_zero (p : MvPolynomial (Fin 2) ℝ) :
  ∫ (v : Fin 2 → ℝ), (MvPolynomial.eval v) p ∂MvPolynomial.proriolMeasure 0 0 0 = p.proriolTriangleMoment

Lean proof

/-- The finite moment formula agrees with integration for every polynomial. -/
theorem integral_eval_proriolMeasure_zero (p : MvPolynomial (Fin 2) ℝ) :
    (∫ v, eval v p ∂proriolMeasure 0 0 0) = proriolTriangleMoment p := by
  classical
  conv_lhs => rw [p.as_sum]
  simp only [map_sum]
  rw [integral_finsetSum]
  · simp only [integral_monomial_proriolMeasure_zero, proriolTriangleMoment]
  · intro d _
    simpa only [map_one, mul_one] using
      (hasFiniteMoments_proriolMeasure (α := 0) (β := 0) (γ := 0)
        (by norm_num) (by norm_num) (by norm_num)).integrable_mul
          (monomial d (p.coeff d)) 1

theorem MvPolynomial.integralInner_proriolMeasure_zero (p q : MvPolynomial (Fin 2) ℝ) :
  MvPolynomial.integralInner (MvPolynomial.proriolMeasure 0 0 0)
      (MvPolynomial.IntegrablePair.of (MvPolynomial.proriolMeasure 0 0 0) p q ⋯) =
    (p * q).proriolTriangleMoment

Lean proof

/-- Polynomial pairings on the unweighted triangle are finite coefficient sums. -/
theorem integralInner_proriolMeasure_zero (p q : MvPolynomial (Fin 2) ℝ) :
    integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) p q (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) = proriolTriangleMoment (p*q) := by
  rw [integralInner, ← integral_eval_proriolMeasure_zero]
  simp only [map_mul]

theorem MvPolynomial.integral_sq_proriolMeasure_zero (p : MvPolynomial (Fin 2) ℝ) :
  ∫ (v : Fin 2 → ℝ), (MvPolynomial.eval v) p ^ 2 ∂MvPolynomial.proriolMeasure 0 0 0 = (p ^ 2).proriolTriangleMoment

Lean proof

/-- The squared norm is also given by the finite moment formula. -/
theorem integral_sq_proriolMeasure_zero (p : MvPolynomial (Fin 2) ℝ) :
    (∫ v, (eval v p)^2 ∂proriolMeasure 0 0 0) = proriolTriangleMoment (p^2) := by
  rw [← integral_eval_proriolMeasure_zero]
  simp only [map_pow]

theorem MvPolynomial.proriolDegreeBasis_repr_zero (N : ℕ) (p : ↥(MvPolynomial.restrictTotalDegree (Fin 2) ℝ N))
  (i : { d // (d.sum fun x e => e) ≤ N }) :
  ((MvPolynomial.proriolDegreeBasis MvPolynomial.integralInner_proriolMeasure_zero._proof_1
            MvPolynomial.integralInner_proriolMeasure_zero._proof_1
            MvPolynomial.integralInner_proriolMeasure_zero._proof_1 N).repr
        p)
      i =
    (↑p * MvPolynomial.proriol 0 0 0 (↑i 0 + ↑i 1) (↑i 1)).proriolTriangleMoment /
      (MvPolynomial.proriol 0 0 0 (↑i 0 + ↑i 1) (↑i 1) ^ 2).proriolTriangleMoment

Lean proof

/-- Exact finite-arithmetic coordinates in the unweighted Proriol basis. -/
theorem proriolDegreeBasis_repr_zero (N : ℕ)
    (p : restrictTotalDegree (Fin 2) ℝ N)
    (i : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N}) :
    (proriolDegreeBasis (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) N).repr p i =
      proriolTriangleMoment ((p : MvPolynomial (Fin 2) ℝ) *
        proriol 0 0 0 (i.1 0+i.1 1) (i.1 1)) /
      proriolTriangleMoment ((proriol 0 0 0 (i.1 0+i.1 1) (i.1 1))^2) := by
  rw [proriolDegreeBasis_repr, integralInner_proriolMeasure_zero,
    integral_sq_proriolMeasure_zero]

theorem MvPolynomial.proriolTriangleMoment_sq_proriol_pos (n k : ℕ) :
  0 < (MvPolynomial.proriol 0 0 0 n k ^ 2).proriolTriangleMoment

Lean proof

/-- The finite denominator in the Proriol coordinate formula is strictly positive. -/
theorem proriolTriangleMoment_sq_proriol_pos (n k : ℕ) :
    0 < proriolTriangleMoment ((proriol 0 0 0 n k)^2) := by
  rw [← integral_sq_proriolMeasure_zero]
  exact integral_sq_proriolMeasure_pos (by norm_num) (by norm_num) (by norm_num) n k

Theorem 6.1.9 Elementary unweighted Proriol norms

✓ 🤖

#

For \(\beta {\gt}-1\), the Jacobi norm with first parameter zero is

\[ \int _{-1}^1(1+x)^\beta \bigl(P_n^{(0,\beta )}(x)\bigr)^2\, dx =\frac{2^{\beta +1}}{2n+\beta +1}. \]

Writing \(P_{m+k,k}\) for the unweighted DLMF Proriol polynomial, for all \(m,k\ge 0\),

\[ \mathcal M(P_{m+k,k}^2)=\frac1{2(m+k+1)(2k+1)}. \]

Reference: [DLMF, Table 18.3.1 and 18.37.8].

Lean Formalisation

theorem Polynomial.integral_sq_jacobi_zero_left {β : ℝ} (hβ : -1 < β) (n : ℕ) :
  ∫ (x : ℝ), Polynomial.eval x (Polynomial.jacobi 0 β n) ^ 2 ∂Polynomial.jacobiMeasure 0 β =
    2 ^ (β + 1) / (2 * ↑n + β + 1)

Lean proof

/-- Jacobi norms with first parameter zero need no Gamma factors. -/
theorem integral_sq_jacobi_zero_left {β : ℝ} (hβ : -1 < β) (n : ℕ) :
    (∫ x, (jacobi 0 β n).eval x ^ 2 ∂jacobiMeasure 0 β) =
      (2 : ℝ)^(β+1)/(2*n+β+1) := by
  cases n with
  | zero =>
    rw [integral_sq_jacobi_zero (by norm_num) hβ]
    simp only [GammaOn, GammaPoint.ofPos, zero_add, Nat.cast_zero, mul_zero, Gamma_one, mul_one]
    rw [show β+2 = (β+1)+1 by ring, Gamma_add_one (by linarith : β+1 ≠ 0)]
    have hg : Gamma (β+1) ≠ 0 := (Gamma_pos_of_pos (by linarith)).ne'
    field_simp
  | succ n =>
    rw [integral_sq_jacobi_succ (by norm_num) hβ]
    simp only [GammaOn, GammaPoint.ofPos, zero_add, add_zero]
    rw [show (n : ℝ)+2 = (n+1 : ℕ)+1 by push_cast; ring, Gamma_nat_eq_factorial]
    have hg : Gamma ((n : ℝ)+β+2) ≠ 0 :=
      (Gamma_pos_of_pos (by have := Nat.cast_nonneg (α := ℝ) n; linarith)).ne'
    have hf : ((n+1).factorial : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero _)
    have hd : 2*(n : ℝ)+β+3 ≠ 0 := by have := Nat.cast_nonneg (α := ℝ) n; linarith
    simp only [Nat.cast_succ]
    field_simp
    ring

1 related Lean declaration

theorem MvPolynomial.proriolTriangleMoment_sq_proriol (m k : ℕ) :
  (MvPolynomial.proriol 0 0 0 (m + k) k ^ 2).proriolTriangleMoment = 1 / (2 * (↑m + ↑k + 1) * (2 * ↑k + 1))

Lean proof

/-- Rational squared norm in the unweighted DLMF triangle normalization. -/
theorem proriolTriangleMoment_sq_proriol (m k : ℕ) :
    proriolTriangleMoment ((proriol 0 0 0 (m+k) k)^2) =
      1 / (2*((m : ℝ)+k+1)*(2*k+1)) := by
  rw [← integral_sq_proriolMeasure_zero,
    integral_sq_proriolMeasure (by norm_num) (by norm_num) (by norm_num)]
  simp only [zero_add, add_zero, Nat.add_sub_cancel]
  rw [integral_sq_jacobi_zero_left (by have := Nat.cast_nonneg (α := ℝ) k; linarith : -1 < (2 : ℝ)*k+1),
    integral_sq_jacobi_zero_left (by norm_num : (-1 : ℝ) < 0)]
  rw [show (2 : ℝ)*k+1+1 = ((2*k+2 : ℕ) : ℝ) by push_cast; ring, rpow_natCast]
  norm_num only [rpow_ofNat, add_zero, zero_add, pow_one]
  rw [pow_add]
  have hp : (2 : ℝ)^(2*k) ≠ 0 := by positivity
  have hm : 2*(m : ℝ)+(2*k+1)+1 ≠ 0 := by positivity
  have hk : 2*(k : ℝ)+1 ≠ 0 := by positivity
  have hmk : (m : ℝ)+k+1 ≠ 0 := by positivity
  field_simp
  ring

Theorem 6.1.10 Finite-sum formulas for all Proriol extension entries

✓ 🤖

#

Let \(p\) have degree at most \(N\), and let \(e=E_Np\) be its actual extension coordinates in the signed, reflected Volterra basis. For \(m+k\le N\),

\[ e_{m+k,k}=(-1)^m\frac{\mathcal M(p(y)P_{m+k,k}(x,y))}{\mathcal M(P_{m+k,k}^2)} =(-1)^m\, 2(m+k+1)(2k+1)\, \mathcal M(p(y)P_{m+k,k}(x,y)). \]

Here \(P\) is the unreflected DLMF basis and \(\mathcal M\) is the explicit finite coefficient sum above. Entries above the cutoff vanish by the existing extension theorem. Thus every entry is expressed using finite polynomial arithmetic, with no integral or abstract basis-coordinate operation on the right-hand side.

Reference: [GO20, Section 3.1], with orthogonal projection in the normalization of [DLMF, 18.37.8].

Lean Formalisation

theorem MvPolynomial.proriolVolterraCoordinateTransport_apply (N : ℕ) (c : { d // (d.sum fun x e => e) ≤ N } →₀ ℝ)
  (d : { d // (d.sum fun x e => e) ≤ N }) :
  ((MvPolynomial.proriolVolterraCoordinateTransport N) c) ⟨↑d 0 + ↑d 1, ⟨↑d 1, ⋯⟩⟩ = (-1) ^ ↑d 0 * c d

Lean proof

/-- Entrywise effect of the signed coordinate transport. -/
theorem proriolVolterraCoordinateTransport_apply (N : ℕ)
    (c : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} →₀ ℝ)
    (d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N}) :
    proriolVolterraCoordinateTransport N c ⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ =
      (-1 : ℝ)^(d.1 0) * c d := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c e hc he => simp [hc, he, mul_add]
  | single e a =>
    rw [proriolVolterraCoordinateTransport, Finsupp.linearCombination_single]
    simp only [Finsupp.smul_apply, smul_eq_mul]
    by_cases he : e = d
    · rw [he]
      simp [mul_comm]
    · have hn : (⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ : Σ n : ℕ, Fin (n+1)) ≠
          ⟨e.1 0+e.1 1, ⟨e.1 1, by omega⟩⟩ := by
        intro h
        exact he (Subtype.ext (diskIndex_injective h)).symm
      rw [Finsupp.single_eq_of_ne hn, Finsupp.single_eq_of_ne (Ne.symm he)]
      simp

2 related Lean declarations

theorem MvPolynomial.proriolExtensionCoefficients_eq_moment (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N)
  (d : { d // (d.sum fun x e => e) ≤ N }) :
  (MvPolynomial.proriolExtensionCoefficients N p hp) ⟨↑d 0 + ↑d 1, ⟨↑d 1, ⋯⟩⟩ =
    (-1) ^ ↑d 0 *
        (MvPolynomial.triangleExtendY p * MvPolynomial.proriol 0 0 0 (↑d 0 + ↑d 1) (↑d 1)).proriolTriangleMoment /
      (MvPolynomial.proriol 0 0 0 (↑d 0 + ↑d 1) (↑d 1) ^ 2).proriolTriangleMoment

Lean proof

/-- Every extension entry is an explicit finite polynomial moment quotient.
The moment operation is a finite sum of monomial coefficients divided by
positive integers; the norm denominator is strictly positive. -/
theorem proriolExtensionCoefficients_eq_moment (N : ℕ) (p : ℝ[X])
    (hp : p.natDegree ≤ N)
    (d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N}) :
    proriolExtensionCoefficients N p hp ⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ =
      (-1 : ℝ)^(d.1 0) *
        proriolTriangleMoment (triangleExtendY p * proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) /
        proriolTriangleMoment ((proriol 0 0 0 (d.1 0+d.1 1) (d.1 1))^2) := by
  rw [proriolExtensionCoefficients, proriolVolterraCoordinateTransport_apply,
    proriolDegreeBasis_repr_zero]
  ring

theorem MvPolynomial.proriolExtensionCoefficients_eq_scaled_moment (N : ℕ) (p : Polynomial ℝ) (hp : p.natDegree ≤ N)
  (d : { d // (d.sum fun x e => e) ≤ N }) :
  (MvPolynomial.proriolExtensionCoefficients N p hp) ⟨↑d 0 + ↑d 1, ⟨↑d 1, ⋯⟩⟩ =
    (-1) ^ ↑d 0 * (2 * (↑(↑d 0) + ↑(↑d 1) + 1) * (2 * ↑(↑d 1) + 1)) *
      (MvPolynomial.triangleExtendY p * MvPolynomial.proriol 0 0 0 (↑d 0 + ↑d 1) (↑d 1)).proriolTriangleMoment

Lean proof

/-- All extension entries as finite coefficient sums with an elementary
normalization factor. No norm integral or basis-coordinate operation remains. -/
theorem proriolExtensionCoefficients_eq_scaled_moment (N : ℕ) (p : ℝ[X])
    (hp : p.natDegree ≤ N)
    (d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N}) :
    proriolExtensionCoefficients N p hp ⟨d.1 0+d.1 1, ⟨d.1 1, by omega⟩⟩ =
      (-1 : ℝ)^(d.1 0) * (2*((d.1 0 : ℝ)+d.1 1+1)*(2*d.1 1+1)) *
        proriolTriangleMoment (triangleExtendY p * proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) := by
  rw [proriolExtensionCoefficients_eq_moment, proriolTriangleMoment_sq_proriol]
  simp only [div_div_eq_mul_div, div_one]
  ring

The explicit shifted-Jacobi formula and its support are Theorems 6.1.12 and 6.1.11.

Theorem 6.1.11 Jacobi extension stays in one triangle degree

✓ 🤖

#

The inner-coordinate extension of \(P_n^{(1,0)}(2y-1)\) is orthogonal, for unnormalized area measure on \(0{\lt}y{\lt}x{\lt}1\), to every polynomial of total degree less than \(n\). Consequently its Proriol extension coordinates vanish in every total-degree block except \(n\). Reference: [GO20, Section 3.1].

Lean Formalisation

theorem Polynomial.integral_mul_shiftedJacobi_one_zero_eq_zero {n : ℕ} (q : Polynomial ℝ) (hq : q.natDegree < n) :
  ∫ (y : ℝ) in 0..1, (1 - y) * Polynomial.eval y q * Polynomial.eval y (Polynomial.shiftedJacobi 1 0 n) = 0

Lean proof

/-- Orthogonality for shifted `(1,0)` modes with the unnormalized density. -/
theorem integral_mul_shiftedJacobi_one_zero_eq_zero {n : ℕ} (q : ℝ[X])
    (hq : q.natDegree < n) :
    (∫ y in (0 : ℝ)..1, (1-y)*q.eval y*(shiftedJacobi 1 0 n).eval y) = 0 := by
  have h := (isOrthogonal_shiftedJacobiSequence (by norm_num : (-1 : ℝ) < 1)
    (by norm_num : (-1 : ℝ) < 0)).integralInner_eq_zero_of_degree_lt
      (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num))
      (degree_le_natDegree.trans_lt (by exact_mod_cast hq))
  change integralInner (unitJacobiMeasure 1 0) (IntegrablePair.of (unitJacobiMeasure 1 0) q (shiftedJacobi 1 0 n) (h := (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _)) = 0 at h
  let g : IntegrableInput (unitJacobiMeasure 1 0) := ⟨fun x ↦ q.eval x * (shiftedJacobi 1 0 n).eval x, (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _⟩
  have hg : Measurable g.val := by dsimp [g]; fun_prop
  have hd : (∫ x, g.val x ∂unitJacobiMeasure 1 0) = 4 *
      ∫ x in (0 : ℝ)..1, (1-x) * g.val x := by
    rw [integral_unitJacobiMeasure_subtype 1 0 g hg]
    simp only [unitJacobiWeight_apply, add_zero, Real.rpow_one, Real.rpow_zero,
      mul_one, mul_assoc]
    norm_num only [one_add_one_eq_two, Real.rpow_two]
    rw [integral_const_mul, integral_subtype measurableSet_Ioo (fun x : ℝ ↦ (1-x)*g.val x),
      restrict_Ioo_eq_restrict_Ioc,
      ← intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
  dsimp only [g] at hd
  rw [integralInner, hd] at h
  have he : (∫ y in (0 : ℝ)..1, (1-y)*(q.eval y*(shiftedJacobi 1 0 n).eval y)) = 0 := by
    nlinarith [h]
  simpa only [mul_assoc] using he

3 related Lean declarations

theorem MvPolynomial.integralInner_extendY_monomial (p : Polynomial ℝ) (d : Fin 2 →₀ ℕ) (a : ℝ) :
  MvPolynomial.integralInner (MvPolynomial.proriolMeasure 0 0 0)
      (MvPolynomial.IntegrablePair.of (MvPolynomial.proriolMeasure 0 0 0) (MvPolynomial.triangleExtendY p)
        ((MvPolynomial.monomial d) a) ⋯) =
    a / (↑(d 0) + 1) * ∫ (y : ℝ) in 0..1, Polynomial.eval y p * y ^ d 1 * (1 - y ^ (d 0 + 1))

Lean proof

/-- Pairing an extended polynomial with a triangle monomial reduces to one
ordinary integral. The formula includes the exact triangle marginal factor. -/
theorem integralInner_extendY_monomial (p : ℝ[X]) (d : Fin 2 →₀ ℕ) (a : ℝ) :
    integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (triangleExtendY p) (monomial d a) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) =
      a/((d 0 : ℝ)+1) * ∫ y in (0 : ℝ)..1, p.eval y*y^(d 1)*(1-y^(d 0+1)) := by
  induction p using Polynomial.induction_on' with
  | add p q hp hq =>
    simp only [map_add]
    rw [integralInner_add_left
      (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)), hp, hq]
    simp only [Polynomial.eval_add, add_mul]
    rw [intervalIntegral.integral_add (by apply Continuous.intervalIntegrable; fun_prop)
      (by apply Continuous.intervalIntegrable; fun_prop)]
    ring
  | monomial n b =>
    have hm : triangleExtendY (Polynomial.monomial n b) * monomial d a =
        monomial (Finsupp.single 1 n+d) (b*a) := by
      rw [← Polynomial.C_mul_X_pow_eq_monomial, map_mul, map_pow]
      simp only [triangleExtendY, Polynomial.aeval_C, Polynomial.aeval_X]
      change C b*X 1^n*monomial d a = _
      rw [MvPolynomial.C_mul_X_pow_eq_monomial, monomial_mul_monomial]
    rw [integralInner]
    simp_rw [← map_mul]
    rw [hm, integral_monomial_proriolMeasure_zero]
    simp only [Finsupp.add_apply, Finsupp.single_eq_same, Finsupp.single_eq_of_ne (by decide : (0 : Fin 2) ≠ 1),
      zero_add, Nat.cast_add, Polynomial.eval_monomial]
    have he : (∫ y in (0 : ℝ)..1, b*y^n*y^(d 1)*(1-y^(d 0+1))) =
        b*((1/((n : ℝ)+d 1+1))-(1/((n : ℝ)+d 1+d 0+2))) := by
      calc
        _ = b*((∫ y in (0 : ℝ)..1, y^(n+d 1)) -
            ∫ y in (0 : ℝ)..1, y^(n+d 1+d 0+1)) := by
          rw [← intervalIntegral.integral_sub (by apply Continuous.intervalIntegrable; fun_prop)
            (by apply Continuous.intervalIntegrable; fun_prop), ← intervalIntegral.integral_const_mul]
          apply intervalIntegral.integral_congr
          intro y _
          dsimp only
          simp only [pow_add, pow_one]
          ring
        _ = _ := by
          rw [integral_pow, integral_pow]
          simp only [one_pow, zero_pow (Nat.succ_ne_zero _), sub_zero, Nat.cast_add, Nat.cast_one]
          ring
    rw [he]
    have h0 : (d 0 : ℝ)+1 ≠ 0 := by positivity
    have h1 : (n : ℝ)+d 1+1 ≠ 0 := by positivity
    have h2 : (n : ℝ)+d 1+d 0+2 ≠ 0 := by positivity
    have h3 : (d 0 : ℝ)+((n : ℝ)+d 1)+2 ≠ 0 := by positivity
    field_simp
    ring

theorem MvPolynomial.integralInner_extendY_shiftedJacobi_eq_zero {n : ℕ} (q : MvPolynomial (Fin 2) ℝ) (hq : q.totalDegree < n) :
  MvPolynomial.integralInner (MvPolynomial.proriolMeasure 0 0 0)
      (MvPolynomial.IntegrablePair.of (MvPolynomial.proriolMeasure 0 0 0)
        (MvPolynomial.triangleExtendY (Polynomial.shiftedJacobi 1 0 n)) q ⋯) =
    0

Lean proof

/-- Extending a shifted `(1,0)` mode makes it orthogonal to every lower
triangle degree, not merely to the inner-degree-zero modes. -/
theorem integralInner_extendY_shiftedJacobi_eq_zero {n : ℕ}
    (q : MvPolynomial (Fin 2) ℝ) (hq : q.totalDegree < n) :
    integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (triangleExtendY (shiftedJacobi 1 0 n)) q (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) = 0 := by
  classical
  have hm (d : Fin 2 →₀ ℕ) (a : ℝ) (hd : d 0+d 1 < n) :
      integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (triangleExtendY (shiftedJacobi 1 0 n)) (monomial d a) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) = 0 := by
    let r : ℝ[X] := Polynomial.X^(d 1) * ∑ i ∈ Finset.range (d 0+1), Polynomial.X^i
    have hr : r.natDegree ≤ d 0+d 1 := by
      apply Polynomial.natDegree_mul_le.trans
      rw [Polynomial.natDegree_X_pow]
      have hs : (∑ i ∈ Finset.range (d 0+1), (Polynomial.X : ℝ[X])^i).natDegree ≤ d 0 := by
        apply Polynomial.natDegree_sum_le_of_forall_le
        intro i hi
        simpa only [Polynomial.natDegree_X_pow] using (Nat.le_of_lt_succ (Finset.mem_range.mp hi))
      omega
    rw [integralInner_extendY_monomial]
    have he : (∫ y in (0 : ℝ)..1, (shiftedJacobi 1 0 n).eval y*y^(d 1)*(1-y^(d 0+1))) =
        ∫ y in (0 : ℝ)..1, (1-y)*r.eval y*(shiftedJacobi 1 0 n).eval y := by
      apply intervalIntegral.integral_congr
      intro y _
      dsimp only
      simp only [r, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X,
        Polynomial.eval_finsetSum]
      linear_combination -(shiftedJacobi 1 0 n).eval y*y^(d 1)*geom_sum_mul_neg y (d 0+1)
    rw [he, integral_mul_shiftedJacobi_one_zero_eq_zero r (hr.trans_lt hd), mul_zero]
  let B := integralBilinForm (proriolMeasure 0 0 0)
    (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num))
  change B (triangleExtendY (shiftedJacobi 1 0 n)) q = 0
  conv_lhs => rw [q.as_sum]
  rw [map_sum]
  apply Finset.sum_eq_zero
  intro d hd
  apply hm
  have h := le_totalDegree hd
  rw [sum_exponents_fin_two] at h
  omega

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_eq_zero_of_degree_ne (n : ℕ) (i : (m : ℕ) × Fin (m + 1))
  (hi : i.fst ≠ n) : (MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯) i = 0

Lean proof

/-- A shifted `(1,0)` Jacobi mode extends entirely within its own total-degree
block, including all positive inner degrees. -/
theorem proriolExtensionCoefficients_shiftedJacobi_eq_zero_of_degree_ne (n : ℕ)
    (i : Σ m : ℕ, Fin (m+1)) (hi : i.1 ≠ n) :
    proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
      (natDegree_shiftedJacobi_le 1 0 n) i = 0 := by
  by_cases hn : n < i.1
  · exact proriolExtensionCoefficients_eq_zero _ _ _ _ hn
  have hn : i.1 < n := by omega
  let d : Fin 2 →₀ ℕ := Finsupp.single 0 (i.1-i.2.1)+Finsupp.single 1 i.2.1
  have hd0 : d 0 = i.1-i.2.1 := by simp [d]
  have hd1 : d 1 = i.2.1 := by simp [d]
  have hd : d 0+d 1 = i.1 := by rw [hd0, hd1]; omega
  let e : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ n} :=
    ⟨d, by rw [sum_exponents_fin_two, hd]; omega⟩
  have he : (⟨e.1 0+e.1 1, ⟨e.1 1, by omega⟩⟩ : Σ m : ℕ, Fin (m+1)) = i := by
    apply Sigma.ext hd
    exact (Fin.heq_ext_iff (congrArg (fun t : ℕ ↦ t+1) hd)).mpr hd1
  rw [← he, proriolExtensionCoefficients_eq_moment]
  have hz := integralInner_extendY_shiftedJacobi_eq_zero
    (proriol 0 0 0 (d 0+d 1) (d 1))
    ((totalDegree_proriol_le 0 0 0 (by omega)).trans_lt (by rw [hd]; exact hn))
  rw [integralInner_proriolMeasure_zero] at hz
  change (-1 : ℝ)^(d 0)*proriolTriangleMoment
    (triangleExtendY (shiftedJacobi 1 0 n)*proriol 0 0 0 (d 0+d 1) (d 1)) / _ = 0
  rw [hz, mul_zero, zero_div]

Theorem 6.1.12 Closed-form Jacobi-to-Proriol extension

✓ 🤖

#

In the signed reflected Volterra convention, every extension column is

\[ E_{(m,k),n}=\begin{cases} (-1)^{n-k}\dfrac {2k+1}{n+1},& m=n,\\ 0,& m\ne n. \end{cases} \]

These are the actual previously defined coordinates, including the constant and linear columns. More generally, for \(\deg q\le n\), \(\int _0^1P_n^{(1,0)}(2y-1)q(y)\, dy=q(1)/(n+1)\). Reference: [GO20, Section 3.1].

Lean Formalisation

theorem Polynomial.integral_shiftedJacobi_one_zero_mul (n : ℕ) (q : Polynomial ℝ) (hq : q.natDegree ≤ n) :
  ∫ (y : ℝ) in 0..1, Polynomial.eval y (Polynomial.shiftedJacobi 1 0 n) * Polynomial.eval y q =
    Polynomial.eval 1 q / (↑n + 1)

Lean proof

/-- Endpoint reproduction by a shifted `(1,0)` Jacobi mode. -/
theorem integral_shiftedJacobi_one_zero_mul (n : ℕ) (q : ℝ[X]) (hq : q.natDegree ≤ n) :
    (∫ y in (0 : ℝ)..1, (shiftedJacobi 1 0 n).eval y*q.eval y) =
      q.eval 1/((n : ℝ)+1) := by
  have hi : (∫ y in (0 : ℝ)..1, (shiftedJacobi 1 0 n).eval y) = 1/((n : ℝ)+1) := by
    rw [integral_shiftedJacobi_one_zero, eval_shiftedJacobi_zero_left_one, one_mul]
  by_cases hn : n = 0
  · subst n
    have hq0 : q.natDegree = 0 := Nat.eq_zero_of_le_zero hq
    rw [eq_C_of_natDegree_eq_zero hq0]
    simp only [eval_C, intervalIntegral.integral_mul_const, hi]
    ring
  let r := q /ₘ (X-C (1 : ℝ))
  have hr : r.natDegree < n := by
    dsimp only [r]
    rw [natDegree_divByMonic _ (monic_X_sub_C _), natDegree_X_sub_C]
    omega
  have he (y : ℝ) : q.eval 1+(y-1)*r.eval y = q.eval y := by
    have h := congrArg (fun p : ℝ[X] ↦ p.eval y) (modByMonic_add_div q (X-C (1 : ℝ)))
    simpa only [modByMonic_X_sub_C_eq_C_eval, eval_add, eval_mul, eval_sub, eval_C, eval_X] using h
  calc
    _ = q.eval 1*(∫ y in (0 : ℝ)..1, (shiftedJacobi 1 0 n).eval y) -
        ∫ y in (0 : ℝ)..1, (1-y)*r.eval y*(shiftedJacobi 1 0 n).eval y := by
      rw [← intervalIntegral.integral_const_mul,
        ← intervalIntegral.integral_sub (by apply Continuous.intervalIntegrable; fun_prop)
          (by apply Continuous.intervalIntegrable; fun_prop)]
      apply intervalIntegral.integral_congr
      intro y _
      dsimp only
      linear_combination -(shiftedJacobi 1 0 n).eval y*he y
    _ = _ := by
      rw [integral_mul_shiftedJacobi_one_zero_eq_zero r hr, hi, sub_zero]
      ring

5 related Lean declarations

theorem Polynomial.integral_shiftedJacobi_one_zero_mul_zero_zero (n k : ℕ) (hk : k ≤ n) :
  ∫ (y : ℝ) in 0..1,
      Polynomial.eval y (Polynomial.shiftedJacobi 1 0 n) * Polynomial.eval y (Polynomial.shiftedJacobi 0 0 k) =
    1 / (↑n + 1)

Lean proof

/-- The mixed Jacobi/Legendre edge integral is constant throughout the degree block. -/
theorem integral_shiftedJacobi_one_zero_mul_zero_zero (n k : ℕ) (hk : k ≤ n) :
    (∫ y in (0 : ℝ)..1, (shiftedJacobi 1 0 n).eval y*(shiftedJacobi 0 0 k).eval y) =
      1/((n : ℝ)+1) := by
  rw [integral_shiftedJacobi_one_zero_mul n _ ((natDegree_shiftedJacobi_le 0 0 k).trans hk),
    eval_shiftedJacobi_zero_left_one]

theorem Polynomial.integral_mul_shiftedJacobi_zero_zero (j k : ℕ) :
  ∫ (y : ℝ) in 0..1,
      Polynomial.eval y (Polynomial.shiftedJacobi 0 0 j) * Polynomial.eval y (Polynomial.shiftedJacobi 0 0 k) =
    if j = k then 1 / (2 * ↑k + 1) else 0

Lean proof

/-- Unweighted Legendre orthogonality in shifted Jacobi notation. -/
theorem integral_mul_shiftedJacobi_zero_zero (j k : ℕ) :
    (∫ y in (0 : ℝ)..1, (shiftedJacobi 0 0 j).eval y*(shiftedJacobi 0 0 k).eval y) =
      if j = k then 1/(2*(k : ℝ)+1) else 0 := by
  have h := integralInner_shiftedJacobi (0 : ℝ) 0 j k
    (hi := (hasFiniteMoments_jacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _)
  let g : IntegrableInput (unitJacobiMeasure 0 0) := ⟨fun x ↦ (shiftedJacobi 0 0 j).eval x * (shiftedJacobi 0 0 k).eval x, (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _⟩
  have hg : Measurable g.val := by dsimp [g]; fun_prop
  have hd : (∫ x, g.val x ∂unitJacobiMeasure 0 0) = 2 *
      ∫ x in (0 : ℝ)..1, g.val x := by
    rw [integral_unitJacobiMeasure_subtype 0 0 g hg]
    simp only [unitJacobiWeight_apply, zero_add, Real.rpow_one, Real.rpow_zero,
      mul_one]
    rw [integral_const_mul, integral_subtype measurableSet_Ioo g.val,
      restrict_Ioo_eq_restrict_Ioc,
      ← intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
  dsimp only [g] at hd
  rw [integralInner, hd] at h
  by_cases hj : j = k
  · subst j
    rw [integralInner, show (fun x ↦ (jacobi (0 : ℝ) 0 k).eval x*
      (jacobi (0 : ℝ) 0 k).eval x) = (fun x ↦ (jacobi (0 : ℝ) 0 k).eval x^2) by ext; ring,
      integral_sq_jacobi_zero_left (by norm_num)] at h
    norm_num only [zero_add, Real.rpow_one, add_zero] at h
    simp only [ite_true]
    linear_combination h/2
  · rw [integralInner, integral_mul_jacobi_eq_zero (by norm_num) (by norm_num) hj] at h
    simp only [ite_eq_right_iff.mpr (fun h ↦ (hj h).elim)]
    linarith

theorem MvPolynomial.eval_proriol_outer_one (n k : ℕ) (y : ℝ) :
  (MvPolynomial.eval ![1, y]) (MvPolynomial.proriol 0 0 0 n k) = Polynomial.eval y (Polynomial.shiftedJacobi 0 0 k)

Lean proof

/-- Restriction of a DLMF Proriol mode to the outer edge is a shifted Legendre mode. -/
theorem eval_proriol_outer_one (n k : ℕ) (y : ℝ) :
    eval (![1,y] : Fin 2 → ℝ) (proriol 0 0 0 n k) = (shiftedJacobi 0 0 k).eval y := by
  have h := eval_proriol_scaled 0 0 0 n k 1 y
  simpa only [one_mul, one_pow, mul_one, zero_add, eval_shiftedJacobi_zero_left_one] using h

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_same_degree (n : ℕ) (k : Fin (n + 1)) :
  (MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯) ⟨n, k⟩ =
    (-1) ^ (n - ↑k) * (2 * ↑↑k + 1) / (↑n + 1)

Lean proof

/-- Every entry in the nonzero degree block has an explicit rational formula,
including its sign in the reflected Volterra normalization. -/
theorem proriolExtensionCoefficients_shiftedJacobi_same_degree (n : ℕ) (k : Fin (n+1)) :
    proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
      (natDegree_shiftedJacobi_le 1 0 n) ⟨n, k⟩ =
      (-1 : ℝ)^(n-k.1)*(2*(k.1 : ℝ)+1)/((n : ℝ)+1) := by
  classical
  let c := proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
    (natDegree_shiftedJacobi_le 1 0 n)
  have he (y : ℝ) :
      (∑ i ∈ c.support, c i*((-1 : ℝ)^(i.1-i.2.1)*(shiftedJacobi 0 0 i.2.1).eval y)) =
        (shiftedJacobi 1 0 n).eval y := by
    have h := eval_proriolVolterraSynthesis_extension n (shiftedJacobi 1 0 n)
      (natDegree_shiftedJacobi_le 1 0 n) 0 y
    change eval (![0,y] : Fin 2 → ℝ) (proriolVolterraSynthesis c) = _ at h
    simpa only [proriolVolterraSynthesis, Finsupp.linearCombination_apply, Finsupp.sum,
      map_sum, smul_eval, smul_eq_mul, eval_triangleReflect, sub_zero,
      eval_proriol_outer_one] using h
  have hi := congrArg (fun f : ℝ → ℝ ↦ ∫ y in (0 : ℝ)..1, f y*(shiftedJacobi 0 0 k.1).eval y)
    (funext he)
  simp_rw [Finset.sum_mul] at hi
  rw [intervalIntegral.integral_finsetSum] at hi
  · simp_rw [mul_assoc, intervalIntegral.integral_const_mul,
      integral_mul_shiftedJacobi_zero_zero] at hi
    rw [integral_shiftedJacobi_one_zero_mul_zero_zero n k.1 (by omega)] at hi
    have hs : (∑ i ∈ c.support, c i*((-1 : ℝ)^(i.1-i.2.1)*
        (if i.2.1 = k.1 then 1/(2*(k.1 : ℝ)+1) else 0))) =
        c ⟨n,k⟩*((-1 : ℝ)^(n-k.1)*(1/(2*(k.1 : ℝ)+1))) := by
      refine (Finset.sum_eq_single (s := c.support)
        (f := fun i : Σ m : ℕ, Fin (m+1) ↦ c i*((-1 : ℝ)^(i.1-i.2.1)*
          (if i.2.1 = k.1 then 1/(2*(k.1 : ℝ)+1) else 0))) ⟨n,k⟩ ?_ ?_).trans ?_
      · intro i him hne
        have hn : i.1 = n := by
          by_contra h
          exact (Finsupp.mem_support_iff.mp him)
            (proriolExtensionCoefficients_shiftedJacobi_eq_zero_of_degree_ne n i h)
        have hk : i.2.1 ≠ k.1 := by
          intro h
          apply hne
          exact Sigma.ext hn ((Fin.heq_ext_iff (congrArg (fun t : ℕ ↦ t+1) hn)).mpr h)
        simp [hk]
      · intro hn
        rw [Finsupp.notMem_support_iff.mp hn]
        simp
      · simp
    rw [hs] at hi
    have hs2 : (-1 : ℝ)^(n-k.1)*(-1 : ℝ)^(n-k.1) = 1 := by
      rw [← mul_pow]; norm_num
    change c ⟨n,k⟩ = _
    have hn : (n : ℝ)+1 ≠ 0 := by positivity
    have hk : 2*(k.1 : ℝ)+1 ≠ 0 := by positivity
    field_simp at hi ⊢
    linear_combination (-1 : ℝ)^(n-k.1)*hi-c ⟨n,k⟩*((n : ℝ)+1)*hs2
  · intro i _
    apply Continuous.intervalIntegrable
    fun_prop

theorem MvPolynomial.proriolExtensionCoefficients_shiftedJacobi_apply (n : ℕ) (i : (m : ℕ) × Fin (m + 1)) :
  (MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯) i =
    if i.fst = n then (-1) ^ (n - ↑i.snd) * (2 * ↑↑i.snd + 1) / (↑n + 1) else 0

Lean proof

/-- The entire extension column: all off-degree blocks vanish. -/
theorem proriolExtensionCoefficients_shiftedJacobi_apply (n : ℕ)
    (i : Σ m : ℕ, Fin (m+1)) :
    proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
      (natDegree_shiftedJacobi_le 1 0 n) i =
      if i.1 = n then (-1 : ℝ)^(n-i.2.1)*(2*(i.2.1 : ℝ)+1)/((n : ℝ)+1) else 0 := by
  classical
  by_cases hi : i.1 = n
  · obtain ⟨m,k⟩ := i
    dsimp only at hi
    subst m
    simpa only [ite_true] using proriolExtensionCoefficients_shiftedJacobi_same_degree n k
  · simp [hi, proriolExtensionCoefficients_shiftedJacobi_eq_zero_of_degree_ne n i hi]

Definition 6.1.13 Finite Volterra coefficient assembly

✓ 🤖

#

Let \(S\) be synthesis in the signed reflected Proriol basis \(Q_{n,k}\). For finite shifted Jacobi \((1,0)\) coefficients \(c\), set

\[ Ec=S^{-1}\! \left(\sum _n c_nP_n^{(1,0)}(2y-1)\right),\qquad M_Kb=S^{-1}\bigl(K(1-x,y)Sb\bigr),\qquad B_K=DM_KE, \]

where \(b\) is a finite triangular coefficient vector and \(D\) selects inner index zero. The \(n\)th column of \(E\) is the coordinate vector of \(P_n^{(1,0)}(2y-1)\). The endpoint factor and output reflection are kept outside \(B_K\). Reference: [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.proriolVolterraSynthesis_surjective : Function.Surjective ⇑MvPolynomial.proriolVolterraSynthesis

Lean proof

/-- Every polynomial has finite signed reflected Proriol coordinates. -/
theorem proriolVolterraSynthesis_surjective : Function.Surjective proriolVolterraSynthesis := by
  intro p
  let q := triangleReflect p
  let N := q.totalDegree
  let b := proriolDegreeBasis (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) N
  let v : restrictTotalDegree (Fin 2) ℝ N :=
    ⟨q, (mem_restrictTotalDegree (Fin 2) N q).mpr le_rfl⟩
  refine ⟨proriolVolterraCoordinateTransport N (b.repr v), ?_⟩
  rw [proriolVolterraSynthesis_transport]
  have h := congrArg (fun t : restrictTotalDegree (Fin 2) ℝ N ↦
    (t : MvPolynomial (Fin 2) ℝ)) (b.linearCombination_repr v)
  have hf : (fun d ↦ (b d : MvPolynomial (Fin 2) ℝ)) =
      (fun d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} ↦
        proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) := by
    funext d
    exact proriolDegreeBasis_apply _ _ _ N d
  change (↑((b.repr v).sum (fun i a ↦ a • b i)) : MvPolynomial (Fin 2) ℝ) = q at h
  simp only [Finsupp.sum, Submodule.coe_sum, Submodule.coe_smul] at h
  rw [← hf, Finsupp.linearCombination_apply]
  simp only [Finsupp.sum]
  rw [h]
  exact triangleReflect_involutive p

5 related Lean declarations

def MvPolynomial.proriolVolterraEquiv : ((n : ℕ) × Fin (n + 1) →₀ ℝ) ≃ₗ[ℝ] MvPolynomial (Fin 2) ℝ

Lean definition

/-- Coordinates for the existing signed reflected synthesis, with no cutoff choice. -/
def proriolVolterraEquiv : ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) ≃ₗ[ℝ]
    MvPolynomial (Fin 2) ℝ :=
  LinearEquiv.ofBijective proriolVolterraSynthesis
    ⟨proriolVolterraSynthesis_injective, proriolVolterraSynthesis_surjective⟩

def MvPolynomial.proriolExtensionMap : (ℕ →₀ ℝ) →ₗ[ℝ] (n : ℕ) × Fin (n + 1) →₀ ℝ

Lean definition

/-- Exact inner extension on finite shifted Jacobi input coefficients. -/
def proriolExtensionMap : (ℕ →₀ ℝ) →ₗ[ℝ] ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) :=
  proriolVolterraEquiv.symm.toLinearMap.comp
    (triangleExtendY.toLinearMap.comp (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)))

theorem MvPolynomial.proriolExtensionMap_single (n : ℕ) :
  MvPolynomial.proriolExtensionMap (Finsupp.single n 1) =
    MvPolynomial.proriolExtensionCoefficients n (Polynomial.shiftedJacobi 1 0 n) ⋯

Lean proof

/-- Each extension column is the already established finite coordinate vector. -/
theorem proriolExtensionMap_single (n : ℕ) :
    proriolExtensionMap (Finsupp.single n 1) =
      proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
        (natDegree_shiftedJacobi_le 1 0 n) := by
  apply proriolVolterraEquiv.injective
  change proriolVolterraEquiv (proriolVolterraEquiv.symm _) = _
  rw [proriolVolterraEquiv.apply_symm_apply]
  change triangleExtendY (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
    (Finsupp.single n 1)) = proriolVolterraSynthesis _
  simpa using (proriolVolterraSynthesis_extension n (shiftedJacobi 1 0 n)
    (natDegree_shiftedJacobi_le 1 0 n)).symm

def MvPolynomial.proriolKernelMap : MvPolynomial (Fin 2) ℝ →ₐ[ℝ] Module.End ℝ ((n : ℕ) × Fin (n + 1) →₀ ℝ)

Lean definition

/-- Reflected kernel multiplication as an algebra homomorphism on finite coordinates. -/
def proriolKernelMap : MvPolynomial (Fin 2) ℝ →ₐ[ℝ]
    Module.End ℝ ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) :=
  (proriolVolterraEquiv.symm.conjAlgEquiv ℝ).toAlgHom.comp
    ((Algebra.lmul ℝ (MvPolynomial (Fin 2) ℝ)).comp triangleReflect)

def MvPolynomial.volterraProriolCoefficients (K : MvPolynomial (Fin 2) ℝ) : (ℕ →₀ ℝ) →ₗ[ℝ] ℕ →₀ ℝ

Lean definition

/-- The core coefficient operator: extension, kernel multiplication, then marginal. -/
def volterraProriolCoefficients (K : MvPolynomial (Fin 2) ℝ) :
    (ℕ →₀ ℝ) →ₗ[ℝ] (ℕ →₀ ℝ) :=
  proriolMarginalCoefficients.comp ((proriolKernelMap K).comp proriolExtensionMap)

Theorem 6.1.14 Algebraic properties of Volterra coefficient assembly

✓ 🤖

#

Synthesis \(S\) is a linear equivalence between finitely supported triangular coefficients and bivariate polynomials. The kernel map \(K\mapsto M_K\) is an algebra homomorphism on finitely supported vectors.

Lean Formalisation

theorem MvPolynomial.proriolVolterraSynthesis_surjective : Function.Surjective ⇑MvPolynomial.proriolVolterraSynthesis

Lean proof

/-- Every polynomial has finite signed reflected Proriol coordinates. -/
theorem proriolVolterraSynthesis_surjective : Function.Surjective proriolVolterraSynthesis := by
  intro p
  let q := triangleReflect p
  let N := q.totalDegree
  let b := proriolDegreeBasis (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) N
  let v : restrictTotalDegree (Fin 2) ℝ N :=
    ⟨q, (mem_restrictTotalDegree (Fin 2) N q).mpr le_rfl⟩
  refine ⟨proriolVolterraCoordinateTransport N (b.repr v), ?_⟩
  rw [proriolVolterraSynthesis_transport]
  have h := congrArg (fun t : restrictTotalDegree (Fin 2) ℝ N ↦
    (t : MvPolynomial (Fin 2) ℝ)) (b.linearCombination_repr v)
  have hf : (fun d ↦ (b d : MvPolynomial (Fin 2) ℝ)) =
      (fun d : {d : Fin 2 →₀ ℕ // d.sum (fun _ e ↦ e) ≤ N} ↦
        proriol 0 0 0 (d.1 0+d.1 1) (d.1 1)) := by
    funext d
    exact proriolDegreeBasis_apply _ _ _ N d
  change (↑((b.repr v).sum (fun i a ↦ a • b i)) : MvPolynomial (Fin 2) ℝ) = q at h
  simp only [Finsupp.sum, Submodule.coe_sum, Submodule.coe_smul] at h
  rw [← hf, Finsupp.linearCombination_apply]
  simp only [Finsupp.sum]
  rw [h]
  exact triangleReflect_involutive p

2 related Lean declarations

def MvPolynomial.proriolVolterraEquiv : ((n : ℕ) × Fin (n + 1) →₀ ℝ) ≃ₗ[ℝ] MvPolynomial (Fin 2) ℝ

Lean definition

/-- Coordinates for the existing signed reflected synthesis, with no cutoff choice. -/
def proriolVolterraEquiv : ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) ≃ₗ[ℝ]
    MvPolynomial (Fin 2) ℝ :=
  LinearEquiv.ofBijective proriolVolterraSynthesis
    ⟨proriolVolterraSynthesis_injective, proriolVolterraSynthesis_surjective⟩

def MvPolynomial.proriolKernelMap : MvPolynomial (Fin 2) ℝ →ₐ[ℝ] Module.End ℝ ((n : ℕ) × Fin (n + 1) →₀ ℝ)

Lean definition

/-- Reflected kernel multiplication as an algebra homomorphism on finite coordinates. -/
def proriolKernelMap : MvPolynomial (Fin 2) ℝ →ₐ[ℝ]
    Module.End ℝ ((Σ n : ℕ, Fin (n+1)) →₀ ℝ) :=
  (proriolVolterraEquiv.symm.conjAlgEquiv ℝ).toAlgHom.comp
    ((Algebra.lmul ℝ (MvPolynomial (Fin 2) ℝ)).comp triangleReflect)

Reference details: Exact finite Volterra coefficient action

Theorem 6.1.15 Exact finite Volterra coefficient action

✓ 🤖

#

For every real bivariate polynomial kernel \(K\), finite coefficient vector \(c\), and real \(x\), writing \(u(y)=\sum _n c_nP_n^{(1,0)}(2y-1)\),

\[ x\sum _m(B_Kc)_m P_m^{(1,0)}(1-2x)=\int _0^x K(x,y)u(y)\, dy. \]

The integral is oriented when \(x{\lt}0\). Kernel multiplication reconstructs exactly \(K(1-x,y)Sc\). For \(K=1\), \(B_K\) is the existing diagonal with entries \((-1)^n/(n+1)\), including degree zero. Reference: [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.proriolVolterraSynthesis_kernelMap (K : MvPolynomial (Fin 2) ℝ) (c : (n : ℕ) × Fin (n + 1) →₀ ℝ) :
  MvPolynomial.proriolVolterraSynthesis ((MvPolynomial.proriolKernelMap K) c) =
    MvPolynomial.triangleReflect K * MvPolynomial.proriolVolterraSynthesis c

Lean proof

/-- Kernel multiplication reconstructs the reflected polynomial product exactly. -/
theorem proriolVolterraSynthesis_kernelMap (K : MvPolynomial (Fin 2) ℝ)
    (c : (Σ n : ℕ, Fin (n+1)) →₀ ℝ) :
    proriolVolterraSynthesis (proriolKernelMap K c) =
      triangleReflect K * proriolVolterraSynthesis c := by
  change proriolVolterraEquiv (proriolVolterraEquiv.symm _) = _
  exact proriolVolterraEquiv.apply_symm_apply _

2 related Lean declarations

theorem MvPolynomial.volterraProriolCoefficients_exact (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) (x : ℝ) :
  x *
      Polynomial.eval (1 - x)
        ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) (K.volterraProriolCoefficients c)) =
    ∫ (y : ℝ) in 0..x,
      (MvPolynomial.eval ![x, y]) K * Polynomial.eval y ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) c)

Lean proof

/-- The endpoint factor and output reflection are retained explicitly. -/
theorem volterraProriolCoefficients_exact (K : MvPolynomial (Fin 2) ℝ)
    (c : ℕ →₀ ℝ) (x : ℝ) :
    x * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
      (volterraProriolCoefficients K c)).eval (1-x) =
      ∫ y in (0 : ℝ)..x, eval (![x,y] : Fin 2 → ℝ) K *
        (Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c).eval y := by
  have h := eval_proriolMarginalPolynomial (proriolKernelMap K (proriolExtensionMap c)) (1-x)
  rw [proriolVolterraSynthesis_kernelMap] at h
  have he : proriolVolterraSynthesis (proriolExtensionMap c) =
      triangleExtendY (Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c) :=
    proriolVolterraEquiv.apply_symm_apply _
  rw [he] at h
  change _ = volterraPolynomial K _ x at h
  rw [volterraPolynomial_apply] at h
  simpa [proriolMarginalPolynomial, volterraProriolCoefficients] using h

theorem MvPolynomial.volterraProriolCoefficients_one :
  MvPolynomial.volterraProriolCoefficients 1 = MvPolynomial.volterraJacobiDiagonal

Lean proof

/-- Constant-kernel assembly recovers the established Jacobi diagonal exactly. -/
theorem volterraProriolCoefficients_one :
    volterraProriolCoefficients 1 = volterraJacobiDiagonal := by
  apply LinearMap.ext
  intro c
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd => simp [hc, hd]
  | single n a =>
    have hs : Finsupp.single n a = a • Finsupp.single n (1 : ℝ) := by simp
    rw [hs, map_smul, map_smul]
    congr 1
    simp only [volterraProriolCoefficients, LinearMap.comp_apply, map_one,
      Module.End.one_apply, proriolExtensionMap_single,
      proriolMarginalCoefficients_extension_shiftedJacobi,
      volterraJacobiDiagonal_single, one_mul]

Theorem 6.1.16 Volterra bandwidth and exact rectangular sections

✓ 🤖

#

Let \(d=\operatorname {totalDegree}K\), with \(d=0\) for the zero kernel. The degree blocks of \(M_K\) vanish when \(|m-n|{\gt}d\), and the core Volterra matrix satisfies \((B_K)_{mn}=0\) under the same condition. These bounds precede the explicit endpoint factor and reflection. Inputs supported in \(0\le n{\lt}N\) produce coefficients supported in \(0\le m{\lt}N+d\). The corresponding \((N+d)\times N\) section has exactly the full operator’s action on the retained rows and loses no output coefficients. Reference: [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.triangleReflect_proriolVolterraSynthesis_single (i : (n : ℕ) × Fin (n + 1)) (a : ℝ) :
  MvPolynomial.triangleReflect (MvPolynomial.proriolVolterraSynthesis (Finsupp.single i a)) =
    (a * (-1) ^ (i.fst - ↑i.snd)) • MvPolynomial.proriol 0 0 0 i.fst ↑i.snd

Lean proof

/-- Reflection removes the simplex coordinate change from each synthesis column. -/
theorem triangleReflect_proriolVolterraSynthesis_single
    (i : Σ n : ℕ, Fin (n+1)) (a : ℝ) :
    triangleReflect (proriolVolterraSynthesis (Finsupp.single i a)) =
      (a * (-1 : ℝ)^(i.1-i.2.val)) • proriol 0 0 0 i.1 i.2 := by
  simp only [proriolVolterraSynthesis, Finsupp.linearCombination_single, map_smul,
    smul_smul]
  rw [triangleReflect_involutive]

7 related Lean declarations

theorem MvPolynomial.integralInner_reflect_proriolVolterraSynthesis (c : (n : ℕ) × Fin (n + 1) →₀ ℝ)
  (i : (n : ℕ) × Fin (n + 1)) :
  MvPolynomial.integralInner (MvPolynomial.proriolMeasure 0 0 0)
      (MvPolynomial.IntegrablePair.of (MvPolynomial.proriolMeasure 0 0 0)
        (MvPolynomial.triangleReflect (MvPolynomial.proriolVolterraSynthesis c))
        (MvPolynomial.proriol 0 0 0 i.fst ↑i.snd) ⋯) =
    c i * (-1) ^ (i.fst - ↑i.snd) *
      MvPolynomial.integralInner (MvPolynomial.proriolMeasure 0 0 0)
        (MvPolynomial.IntegrablePair.of (MvPolynomial.proriolMeasure 0 0 0) (MvPolynomial.proriol 0 0 0 i.fst ↑i.snd)
          (MvPolynomial.proriol 0 0 0 i.fst ↑i.snd) ⋯)

Lean proof

/-- Orthogonality extracts one signed reflected coefficient. -/
theorem integralInner_reflect_proriolVolterraSynthesis
    (c : (Σ n : ℕ, Fin (n+1)) →₀ ℝ) (i : Σ n : ℕ, Fin (n+1)) :
    integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (triangleReflect (proriolVolterraSynthesis c)) (proriol 0 0 0 i.1 i.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) =
      c i * (-1 : ℝ)^(i.1-i.2.val) *
        integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (proriol 0 0 0 i.1 i.2) (proriol 0 0 0 i.1 i.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp [integralInner]
  | add c d hc hd =>
    simp only [map_add, Finsupp.add_apply,
      integralInner_add_left (hasFiniteMoments_proriolMeasure (α := 0) (β := 0) (γ := 0) (by norm_num) (by norm_num) (by norm_num)),
      hc, hd, add_mul]
  | single j a =>
    simp only [triangleReflect_proriolVolterraSynthesis_single]
    rw [integralInner_smul_left (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)]
    by_cases h : j = i
    · subst j
      simp
    · have hne : (j.1,j.2.val) ≠ (i.1,i.2.val) := by
        intro he
        apply h
        exact Sigma.ext (congrArg Prod.fst he)
          ((Fin.heq_ext_iff (congrArg (fun n : ℕ ↦ n+1) (congrArg Prod.fst he))).mpr
            (congrArg Prod.snd he))
      rw [integralInner_proriolMeasure_eq_zero (by norm_num) (by norm_num) (by norm_num)
        (by omega) (by omega) hne, mul_zero, Finsupp.single_eq_of_ne (Ne.symm h)]
      simp

theorem MvPolynomial.proriolKernelMap_entry_eq_zero (K : MvPolynomial (Fin 2) ℝ) (i j : (n : ℕ) × Fin (n + 1))
  (hgap : j.fst + K.totalDegree < i.fst ∨ i.fst + K.totalDegree < j.fst) :
  ((MvPolynomial.proriolKernelMap K) (Finsupp.single j 1)) i = 0

Lean proof

/-- Multiplication by an arbitrary polynomial has total-degree block bandwidth
bounded by its total degree; no finite-section product is used. -/
theorem proriolKernelMap_entry_eq_zero (K : MvPolynomial (Fin 2) ℝ)
    (i j : Σ n : ℕ, Fin (n+1))
    (hgap : j.1 + K.totalDegree < i.1 ∨ i.1 + K.totalDegree < j.1) :
    proriolKernelMap K (Finsupp.single j 1) i = 0 := by
  have h := integralInner_reflect_proriolVolterraSynthesis
    (proriolKernelMap K (Finsupp.single j 1)) i
  simp only [proriolVolterraSynthesis_kernelMap, map_mul,
    triangleReflect_proriolVolterraSynthesis_single, one_mul, mul_smul_comm] at h
  rw [integralInner_smul_left (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)] at h
  have hz : integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (K * proriol 0 0 0 j.1 j.2) (proriol 0 0 0 i.1 i.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) = 0 := by
    rcases hgap with hgap | hgap
    · apply integralInner_proriolMeasure_eq_zero_of_totalDegree_lt
        (by norm_num) (by norm_num) (by norm_num) _ (by omega)
      exact (totalDegree_mul _ _).trans_lt
        ((Nat.add_le_add_left (totalDegree_proriol_le 0 0 0 (by omega)) _).trans_lt
          (by omega))
    · have he : integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (K * proriol 0 0 0 j.1 j.2) (proriol 0 0 0 i.1 i.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) =
        integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (K * proriol 0 0 0 i.1 i.2) (proriol 0 0 0 j.1 j.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) := by
        unfold integralInner
        congr 1
        funext x
        simp only [map_mul]
        ring
      rw [he]
      apply integralInner_proriolMeasure_eq_zero_of_totalDegree_lt
        (by norm_num) (by norm_num) (by norm_num) _ (by omega)
      exact (totalDegree_mul _ _).trans_lt
        ((Nat.add_le_add_left (totalDegree_proriol_le 0 0 0 (by omega)) _).trans_lt
          (by omega))
  have href := triangleReflect_involutive K
  dsimp only [integralInner, IntegrablePair.of] at h hz
  rw [href, hz, mul_zero] at h
  have hn : integralInner (proriolMeasure 0 0 0) (IntegrablePair.of (proriolMeasure 0 0 0) (proriol 0 0 0 i.1 i.2) (proriol 0 0 0 i.1 i.2) (h := (hasFiniteMoments_proriolMeasure (by norm_num) (by norm_num) (by norm_num)).integrable_mul _ _)) ≠ 0 := by
    rw [integralInner_self]
    exact (integral_sq_proriolMeasure_pos (by norm_num) (by norm_num) (by norm_num) _ _).ne'
  exact (mul_eq_zero.mp (mul_eq_zero.mp h.symm |>.resolve_right hn)).resolve_right
    (pow_ne_zero _ (by norm_num))

theorem MvPolynomial.volterraProriolCoefficients_entry_eq_zero (K : MvPolynomial (Fin 2) ℝ) (m n : ℕ)
  (hgap : n + K.totalDegree < m ∨ m + K.totalDegree < n) : (K.volterraProriolCoefficients (Finsupp.single n 1)) m = 0

Lean proof

/-- A degree-d polynomial kernel gives bandwidth (d,d) before the explicit
endpoint factor and output reflection. -/
theorem volterraProriolCoefficients_entry_eq_zero (K : MvPolynomial (Fin 2) ℝ)
    (m n : ℕ) (hgap : n + K.totalDegree < m ∨ m + K.totalDegree < n) :
    volterraProriolCoefficients K (Finsupp.single n 1) m = 0 := by
  classical
  rw [volterraProriolCoefficients, LinearMap.comp_apply, LinearMap.comp_apply,
    proriolMarginalCoefficients_apply, proriolExtensionMap_single]
  let c := proriolExtensionCoefficients n (shiftedJacobi 1 0 n)
    (natDegree_shiftedJacobi_le 1 0 n)
  change proriolKernelMap K c ⟨m,0⟩ = 0
  conv_lhs => rw [← Finsupp.sum_single c]
  simp only [Finsupp.sum, map_sum, Finsupp.finsetSum_apply]
  apply Finset.sum_eq_zero
  intro i hi
  have hn : i.1 = n := by
    by_contra h
    exact (Finsupp.mem_support_iff.mp hi)
      (proriolExtensionCoefficients_shiftedJacobi_eq_zero_of_degree_ne n i h)
  have hz := proriolKernelMap_entry_eq_zero K ⟨m,0⟩ i (by simpa [hn] using hgap)
  have hs : Finsupp.single i (c i) = (c i) • Finsupp.single i (1 : ℝ) := by simp
  rw [hs, map_smul, Finsupp.smul_apply, hz, smul_zero]

def MvPolynomial.volterraProriolSection (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) : Matrix (Fin (N + K.totalDegree)) (Fin N) ℝ

Lean definition

/-- Exact rectangular section: N input modes require at most N+d output modes
before the explicit endpoint factor. -/
def volterraProriolSection (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) :
    Matrix (Fin (N + K.totalDegree)) (Fin N) ℝ :=
  fun i j ↦ volterraProriolCoefficients K (Finsupp.single j.val 1) i.val

theorem MvPolynomial.volterraProriolSection_eq_zero (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) (i : Fin (N + K.totalDegree))
  (j : Fin N) (hgap : ↑j + K.totalDegree < ↑i ∨ ↑i + K.totalDegree < ↑j) : K.volterraProriolSection N i j = 0

Lean proof

/-- The finite section inherits the same two-sided bandwidth. -/
theorem volterraProriolSection_eq_zero (K : MvPolynomial (Fin 2) ℝ) (N : ℕ)
    (i : Fin (N + K.totalDegree)) (j : Fin N)
    (hgap : j.val + K.totalDegree < i.val ∨ i.val + K.totalDegree < j.val) :
    volterraProriolSection K N i j = 0 :=
  volterraProriolCoefficients_entry_eq_zero K i.val j.val hgap

theorem MvPolynomial.volterraProriolSection_mulVec (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) (v : Fin N → ℝ)
  (i : Fin (N + K.totalDegree)) :
  (K.volterraProriolSection N).mulVec v i = (K.volterraProriolCoefficients (∑ j, Finsupp.single (↑j) (v j))) ↑i

Lean proof

/-- Matrix-vector multiplication in the rectangular section agrees with the
full finite-support operator at every retained row. -/
theorem volterraProriolSection_mulVec (K : MvPolynomial (Fin 2) ℝ) (N : ℕ)
    (v : Fin N → ℝ) (i : Fin (N + K.totalDegree)) :
    (volterraProriolSection K N).mulVec v i =
      volterraProriolCoefficients K (∑ j : Fin N, Finsupp.single j.val (v j)) i.val := by
  classical
  simp only [Matrix.mulVec, dotProduct, map_sum, Finsupp.finsetSum_apply]
  apply Finset.sum_congr rfl
  intro j _
  rw [show Finsupp.single j.val (v j) = (v j) • Finsupp.single j.val (1 : ℝ) by simp,
    map_smul, Finsupp.smul_apply]
  simp only [volterraProriolSection, smul_eq_mul, mul_comm]

theorem MvPolynomial.volterraProriolCoefficients_cutoff (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) (c : ℕ →₀ ℝ)
  (hc : ∀ n ∈ c.support, n < N) (m : ℕ) (hm : N + K.totalDegree ≤ m) : (K.volterraProriolCoefficients c) m = 0

Lean proof

/-- No rows are lost by the rectangular cutoff for inputs supported below N. -/
theorem volterraProriolCoefficients_cutoff (K : MvPolynomial (Fin 2) ℝ)
    (N : ℕ) (c : ℕ →₀ ℝ) (hc : ∀ n ∈ c.support, n < N)
    (m : ℕ) (hm : N + K.totalDegree ≤ m) :
    volterraProriolCoefficients K c m = 0 := by
  classical
  conv_lhs => rw [← Finsupp.sum_single c]
  simp only [Finsupp.sum, map_sum, Finsupp.finsetSum_apply]
  apply Finset.sum_eq_zero
  intro n hn
  have hz := volterraProriolCoefficients_entry_eq_zero K m n (Or.inl (by
    have := hc n hn
    omega))
  have hs : Finsupp.single n (c n) = (c n) • Finsupp.single n (1 : ℝ) := by simp
  rw [hs, map_smul, Finsupp.smul_apply, hz, smul_zero]

No same-size truncation of intermediate multiplication operators is asserted.

Theorem 6.1.17 Operator Clenshaw for polynomial Volterra kernels

✓ 🤖

#

For \(p\in \mathbb {R}[t]\), polynomial functional calculus obeys \(M_{p(K)}=p(M_K)\), and the two coordinate operators commute. Suppose bivariate polynomials satisfy \(p_{k+2}=a_kp_{k+1}+b_kp_k\). Applying the backward Clenshaw recurrence to \(M_{a_k},M_{b_k},M_{c_k}\) with initial operators \(M_{p_0},M_{p_1}\) computes \(M_{\sum _{k{\lt}N}c_kp_k}\) exactly. Placing it between \(E\) and \(D\) gives \(B_{\sum _{k{\lt}N}c_kp_k}\). This permits polynomial-valued coefficients and nested coordinate expansions. The identity is on finitely supported vectors; no floating-point stability or finite-section recurrence is claimed. References: [Cle55]; [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.proriolKernelMap_aeval (K : MvPolynomial (Fin 2) ℝ) (p : Polynomial ℝ) :
  MvPolynomial.proriolKernelMap ((Polynomial.aeval K) p) = (Polynomial.aeval (MvPolynomial.proriolKernelMap K)) p

Lean proof

/-- Polynomial functional calculus commutes with the kernel operator map.
In particular this applies to either coordinate and to nested kernel expansions. -/
theorem proriolKernelMap_aeval (K : MvPolynomial (Fin 2) ℝ) (p : ℝ[X]) :
    proriolKernelMap (Polynomial.aeval K p) =
      Polynomial.aeval (proriolKernelMap K) p := by
  exact (Polynomial.aeval_algHom_apply proriolKernelMap K p).symm

3 related Lean declarations

theorem MvPolynomial.proriolKernelMap_X_commute (i j : Fin 2) :
  Commute (MvPolynomial.proriolKernelMap (MvPolynomial.X i)) (MvPolynomial.proriolKernelMap (MvPolynomial.X j))

Lean proof

/-- Coordinate operators commute on all finitely supported Proriol vectors. -/
theorem proriolKernelMap_X_commute (i j : Fin 2) :
    Commute (proriolKernelMap (X i)) (proriolKernelMap (X j)) := by
  show proriolKernelMap (X i) * proriolKernelMap (X j) = _
  rw [← map_mul, ← map_mul, mul_comm]

theorem MvPolynomial.proriolKernelMap_clenshaw (a b c p : ℕ → MvPolynomial (Fin 2) ℝ)
  (hp : ∀ (k : ℕ), p (k + 2) = a k * p (k + 1) + b k * p k) (N : ℕ) :
  Polynomial.clenshaw (fun k => MvPolynomial.proriolKernelMap (a k)) (fun k => MvPolynomial.proriolKernelMap (b k))
      (fun k => MvPolynomial.proriolKernelMap (c k)) (MvPolynomial.proriolKernelMap (p 0))
      (MvPolynomial.proriolKernelMap (p 1)) N =
    MvPolynomial.proriolKernelMap (∑ k ∈ Finset.range N, c k * p k)

Lean proof

/-- A polynomial-valued backward recurrence evaluates its kernel multiplication
operator exactly. Coefficients may themselves be bivariate polynomials. -/
theorem proriolKernelMap_clenshaw (a b c p : ℕ → MvPolynomial (Fin 2) ℝ)
    (hp : ∀ k, p (k+2) = a k * p (k+1) + b k * p k) (N : ℕ) :
    Polynomial.clenshaw (fun k ↦ proriolKernelMap (a k))
      (fun k ↦ proriolKernelMap (b k)) (fun k ↦ proriolKernelMap (c k))
      (proriolKernelMap (p 0)) (proriolKernelMap (p 1)) N =
      proriolKernelMap (∑ k ∈ Finset.range N, c k * p k) := by
  have h := Polynomial.clenshaw_map
    (S := Module.End ℝ ((Σ n : ℕ, Fin (n+1)) →₀ ℝ)) proriolKernelMap.toRingHom a b c (p 0) (p 1) N
  rw [Polynomial.clenshaw_eq_sum a b c p hp N] at h
  exact h

theorem MvPolynomial.volterraProriolCoefficients_clenshaw (a b c p : ℕ → MvPolynomial (Fin 2) ℝ)
  (hp : ∀ (k : ℕ), p (k + 2) = a k * p (k + 1) + b k * p k) (N : ℕ) :
  MvPolynomial.proriolMarginalCoefficients ∘ₗ
      Polynomial.clenshaw (fun k => MvPolynomial.proriolKernelMap (a k)) (fun k => MvPolynomial.proriolKernelMap (b k))
          (fun k => MvPolynomial.proriolKernelMap (c k)) (MvPolynomial.proriolKernelMap (p 0))
          (MvPolynomial.proriolKernelMap (p 1)) N ∘ₗ
        MvPolynomial.proriolExtensionMap =
    (∑ k ∈ Finset.range N, c k * p k).volterraProriolCoefficients

Lean proof

/-- Inserting operator Clenshaw between extension and marginal gives the exact
finite Volterra coefficient map for the polynomial kernel expansion. -/
theorem volterraProriolCoefficients_clenshaw (a b c p : ℕ → MvPolynomial (Fin 2) ℝ)
    (hp : ∀ k, p (k+2) = a k * p (k+1) + b k * p k) (N : ℕ) :
    proriolMarginalCoefficients.comp
      ((Polynomial.clenshaw (fun k ↦ proriolKernelMap (a k))
        (fun k ↦ proriolKernelMap (b k)) (fun k ↦ proriolKernelMap (c k))
        (proriolKernelMap (p 0)) (proriolKernelMap (p 1)) N).comp proriolExtensionMap) =
      volterraProriolCoefficients (∑ k ∈ Finset.range N, c k * p k) := by
  rw [proriolKernelMap_clenshaw a b c p hp]
  rfl

Definition 6.1.18 The physical Volterra triangle

✓ 🤖

#

The physical Volterra triangle is \(\Delta =\{ (x,y)\in \mathbb R^2:0\le y\le x\le 1\} \).

Lean Formalisation

def Real.volterraTriangle : Set (Fin 2 → ℝ)

Lean definition

/-- The physical triangle for Volterra integration on the unit interval. -/
def volterraTriangle : Set (Fin 2 → ℝ) :=
  {z | z 0 ∈ Icc 0 1 ∧ z 1 ∈ Icc 0 (z 0)}

Formal details: Integrable Volterra row pairs and related results

Definition 6.1.19 Integrable Volterra row pairs

✓ 🤖

#

For \(x\in \mathbb R\), put \(J_x=(\min (0,x),\max (0,x))\). A Volterra input at \(x\) consists of two real-valued functions \(k,f\) on \(J_x\) whose product is Lebesgue integrable there. Neither factor is required to be separately integrable, and no endpoint values are part of the input.

Lean Formalisation

inductive Real.VolterraIntegralInput (x : ℝ) : Type

Lean definition

/-- A pair of classical rows with an integrable product on the open integration interval. -/
structure VolterraIntegralInput (x : ℝ) where
  kernel : Ioo (min 0 x) (max 0 x) → ℝ
  input : Ioo (min 0 x) (max 0 x) → ℝ
  integrable : Integrable (fun y ↦ kernel y * input y)
    ((volume : Measure ℝ).comap Subtype.val)

Theorem 6.1.20 Constructing integrable Volterra rows

✓ 🤖

#

Let \(J_x=(\min (0,x),\max (0,x))\). If \(y\mapsto K(x,y)f(y)\) is integrable between \(0\) and \(x\), its restrictions to \(J_x\) define an integrable Volterra row. The product is integrable in each of the following cases:

\(K\) is continuous on \(\Delta \), \(f\) is continuous on \([0,1]\), and \(x\in [0,1]\);
\(K\) is a polynomial kernel, \(f\) is locally integrable on \(\mathbb {R}\), and \(x\in \mathbb {R}\);
\(K\) is continuous on \(\Delta \), \(x\in [0,1]\), and \(f\) is integrable on \([0,x]\);
\(K\) is a polynomial kernel, \(f\) is integrable on \([0,b]\), and \(x\in [0,b]\);
the slice \(K(x,\cdot )\) is absolutely continuous between \(0\) and \(x\), and \(f\) is integrable on that interval.

Lean Formalisation

theorem Real.intervalIntegrable_volterra {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (hf : ContinuousOn f (Set.Icc 0 1)) {x : ℝ} (hx : x ∈ Set.Icc 0 1) :
  IntervalIntegrable (fun y => K ![x, y] * f y) MeasureTheory.volume 0 x

Lean proof

/-- Continuous triangle kernels and continuous inputs give integrable slices. -/
theorem intervalIntegrable_volterra {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hf : ContinuousOn f (Icc 0 1))
    {x : ℝ} (hx : x ∈ Icc 0 1) :
    IntervalIntegrable (fun y ↦ K ![x,y] * f y) volume 0 x := by
  apply ContinuousOn.intervalIntegrable_of_Icc (by exact hx.1)
  apply ContinuousOn.mul
  · apply hK.comp (by fun_prop : ContinuousOn (fun y : ℝ ↦ ![x,y]) (Icc 0 x))
    intro y hy
    exact ⟨hx, hy⟩
  · exact hf.mono (Icc_subset_Icc le_rfl hx.2)

12 related Lean declarations

def Real.VolterraIntegralInput.ofKernel (K : (Fin 2 → ℝ) → ℝ) (f : ℝ → ℝ) {x : ℝ}
  (h : IntervalIntegrable (fun y => K ![x, y] * f y) MeasureTheory.volume 0 x) : x.VolterraIntegralInput

Lean definition

/-- Restriction of a globally given row whose oriented integral exists. -/
def VolterraIntegralInput.ofKernel (K : (Fin 2 → ℝ) → ℝ) (f : ℝ → ℝ)
    {x : ℝ} (h : IntervalIntegrable (fun y ↦ K ![x,y] * f y) volume 0 x) :
    VolterraIntegralInput x where
  kernel y := K ![x,(y : ℝ)]
  input y := f y
  integrable := by
    have hi := intervalIntegrable_iff.mp h
    rw [uIoc, integrableOn_Ioc_iff_integrableOn_Ioo] at hi
    exact (integrableOn_iff_comap_subtypeVal measurableSet_Ioo).mp hi

def Real.VolterraIntegralInput.ofContinuous {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (hf : ContinuousOn f (Set.Icc 0 1)) (x : ↑(Set.Icc 0 1)) : (↑x).VolterraIntegralInput

Lean definition

/-- Continuous triangle data supply each physical row pair. -/
def VolterraIntegralInput.ofContinuous
    {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hf : ContinuousOn f (Icc 0 1))
    (x : Icc (0 : ℝ) 1) : VolterraIntegralInput (x : ℝ) :=
  VolterraIntegralInput.ofKernel K f (intervalIntegrable_volterra hK hf x.property)

theorem MvPolynomial.intervalIntegrable_polynomialKernel_mul (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ}
  (hf : MeasureTheory.LocallyIntegrable f MeasureTheory.volume) (x a b : ℝ) :
  IntervalIntegrable (fun y => (MvPolynomial.eval ![x, y]) K * f y) MeasureTheory.volume a b

Lean proof

/-- Locally integrable inputs remain integrable after polynomial kernel multiplication. -/
theorem intervalIntegrable_polynomialKernel_mul (K : MvPolynomial (Fin 2) ℝ)
    {f : ℝ → ℝ} (hf : LocallyIntegrable f volume) (x a b : ℝ) :
    IntervalIntegrable (fun y ↦ eval (![x, y] : Fin 2 → ℝ) K * f y) volume a b := by
  have hi : IntervalIntegrable f volume a b := intervalIntegrable_iff.mpr
    ((hf.integrableOn_isCompact isCompact_uIcc).mono_set uIoc_subset_uIcc)
  exact hi.continuousOn_mul ((K.continuous_eval.comp (by fun_prop)).continuousOn)

def Real.VolterraIntegralInput.ofPolynomial (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ}
  (hf : MeasureTheory.LocallyIntegrable f MeasureTheory.volume) (x : ℝ) : x.VolterraIntegralInput

Lean definition

/-- Polynomial kernels and locally integrable inputs supply every oriented row.
Reference: Linz (1985), the first-kind differentiation identity. -/
def _root_.Real.VolterraIntegralInput.ofPolynomial
    (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ}
    (hf : LocallyIntegrable f volume) (x : ℝ) : Real.VolterraIntegralInput x :=
  .ofKernel (fun z ↦ eval z K) f (intervalIntegrable_polynomialKernel_mul K hf x 0 x)

theorem Real.intervalIntegrable_continuousVolterra_mul_row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {f : ℝ → ℝ} (x : ↑(Set.Icc 0 1)) (hf : IntervalIntegrable f MeasureTheory.volume 0 ↑x) :
  IntervalIntegrable (fun y => K ![↑x, y] * f y) MeasureTheory.volume 0 ↑x

Lean proof

/-- A continuous triangle kernel preserves integrability on an individual row. -/
theorem intervalIntegrable_continuousVolterra_mul_row
    {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K volterraTriangle)
    {f : ℝ → ℝ} (x : Icc (0 : ℝ) 1)
    (hf : IntervalIntegrable f volume 0 (x : ℝ)) :
    IntervalIntegrable (fun y ↦ K ![(x : ℝ),y]*f y) volume 0 (x : ℝ) := by
  apply hf.continuousOn_mul
  rw [uIcc_of_le x.property.1]
  exact hK.comp (by fun_prop) (fun y hy ↦ ⟨x.property, hy⟩)

def Real.VolterraIntegralInput.ofContinuousKernel {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {f : ℝ → ℝ} (x : ↑(Set.Icc 0 1)) (hf : IntervalIntegrable f MeasureTheory.volume 0 ↑x) : (↑x).VolterraIntegralInput

Lean definition

/-- Rowwise integrable inputs supply classical continuous-kernel Volterra data. -/
def VolterraIntegralInput.ofContinuousKernel
    {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K volterraTriangle)
    {f : ℝ → ℝ} (x : Icc (0 : ℝ) 1)
    (hf : IntervalIntegrable f volume 0 (x : ℝ)) : VolterraIntegralInput (x : ℝ) :=
  .ofKernel K f (intervalIntegrable_continuousVolterra_mul_row hK x hf)

theorem MvPolynomial.intervalIntegrable_polynomialKernel_mul_on (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ} {b : ℝ}
  (hf : MeasureTheory.IntegrableOn f (Set.Icc 0 b) MeasureTheory.volume) (x : ↑(Set.Icc 0 b)) :
  IntervalIntegrable (fun y => (MvPolynomial.eval ![↑x, y]) K * f y) MeasureTheory.volume 0 ↑x

Lean proof

/-- Polynomial multiplication preserves integrability on each subinterval. -/
theorem intervalIntegrable_polynomialKernel_mul_on (K : MvPolynomial (Fin 2) ℝ)
    {f : ℝ → ℝ} {b : ℝ} (hf : IntegrableOn f (Icc 0 b)) (x : Icc (0 : ℝ) b) :
    IntervalIntegrable (fun y ↦ eval ![(x : ℝ),y] K * f y) volume 0 (x : ℝ) := by
  have hi : IntervalIntegrable f volume 0 (x : ℝ) := by
    apply intervalIntegrable_iff.mpr
    rw [uIoc_of_le x.property.1]
    exact hf.mono_set (fun y hy ↦ ⟨hy.1.le, hy.2.trans x.property.2⟩)
  exact hi.continuousOn_mul ((K.continuous_eval.comp (by fun_prop)).continuousOn)

def Real.VolterraIntegralInput.ofIntegrableOnPolynomial (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ} {b : ℝ}
  (hf : MeasureTheory.IntegrableOn f (Set.Icc 0 b) MeasureTheory.volume) (x : ↑(Set.Icc 0 b)) :
  (↑x).VolterraIntegralInput

Lean definition

/-- Polynomial kernels with interval-integrable inputs supply every physical row. -/
def _root_.Real.VolterraIntegralInput.ofIntegrableOnPolynomial
    (K : MvPolynomial (Fin 2) ℝ) {f : ℝ → ℝ} {b : ℝ}
    (hf : IntegrableOn f (Icc 0 b)) (x : Icc (0 : ℝ) b) :
    Real.VolterraIntegralInput (x : ℝ) :=
  .ofKernel (fun z ↦ eval z K) f (intervalIntegrable_polynomialKernel_mul_on K hf x)

theorem Real.intervalIntegrable_locallyIntegrable (f : ℝ → ℝ) (hf : MeasureTheory.LocallyIntegrable f MeasureTheory.volume)
  (x : ℝ) : IntervalIntegrable f MeasureTheory.volume 0 x

Lean proof

/-- Local integrability supplies every finite oriented input interval. -/
theorem intervalIntegrable_locallyIntegrable (f : ℝ → ℝ)
    (hf : LocallyIntegrable f volume) (x : ℝ) : IntervalIntegrable f volume 0 x :=
  intervalIntegrable_iff.mpr
    ((hf.integrableOn_isCompact isCompact_uIcc).mono_set uIoc_subset_uIcc)

theorem Real.intervalIntegrable_of_integrableOn_Icc {f : ℝ → ℝ} {b x : ℝ}
  (hf : MeasureTheory.IntegrableOn f (Set.Icc 0 b) MeasureTheory.volume) (hx : x ∈ Set.Icc 0 b) :
  IntervalIntegrable f MeasureTheory.volume 0 x

Lean proof

/-- Interval integrability restricts to every initial subinterval. -/
theorem intervalIntegrable_of_integrableOn_Icc {f : ℝ → ℝ} {b x : ℝ}
    (hf : IntegrableOn f (Icc 0 b)) (hx : x ∈ Icc 0 b) :
    IntervalIntegrable f volume 0 x := by
  apply intervalIntegrable_iff.mpr
  rw [uIoc_of_le hx.1]
  exact hf.mono_set (fun y hy ↦ ⟨hy.1.le, hy.2.trans hx.2⟩)

theorem Real.intervalIntegrable_absolutelyContinuousKernel_mul {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} {x : ℝ}
  (hK : AbsolutelyContinuousOnInterval (fun y => K ![x, y]) 0 x) (hf : IntervalIntegrable f MeasureTheory.volume 0 x) :
  IntervalIntegrable (fun y => K ![x, y] * f y) MeasureTheory.volume 0 x

Lean proof

/-- Absolutely continuous kernel slices preserve input integrability. -/
theorem intervalIntegrable_absolutelyContinuousKernel_mul
    {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} {x : ℝ}
    (hK : AbsolutelyContinuousOnInterval (fun y ↦ K ![x,y]) 0 x)
    (hf : IntervalIntegrable f volume 0 x) :
    IntervalIntegrable (fun y ↦ K ![x,y]*f y) volume 0 x :=
  hf.continuousOn_mul hK.continuousOn

def Real.VolterraIntegralInput.ofAbsolutelyContinuous {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} {x : ℝ}
  (hK : AbsolutelyContinuousOnInterval (fun y => K ![x, y]) 0 x) (hf : IntervalIntegrable f MeasureTheory.volume 0 x) :
  x.VolterraIntegralInput

Lean definition

/-- Absolutely continuous slices and integrable inputs give classical row pairs. -/
def VolterraIntegralInput.ofAbsolutelyContinuous
    {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ} {x : ℝ}
    (hK : AbsolutelyContinuousOnInterval (fun y ↦ K ![x,y]) 0 x)
    (hf : IntervalIntegrable f volume 0 x) : VolterraIntegralInput x :=
  .ofKernel K f (intervalIntegrable_absolutelyContinuousKernel_mul hK hf)

Definition 6.1.21 Classical Volterra integration

✓ 🤖

#

For an integrable row pair \((k,f)\) at \(x\), define its oriented value by

\[ V(k,f;x)= \begin{cases} \displaystyle \int _{J_x} k(y)f(y)\, dy,& x\ge 0,\\ \displaystyle -\int _{J_x} k(y)f(y)\, dy,& x{\lt}0. \end{cases} \]

For the row \(k(y)=K(x,y)\) this is denoted \(V_Kf(x)\). The integral exists by the input’s product-integrability condition.

Lean Formalisation

def Real.volterraIntegral {x : ℝ} (d : x.VolterraIntegralInput) : ℝ

Lean definition

/-- The classical oriented integral of an integrable kernel-input row pair. -/
def volterraIntegral {x : ℝ} (d : VolterraIntegralInput x) : ℝ :=
  if 0 ≤ x then ∫ y, d.kernel y * d.input y ∂(volume : Measure ℝ).comap Subtype.val else -(∫ y, d.kernel y * d.input y ∂(volume : Measure ℝ).comap Subtype.val)

Reference details: Orientation and the zero-length row and related results

Theorem 6.1.22 Orientation and the zero-length row

✓ 🤖

#

For a row with \(K(x,\cdot )f\) integrable on \(J_x=(\min (0,x),\max (0,x))\),

\[ V_Kf(x)= \begin{cases} \displaystyle \int _{J_x}K(x,y)f(y)\, dy,& x\ge 0,\\ \displaystyle -\int _{J_x}K(x,y)f(y)\, dy,& x{\lt}0. \end{cases} \]

In particular \(V_Kf(0)=0\); no endpoint values of the factors are used.

Lean Formalisation

theorem Real.volterraIntegral_of_nonneg {x : ℝ} (hx : 0 ≤ x) (d : x.VolterraIntegralInput) :
  Real.volterraIntegral d =
    ∫ (y : { x_1 // x_1 ∈ Set.Ioo (min 0 x) (max 0 x) }),
      d.kernel y * d.input y ∂MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume

Lean proof

/-- Nonnegative endpoints give the integral over the open row interval. -/
theorem volterraIntegral_of_nonneg {x : ℝ} (hx : 0 ≤ x) (d : VolterraIntegralInput x) :
    volterraIntegral d =
      ∫ y, d.kernel y * d.input y ∂(volume : Measure ℝ).comap Subtype.val :=
  ite_eq_left hx

2 related Lean declarations

theorem Real.volterraIntegral_of_neg {x : ℝ} (hx : x < 0) (d : x.VolterraIntegralInput) :
  Real.volterraIntegral d =
    -∫ (y : { x_1 // x_1 ∈ Set.Ioo (min 0 x) (max 0 x) }),
        d.kernel y * d.input y ∂MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume

Lean proof

/-- Negative endpoints reverse orientation. -/
theorem volterraIntegral_of_neg {x : ℝ} (hx : x < 0) (d : VolterraIntegralInput x) :
    volterraIntegral d =
      -(∫ y, d.kernel y * d.input y ∂(volume : Measure ℝ).comap Subtype.val) :=
  ite_eq_right (not_le.mpr hx)

theorem Real.volterraIntegral_zero (d : Real.VolterraIntegralInput 0) : Real.volterraIntegral d = 0

Lean proof

/-- A zero-length row has value zero, without evaluating either factor. -/
theorem volterraIntegral_zero (d : VolterraIntegralInput 0) : volterraIntegral d = 0 := by
  have : IsEmpty (Ioo (min (0 : ℝ) 0) (max 0 0)) :=
    ⟨fun y ↦ (lt_irrefl (0 : ℝ)) (by
      simpa only [min_self, max_self] using lt_trans y.property.1 y.property.2)⟩
  rw [volterraIntegral_of_nonneg (le_refl 0)]
  exact integral_of_isEmpty

Theorem 6.1.23 Volterra kernel and input stability

✓ 🤖

#

Let \(K,L\) be continuous on \(\Delta \) and \(f,g\) continuous on \([0,1]\). Their Volterra integrands are integrable for each \(x\in [0,1]\). Suppose \(M,F,\delta ,\eta \ge 0\), with \(|K|\le M\), \(|f|\le F\), \(|L-K|\le \delta \) and \(|g-f|\le \eta \) on the respective domains. Then

\[ |V_Lg(x)-V_Kf(x)|\le x\bigl(\delta F+(M+\delta )\eta \bigr). \]

For continuous approximants \(L_n,g_n\) with such nonnegative uniform error bounds \(\delta _n,\eta _n\to 0\), the outputs converge uniformly to \(V_Kf\) on \([0,1]\).

Lean Formalisation

theorem Real.abs_volterraIntegral_sub_le {K L : (Fin 2 → ℝ) → ℝ} {f g : ℝ → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (hL : ContinuousOn L Real.volterraTriangle) (hf : ContinuousOn f (Set.Icc 0 1)) (hg : ContinuousOn g (Set.Icc 0 1))
  {M F δ η : ℝ} (hM : 0 ≤ M) (_hF : 0 ≤ F) (hδ : 0 ≤ δ) (_hη : 0 ≤ η) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (bf : ∀ y ∈ Set.Icc 0 1, |f y| ≤ F) (eK : ∀ z ∈ Real.volterraTriangle, |L z - K z| ≤ δ)
  (ef : ∀ y ∈ Set.Icc 0 1, |g y - f y| ≤ η) (x : ↑(Set.Icc 0 1)) :
  |Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hL hg x) -
        Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK hf x)| ≤
    (δ * F + (M + δ) * η) * ↑x

Lean proof

/-- Kernel and input errors contribute separately, including their cross term. -/
theorem abs_volterraIntegral_sub_le {K L : (Fin 2 → ℝ) → ℝ} {f g : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hL : ContinuousOn L volterraTriangle)
    (hf : ContinuousOn f (Icc 0 1)) (hg : ContinuousOn g (Icc 0 1))
    {M F δ η : ℝ} (hM : 0 ≤ M) (_hF : 0 ≤ F) (hδ : 0 ≤ δ) (_hη : 0 ≤ η)
    (bK : ∀ z ∈ volterraTriangle, |K z| ≤ M)
    (bf : ∀ y ∈ Icc 0 1, |f y| ≤ F)
    (eK : ∀ z ∈ volterraTriangle, |L z-K z| ≤ δ)
    (ef : ∀ y ∈ Icc 0 1, |g y-f y| ≤ η)
    (x : Icc (0 : ℝ) 1) :
    |volterraIntegral (VolterraIntegralInput.ofContinuous hL hg x) -
      volterraIntegral (VolterraIntegralInput.ofContinuous hK hf x)| ≤
      (δ*F + (M+δ)*η)*x := by
  have hx := x.property
  simp only [VolterraIntegralInput.ofContinuous, volterraIntegral_ofKernel]
  rw [← intervalIntegral.integral_sub (intervalIntegrable_volterra hL hg hx)
    (intervalIntegrable_volterra hK hf hx)]
  have hb : ∀ y ∈ uIoc (0 : ℝ) x,
      ‖L ![x,y]*g y-K ![x,y]*f y‖ ≤ δ*F+(M+δ)*η := by
    intro y hy
    rw [uIoc_of_le hx.1] at hy
    have hyx : y ∈ Icc (0 : ℝ) (x : ℝ) := Ioc_subset_Icc_self hy
    have hy1 : y ∈ Icc (0 : ℝ) 1 := ⟨hyx.1, hyx.2.trans hx.2⟩
    have hz : (![x,y] : Fin 2 → ℝ) ∈ volterraTriangle := ⟨hx, hyx⟩
    have bL : |L ![x,y]| ≤ M+δ := by
      calc
        _ = |K ![x,y]+(L ![x,y]-K ![x,y])| := by congr 1; ring
        _ ≤ _ := abs_add_le _ _
        _ ≤ M+δ := add_le_add (bK _ hz) (eK _ hz)
    rw [Real.norm_eq_abs]
    calc
      _ = |(L ![x,y]-K ![x,y])*f y + L ![x,y]*(g y-f y)| := by congr 1; ring
      _ ≤ _ := abs_add_le _ _
      _ ≤ δ*F+(M+δ)*η := by
        simp only [abs_mul]
        exact add_le_add (mul_le_mul (eK _ hz) (bf y hy1) (abs_nonneg _) hδ)
          (mul_le_mul bL (ef y hy1) (abs_nonneg _) (by positivity))
  simpa only [Real.norm_eq_abs, sub_zero, abs_of_nonneg hx.1] using
    intervalIntegral.norm_integral_le_of_norm_le_const hb

1 related Lean declaration

theorem Real.tendstoUniformly_volterraIntegral_of_error_bounds {K : (Fin 2 → ℝ) → ℝ} {L : ℕ → (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
  {g : ℕ → ℝ → ℝ} (hK : ContinuousOn K Real.volterraTriangle) (hL : ∀ (n : ℕ), ContinuousOn (L n) Real.volterraTriangle)
  (hf : ContinuousOn f (Set.Icc 0 1)) (hg : ∀ (n : ℕ), ContinuousOn (g n) (Set.Icc 0 1)) {M F : ℝ} (hM : 0 ≤ M)
  (hF : 0 ≤ F) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (bf : ∀ y ∈ Set.Icc 0 1, |f y| ≤ F) {δ η : ℕ → ℝ}
  (hδ : ∀ (n : ℕ), 0 ≤ δ n) (hη : ∀ (n : ℕ), 0 ≤ η n) (eK : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |L n z - K z| ≤ δ n)
  (ef : ∀ (n : ℕ), ∀ y ∈ Set.Icc 0 1, |g n y - f y| ≤ η n) (tδ : Filter.Tendsto δ Filter.atTop (nhds 0))
  (tη : Filter.Tendsto η Filter.atTop (nhds 0)) :
  TendstoUniformly (fun n x => Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous ⋯ ⋯ x))
    (fun x => Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK hf x)) Filter.atTop

Lean proof

/-- Vanishing uniform kernel and input error bounds give uniform output convergence. -/
theorem tendstoUniformly_volterraIntegral_of_error_bounds
    {K : (Fin 2 → ℝ) → ℝ} {L : ℕ → (Fin 2 → ℝ) → ℝ}
    {f : ℝ → ℝ} {g : ℕ → ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hL : ∀ n, ContinuousOn (L n) volterraTriangle)
    (hf : ContinuousOn f (Icc 0 1)) (hg : ∀ n, ContinuousOn (g n) (Icc 0 1))
    {M F : ℝ} (hM : 0 ≤ M) (hF : 0 ≤ F)
    (bK : ∀ z ∈ volterraTriangle, |K z| ≤ M) (bf : ∀ y ∈ Icc 0 1, |f y| ≤ F)
    {δ η : ℕ → ℝ} (hδ : ∀ n, 0 ≤ δ n) (hη : ∀ n, 0 ≤ η n)
    (eK : ∀ n z, z ∈ volterraTriangle → |L n z-K z| ≤ δ n)
    (ef : ∀ n y, y ∈ Icc 0 1 → |g n y-f y| ≤ η n)
    (tδ : Tendsto δ atTop (𝓝 0)) (tη : Tendsto η atTop (𝓝 0)) :
    TendstoUniformly
      (fun n (x : Icc (0 : ℝ) 1) ↦ volterraIntegral
        (VolterraIntegralInput.ofContinuous (hL n) (hg n) x))
      (fun x ↦ volterraIntegral (VolterraIntegralInput.ofContinuous hK hf x)) atTop := by
  have ht : Tendsto (fun n ↦ δ n*F+(M+δ n)*η n) atTop (𝓝 0) := by
    simpa using (tδ.mul_const F).add ((tδ.const_add M).mul tη)
  apply Metric.tendstoUniformly_iff.mpr
  intro ε hε
  filter_upwards [ht.eventually (gt_mem_nhds hε)] with n hn x
  rw [Real.dist_eq, abs_sub_comm]
  exact ((abs_volterraIntegral_sub_le hK (hL n) hf (hg n) hM hF (hδ n) (hη n)
    bK bf (eK n) (ef n) x).trans (mul_le_of_le_one_right
      (by have := hδ n; have := hη n; positivity) x.property.2)).trans_lt hn

Theorem 6.1.24 Approximation by finite Proriol Volterra assembly

✓ 🤖

#

Every continuous real kernel on \(\Delta \) admits uniform bivariate polynomial approximations. More generally, polynomial functions uniformly approximate continuous real functions on any compact subset of \(\mathbb {R}^2\). Let \(P\) be a polynomial kernel and \(p=\sum _n c_nJ_n\) a finite shifted-Jacobi input, with \(J_n=P_n^{(1,0)}(2x-1)\). If their kernel and input errors relative to \(K,f\) are bounded by \(\delta ,\eta \), then

\[ \left|x\sum _j(B_Pc)_jJ_j(1-x)-V_Kf(x)\right| \le x\bigl(\delta F+(M+\delta )\eta \bigr),\qquad B_P=D M_P E. \]

Vanishing uniform approximation errors therefore give uniform convergence of these assembled physical outputs on all of \([0,1]\), including the endpoints. For each continuous \(K,f\) and each \(\varepsilon {\gt}0\), there exist a polynomial \(P\) and finite coefficient vector \(c\) for which this output error is less than \(\varepsilon \) everywhere on \([0,1]\). Reference: [GO20, Sections 3.1–3.2].

Lean Formalisation

theorem MvPolynomial.isCompact_volterraTriangle : IsCompact Real.volterraTriangle

Lean proof

/-- The physical Volterra triangle is compact. -/
theorem isCompact_volterraTriangle : IsCompact volterraTriangle := by
  have he : volterraTriangle = Icc (0 : Fin 2 → ℝ) 1 ∩ {z | z 1 ≤ z 0} := by
    ext z
    constructor
    · intro ⟨hx, hy⟩
      refine ⟨⟨?_, ?_⟩, hy.2⟩
      · intro i; fin_cases i <;> simp_all
      · intro i; fin_cases i <;> simp_all; exact hy.2.trans hx.2
    · rintro ⟨⟨h0,h1⟩,hy⟩
      exact ⟨⟨h0 0,h1 0⟩,⟨h0 1,hy⟩⟩
  rw [he]
  exact isCompact_Icc.inter_right (isClosed_le (continuous_apply 1) (continuous_apply 0))

4 related Lean declarations

theorem MvPolynomial.exists_polynomial_near_volterraKernel {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {ε : ℝ} (hε : 0 < ε) : ∃ p, ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) p - K z| < ε

Lean proof

/-- Every continuous Volterra kernel has uniform polynomial approximants on its triangle. -/
theorem exists_polynomial_near_volterraKernel {K : (Fin 2 → ℝ) → ℝ}
    (hK : ContinuousOn K volterraTriangle) {ε : ℝ} (hε : 0 < ε) :
    ∃ p : MvPolynomial (Fin 2) ℝ, ∀ z ∈ volterraTriangle, |eval z p-K z| < ε :=
  exists_polynomial_near_on_compact isCompact_volterraTriangle hK hε

theorem MvPolynomial.volterraProriolCoefficients_error {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) (hf : ContinuousOn f (Set.Icc 0 1)) (P : MvPolynomial (Fin 2) ℝ)
  (c : ℕ →₀ ℝ) {M F δ η : ℝ} (hM : 0 ≤ M) (hF : 0 ≤ F) (hδ : 0 ≤ δ) (hη : 0 ≤ η)
  (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (bf : ∀ y ∈ Set.Icc 0 1, |f y| ≤ F)
  (eK : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) P - K z| ≤ δ)
  (ef :
    ∀ y ∈ Set.Icc 0 1, |Polynomial.eval y ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) c) - f y| ≤ η)
  (x : ↑(Set.Icc 0 1)) :
  |↑x *
          Polynomial.eval (1 - ↑x)
            ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) (P.volterraProriolCoefficients c)) -
        Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK hf x)| ≤
    (δ * F + (M + δ) * η) * ↑x

Lean proof

/-- The finite coefficient assembly inherits the separate kernel and input error bound. -/
theorem volterraProriolCoefficients_error {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hf : ContinuousOn f (Icc 0 1))
    (P : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ)
    {M F δ η : ℝ} (hM : 0 ≤ M) (hF : 0 ≤ F) (hδ : 0 ≤ δ) (hη : 0 ≤ η)
    (bK : ∀ z ∈ volterraTriangle, |K z| ≤ M) (bf : ∀ y ∈ Icc 0 1, |f y| ≤ F)
    (eK : ∀ z ∈ volterraTriangle, |eval z P-K z| ≤ δ)
    (ef : ∀ y ∈ Icc 0 1,
      |(Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c).eval y-f y| ≤ η)
    (x : Icc (0 : ℝ) 1) :
    |(x : ℝ) * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
      (volterraProriolCoefficients P c)).eval (1-(x : ℝ)) - volterraIntegral (VolterraIntegralInput.ofContinuous hK hf x)| ≤
      (δ*F+(M+δ)*η)*(x : ℝ) := by
  rw [volterraProriolCoefficients_exact]
  simpa only [VolterraIntegralInput.ofContinuous, volterraIntegral_ofKernel] using
    abs_volterraIntegral_sub_le hK P.continuous_eval.continuousOn hf
      (Polynomial.continuous _).continuousOn hM hF hδ hη bK bf eK ef x

theorem MvPolynomial.tendstoUniformly_volterraProriolCoefficients {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) (hf : ContinuousOn f (Set.Icc 0 1)) (P : ℕ → MvPolynomial (Fin 2) ℝ)
  (c : ℕ → ℕ →₀ ℝ) {M F : ℝ} (hM : 0 ≤ M) (hF : 0 ≤ F) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (bf : ∀ y ∈ Set.Icc 0 1, |f y| ≤ F) {δ η : ℕ → ℝ} (hδ : ∀ (n : ℕ), 0 ≤ δ n) (hη : ∀ (n : ℕ), 0 ≤ η n)
  (eK : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (P n) - K z| ≤ δ n)
  (ef :
    ∀ (n : ℕ),
      ∀ y ∈ Set.Icc 0 1,
        |Polynomial.eval y ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) (c n)) - f y| ≤ η n)
  (tδ : Filter.Tendsto δ Filter.atTop (nhds 0)) (tη : Filter.Tendsto η Filter.atTop (nhds 0)) :
  TendstoUniformly
    (fun n x =>
      ↑x *
        Polynomial.eval (1 - ↑x)
          ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) ((P n).volterraProriolCoefficients (c n))))
    (fun x => Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK hf x)) Filter.atTop

Lean proof

/-- Vanishing polynomial approximation errors give uniform convergence of the
physical outputs assembled by `D M_K E`, including both endpoints. -/
theorem tendstoUniformly_volterraProriolCoefficients
    {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hf : ContinuousOn f (Icc 0 1))
    (P : ℕ → MvPolynomial (Fin 2) ℝ) (c : ℕ → ℕ →₀ ℝ)
    {M F : ℝ} (hM : 0 ≤ M) (hF : 0 ≤ F)
    (bK : ∀ z ∈ volterraTriangle, |K z| ≤ M) (bf : ∀ y ∈ Icc 0 1, |f y| ≤ F)
    {δ η : ℕ → ℝ} (hδ : ∀ n, 0 ≤ δ n) (hη : ∀ n, 0 ≤ η n)
    (eK : ∀ n z, z ∈ volterraTriangle → |eval z (P n)-K z| ≤ δ n)
    (ef : ∀ n y, y ∈ Icc 0 1 →
      |(Finsupp.linearCombination ℝ (shiftedJacobi 1 0) (c n)).eval y-f y| ≤ η n)
    (tδ : Tendsto δ atTop (𝓝 0)) (tη : Tendsto η atTop (𝓝 0)) :
    TendstoUniformly (fun n (x : Icc (0 : ℝ) 1) ↦ (x : ℝ) * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
      (volterraProriolCoefficients (P n) (c n))).eval (1-(x : ℝ)))
      (fun x ↦ volterraIntegral (VolterraIntegralInput.ofContinuous hK hf x)) atTop := by
  simp_rw [volterraProriolCoefficients_exact]
  simpa only [VolterraIntegralInput.ofContinuous, volterraIntegral_ofKernel] using
    tendstoUniformly_volterraIntegral_of_error_bounds hK
    (fun n ↦ (P n).continuous_eval.continuousOn) hf
    (fun n ↦ (Polynomial.continuous _).continuousOn) hM hF bK bf hδ hη eK ef tδ tη

theorem MvPolynomial.exists_volterraProriolCoefficients_approximation {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) (hf : ContinuousOn f (Set.Icc 0 1)) {ε : ℝ} (hε : 0 < ε) :
  ∃ P c,
    ∀ (x : ↑(Set.Icc 0 1)),
      |↑x *
              Polynomial.eval (1 - ↑x)
                ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) (P.volterraProriolCoefficients c)) -
            Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK hf x)| <
        ε

Lean proof

/-- Continuous data admit a finite coefficient assembly with any prescribed
uniform output tolerance; the kernel and input are approximated independently. -/
theorem exists_volterraProriolCoefficients_approximation
    {K : (Fin 2 → ℝ) → ℝ} {f : ℝ → ℝ}
    (hK : ContinuousOn K volterraTriangle) (hf : ContinuousOn f (Icc 0 1))
    {ε : ℝ} (hε : 0 < ε) :
    ∃ (P : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ), ∀ x : Icc (0 : ℝ) 1,
      |(x : ℝ) * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
        (volterraProriolCoefficients P c)).eval (1-(x : ℝ)) - volterraIntegral (VolterraIntegralInput.ofContinuous hK hf x)| < ε := by
  obtain ⟨m, hm⟩ := isCompact_volterraTriangle.exists_bound_of_continuousOn hK
  obtain ⟨a, ha⟩ := isCompact_Icc.exists_bound_of_continuousOn hf
  let M := |m|
  let F := |a|
  have hM : 0 ≤ M := abs_nonneg _
  have hF : 0 ≤ F := abs_nonneg _
  have bK : ∀ z ∈ volterraTriangle, |K z| ≤ M := fun z hz ↦
    (hm z hz).trans (le_abs_self m)
  have bf : ∀ y ∈ Icc 0 1, |f y| ≤ F := fun y hy ↦
    (ha y hy).trans (le_abs_self a)
  let δ := min 1 (ε/(2*(F+M+1)))
  have hD : 0 < F+M+1 := by positivity
  have hδ : 0 < δ := lt_min (by norm_num) (by positivity)
  have hδ1 : δ ≤ 1 := min_le_left _ _
  have hδε : δ*(F+M+1) ≤ ε/2 := by
    have h := mul_le_mul_of_nonneg_right (min_le_right 1 (ε/(2*(F+M+1)))) hD.le
    dsimp [δ]
    convert h using 1
    field_simp
  obtain ⟨P, hP⟩ := exists_polynomial_near_volterraKernel hK hδ
  obtain ⟨p, hp⟩ := exists_polynomial_near_of_continuousOn 0 1 f hf δ hδ
  let S := shiftedJacobiSequence (by norm_num : (-1 : ℝ) < 1)
    (by norm_num : (-1 : ℝ) < 0)
  let B := S.basis (fun n ↦ isUnit_iff_ne_zero.mpr (leadingCoeff_ne_zero.mpr (S.ne_zero n)))
  let c := B.repr p
  have hc : Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c = p := by
    have he : (fun n ↦ B n) = shiftedJacobi 1 0 := by
      funext n
      simp [B, S]
    rw [← he]
    exact B.linearCombination_repr p
  refine ⟨P, c, fun x ↦ ?_⟩
  have he := volterraProriolCoefficients_error hK hf P c hM hF hδ.le hδ.le
    bK bf (fun z hz ↦ (hP z hz).le) (by simpa [hc] using fun y hy ↦ (hp y hy).le) x
  calc
    _ ≤ (δ*F+(M+δ)*δ)*(x : ℝ) := he
    _ ≤ δ*F+(M+δ)*δ := mul_le_of_le_one_right (by positivity) x.property.2
    _ ≤ δ*(F+M+1) := by nlinarith [mul_nonneg hδ.le (sub_nonneg.mpr hδ1)]
    _ ≤ ε/2 := hδε
    _ < ε := by linarith

These are operator-action approximation results; no coefficient-norm or inverse-solver convergence is asserted.

Theorem 6.1.25 Shifted Jacobi Hilbert bases

✓ 🤖

#

For \(a,b{\gt}-1\), the affine Jacobi measure has strictly positive polynomial square integrals, and its normalized shifted Jacobi polynomials form a Hilbert basis of real \(L^2\). The normalization is the reciprocal positive square root of the squared polynomial norm. In particular, \(\mu _{0,0}^{\mathrm{unit}}=2\, dx|_{[0,1]}\); the affine measure preserves the original mass rather than being normalized to probability.

Lean Formalisation

theorem Polynomial.hasPositiveDefiniteIntegral_unitJacobiMeasure {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) :
  Polynomial.HasPositiveDefiniteIntegral (Polynomial.unitJacobiMeasure α β)

Lean proof

/-- Strict positivity of polynomial squares for the affine Jacobi measure. -/
@[aesop (rule_sets := [PolynomialIntegrability]) unsafe 80% apply]
theorem hasPositiveDefiniteIntegral_unitJacobiMeasure {α β : ℝ}
    (hα : -1 < α) (hβ : -1 < β) : HasPositiveDefiniteIntegral (unitJacobiMeasure α β) := by
  apply HasPositiveDefiniteIntegral.of_positive
  intro p hp
  let q : ℝ[X] := p.comp ((X+1)*C (1/2))
  have hq : q ≠ 0 := by
    intro hz
    apply hp
    apply Polynomial.funext
    intro x
    have he := congrArg (fun r : ℝ[X] ↦ r.eval (2*x-1)) hz
    simpa only [q, eval_comp, eval_mul, eval_add, eval_X, eval_one, eval_C, eval_zero,
      show (2*x-1+1)*(1/2 : ℝ)=x by ring] using he
  have h := hasPositiveDefiniteIntegral_jacobiMeasure hα hβ q hq
  rw [integral_unitJacobiMeasure α β ⟨fun x ↦ p.eval x ^ 2,
    hasFiniteMoments_unitJacobiMeasure hα hβ p⟩]
  simpa [q, eval_comp, div_eq_mul_inv] using h

3 related Lean declarations

def Polynomial.hilbertBasisShiftedJacobi {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) :
  HilbertBasis ℕ ℝ ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure α β))

Lean definition

/-- The normalized shifted Jacobi sequence is a Hilbert basis on the unit interval. -/
def hilbertBasisShiftedJacobi {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) :
    HilbertBasis ℕ ℝ (Lp ℝ 2 (unitJacobiMeasure α β)) :=
  (isOrthogonal_shiftedJacobiSequence hα hβ).hilbertBasis
    (hasFiniteMoments_unitJacobiMeasure hα hβ)
    (hasPositiveDefiniteIntegral_unitJacobiMeasure hα hβ)
    (polynomialToL2_denseRange (hasFiniteMoments_unitJacobiMeasure hα hβ) 0 1
      (ae_mem_Icc_unitJacobiMeasure α β))

theorem Polynomial.hilbertBasisShiftedJacobi_apply {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) (n : ℕ) :
  (Polynomial.hilbertBasisShiftedJacobi hα hβ) n = (Polynomial.shiftedJacobiSequence hα hβ).normalizedToL2 ⋯ ⟨n, ⋯⟩

Lean proof

/-- The basis vectors are the existing shifted polynomials normalized by their squared norms. -/
@[simp] theorem hilbertBasisShiftedJacobi_apply {α β : ℝ} (hα : -1 < α) (hβ : -1 < β)
    (n : ℕ) : hilbertBasisShiftedJacobi hα hβ n =
      (shiftedJacobiSequence hα hβ).normalizedToL2
        (hasFiniteMoments_unitJacobiMeasure hα hβ)
        ⟨n, Sequence.squaredNorm_pos (hasPositiveDefiniteIntegral_unitJacobiMeasure hα hβ)
          (shiftedJacobiSequence hα hβ) n⟩ :=
  (isOrthogonal_shiftedJacobiSequence hα hβ).hilbertBasis_apply _ _ _ n

theorem Polynomial.unitJacobiMeasure_zero_zero :
  Polynomial.unitJacobiMeasure 0 0 = 2 • MeasureTheory.volume.restrict (Set.Icc 0 1)

Lean proof

/-- The affine Legendre measure includes the factor two from its original mass. -/
theorem unitJacobiMeasure_zero_zero : unitJacobiMeasure 0 0 =
    (2 : ℝ≥0∞) • volume.restrict (Icc (0 : ℝ) 1) := by
  let := isFiniteMeasure_unitJacobiMeasure (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0)
  let : IsFiniteMeasure ((2 : ℝ≥0∞) • volume.restrict (Icc (0 : ℝ) 1)) :=
    ⟨by simp⟩
  apply MeasureTheory.ext_of_forall_integral_eq_of_IsFiniteMeasure
  intro f
  let g : IntegrableInput (unitJacobiMeasure 0 0) := ⟨f, by
      rw [unitJacobiMeasure, integrable_map_measure f.continuous.aestronglyMeasurable (by fun_prop)]
      exact integrable_jacobiMeasure (by norm_num) (by norm_num)
        (f.continuous.comp (by fun_prop)).continuousOn⟩
  have hg : Measurable g.val := by dsimp [g]; fun_prop
  have hd : (∫ x, g.val x ∂unitJacobiMeasure 0 0) = 2 *
      ∫ x in (0 : ℝ)..1, g.val x := by
    rw [integral_unitJacobiMeasure_subtype 0 0 g hg]
    simp only [unitJacobiWeight_apply, zero_add, Real.rpow_one, Real.rpow_zero,
      mul_one]
    rw [integral_const_mul, integral_subtype measurableSet_Ioo g.val,
      restrict_Ioo_eq_restrict_Ioc,
      ← intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
  dsimp only [g] at hd
  rw [hd, integral_smul_measure]
  norm_num
  rw [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1),
    ← restrict_Ioc_eq_restrict_Icc]

Theorem 6.1.26 Bounded signed kernels between finite measure spaces

✓ 🤖

#

For any measure, an almost-everywhere bound \(|k|\le M\), \(M\ge 0\), gives bounded multiplication on real \(L^2\) with norm at most \(M\). Let \(\mu ,\nu \) be finite measures and let \(k\) be an almost-everywhere strongly measurable real kernel with \(|k|\le M\) on their product. There is a bounded operator \(T:L^2(\nu )\to L^2(\mu )\) such that

\[ \langle g,Tf\rangle =\iint k(x,y)g(x)f(y)\, d\mu (x)d\nu (y),\qquad \| T\| \le M\sqrt{\mu (X)\nu (Y)}. \]

Every displayed pairing is absolutely integrable. The kernel may have either sign.

Lean Formalisation

theorem MeasureTheory.memLp_bounded_mul.{u_1, u_3} {X : Type u_1} [MeasurableSpace X] {𝕜 : Type u_3} [RCLike 𝕜]
  (μ : MeasureTheory.Measure X) (k : X → 𝕜) (hk : MeasureTheory.AEStronglyMeasurable k μ) {M : ℝ}
  (hb : ∀ᵐ (x : X) ∂μ, ‖k x‖ ≤ M) (u : ↥(MeasureTheory.Lp 𝕜 2 μ)) : MeasureTheory.MemLp (fun x => k x * ↑↑u x) 2 μ

Lean proof

/-- A bounded measurable multiplier preserves L². -/
theorem memLp_bounded_mul (μ : Measure X) (k : X → 𝕜) (hk : AEStronglyMeasurable k μ)
    {M : ℝ} (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ M) (u : Lp 𝕜 2 μ) :
    MemLp (fun x ↦ k x * u x) 2 μ := by
  apply (Lp.memLp u).of_le_mul (c := M) (hk.mul (Lp.aestronglyMeasurable u))
  filter_upwards [hb] with x hx
  rw [Pi.mul_apply, norm_mul]
  exact mul_le_mul_of_nonneg_right hx (norm_nonneg _)

7 related Lean declarations

def MeasureTheory.boundedMulL2.{u_1, u_3} {X : Type u_1} [MeasurableSpace X] {𝕜 : Type u_3} [RCLike 𝕜]
  (μ : MeasureTheory.Measure X) (k : X → 𝕜) (hk : MeasureTheory.AEStronglyMeasurable k μ) {M : ℝ} (_hM : 0 ≤ M)
  (hb : ∀ᵐ (x : X) ∂μ, ‖k x‖ ≤ M) : ↥(MeasureTheory.Lp 𝕜 2 μ) →L[𝕜] ↥(MeasureTheory.Lp 𝕜 2 μ)

Lean definition

/-- Multiplication by an essentially bounded scalar function on L². -/
def boundedMulL2 (μ : Measure X) (k : X → 𝕜) (hk : AEStronglyMeasurable k μ)
    {M : ℝ} (_hM : 0 ≤ M) (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ M) : Lp 𝕜 2 μ →L[𝕜] Lp 𝕜 2 μ :=
  LinearMap.mkContinuous
    { toFun u := (memLp_bounded_mul μ k hk hb u).toLp _
      map_add' u v := by
        apply Lp.ext
        filter_upwards [(memLp_bounded_mul μ k hk hb (u+v)).coeFn_toLp,
          (memLp_bounded_mul μ k hk hb u).coeFn_toLp,
          (memLp_bounded_mul μ k hk hb v).coeFn_toLp, Lp.coeFn_add u v,
          Lp.coeFn_add ((memLp_bounded_mul μ k hk hb u).toLp _)
            ((memLp_bounded_mul μ k hk hb v).toLp _)] with x ha hu hv huv hs
        simp only [ha, hs, hu, hv, huv, Pi.add_apply, mul_add]
      map_smul' r u := by
        change (memLp_bounded_mul μ k hk hb (r • u)).toLp _ = r • _
        apply Lp.ext
        filter_upwards [(memLp_bounded_mul μ k hk hb (r • u)).coeFn_toLp,
          (memLp_bounded_mul μ k hk hb u).coeFn_toLp, Lp.coeFn_smul r u,
          Lp.coeFn_smul r ((memLp_bounded_mul μ k hk hb u).toLp _)] with x ha hu hru hs
        simp only [ha, hs, hu, hru, Pi.smul_apply, smul_eq_mul]
        ring }
    M (fun u ↦ Lp.norm_le_mul_norm_of_ae_le_mul (by
      change ∀ᵐ x ∂μ, ‖(memLp_bounded_mul μ k hk hb u).toLp _ x‖ ≤ M * ‖u x‖
      filter_upwards [(memLp_bounded_mul μ k hk hb u).coeFn_toLp, hb] with x hx hkx
      rw [hx, norm_mul]
      exact mul_le_mul_of_nonneg_right hkx (norm_nonneg _)))

theorem MeasureTheory.boundedMulL2_ae.{u_1, u_3} {X : Type u_1} [MeasurableSpace X] {𝕜 : Type u_3} [RCLike 𝕜]
  (μ : MeasureTheory.Measure X) (k : X → 𝕜) (hk : MeasureTheory.AEStronglyMeasurable k μ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ᵐ (x : X) ∂μ, ‖k x‖ ≤ M) (u : ↥(MeasureTheory.Lp 𝕜 2 μ)) :
  ↑↑((MeasureTheory.boundedMulL2 μ k hk hM hb) u) =ᵐ[μ] fun x => k x * ↑↑u x

Lean proof

/-- The multiplier has its expected almost-everywhere representative. -/
theorem boundedMulL2_ae (μ : Measure X) (k : X → 𝕜) (hk : AEStronglyMeasurable k μ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ M) (u : Lp 𝕜 2 μ) :
    boundedMulL2 μ k hk hM hb u =ᵐ[μ] fun x ↦ k x * u x :=
  (memLp_bounded_mul μ k hk hb u).coeFn_toLp

theorem MeasureTheory.norm_boundedMulL2_le.{u_1, u_3} {X : Type u_1} [MeasurableSpace X] {𝕜 : Type u_3} [RCLike 𝕜]
  (μ : MeasureTheory.Measure X) (k : X → 𝕜) (hk : MeasureTheory.AEStronglyMeasurable k μ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ᵐ (x : X) ∂μ, ‖k x‖ ≤ M) : ‖MeasureTheory.boundedMulL2 μ k hk hM hb‖ ≤ M

Lean proof

/-- The essential multiplier bound controls the operator norm. -/
theorem norm_boundedMulL2_le (μ : Measure X) (k : X → 𝕜) (hk : AEStronglyMeasurable k μ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ M) :
    ‖boundedMulL2 μ k hk hM hb‖ ≤ M := by
  apply ContinuousLinearMap.opNorm_le_bound _ hM
  intro u
  apply Lp.norm_le_mul_norm_of_ae_le_mul
  filter_upwards [boundedMulL2_ae μ k hk hM hb u, hb] with x hx hkx
  rw [hx, norm_mul]
  exact mul_le_mul_of_nonneg_right hkx (norm_nonneg _)

def MeasureTheory.boundedKernelL2Operator.{u_1, u_2} {X : Type u_1} {Y : Type u_2} [MeasurableSpace X] [MeasurableSpace Y]
  (μ : MeasureTheory.Measure X) (ν : MeasureTheory.Measure Y) [MeasureTheory.IsFiniteMeasure μ]
  [MeasureTheory.IsFiniteMeasure ν] (k : X × Y → ℝ) (hk : MeasureTheory.AEStronglyMeasurable k (μ.prod ν)) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ᵐ (z : X × Y) ∂μ.prod ν, ‖k z‖ ≤ M) : ↥(MeasureTheory.Lp ℝ 2 ν) →L[ℝ] ↥(MeasureTheory.Lp ℝ 2 μ)

Lean definition

/-- Integral operator of a bounded signed kernel between finite measure spaces. -/
def boundedKernelL2Operator : Lp ℝ 2 ν →L[ℝ] Lp ℝ 2 μ :=
  (dominatedL2Pullback μ (μ.prod ν) Prod.fst measurable_fst (measure_ne_top ν Set.univ) (by simp)).adjoint.comp
    ((boundedMulL2 (μ.prod ν) k hk hM hb).comp
      (dominatedL2Pullback ν (μ.prod ν) Prod.snd measurable_snd (measure_ne_top μ Set.univ) (by simp)))

theorem MeasureTheory.norm_boundedKernelL2Operator_le.{u_1, u_2} {X : Type u_1} {Y : Type u_2} [MeasurableSpace X]
  [MeasurableSpace Y] (μ : MeasureTheory.Measure X) (ν : MeasureTheory.Measure Y) [MeasureTheory.IsFiniteMeasure μ]
  [MeasureTheory.IsFiniteMeasure ν] (k : X × Y → ℝ) (hk : MeasureTheory.AEStronglyMeasurable k (μ.prod ν)) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ᵐ (z : X × Y) ∂μ.prod ν, ‖k z‖ ≤ M) :
  ‖MeasureTheory.boundedKernelL2Operator μ ν k hk hM hb‖ ≤ √(ν Set.univ).toReal * (M * √(μ Set.univ).toReal)

Lean proof

/-- Finite measure masses and the kernel bound control the operator norm. -/
theorem norm_boundedKernelL2Operator_le :
    ‖boundedKernelL2Operator μ ν k hk hM hb‖ ≤
      Real.sqrt (ν Set.univ).toReal * (M * Real.sqrt (μ Set.univ).toReal) := by
  unfold boundedKernelL2Operator
  apply (ContinuousLinearMap.opNorm_comp_le _ _).trans
  rw [ContinuousLinearMap.adjoint.norm_map]
  apply mul_le_mul (norm_dominatedL2Pullback_le _ _ _ _ _ _) _ (norm_nonneg _) (by positivity)
  exact (ContinuousLinearMap.opNorm_comp_le _ _).trans
    (mul_le_mul (norm_boundedMulL2_le _ _ _ _ _) (norm_dominatedL2Pullback_le _ _ _ _ _ _)
      (norm_nonneg _) hM)

theorem MeasureTheory.inner_boundedKernelL2Operator.{u_1, u_2} {X : Type u_1} {Y : Type u_2} [MeasurableSpace X]
  [MeasurableSpace Y] (μ : MeasureTheory.Measure X) (ν : MeasureTheory.Measure Y) [MeasureTheory.IsFiniteMeasure μ]
  [MeasureTheory.IsFiniteMeasure ν] (k : X × Y → ℝ) (hk : MeasureTheory.AEStronglyMeasurable k (μ.prod ν)) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ᵐ (z : X × Y) ∂μ.prod ν, ‖k z‖ ≤ M) (f : ↥(MeasureTheory.Lp ℝ 2 ν))
  (g : ↥(MeasureTheory.Lp ℝ 2 μ)) :
  inner ℝ g ((MeasureTheory.boundedKernelL2Operator μ ν k hk hM hb) f) =
    ∫ (z : X × Y), k z * (↑↑g z.1 * ↑↑f z.2) ∂μ.prod ν

Lean proof

/-- The bounded-kernel operator has the expected weak integral pairing. -/
theorem inner_boundedKernelL2Operator (f : Lp ℝ 2 ν) (g : Lp ℝ 2 μ) :
    ⟪g, boundedKernelL2Operator μ ν k hk hM hb f⟫_ℝ =
      ∫ z, k z * (g z.1 * f z.2) ∂μ.prod ν := by
  rw [boundedKernelL2Operator, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.adjoint_inner_right, ContinuousLinearMap.comp_apply, L2.inner_def]
  apply integral_congr_ae
  filter_upwards [boundedMulL2_ae (μ.prod ν) k hk hM hb
      (dominatedL2Pullback ν (μ.prod ν) Prod.snd measurable_snd (measure_ne_top μ Set.univ) (by simp) f),
    dominatedL2Pullback_ae μ (μ.prod ν) Prod.fst measurable_fst (measure_ne_top ν Set.univ) (by simp) g,
    dominatedL2Pullback_ae ν (μ.prod ν) Prod.snd measurable_snd (measure_ne_top μ Set.univ) (by simp) f]
    with z hz hg hf
  simp only [hz, hg, hf, Function.comp_apply, Real.inner_apply]
  ring

theorem MeasureTheory.integrable_boundedKernelL2_pair.{u_1, u_2} {X : Type u_1} {Y : Type u_2} [MeasurableSpace X]
  [MeasurableSpace Y] (μ : MeasureTheory.Measure X) (ν : MeasureTheory.Measure Y) [MeasureTheory.IsFiniteMeasure μ]
  [MeasureTheory.IsFiniteMeasure ν] (k : X × Y → ℝ) (hk : MeasureTheory.AEStronglyMeasurable k (μ.prod ν)) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ᵐ (z : X × Y) ∂μ.prod ν, ‖k z‖ ≤ M) (f : ↥(MeasureTheory.Lp ℝ 2 ν))
  (g : ↥(MeasureTheory.Lp ℝ 2 μ)) : MeasureTheory.Integrable (fun z => k z * (↑↑g z.1 * ↑↑f z.2)) (μ.prod ν)

Lean proof

/-- Every weak pairing for a bounded kernel is absolutely integrable. -/
theorem integrable_boundedKernelL2_pair (f : Lp ℝ 2 ν) (g : Lp ℝ 2 μ) :
    Integrable (fun z ↦ k z * (g z.1*f z.2)) (μ.prod ν) := by
  let hf := dominatedL2Pullback ν (μ.prod ν) Prod.snd measurable_snd (measure_ne_top μ Set.univ) (by simp) f
  let hg := dominatedL2Pullback μ (μ.prod ν) Prod.fst measurable_fst (measure_ne_top ν Set.univ) (by simp) g
  apply (L2.integrable_inner (𝕜 := ℝ) (boundedMulL2 (μ.prod ν) k hk hM hb hf) hg).congr
  filter_upwards [boundedMulL2_ae (μ.prod ν) k hk hM hb hf,
    dominatedL2Pullback_ae μ (μ.prod ν) Prod.fst measurable_fst (measure_ne_top ν Set.univ) (by simp) g,
    dominatedL2Pullback_ae ν (μ.prod ν) Prod.snd measurable_snd (measure_ne_top μ Set.univ) (by simp) f]
    with z hz hgz hfz
  dsimp only [hf, hg] at hz ⊢
  simp only [Real.inner_apply, hz, hgz, hfz, Function.comp_apply]
  ring

Theorem 6.1.27 Integrable Volterra rows from square-integrable inputs

✓ 🤖

#

For \(\mu =2\, dx|_{[0,1]}\), every \(f\in L^2(\mu )\) is integrable on \([0,1]\). For every kernel \(K\) continuous on \(\Delta \) and \(x\in [0,1]\), the product \(y\mapsto K(x,y)f(y)\) is integrable between \(0\) and \(x\).

Lean Formalisation

theorem Real.integrableOn_coe_unitLegendreLp (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  MeasureTheory.IntegrableOn (fun y => ↑↑f y) (Set.Icc 0 1) MeasureTheory.volume

Lean proof

/-- L² data for the affine Legendre measure are integrable on the physical interval. -/
theorem integrableOn_coe_unitLegendreLp (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    IntegrableOn (fun y ↦ f y) (Icc (0 : ℝ) 1) := by
  have hi := (Lp.memLp f).integrable (by norm_num : (1 : ℝ≥0∞) ≤ 2)
  conv at hi => arg 2; rw [unitJacobiMeasure_zero_zero]
  exact (integrable_smul_measure (by norm_num : (2 : ℝ≥0∞) ≠ 0) (by norm_num)).mp hi

1 related Lean declaration

def Real.VolterraIntegralInput.ofUnitLegendreLp {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) (x : ↑(Set.Icc 0 1)) : (↑x).VolterraIntegralInput

Lean definition

/-- Every L² input supplies an integrable continuous-kernel row on the physical interval. -/
def VolterraIntegralInput.ofUnitLegendreLp
    {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K volterraTriangle)
    (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) (x : Icc (0 : ℝ) 1) :
    VolterraIntegralInput (x : ℝ) :=
  .ofContinuousKernel hK (f := fun y ↦ f y) x (by
    apply intervalIntegrable_iff.mpr
    rw [uIoc_of_le x.property.1]
    exact (integrableOn_coe_unitLegendreLp f).mono_set
      (fun y hy ↦ ⟨hy.1.le, hy.2.trans x.property.2⟩))

Theorem 6.1.28 Volterra realization on physical L² functions

✓ 🤖

#

Let \(K\) be continuous on the physical triangle \(\Delta \), with \(|K|\le M\), \(M\ge 0\), and put \(\mu =2\, dx|_{[0,1]}\). Extend the kernel by zero outside \(0\le y\le x\le 1\), obtaining \(\widetilde K\). The bounded operator \(T_K:L^2(\mu )\to L^2(\mu )\) has norm at most \(M\) and satisfies

\[ \langle g,T_Kf\rangle =\tfrac 12\iint \widetilde K(x,y)g(x)f(y)\, d\mu (x)d\mu (y) =\int _{[0,1]} g(x)V_Kf(x)\, d\mu (x). \]

The double pairing is absolutely integrable for every \(f,g\in L^2(\mu )\). For \(x\in [0,1]\), the row integral against \(\mu \) is \(2V_Kf(x)\).

Lean Formalisation

theorem Real.measurable_volterraL2Kernel {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) :
  Measurable (Real.volterraL2Kernel K)

Lean proof

/-- Continuity on the triangle suffices for measurability of the zero extension. -/
theorem measurable_volterraL2Kernel {K : (Fin 2 → ℝ) → ℝ}
    (hK : ContinuousOn K volterraTriangle) : Measurable (volterraL2Kernel K) := by
  apply ContinuousOn.measurable_piecewise
    (f := fun z : ℝ × ℝ ↦ K ![z.1,z.2]) (g := fun _ ↦ (0 : ℝ))
    (s := {z : ℝ × ℝ | z.1 ∈ Icc (0 : ℝ) 1 ∧ z.2 ∈ Icc 0 z.1})
  · exact hK.comp (by fun_prop) (fun z hz ↦ hz)
  · fun_prop
  · exact (measurableSet_Icc.preimage measurable_fst).inter
      ((measurableSet_le measurable_const measurable_snd).inter
        (measurableSet_le measurable_snd measurable_fst))

8 related Lean declarations

def Real.volterraL2Kernel (K : (Fin 2 → ℝ) → ℝ) (z : ℝ × ℝ) : ℝ

Lean definition

/-- Volterra kernel, extended by zero off its physical triangle. -/
def volterraL2Kernel (K : (Fin 2 → ℝ) → ℝ) (z : ℝ × ℝ) : ℝ :=
  if z.1 ∈ Icc (0 : ℝ) 1 ∧ z.2 ∈ Icc 0 z.1 then K ![z.1,z.2] else 0

theorem Real.norm_volterraL2Kernel_le {K : (Fin 2 → ℝ) → ℝ} {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (z : ℝ × ℝ) : ‖Real.volterraL2Kernel K z‖ ≤ M

Lean proof

/-- A triangle bound is a global bound for the zero-extended kernel. -/
theorem norm_volterraL2Kernel_le {K : (Fin 2 → ℝ) → ℝ} {M : ℝ} (hM : 0 ≤ M)
    (hb : ∀ z ∈ volterraTriangle, |K z| ≤ M) (z : ℝ × ℝ) :
    ‖volterraL2Kernel K z‖ ≤ M := by
  unfold volterraL2Kernel
  split_ifs with hz
  · exact hb _ hz
  · simpa using hM

def Real.volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0)) →L[ℝ]
    ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))

Lean definition

/-- The physical Volterra operator on L² of the affine Legendre measure. -/
def volterraL2Operator :
    Lp ℝ 2 (unitJacobiMeasure 0 0) →L[ℝ] Lp ℝ 2 (unitJacobiMeasure 0 0) :=
  (1/2 : ℝ) • boundedKernelL2Operator _ _ (volterraL2Kernel K)
    (measurable_volterraL2Kernel hK).aestronglyMeasurable hM
    (Filter.Eventually.of_forall (norm_volterraL2Kernel_le hM hb))

theorem Real.norm_volterraL2Operator_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : ‖Real.volterraL2Operator hK hM hb‖ ≤ M

Lean proof

/-- The kernel supremum bounds the physical Volterra operator norm. -/
theorem norm_volterraL2Operator_le : ‖volterraL2Operator hK hM hb‖ ≤ M := by
  have hm : (unitJacobiMeasure 0 0) univ = 2 := by
    rw [unitJacobiMeasure_zero_zero]
    simp
  rw [volterraL2Operator, norm_smul]
  have hh := norm_boundedKernelL2Operator_le (unitJacobiMeasure 0 0)
    (unitJacobiMeasure 0 0) (volterraL2Kernel K)
    (measurable_volterraL2Kernel hK).aestronglyMeasurable hM
    (Filter.Eventually.of_forall (norm_volterraL2Kernel_le hM hb))
  rw [hm] at hh
  norm_num only [ENNReal.toReal_ofNat] at hh
  have hs : sqrt 2 * (M * sqrt 2) = 2*M := by
    nlinarith [sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  rw [hs] at hh
  norm_num only [norm_div, norm_one, norm_ofNat]
  linarith

theorem Real.inner_volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (f g : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  inner ℝ g ((Real.volterraL2Operator hK hM hb) f) =
    1 / 2 *
      ∫ (z : ℝ × ℝ),
        Real.volterraL2Kernel K z *
          (↑↑g z.1 * ↑↑f z.2) ∂(Polynomial.unitJacobiMeasure 0 0).prod (Polynomial.unitJacobiMeasure 0 0)

Lean proof

/-- Weak pairing for every pair of L² functions. -/
theorem inner_volterraL2Operator (f g : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    ⟪g, volterraL2Operator hK hM hb f⟫_ℝ =
      (1/2 : ℝ) * ∫ z, volterraL2Kernel K z * (g z.1*f z.2)
        ∂(unitJacobiMeasure 0 0).prod (unitJacobiMeasure 0 0) := by
  rw [volterraL2Operator, smul_apply, inner_smul_right,
    inner_boundedKernelL2Operator]

theorem Real.integrable_volterraL2_pair {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (f g : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  MeasureTheory.Integrable (fun z => Real.volterraL2Kernel K z * (↑↑g z.1 * ↑↑f z.2))
    ((Polynomial.unitJacobiMeasure 0 0).prod (Polynomial.unitJacobiMeasure 0 0))

Lean proof

/-- The original weak kernel pairing is absolutely integrable on the square. -/
theorem integrable_volterraL2_pair (f g : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    Integrable (fun z ↦ volterraL2Kernel K z * (g z.1*f z.2))
      ((unitJacobiMeasure 0 0).prod (unitJacobiMeasure 0 0)) :=
  integrable_boundedKernelL2_pair _ _ _ (measurable_volterraL2Kernel hK).aestronglyMeasurable
    hM (Filter.Eventually.of_forall (norm_volterraL2Kernel_le hM hb)) f g

theorem Real.integral_volterraL2Kernel (K : (Fin 2 → ℝ) → ℝ) (f : ℝ → ℝ) (x : ↑(Set.Icc 0 1))
  (hi : IntervalIntegrable (fun y => K ![↑x, y] * f y) MeasureTheory.volume 0 ↑x) :
  ∫ (y : ℝ), Real.volterraL2Kernel K (↑x, y) * f y ∂Polynomial.unitJacobiMeasure 0 0 =
    2 * Real.volterraIntegral (Real.VolterraIntegralInput.ofKernel K f hi)

Lean proof

/-- An existing physical row integral has the affine Legendre normalization factor two. -/
theorem integral_volterraL2Kernel (K : (Fin 2 → ℝ) → ℝ) (f : ℝ → ℝ)
    (x : Icc (0 : ℝ) 1)
    (hi : IntervalIntegrable (fun y ↦ K ![(x : ℝ),y]*f y) volume 0 (x : ℝ)) :
    (∫ y, volterraL2Kernel K ((x : ℝ),y)*f y ∂unitJacobiMeasure 0 0) =
      2*volterraIntegral (.ofKernel K f hi) := by
  rw [volterraIntegral_ofKernel]
  exact integral_volterraL2Kernel_bridge K f x.property hi

theorem Real.inner_volterraL2Operator_eq_integral {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f g : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  inner ℝ g ((Real.volterraL2Operator hK hM hb) f) =
    ∫ (x : ↑(Set.Icc 0 1)),
      ↑↑g ↑x *
        Real.volterraIntegral
          (Real.VolterraIntegralInput.ofUnitLegendreLp hK f
            x) ∂MeasureTheory.Measure.comap Subtype.val (Polynomial.unitJacobiMeasure 0 0)

Lean proof

/-- Fubini identifies the L² realization with classical integrals on the physical interval. -/
theorem inner_volterraL2Operator_eq_integral (f g : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    ⟪g, volterraL2Operator hK hM hb f⟫_ℝ =
      ∫ x : Icc (0 : ℝ) 1, g x * volterraIntegral (.ofUnitLegendreLp hK f x)
        ∂(unitJacobiMeasure 0 0).comap Subtype.val := by
  simp only [VolterraIntegralInput.ofUnitLegendreLp,
    VolterraIntegralInput.ofContinuousKernel, volterraIntegral_ofKernel]
  rw [integral_subtype_comap (μ := unitJacobiMeasure 0 0) measurableSet_Icc
    (fun x : ℝ ↦ g x * ∫ y in (0 : ℝ)..x, K ![x,y]*f y),
    Measure.restrict_eq_self_of_ae_mem (ae_mem_Icc_unitJacobiMeasure 0 0)]
  rw [inner_volterraL2Operator, integral_prod _ (integrable_volterraL2_pair hK hM hb f g),
    ← integral_const_mul]
  apply integral_congr_ae
  filter_upwards [ae_mem_Icc_unitJacobiMeasure 0 0] with x hx
  simp_rw [show ∀ y, volterraL2Kernel K (x,y)*(g x*f y) =
    g x*(volterraL2Kernel K (x,y)*f y) by intro y; ring]
  rw [integral_const_mul, integral_volterraL2Kernel_bridge K f hx
    (intervalIntegrable_continuousVolterra_mul_row hK ⟨x,hx⟩ (by
      apply intervalIntegrable_iff.mpr
      rw [uIoc_of_le hx.1]
      exact (integrableOn_coe_unitLegendreLp f).mono_set
        (fun y hy ↦ ⟨hy.1.le, hy.2.trans hx.2⟩)))]
  ring

For \(x\in [0,1]\), the row integral against \(\mu \) is \(2V_Kf(x)\), explaining the factor \(1/2\) in the operator construction.

Reference details: Volterra coefficient-section convergence and related results

Theorem 6.1.29 Volterra coefficient-section convergence

✓ 🤖

#

Use the normalized shifted Legendre Hilbert basis of \(L^2(\mu )\), with coordinate isometry \(U\). Then \(A_K=UT_KU^{-1}\) satisfies \(A_K(Uf)=U(T_Kf)\), \(\| A_K\| \le M\), and

\[ P_NA_KP_Nc\longrightarrow A_Kc\quad \hbox{in }\ell ^2 \qquad (c\in \ell ^2). \]

Every continuous triangle kernel admits a finite bound \(M\) and hence these realizations.

Lean Formalisation

theorem Real.norm_volterraL2CoefficientOperator_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : ‖Real.volterraL2CoefficientOperator hK hM hb‖ ≤ M

Lean proof

/-- Coordinate transport preserves the physical Volterra norm bound. -/
theorem norm_volterraL2CoefficientOperator_le : ‖volterraL2CoefficientOperator hK hM hb‖ ≤ M := by
  rw [volterraL2CoefficientOperator, HilbertBasis.norm_coefficientOperator]
  exact norm_volterraL2Operator_le hK hM hb

4 related Lean declarations

def Real.volterraL2CoefficientOperator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : ↥(lp (fun x => ℝ) 2) →L[ℝ] ↥(lp (fun x => ℝ) 2)

Lean definition

/-- The Volterra operator in normalized shifted Legendre coordinates. -/
def volterraL2CoefficientOperator :
    lp (fun _ : ℕ ↦ ℝ) 2 →L[ℝ] lp (fun _ : ℕ ↦ ℝ) 2 :=
  (hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0) (by norm_num)).coefficientOperator
    (volterraL2Operator hK hM hb)

theorem Real.volterraL2CoefficientOperator_repr {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  have b :=
    Polynomial.hilbertBasisShiftedJacobi Real.volterraL2CoefficientOperator._proof_1
      Real.volterraL2CoefficientOperator._proof_1;
  (Real.volterraL2CoefficientOperator hK hM hb) (b.repr f) = b.repr ((Real.volterraL2Operator hK hM hb) f)

Lean proof

/-- Normalized coordinates represent the Volterra action exactly. -/
theorem volterraL2CoefficientOperator_repr (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    let b := hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0)
    volterraL2CoefficientOperator hK hM hb (b.repr f) =
      b.repr (volterraL2Operator hK hM hb f) :=
  (hilbertBasisShiftedJacobi (by norm_num) (by norm_num)).coefficientOperator_repr _ f

theorem Real.tendsto_volterraL2CoefficientOperator_finiteSections {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (c : ↥(lp (fun x => ℝ) 2)) :
  Filter.Tendsto
    (fun n => (lp.initialL2Projection n) ((Real.volterraL2CoefficientOperator hK hM hb) ((lp.initialL2Projection n) c)))
    Filter.atTop (nhds ((Real.volterraL2CoefficientOperator hK hM hb) c))

Lean proof

/-- Leading normalized sections converge strongly for all square-summable inputs. -/
theorem tendsto_volterraL2CoefficientOperator_finiteSections (c : lp (fun _ : ℕ ↦ ℝ) 2) :
    Tendsto (fun n ↦ lp.initialL2Projection n
      (volterraL2CoefficientOperator hK hM hb (lp.initialL2Projection n c)))
      atTop (𝓝 (volterraL2CoefficientOperator hK hM hb c)) := by
  simpa only [lp.initialL2Projection_apply] using
    lp.tendsto_initialL2Sections (volterraL2CoefficientOperator hK hM hb) c

theorem Real.exists_volterraL2_bound {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) :
  ∃ M,
    ∃ (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M),
      ‖Real.volterraL2Operator hK hM hb‖ ≤ M ∧ ‖Real.volterraL2CoefficientOperator hK hM hb‖ ≤ M

Lean proof

/-- Every continuous triangle kernel has a finite L² norm certificate. -/
theorem exists_volterraL2_bound {K : (Fin 2 → ℝ) → ℝ}
    (hK : ContinuousOn K volterraTriangle) :
    ∃ (M : ℝ) (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |K z| ≤ M),
      ‖volterraL2Operator hK hM hb‖ ≤ M ∧ ‖volterraL2CoefficientOperator hK hM hb‖ ≤ M := by
  obtain ⟨M,hb⟩ := MvPolynomial.isCompact_volterraTriangle.exists_bound_of_continuousOn hK
  have hb' : ∀ z ∈ volterraTriangle, |K z| ≤ |M| := fun z hz ↦
    (hb z hz).trans (le_abs_self M)
  exact ⟨|M|, abs_nonneg M, hb', norm_volterraL2Operator_le hK _ hb',
    norm_volterraL2CoefficientOperator_le hK _ hb'⟩

Operator-norm convergence and second-kind solves are given in Theorems 6.1.36 and 6.1.44.

Theorem 6.1.30 Exact L² bridge to finite Proriol assembly

✓ 🤖

#

For a polynomial kernel \(K\) and finite shifted-Jacobi input \(p=\sum _n c_nP_n^{(1,0)}(2x-1)\), form

\[ q(x)=x\sum _j(B_Kc)_jP_j^{(1,0)}(1-2x),\qquad B_K=D M_K E. \]

The polynomial \(q\) evaluates to \(V_Kp\) and its \(L^2(\mu )\) class is exactly \(T_K[p]\). Thus \(A_K(U[p])=U[q]\). More generally, any polynomial identity \(V_Kp=q\) on \([0,1]\) identifies the bounded operator’s polynomial output. The normalized shifted Legendre coordinates \(U\) describe the physical output; they are distinct from the unscaled shifted-Jacobi coordinates inside \(B_K\).

Lean Formalisation

theorem Real.volterraL2Operator_polynomial {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (p q : Polynomial ℝ)
  (hq :
    ∀ (x : ↑(Set.Icc 0 1)),
      Real.volterraIntegral (Real.VolterraIntegralInput.ofContinuous hK ⋯ x) = Polynomial.eval (↑x) q) :
  (Real.volterraL2Operator hK hM hb) ((Polynomial.polynomialToL2 ⋯) p) = (Polynomial.polynomialToL2 ⋯) q

Lean proof

/-- A physical polynomial integral identity identifies the L² output exactly. -/
theorem volterraL2Operator_polynomial {K : (Fin 2 → ℝ) → ℝ}
    (hK : ContinuousOn K volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
    (hb : ∀ z ∈ volterraTriangle, |K z| ≤ M) (p q : ℝ[X])
    (hq : ∀ x : Icc (0 : ℝ) 1,
      volterraIntegral (.ofContinuous hK p.continuous.continuousOn x) = q.eval (x : ℝ)) :
    volterraL2Operator hK hM hb
      (polynomialToL2 (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)) p) =
      polynomialToL2 (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)) q := by
  let hm := hasFiniteMoments_unitJacobiMeasure (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0)
  apply ext_inner_left ℝ
  intro g
  have hp := (Measure.quasiMeasurePreserving_snd (μ := unitJacobiMeasure 0 0)
    (ν := unitJacobiMeasure 0 0)).ae_eq_comp (coe_polynomialToL2 hm p)
  have he : (fun z : ℝ × ℝ ↦ volterraL2Kernel K z * (g z.1 * polynomialToL2 hm p z.2)) =ᵐ[(unitJacobiMeasure 0 0).prod (unitJacobiMeasure 0 0)]
      (fun z ↦ volterraL2Kernel K z * (g z.1*p.eval z.2)) := by
    filter_upwards [hp] with z hz
    simp only [Function.comp_apply] at hz
    rw [hz]
  have hi := (integrable_volterraL2_pair hK hM hb (polynomialToL2 hm p) g).congr he
  rw [inner_volterraL2Operator, integral_congr_ae he, integral_prod _ hi, ← integral_const_mul,
    L2.inner_def]
  apply integral_congr_ae
  filter_upwards [ae_mem_Icc_unitJacobiMeasure 0 0, coe_polynomialToL2 hm q] with x hx hqx
  simp_rw [show ∀ y, volterraL2Kernel K (x,y)*(g x*p.eval y) =
    g x*(volterraL2Kernel K (x,y)*p.eval y) by intro y; ring]
  rw [integral_const_mul, integral_volterraL2Kernel K (fun y ↦ p.eval y) ⟨x,hx⟩
    (intervalIntegrable_volterra hK p.continuous.continuousOn hx)]
  rw [show volterraIntegral (.ofKernel K (fun y ↦ p.eval y)
      (intervalIntegrable_volterra hK p.continuous.continuousOn hx)) = q.eval x from
    hq ⟨x,hx⟩]
  simp only [Real.inner_apply, hqx]
  ring

4 related Lean declarations

def MvPolynomial.volterraProriolOutput (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) : Polynomial ℝ

Lean definition

/-- The physical output polynomial reconstructed from finite Proriol Volterra coordinates. -/
def volterraProriolOutput (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) : ℝ[X] :=
  Polynomial.X * (Finsupp.linearCombination ℝ (shiftedJacobi 1 0)
    (volterraProriolCoefficients K c)).comp (1-Polynomial.X)

theorem MvPolynomial.eval_volterraProriolOutput (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) (x : ℝ) :
  Polynomial.eval x (K.volterraProriolOutput c) = Real.volterraIntegral (Real.VolterraIntegralInput.ofPolynomial K ⋯ x)

Lean proof

/-- The physical output includes both endpoint multiplication and reflection. -/
theorem eval_volterraProriolOutput (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) (x : ℝ) :
    (volterraProriolOutput K c).eval x =
      volterraIntegral (.ofPolynomial K
        (Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c).continuous.locallyIntegrable x) := by
  rw [VolterraIntegralInput.ofPolynomial, volterraIntegral_ofKernel]
  simp only [volterraProriolOutput, Polynomial.eval_mul, Polynomial.eval_X,
    Polynomial.eval_comp, Polynomial.eval_sub, Polynomial.eval_one]
  exact volterraProriolCoefficients_exact K c x

theorem MvPolynomial.volterraL2Operator_proriol (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) :
  (Real.volterraL2Operator ⋯ hM hb)
      ((Polynomial.polynomialToL2 ⋯) ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) c)) =
    (Polynomial.polynomialToL2 ⋯) (K.volterraProriolOutput c)

Lean proof

/-- The bounded L² realization reproduces the existing finite polynomial assembly exactly. -/
theorem volterraL2Operator_proriol (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M) :
    volterraL2Operator K.continuous_eval.continuousOn hM hb
      (polynomialToL2 (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num))
        (Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c)) =
      polynomialToL2 (hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num))
        (volterraProriolOutput K c) :=
  volterraL2Operator_polynomial K.continuous_eval.continuousOn hM hb _ _
    (fun x ↦ by
      simpa only [VolterraIntegralInput.ofContinuous, VolterraIntegralInput.ofPolynomial,
        volterraIntegral_ofKernel] using (eval_volterraProriolOutput K c (x : ℝ)).symm)

theorem MvPolynomial.volterraL2CoefficientOperator_proriol (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) :
  have b :=
    Polynomial.hilbertBasisShiftedJacobi Real.volterraL2Operator_polynomial._proof_1
      Real.volterraL2Operator_polynomial._proof_1;
  have hm := ⋯;
  (Real.volterraL2CoefficientOperator ⋯ hM hb)
      (b.repr ((Polynomial.polynomialToL2 hm) ((Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi 1 0)) c))) =
    b.repr ((Polynomial.polynomialToL2 hm) (K.volterraProriolOutput c))

Lean proof

/-- Normalized L² coordinates of finite assembly agree with the bounded coefficient action. -/
theorem volterraL2CoefficientOperator_proriol (K : MvPolynomial (Fin 2) ℝ) (c : ℕ →₀ ℝ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M) :
    let b := hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0)
    let hm := hasFiniteMoments_unitJacobiMeasure (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0)
    volterraL2CoefficientOperator K.continuous_eval.continuousOn hM hb
      (b.repr (polynomialToL2 hm (Finsupp.linearCombination ℝ (shiftedJacobi 1 0) c))) =
      b.repr (polynomialToL2 hm (volterraProriolOutput K c)) := by
  dsimp only
  rw [volterraL2CoefficientOperator, HilbertBasis.coefficientOperator_repr,
    volterraL2Operator_proriol]

Theorem 6.1.31 Uniform kernel approximation in operator norm

✓ 🤖

#

For continuous triangle kernels \(K,L\), with finite nonnegative bounds as above, \(T_K-T_L=T_{K-L}\). If \(|K-L|\le \delta \) on \(\Delta \), \(\delta \ge 0\), then \(\| T_K-T_L\| \le \delta \). Every continuous \(K\) therefore admits polynomial kernels \(p\) with \(\| T_p-T_K\| {\lt}\varepsilon \), for any \(\varepsilon {\gt}0\). More generally, uniform kernel error bounds tending to zero imply convergence of the corresponding physical operators in operator norm.

Lean Formalisation

theorem Real.volterraL2Operator_sub {K L : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (hL : ContinuousOn L Real.volterraTriangle) {M N δ : ℝ} (hM : 0 ≤ M) (hN : 0 ≤ N)
  (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (bL : ∀ z ∈ Real.volterraTriangle, |L z| ≤ N) (hδ : 0 ≤ δ)
  (hKL : ∀ z ∈ Real.volterraTriangle, |K z - L z| ≤ δ) :
  Real.volterraL2Operator hK hM bK - Real.volterraL2Operator hL hN bL = Real.volterraL2Operator ⋯ hδ hKL

Lean proof

/-- Subtracting physical kernels subtracts their bounded L² realizations. -/
theorem volterraL2Operator_sub :
    volterraL2Operator hK hM bK - volterraL2Operator hL hN bL =
      volterraL2Operator (hK.sub hL) hδ hKL := by
  apply ContinuousLinearMap.ext
  intro f
  apply ext_inner_left ℝ
  intro g
  rw [sub_apply, inner_sub_right]
  simp only [inner_volterraL2Operator]
  rw [← mul_sub, ← integral_sub (integrable_volterraL2_pair hK hM bK f g)
    (integrable_volterraL2_pair hL hN bL f g)]
  congr 1
  apply integral_congr_ae
  filter_upwards [] with z
  simp only [volterraL2Kernel, Pi.sub_apply]
  split_ifs <;> ring

3 related Lean declarations

theorem Real.norm_volterraL2Operator_sub_le {K L : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  (hL : ContinuousOn L Real.volterraTriangle) {M N δ : ℝ} (hM : 0 ≤ M) (hN : 0 ≤ N)
  (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (bL : ∀ z ∈ Real.volterraTriangle, |L z| ≤ N) (hδ : 0 ≤ δ)
  (hKL : ∀ z ∈ Real.volterraTriangle, |K z - L z| ≤ δ) :
  ‖Real.volterraL2Operator hK hM bK - Real.volterraL2Operator hL hN bL‖ ≤ δ

Lean proof

/-- The uniform kernel error bounds the physical operator-norm error. -/
theorem norm_volterraL2Operator_sub_le :
    ‖volterraL2Operator hK hM bK - volterraL2Operator hL hN bL‖ ≤ δ := by
  rw [volterraL2Operator_sub hK hL hM hN bK bL hδ hKL]
  exact norm_volterraL2Operator_le (hK.sub hL) hδ hKL

theorem Real.exists_polynomial_near_volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {ε : ℝ} (hε : 0 < ε) :
  ∃ p N,
    ∃ (hN : 0 ≤ N) (bp : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) p| ≤ N),
      ‖Real.volterraL2Operator ⋯ hN bp - Real.volterraL2Operator hK hM bK‖ < ε

Lean proof

/-- Polynomial kernels approximate a continuous Volterra operator in operator norm. -/
theorem exists_polynomial_near_volterraL2Operator {ε : ℝ} (hε : 0 < ε) :
    ∃ (p : MvPolynomial (Fin 2) ℝ) (N : ℝ) (hN : 0 ≤ N)
      (bp : ∀ z ∈ volterraTriangle, |MvPolynomial.eval z p| ≤ N),
      ‖volterraL2Operator p.continuous_eval.continuousOn hN bp -
        volterraL2Operator hK hM bK‖ < ε := by
  obtain ⟨p, hp⟩ := MvPolynomial.exists_polynomial_near_volterraKernel hK
    (half_pos hε)
  have bp : ∀ z ∈ volterraTriangle, |MvPolynomial.eval z p| ≤ M + ε / 2 := by
    intro z hz
    calc
      _ ≤ |MvPolynomial.eval z p - K z| + |K z| := by simpa only [sub_add_cancel] using abs_add_le (MvPolynomial.eval z p - K z) (K z)
      _ ≤ ε / 2 + M := add_le_add (hp z hz).le (bK z hz)
      _ = _ := add_comm _ _
  refine ⟨p, M + ε / 2, by positivity, bp, ?_⟩
  exact (norm_volterraL2Operator_sub_le p.continuous_eval.continuousOn hK
    (by positivity) hM bp bK (half_pos hε).le
    (fun z hz ↦ (hp z hz).le)).trans_lt (half_lt_self hε)

theorem Real.tendsto_volterraL2Operator_of_error_bounds {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  Filter.Tendsto (fun n => Real.volterraL2Operator ⋯ ⋯ ⋯) Filter.atTop (nhds (Real.volterraL2Operator hK hM bK))

Lean proof

/-- Vanishing uniform kernel errors imply convergence in operator norm. -/
theorem tendsto_volterraL2Operator_of_error_bounds
    {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
    (hs : ∀ n, ContinuousOn (Ks n) volterraTriangle)
    {B e : ℕ → ℝ} (hB : ∀ n, 0 ≤ B n)
    (bs : ∀ n z, z ∈ volterraTriangle → |Ks n z| ≤ B n)
    (he : ∀ n, 0 ≤ e n)
    (err : ∀ n z, z ∈ volterraTriangle → |Ks n z - K z| ≤ e n)
    (hte : Tendsto e atTop (𝓝 0)) :
    Tendsto (fun n ↦ volterraL2Operator (hs n) (hB n) (bs n)) atTop
      (𝓝 (volterraL2Operator hK hM bK)) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  exact squeeze_zero (fun _ ↦ norm_nonneg _)
    (fun n ↦ norm_volterraL2Operator_sub_le (hs n) hK (hB n) hM
      (bs n) bK (he n) (err n)) hte

Theorem 6.1.32 Dominated convergence of real L² classes

✓ 🤖

#

For real \(L^2\) representatives, \(\| f\| _2^2=\int f^2\, d\mu \). Let \(f_i,g\in L^2(\mu )\), with \(f_i\to g\) almost everywhere along a countably generated filter. If \(|f_i-g|\le B\) almost everywhere for every \(i\), and \(B^2\) is integrable, then \([f_i]\to [g]\) in \(L^2\) norm.

Lean Formalisation

theorem MeasureTheory.L2.norm_sq_eq_integral_sq.{u_1} {X : Type u_1} [MeasurableSpace X] {μ : MeasureTheory.Measure X}
  (f : ↥(MeasureTheory.Lp ℝ 2 μ)) : ‖f‖ ^ 2 = ∫ (x : X), ↑↑f x ^ 2 ∂μ

Lean proof

/-- The squared norm of an L² class is the integral of the squared representative. -/
theorem L2.norm_sq_eq_integral_sq (f : Lp ℝ 2 μ) :
    ‖f‖ ^ 2 = ∫ x, (f x) ^ 2 ∂μ := by
  rw [← real_inner_self_eq_norm_sq, L2.inner_def]
  simp only [Real.inner_apply, pow_two]

1 related Lean declaration

theorem MeasureTheory.tendsto_L2_of_dominated.{u_1, u_2} {X : Type u_1} {ι : Type u_2} [MeasurableSpace X]
  {μ : MeasureTheory.Measure X} {l : Filter ι} [l.IsCountablyGenerated] (f : ι → X → ℝ) (g : X → ℝ)
  (hf : ∀ (i : ι), MeasureTheory.MemLp (f i) 2 μ) (hg : MeasureTheory.MemLp g 2 μ) (B : X → ℝ)
  (hB : MeasureTheory.Integrable (fun x => B x ^ 2) μ) (hb : ∀ (i : ι), ∀ᵐ (x : X) ∂μ, |f i x - g x| ≤ B x)
  (ht : ∀ᵐ (x : X) ∂μ, Filter.Tendsto (fun i => f i x) l (nhds (g x))) :
  Filter.Tendsto (fun i => MeasureTheory.MemLp.toLp (f i) ⋯) l (nhds (MeasureTheory.MemLp.toLp g hg))

Lean proof

/-- Dominated convergence of representatives gives norm convergence in real L². -/
theorem tendsto_L2_of_dominated
    (f : ι → X → ℝ) (g : X → ℝ)
    (hf : ∀ i, MemLp (f i) 2 μ) (hg : MemLp g 2 μ)
    (B : X → ℝ) (hB : Integrable (fun x ↦ B x ^ 2) μ)
    (hb : ∀ i, ∀ᵐ x ∂μ, |f i x - g x| ≤ B x)
    (ht : ∀ᵐ x ∂μ, Tendsto (fun i ↦ f i x) l (𝓝 (g x))) :
    Tendsto (fun i ↦ (hf i).toLp (f i)) l (𝓝 (hg.toLp g)) := by
  have hs : Tendsto (fun i ↦ ∫ x, (f i x - g x) ^ 2 ∂μ) l (𝓝 0) := by
    simpa only [integral_zero, Pi.pow_apply, Pi.sub_apply] using
      (tendsto_integral_filter_of_dominated_convergence (f := fun _ : X ↦ (0 : ℝ))
        (fun x ↦ B x ^ 2)
        (Eventually.of_forall (fun i ↦ ((hf i).aestronglyMeasurable.sub
          hg.aestronglyMeasurable).pow 2))
        (Eventually.of_forall (fun i ↦ (hb i).mono (fun x hx ↦ by
          rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
          exact sq_le_sq' (abs_le.mp hx).1 (abs_le.mp hx).2))) hB
        (ht.mono (fun x hx ↦ by simpa using (hx.sub_const (g x)).pow 2)))
  rw [tendsto_iff_norm_sub_tendsto_zero]
  have he (i : ι) : ‖(hf i).toLp (f i) - hg.toLp g‖ ^ 2 =
      ∫ x, (f i x - g x) ^ 2 ∂μ := by
    rw [L2.norm_sq_eq_integral_sq]
    apply integral_congr_ae
    filter_upwards [Lp.coeFn_sub ((hf i).toLp (f i)) (hg.toLp g),
      (hf i).coeFn_toLp, hg.coeFn_toLp] with x hx hfx hgx
    simp only [hx, Pi.sub_apply, hfx, hgx]
  have hh := Real.continuous_sqrt.continuousAt.tendsto.comp hs
  simpa only [Function.comp_def, ← he, Real.sqrt_sq (norm_nonneg _), Real.sqrt_zero] using hh

Theorem 6.1.33 Compact operators and two-sided coordinate sections

✓ 🤖

#

On real or complex \(\ell ^2\), the initial coordinate maps \(P_N\) are compact, self-adjoint projections. If \(A\) is compact, its adjoint is compact and

\[ P_NA\to A,\qquad AP_N\to A,\qquad P_NAP_N\to A \quad \hbox{in operator norm}. \]

Lean Formalisation

theorem lp.isCompactOperator_initialL2Projection.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (N : ℕ) :
  IsCompactOperator ⇑(lp.initialL2Projection N)

Lean proof

/-- Initial coordinate projections have finite rank and are compact. -/
theorem isCompactOperator_initialL2Projection (N : ℕ) :
    IsCompactOperator (initialL2Projection (𝕜 := 𝕜) N) := by
  unfold initialL2Projection
  have h (s : Finset ℕ) : IsCompactOperator
      (∑ i ∈ s, (singleContinuousLinearMap 𝕜 (fun _ : ℕ ↦ 𝕜) 2 i).comp
        (evalCLM 𝕜 (fun _ : ℕ ↦ 𝕜) 2 i) :
        lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2) := by
    induction s using Finset.induction_on with
    | empty => simpa using (isCompactOperator_zero :
        IsCompactOperator (0 : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2))
    | @insert i s hi ih =>
      rw [Finset.sum_insert hi]
      exact ((isCompactOperator_of_locallyCompactSpace_rng
        (singleContinuousLinearMap 𝕜 (fun _ : ℕ ↦ 𝕜) 2 i)).comp_clm _).add ih
  exact h _

6 related Lean declarations

theorem lp.adjoint_initialL2Projection.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (N : ℕ) :
  ContinuousLinearMap.adjoint (lp.initialL2Projection N) = lp.initialL2Projection N

Lean proof

/-- Coordinate truncations are self-adjoint. -/
theorem adjoint_initialL2Projection (N : ℕ) :
    (initialL2Projection (𝕜 := 𝕜) N).adjoint = initialL2Projection N := by
  apply ContinuousLinearMap.ext
  intro y
  apply ext_inner_left 𝕜
  intro x
  rw [adjoint_inner_right]
  simp only [initialL2Projection_apply, inner_sum, sum_inner,
    inner_single_left, inner_single_right]

theorem lp.initialL2Projection_idempotent.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (N : ℕ) :
  lp.initialL2Projection N ∘SL lp.initialL2Projection N = lp.initialL2Projection N

Lean proof

/-- Applying an initial projection twice has the same effect as applying it once. -/
theorem initialL2Projection_idempotent (N : ℕ) :
    (initialL2Projection (𝕜 := 𝕜) N).comp (initialL2Projection N) = initialL2Projection N := by
  apply ContinuousLinearMap.ext
  intro f
  apply lp.ext
  funext i
  simp only [ContinuousLinearMap.comp_apply, initialL2Projection_apply, lp.coeFn_sum,
    lp.coeFn_single, Finset.sum_apply, Finset.sum_pi_single]
  split_ifs <;> simp_all

theorem lp.tendsto_initialL2Projection_comp.{u_1} {𝕜 : Type u_1} [RCLike 𝕜]
  (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) (hT : IsCompactOperator ⇑T) :
  Filter.Tendsto (fun N => lp.initialL2Projection N ∘SL T) Filter.atTop (nhds T)

Lean proof

/-- Compact operators have operator-norm convergent output sections. -/
theorem tendsto_initialL2Projection_comp
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (hT : IsCompactOperator T) :
    Tendsto (fun N ↦ (initialL2Projection N).comp T) atTop (𝓝 T) :=
  tendsto_compact_comp_of_strongly_tendsto_id _ norm_initialL2Projection_le
    tendsto_initialL2Projection T hT

theorem lp.isCompactOperator_adjoint_of_initialL2.{u_1} {𝕜 : Type u_1} [RCLike 𝕜]
  (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) (hT : IsCompactOperator ⇑T) :
  IsCompactOperator ⇑(ContinuousLinearMap.adjoint T)

Lean proof

/-- Compactness is preserved by the adjoint on sequence Hilbert space. -/
theorem isCompactOperator_adjoint_of_initialL2
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (hT : IsCompactOperator T) : IsCompactOperator T.adjoint := by
  have ht := (ContinuousLinearMap.adjoint.continuous.tendsto _).comp
    (tendsto_initialL2Projection_comp T hT)
  apply isCompactOperator_of_tendsto ht
  apply Eventually.of_forall
  intro N
  dsimp only [Function.comp_apply]
  rw [adjoint_comp, adjoint_initialL2Projection]
  exact (isCompactOperator_initialL2Projection N).clm_comp T.adjoint

theorem lp.tendsto_comp_initialL2Projection.{u_1} {𝕜 : Type u_1} [RCLike 𝕜]
  (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) (hT : IsCompactOperator ⇑T) :
  Filter.Tendsto (fun N => T ∘SL lp.initialL2Projection N) Filter.atTop (nhds T)

Lean proof

/-- Compact operators have operator-norm convergent input sections. -/
theorem tendsto_comp_initialL2Projection
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (hT : IsCompactOperator T) :
    Tendsto (fun N ↦ T.comp (initialL2Projection N)) atTop (𝓝 T) := by
  have ht := (ContinuousLinearMap.adjoint.continuous.tendsto _).comp
    (tendsto_initialL2Projection_comp T.adjoint
      (isCompactOperator_adjoint_of_initialL2 T hT))
  simpa only [Function.comp_def, adjoint_comp, adjoint_adjoint, adjoint_initialL2Projection] using ht

theorem lp.tendsto_initialL2Sections_norm.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2))
  (hT : IsCompactOperator ⇑T) :
  Filter.Tendsto (fun N => lp.initialL2Projection N ∘SL T ∘SL lp.initialL2Projection N) Filter.atTop (nhds T)

Lean proof

/-- Leading input and output sections converge in operator norm for compact operators. -/
theorem tendsto_initialL2Sections_norm
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (hT : IsCompactOperator T) :
    Tendsto (fun N ↦ (initialL2Projection N).comp (T.comp (initialL2Projection N)))
      atTop (𝓝 T) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  have ho := (tendsto_initialL2Projection_comp T hT).sub (tendsto_const_nhds (x := T))
  have hi := (tendsto_comp_initialL2Projection T hT).sub (tendsto_const_nhds (x := T))
  apply squeeze_zero (fun _ ↦ norm_nonneg _)
    (fun N ↦ show ‖(initialL2Projection N).comp (T.comp (initialL2Projection N)) - T‖ ≤
      ‖T.comp (initialL2Projection N) - T‖ + ‖(initialL2Projection N).comp T - T‖ from ?_)
    (by simpa using hi.norm.add ho.norm)
  calc
    _ ≤ ‖(initialL2Projection N).comp (T.comp (initialL2Projection N)) -
          (initialL2Projection N).comp T‖ + ‖(initialL2Projection N).comp T - T‖ :=
      norm_sub_le_norm_sub_add_norm_sub _ _ _
    _ ≤ _ := by
      apply add_le_add _ le_rfl
      rw [← comp_sub]
      exact (opNorm_comp_le _ _).trans
        (by simpa only [one_mul] using (mul_le_mul_of_nonneg_right
          (norm_initialL2Projection_le (𝕜 := 𝕜) N) (norm_nonneg _)))

Theorem 6.1.34 Compactness from continuous Hilbert-space rows

✓ 🤖

#

Let \(\mu \) be a finite measure supported almost everywhere on a compact set \(S\), and let \(T:\ell ^2(\mathbb R)\to L^2(\mu )\) be bounded. Suppose \(r:S\to \ell ^2(\mathbb R)\) is continuous and \((Tf)(x)=\langle r(x),f\rangle \) almost everywhere, for every \(f\). Then \(T\) is compact.

Lean Formalisation

theorem MeasureTheory.isCompactOperator_of_continuous_L2_rows.{u_1} {X : Type u_1} [MeasurableSpace X] [TopologicalSpace X]
  (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMeasure μ]
  (T : ↥(lp (fun x => ℝ) 2) →L[ℝ] ↥(MeasureTheory.Lp ℝ 2 μ)) (r : X → ↥(lp (fun x => ℝ) 2)) {S : Set X}
  (hS : IsCompact S) (hr : ContinuousOn r S) (hs : ∀ᵐ (x : X) ∂μ, x ∈ S)
  (hT : ∀ (f : ↥(lp (fun x => ℝ) 2)), ↑↑(T f) =ᵐ[μ] fun x => inner ℝ (r x) f) : IsCompactOperator ⇑T

Lean proof

/-- An L² operator with continuous coefficient-space rows on compact support is compact. -/
theorem isCompactOperator_of_continuous_L2_rows
    (T : lp (fun _ : ℕ ↦ ℝ) 2 →L[ℝ] Lp ℝ 2 μ)
    (r : X → lp (fun _ : ℕ ↦ ℝ) 2) {S : Set X}
    (hS : IsCompact S) (hr : ContinuousOn r S) (hs : ∀ᵐ x ∂μ, x ∈ S)
    (hT : ∀ f, T f =ᵐ[μ] fun x ↦ ⟪r x, f⟫_ℝ) : IsCompactOperator T := by
  apply isClosed_setOfPred_isCompactOperator.closure_subset
  rw [Metric.mem_closure_iff]
  intro ε hε
  let c : ℝ := (measureUnivNNReal μ : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹
  have hc : 0 ≤ c := Real.rpow_nonneg (by positivity) _
  let δ := ε / (c + 1)
  have hd : 0 < δ := div_pos hε (by positivity)
  have hu := tendstoUniformlyOn_of_strongly_tendsto_id
    (lp.initialL2Projection (𝕜 := ℝ)) lp.norm_initialL2Projection_le
    lp.tendsto_initialL2Projection (hS.image_of_continuousOn hr)
  obtain ⟨N, hN⟩ := eventually_atTop.1 (Metric.tendstoUniformlyOn_iff.mp hu δ hd)
  refine ⟨T.comp (lp.initialL2Projection N),
    (lp.isCompactOperator_initialL2Projection N).clm_comp T, ?_⟩
  rw [dist_eq_norm, norm_sub_rev]
  have hb : ‖T.comp (lp.initialL2Projection N) - T‖ ≤ c * δ := by
    apply opNorm_le_bound _ (mul_nonneg hc hd.le)
    intro f
    have ha : ∀ᵐ x ∂μ, ‖((T.comp (lp.initialL2Projection N) - T) f) x‖ ≤ δ * ‖f‖ := by
      filter_upwards [hs, hT (lp.initialL2Projection N f), hT f,
        Lp.coeFn_sub (T (lp.initialL2Projection N f)) (T f)] with x hx hp ht he
      change ‖(T (lp.initialL2Projection N f) - T f) x‖ ≤ _
      rw [he, Pi.sub_apply, hp, ht, ← lp.adjoint_initialL2Projection N,
        adjoint_inner_right, ← inner_sub_left]
      apply (norm_inner_le_norm _ _).trans
      apply mul_le_mul_of_nonneg_right _ (norm_nonneg _)
      simpa only [dist_eq_norm, id_eq, norm_sub_rev] using (hN N le_rfl (r x) ⟨x, hx, rfl⟩).le
    simpa only [mul_assoc] using Lp.norm_le_of_ae_bound (mul_nonneg hd.le (norm_nonneg f)) ha
  apply hb.trans_lt
  dsimp only [δ]
  rw [← mul_div_assoc, div_lt_iff₀ (by positivity : 0 < c + 1)]
  nlinarith

Theorem 6.1.35 Continuous L² rows of the physical Volterra kernel

✓ 🤖

#

Under the continuous-kernel hypotheses above, put \(r_x=[y\mapsto \widetilde K(x,y)]\in L^2(\mu )\), \(\mu =2\, dx|_{[0,1]}\). Every row is square integrable, \(\| r_x\| \le \sqrt2 M\), and

\[ \langle r_x,f\rangle =\int \widetilde K(x,y)f(y)\, d\mu (y),\qquad T_Kf(x)=\tfrac 12\langle r_x,f\rangle \quad \hbox{almost everywhere}. \]

The row pairing belongs to \(L^2(\mu )\) for every \(f\in L^2(\mu )\), and \(x\mapsto r_x\) is continuous on the closed unit interval in \(L^2\) norm.

Lean Formalisation

theorem Real.memLp_volterraL2Kernel_row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (x : ℝ) :
  MeasureTheory.MemLp (fun y => Real.volterraL2Kernel K (x, y)) 2 (Polynomial.unitJacobiMeasure 0 0)

Lean proof

/-- Every zero-extended Volterra row belongs to the physical L² space. -/
theorem memLp_volterraL2Kernel_row (x : ℝ) :
    MemLp (fun y ↦ volterraL2Kernel K (x,y)) 2 (unitJacobiMeasure 0 0) :=
  MemLp.of_bound ((measurable_volterraL2Kernel hK).comp
    (measurable_const.prodMk measurable_id)).aestronglyMeasurable M
    (Eventually.of_forall (fun y ↦ norm_volterraL2Kernel_le hM hb (x,y)))

7 related Lean declarations

def Real.volterraL2Row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (x : ℝ) : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))

Lean definition

/-- The L² class of a zero-extended Volterra row. -/
def volterraL2Row (x : ℝ) : Lp ℝ 2 (unitJacobiMeasure 0 0) :=
  (memLp_volterraL2Kernel_row hK hM hb x).toLp _

theorem Real.volterraL2Row_ae {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (x : ℝ) :
  ↑↑(Real.volterraL2Row hK hM hb x) =ᵐ[Polynomial.unitJacobiMeasure 0 0] fun y => Real.volterraL2Kernel K (x, y)

Lean proof

/-- Volterra rows have the expected almost-everywhere representative. -/
theorem volterraL2Row_ae (x : ℝ) :
    volterraL2Row hK hM hb x =ᵐ[unitJacobiMeasure 0 0]
      fun y ↦ volterraL2Kernel K (x,y) :=
  (memLp_volterraL2Kernel_row hK hM hb x).coeFn_toLp

theorem Real.inner_volterraL2Row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (x : ℝ)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  inner ℝ (Real.volterraL2Row hK hM hb x) f =
    ∫ (y : ℝ), Real.volterraL2Kernel K (x, y) * ↑↑f y ∂Polynomial.unitJacobiMeasure 0 0

Lean proof

/-- The row inner product is the ordinary kernel integral. -/
theorem inner_volterraL2Row (x : ℝ) (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    ⟪volterraL2Row hK hM hb x, f⟫_ℝ =
      ∫ y, volterraL2Kernel K (x,y) * f y ∂unitJacobiMeasure 0 0 := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [volterraL2Row_ae hK hM hb x] with y hy
  simp only [Real.inner_apply, hy]

theorem Real.norm_volterraL2Row_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (x : ℝ) :
  ‖Real.volterraL2Row hK hM hb x‖ ≤
    ↑(MeasureTheory.measureUnivNNReal (Polynomial.unitJacobiMeasure 0 0)) ^ (ENNReal.toReal 2)⁻¹ * M

Lean proof

/-- A uniform bound for all row norms. -/
theorem norm_volterraL2Row_le (x : ℝ) :
    ‖volterraL2Row hK hM hb x‖ ≤
      (measureUnivNNReal (unitJacobiMeasure 0 0) : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹ * M := by
  apply Lp.norm_le_of_ae_bound hM
  filter_upwards [volterraL2Row_ae hK hM hb x] with y hy
  rw [hy]
  exact norm_volterraL2Kernel_le hM hb (x,y)

theorem Real.memLp_inner_volterraL2Row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  MeasureTheory.MemLp (fun x => inner ℝ (Real.volterraL2Row hK hM hb x) f) 2 (Polynomial.unitJacobiMeasure 0 0)

Lean proof

/-- Pairing a row with fixed L² data again gives an L² function of the row parameter. -/
theorem memLp_inner_volterraL2Row (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    MemLp (fun x ↦ ⟪volterraL2Row hK hM hb x, f⟫_ℝ) 2 (unitJacobiMeasure 0 0) := by
  have hf := (Lp.memLp f).aestronglyMeasurable.comp_quasiMeasurePreserving
    (Measure.quasiMeasurePreserving_snd (μ := unitJacobiMeasure 0 0)
      (ν := unitJacobiMeasure 0 0))
  have hm := ((measurable_volterraL2Kernel hK).aestronglyMeasurable.mul hf).integral_prod_right'
  simp only [Function.comp_def, Pi.mul_apply] at hm
  simp_rw [← inner_volterraL2Row hK hM hb] at hm
  apply MemLp.of_bound hm
    (((measureUnivNNReal (unitJacobiMeasure 0 0) : ℝ) ^ (2 : ℝ≥0∞).toReal⁻¹ * M) * ‖f‖)
  apply Eventually.of_forall
  intro x
  exact (norm_inner_le_norm _ _).trans
    (mul_le_mul_of_nonneg_right (norm_volterraL2Row_le hK hM hb x) (norm_nonneg _))

theorem Real.volterraL2Operator_ae_inner_row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) :
  ↑↑((Real.volterraL2Operator hK hM hb) f) =ᵐ[Polynomial.unitJacobiMeasure 0 0] fun x =>
    1 / 2 * inner ℝ (Real.volterraL2Row hK hM hb x) f

Lean proof

/-- The physical L² operator is represented by half the row inner product. -/
theorem volterraL2Operator_ae_inner_row (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    volterraL2Operator hK hM hb f =ᵐ[unitJacobiMeasure 0 0]
      fun x ↦ (1/2 : ℝ) * ⟪volterraL2Row hK hM hb x, f⟫_ℝ := by
  let hg := (memLp_inner_volterraL2Row hK hM hb f).const_mul (1/2 : ℝ)
  have he : volterraL2Operator hK hM hb f = hg.toLp _ := by
    apply ext_inner_left ℝ
    intro g
    rw [inner_volterraL2Operator,
      integral_prod _ (integrable_volterraL2_pair hK hM hb f g),
      ← integral_const_mul, L2.inner_def]
    apply integral_congr_ae
    filter_upwards [hg.coeFn_toLp] with x hx
    rw [Real.inner_apply, hx, inner_volterraL2Row]
    simp_rw [show ∀ y, volterraL2Kernel K (x,y)*(g x*f y) =
      g x*(volterraL2Kernel K (x,y)*f y) by intro y; ring]
    rw [integral_const_mul]
    ring
  rw [he]
  exact hg.coeFn_toLp

theorem Real.continuousOn_volterraL2Row {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : ContinuousOn (Real.volterraL2Row hK hM hb) (Set.Icc 0 1)

Lean proof

/-- A continuous triangle kernel has continuous rows in L², including at the endpoints. -/
theorem continuousOn_volterraL2Row : ContinuousOn (volterraL2Row hK hM hb) (Icc 0 1) := by
  rw [continuousOn_iff_continuous_domRestrict, continuous_iff_continuousAt]
  intro x
  apply tendsto_L2_of_dominated
    (fun s : Icc (0 : ℝ) 1 ↦ fun y ↦ volterraL2Kernel K (s,y))
    (fun y ↦ volterraL2Kernel K (x,y))
    (fun s ↦ memLp_volterraL2Kernel_row hK hM hb s)
    (memLp_volterraL2Kernel_row hK hM hb x) (fun _ ↦ 2*M)
    (integrable_const _)
  · intro s
    apply Eventually.of_forall
    intro y
    exact (abs_sub _ _).trans (add_le_add (norm_volterraL2Kernel_le hM hb (s,y))
      (norm_volterraL2Kernel_le hM hb (x,y))) |>.trans_eq (by ring)
  · filter_upwards [ae_mem_Icc_unitJacobiMeasure 0 0, (unitJacobiMeasure 0 0).ae_ne (x : ℝ)]
      with y hy hne
    exact continuousAt_volterra_row_off_diagonal hK x hy hne

Theorem 6.1.36 Compact Volterra operators and norm-convergent sections

✓ 🤖

#

For every continuous triangle kernel, \(T_K\) and its normalized shifted Legendre coefficient operator \(A_K\) are compact. Consequently \(\| P_NA_KP_N-A_K\| \to 0\).

Lean Formalisation

theorem Real.isCompactOperator_volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : IsCompactOperator ⇑(Real.volterraL2Operator hK hM hb)

Lean proof

/-- Every continuous triangle kernel gives a compact physical Volterra operator. -/
theorem isCompactOperator_volterraL2Operator :
    IsCompactOperator (volterraL2Operator hK hM hb) := by
  let b := hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0)
  let S := (volterraL2Operator hK hM hb).comp
    b.repr.symm.toContinuousLinearEquiv.toContinuousLinearMap
  have hc : IsCompactOperator S := by
    apply isCompactOperator_of_continuous_L2_rows (unitJacobiMeasure 0 0) S
      (fun x ↦ (1/2 : ℝ) • b.repr (volterraL2Row hK hM hb x)) isCompact_Icc
    · exact (b.repr.continuous.comp_continuousOn
        (continuousOn_volterraL2Row hK hM hb)).const_smul (1/2 : ℝ)
    · exact ae_mem_Icc_unitJacobiMeasure 0 0
    · intro f
      filter_upwards [volterraL2Operator_ae_inner_row hK hM hb (b.repr.symm f)] with x hx
      change volterraL2Operator hK hM hb (b.repr.symm f) x = _
      rw [hx, real_inner_smul_left]
      congr 1
      rw [← b.repr.inner_map_map, LinearIsometryEquiv.apply_symm_apply]
  have he : S.comp b.repr.toContinuousLinearEquiv.toContinuousLinearMap =
      volterraL2Operator hK hM hb := by
    apply ContinuousLinearMap.ext
    intro f
    change volterraL2Operator hK hM hb (b.repr.symm (b.repr f)) = _
    rw [LinearIsometryEquiv.symm_apply_apply]
  rw [← he]
  exact hc.comp_clm _

2 related Lean declarations

theorem Real.isCompactOperator_volterraL2CoefficientOperator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  IsCompactOperator ⇑(Real.volterraL2CoefficientOperator hK hM hb)

Lean proof

/-- Normalized shifted Legendre coordinates preserve compactness. -/
theorem isCompactOperator_volterraL2CoefficientOperator :
    IsCompactOperator (volterraL2CoefficientOperator hK hM hb) :=
  ((isCompactOperator_volterraL2Operator hK hM hb).comp_clm _).clm_comp _

theorem Real.tendsto_volterraL2CoefficientOperator_sections_norm {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  Filter.Tendsto
    (fun n => lp.initialL2Projection n ∘SL Real.volterraL2CoefficientOperator hK hM hb ∘SL lp.initialL2Projection n)
    Filter.atTop (nhds (Real.volterraL2CoefficientOperator hK hM hb))

Lean proof

/-- Leading normalized Volterra sections converge in operator norm. -/
theorem tendsto_volterraL2CoefficientOperator_sections_norm :
    Tendsto (fun n ↦ (lp.initialL2Projection n).comp
      ((volterraL2CoefficientOperator hK hM hb).comp (lp.initialL2Projection n)))
      atTop (𝓝 (volterraL2CoefficientOperator hK hM hb)) :=
  lp.tendsto_initialL2Sections_norm _ (isCompactOperator_volterraL2CoefficientOperator hK hM hb)

Reference details: Resolvents from summable or factorially bounded iterates

Theorem 6.1.37 Resolvents from summable or factorially bounded iterates

✓ 🤖

#

For a bounded operator \(T\) on a real or complex Banach space, summability of \(\sum _{n\ge 0}T^n\) implies invertibility of \(I-T\), with inverse that series. Every right-hand side has a unique solution of \(u-Tu=f\). A bound \(\| T^n\| \le C M^n/n!\) for all \(n\) suffices for summability. No assumption \(\| T\| {\lt}1\) is required.

Lean Formalisation

theorem ContinuousLinearMap.summable_pow_of_factorial_bound.{u_1, u_2} {𝕜 : Type u_1} {E : Type u_2} [RCLike 𝕜]
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] [CompleteSpace E] (T : E →L[𝕜] E) {C M : ℝ}
  (h : ∀ (n : ℕ), ‖T ^ n‖ ≤ C * (M ^ n / ↑n.factorial)) : Summable fun n => T ^ n

Lean proof

/-- A factorial bound on powers makes the operator Neumann series summable. -/
theorem summable_pow_of_factorial_bound (T : E →L[𝕜] E) {C M : ℝ}
    (h : ∀ n : ℕ, ‖T ^ n‖ ≤ C * (M ^ n / n.factorial)) :
    Summable (fun n : ℕ ↦ T ^ n) :=
  Summable.of_norm_bounded ((Real.summable_pow_div_factorial M).mul_left C) h

4 related Lean declarations

theorem ContinuousLinearMap.isUnit_one_sub_of_summable_pow.{u_1, u_2} {𝕜 : Type u_1} {E : Type u_2} [RCLike 𝕜]
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (T : E →L[𝕜] E) (h : Summable fun n => T ^ n) : IsUnit (1 - T)

Lean proof

/-- Summable iterates give an inverse without assuming that the operator norm is less than one. -/
theorem isUnit_one_sub_of_summable_pow (T : E →L[𝕜] E)
    (h : Summable (fun n : ℕ ↦ T ^ n)) : IsUnit (1 - T) := by
  exact ⟨⟨1 - T, ∑' n : ℕ, T ^ n, h.one_sub_mul_tsum_pow,
    h.tsum_pow_mul_one_sub⟩, rfl⟩

theorem ContinuousLinearMap.inverse_one_sub_eq_tsum_pow.{u_1, u_2} {𝕜 : Type u_1} {E : Type u_2} [RCLike 𝕜]
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (T : E →L[𝕜] E) (h : Summable fun n => T ^ n) :
  Ring.inverse (1 - T) = ∑' (n : ℕ), T ^ n

Lean proof

/-- The resolvent is the norm-convergent series of iterates. -/
theorem inverse_one_sub_eq_tsum_pow (T : E →L[𝕜] E)
    (h : Summable (fun n : ℕ ↦ T ^ n)) :
    Ring.inverse (1 - T) = ∑' n : ℕ, T ^ n := by
  have hi := Ring.inverse_mul_cancel (1 - T) (isUnit_one_sub_of_summable_pow T h)
  calc
    _ = Ring.inverse (1 - T) * ((1 - T) * ∑' n : ℕ, T ^ n) := by
      rw [h.one_sub_mul_tsum_pow, mul_one]
    _ = _ := by rw [← mul_assoc, hi, one_mul]

theorem ContinuousLinearMap.isUnit_one_sub_of_factorial_bound.{u_1, u_2} {𝕜 : Type u_1} {E : Type u_2} [RCLike 𝕜]
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] [CompleteSpace E] (T : E →L[𝕜] E) {C M : ℝ}
  (h : ∀ (n : ℕ), ‖T ^ n‖ ≤ C * (M ^ n / ↑n.factorial)) : IsUnit (1 - T)

Lean proof

/-- A factorial iterate bound implies invertibility of the second-kind equation. -/
theorem isUnit_one_sub_of_factorial_bound (T : E →L[𝕜] E) {C M : ℝ}
    (h : ∀ n : ℕ, ‖T ^ n‖ ≤ C * (M ^ n / n.factorial)) : IsUnit (1 - T) :=
  isUnit_one_sub_of_summable_pow T (summable_pow_of_factorial_bound T h)

theorem ContinuousLinearMap.existsUnique_sub_apply_eq_of_summable_pow.{u_1, u_2} {𝕜 : Type u_1} {E : Type u_2} [RCLike 𝕜]
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (T : E →L[𝕜] E) (h : Summable fun n => T ^ n) (f : E) : ∃! u, u - T u = f

Lean proof

/-- Every right-hand side has a unique solution when the iterate series is summable. -/
theorem existsUnique_sub_apply_eq_of_summable_pow (T : E →L[𝕜] E)
    (h : Summable (fun n : ℕ ↦ T ^ n)) (f : E) : ∃! u : E, u - T u = f := by
  have hu := isUnit_one_sub_of_summable_pow T h
  refine ⟨Ring.inverse (1 - T) f, ?_, ?_⟩
  · have he := congrArg (fun A : E →L[𝕜] E ↦ A f) (Ring.mul_inverse_cancel _ hu)
    simpa only [mul_apply_eq_comp, sub_apply, one_apply_eq_self] using he
  · intro u he
    have hi := congrArg (fun A : E →L[𝕜] E ↦ A u) (Ring.inverse_mul_cancel _ hu)
    simpa only [mul_apply_eq_comp, sub_apply, one_apply_eq_self, he] using hi.symm

Theorem 6.1.38 Factorial Volterra iterates and second-kind invertibility

✓ 🤖

#

For \(|K|\le M\) on \(\Delta \), \(M\ge 0\), and \(n\ge 0\),

\[ |T_K^{n+1}f(x)|\le \frac{\| f\| _{L^2(\mu )}}{\sqrt2} \frac{M^{n+1}x^n}{n!}\quad \hbox{almost everywhere}, \qquad \| T_K^{n+1}\| \le \frac{M^{n+1}}{n!}. \]

More generally, an almost-everywhere majorant \(|f(x)|\le Cx^n\), \(C\ge 0\), gives \(|T_Kf(x)|\le MCx^{n+1}/(n+1)\) almost everywhere. The series of powers is norm summable; \(I-T_K\) is invertible and \(u-T_Ku=f\) has exactly one \(L^2(\mu )\) solution for each \(f\).

Lean Formalisation

theorem Real.volterraL2Operator_ae_bound_of_power {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) {C : ℝ} (_hC : 0 ≤ C) (n : ℕ)
  (hf : ∀ᵐ (y : ℝ) ∂Polynomial.unitJacobiMeasure 0 0, |↑↑f y| ≤ C * y ^ n) :
  ∀ᵐ (x : ℝ) ∂Polynomial.unitJacobiMeasure 0 0,
    |↑↑((Real.volterraL2Operator hK hM hb) f) x| ≤ M * C * x ^ (n + 1) / (↑n + 1)

Lean proof

/-- One Volterra application integrates a power majorant, gaining its next denominator. -/
theorem volterraL2Operator_ae_bound_of_power
    (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) {C : ℝ} (_hC : 0 ≤ C) (n : ℕ)
    (hf : ∀ᵐ y ∂unitJacobiMeasure 0 0, |f y| ≤ C * y ^ n) :
    ∀ᵐ x ∂unitJacobiMeasure 0 0,
      |volterraL2Operator hK hM hb f x| ≤ M * C * x ^ (n+1) / (n+1) := by
  filter_upwards [volterraL2Operator_ae_inner_row hK hM hb f,
    ae_mem_Icc_unitJacobiMeasure 0 0] with x hx hs
  rw [hx, abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 1/2), inner_volterraL2Row]
  have he : (fun y ↦ volterraL2Kernel K (x,y) * f y) =
      (Icc 0 x).indicator (fun y ↦ K ![x,y] * f y) := by
    funext y
    simp [volterraL2Kernel, hs, Set.indicator_apply]
  rw [he, integral_indicator measurableSet_Icc]
  have hi : IntegrableOn (fun y : ℝ ↦ M * C * y ^ n) (Icc 0 x) (unitJacobiMeasure 0 0) :=
    (by fun_prop : Continuous (fun y : ℝ ↦ M * C * y ^ n)).continuousOn.integrableOn_compact
      isCompact_Icc
  have ha : ∀ᵐ y ∂(unitJacobiMeasure 0 0).restrict (Icc 0 x),
      ‖K ![x,y] * f y‖ ≤ M * C * y ^ n := by
    filter_upwards [ae_restrict_of_ae hf, ae_restrict_mem measurableSet_Icc] with y hy hyx
    rw [norm_mul]
    exact (mul_le_mul (hb _ ⟨hs, hyx⟩) hy (abs_nonneg _) hM).trans_eq (by ring)
  have hm : AEStronglyMeasurable (fun y ↦ K ![x,y] * f y)
      ((unitJacobiMeasure 0 0).restrict (Icc 0 x)) := by
    apply AEStronglyMeasurable.mul
    · exact (hK.comp (by fun_prop) (fun y hy ↦ ⟨hs, hy⟩)).aestronglyMeasurable measurableSet_Icc
    · exact (Lp.memLp f).aestronglyMeasurable.restrict
  have hi' := hi.mono' hm ha
  have hn := (norm_integral_le_integral_norm (fun y ↦ K ![x,y] * f y)
    (μ := (unitJacobiMeasure 0 0).restrict (Icc 0 x))).trans
      (integral_mono_ae hi'.norm hi ha)
  rw [integral_const_mul, integral_unitJacobi_pow hs n] at hn
  have hh := mul_le_mul_of_nonneg_left hn (by norm_num : (0 : ℝ) ≤ 1/2)
  convert hh using 1
  ring

5 related Lean declarations

theorem Real.volterraL2Operator_pow_succ_ae_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) (n : ℕ) :
  ∀ᵐ (x : ℝ) ∂Polynomial.unitJacobiMeasure 0 0,
    |↑↑((Real.volterraL2Operator hK hM hb ^ (n + 1)) f) x| ≤ √2 / 2 * ‖f‖ * M ^ (n + 1) * x ^ n / ↑n.factorial

Lean proof

/-- The pointwise majorant for successive Volterra iterates gains a factorial. -/
theorem volterraL2Operator_pow_succ_ae_le
    (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) (n : ℕ) :
    ∀ᵐ x ∂unitJacobiMeasure 0 0,
      |((volterraL2Operator hK hM hb) ^ (n+1)) f x| ≤
        (sqrt 2 / 2 * ‖f‖) * M ^ (n+1) * x ^ n / n.factorial := by
  induction n with
  | zero =>
    filter_upwards [volterraL2Operator_ae_inner_row hK hM hb f] with x hx
    simp only [zero_add, pow_one, pow_zero, Nat.factorial_zero, Nat.cast_one, div_one, mul_one]
    rw [hx, abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 1/2)]
    have hr := norm_volterraL2Row_le hK hM hb x
    rw [unitJacobi_mass_sqrt] at hr
    have hn := (norm_inner_le_norm (𝕜 := ℝ) (volterraL2Row hK hM hb x) f).trans
      (mul_le_mul_of_nonneg_right hr (norm_nonneg f))
    rw [Real.norm_eq_abs] at hn
    nlinarith
  | succ n ih =>
    have hh := volterraL2Operator_ae_bound_of_power hK hM hb
      (((volterraL2Operator hK hM hb) ^ (n+1)) f)
      (C := (sqrt 2 / 2 * ‖f‖) * M ^ (n+1) / n.factorial)
      (by positivity) n (ih.mono (fun x hx ↦ by convert hx using 1; ring))
    filter_upwards [hh] with x hx
    simpa only [pow_succ', mul_apply_eq_comp, Nat.factorial_succ, Nat.cast_mul,
      Nat.cast_add, Nat.cast_one] using hx.trans_eq (by
        field_simp
        ring)

theorem Real.norm_volterraL2Operator_pow_succ_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (n : ℕ) :
  ‖Real.volterraL2Operator hK hM hb ^ (n + 1)‖ ≤ M ^ (n + 1) / ↑n.factorial

Lean proof

/-- A factorial bound for powers of the physical operator, with no small-kernel assumption. -/
theorem norm_volterraL2Operator_pow_succ_le (n : ℕ) :
    ‖(volterraL2Operator hK hM hb) ^ (n+1)‖ ≤ M ^ (n+1) / n.factorial := by
  apply opNorm_le_bound _ (by positivity)
  intro f
  have ha : ∀ᵐ x ∂unitJacobiMeasure 0 0,
      ‖(((volterraL2Operator hK hM hb) ^ (n+1)) f) x‖ ≤
        (sqrt 2 / 2 * ‖f‖) * M ^ (n+1) / n.factorial := by
    filter_upwards [volterraL2Operator_pow_succ_ae_le hK hM hb f n,
      ae_mem_Icc_unitJacobiMeasure 0 0] with x hx hs
    apply hx.trans
    apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
    exact mul_le_of_le_one_right (by positivity) (pow_le_one₀ hs.1 hs.2)
  have hh := Lp.norm_le_of_ae_bound (by positivity) ha
  rw [unitJacobi_mass_sqrt] at hh
  convert hh using 1
  have hs := sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)
  field_simp
  linear_combination -(M ^ (n+1) * ‖f‖) * hs

theorem Real.summable_pow_volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : Summable fun n => Real.volterraL2Operator hK hM hb ^ n

Lean proof

/-- The Volterra Neumann series converges in operator norm for every continuous kernel. -/
theorem summable_pow_volterraL2Operator :
    Summable (fun n : ℕ ↦ (volterraL2Operator hK hM hb) ^ n) := by
  apply (summable_nat_add_iff 1).mp
  apply Summable.of_norm_bounded ((Real.summable_pow_div_factorial M).mul_left M)
  intro n
  exact (norm_volterraL2Operator_pow_succ_le hK hM hb n).trans_eq (by rw [pow_succ']; ring)

theorem Real.isUnit_one_sub_volterraL2Operator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : IsUnit (1 - Real.volterraL2Operator hK hM hb)

Lean proof

/-- Every continuous-kernel Volterra equation of the second kind is invertible on L². -/
theorem isUnit_one_sub_volterraL2Operator : IsUnit (1 - volterraL2Operator hK hM hb) :=
  isUnit_one_sub_of_summable_pow _ (summable_pow_volterraL2Operator hK hM hb)

theorem Real.existsUnique_volterraL2_solution {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (f : ↥(MeasureTheory.Lp ℝ 2 (Polynomial.unitJacobiMeasure 0 0))) : ∃! u, u - (Real.volterraL2Operator hK hM hb) u = f

Lean proof

/-- Each L² right-hand side has exactly one second-kind Volterra solution. -/
theorem existsUnique_volterraL2_solution (f : Lp ℝ 2 (unitJacobiMeasure 0 0)) :
    ∃! u, u - volterraL2Operator hK hM hb u = f :=
  existsUnique_sub_apply_eq_of_summable_pow _ (summable_pow_volterraL2Operator hK hM hb) f

Reference details: Invertibility in normalized Volterra coordinates and related results

Theorem 6.1.39 Invertibility in normalized Volterra coordinates

✓ 🤖

#

For a continuous kernel on the closed Volterra triangle, the normalized coefficient operator \(I-A_K\) is invertible.

Lean Formalisation

theorem Real.isUnit_one_sub_volterraL2CoefficientOperator {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  IsUnit (1 - Real.volterraL2CoefficientOperator hK hM hb)

Lean proof

/-- Normalized coefficient coordinates preserve second-kind invertibility. -/
theorem isUnit_one_sub_volterraL2CoefficientOperator :
    IsUnit (1 - volterraL2CoefficientOperator hK hM hb) := by
  let b := hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0)
    (by norm_num : (-1 : ℝ) < 0)
  have h := (isUnit_one_sub_volterraL2Operator hK hM hb).map
    b.repr.toContinuousLinearEquiv.conjContinuousAlgEquiv.toAlgEquiv.toMonoidHom
  change IsUnit (b.repr.toContinuousLinearEquiv.conjContinuousAlgEquiv
    (1 - volterraL2Operator hK hM hb)) at h
  rw [map_sub, map_one] at h
  exact h

Definition 6.1.40 Second-kind Volterra coefficient inverse

✓ 🤖

#

For a continuous kernel \(K\) on the closed Volterra triangle, define \(R_K=(I-A_K)^{-1}\) on \(\ell ^2\).

Lean Formalisation

def Real.volterraCoefficientInverse {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) : ↥(lp (fun x => ℝ) 2) →L[ℝ] ↥(lp (fun x => ℝ) 2)

Lean definition

/-- The classical inverse of the second-kind normalized coefficient operator. -/
def volterraCoefficientInverse :
    lp (fun _ : ℕ ↦ ℝ) 2 →L[ℝ] lp (fun _ : ℕ ↦ ℝ) 2 :=
  ↑((isUnit_one_sub_volterraL2CoefficientOperator hK hM hb).unit⁻¹)

Theorem 6.1.41 Characterization of the Volterra coefficient inverse

✓ 🤖

#

The coefficient inverse satisfies \(R_K(I-A_K)=I\) and \((I-A_K)R_K=I\).

Lean Formalisation

theorem Real.volterraCoefficientInverse_mul {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  Real.volterraCoefficientInverse hK hM hb * (1 - Real.volterraL2CoefficientOperator hK hM hb) = 1 ∧
    (1 - Real.volterraL2CoefficientOperator hK hM hb) * Real.volterraCoefficientInverse hK hM hb = 1

Lean proof

/-- The inverse has the two defining operator identities. -/
theorem volterraCoefficientInverse_mul :
    volterraCoefficientInverse hK hM hb * (1 - volterraL2CoefficientOperator hK hM hb) = 1 ∧
      (1 - volterraL2CoefficientOperator hK hM hb) * volterraCoefficientInverse hK hM hb = 1 := by
  exact ⟨by simpa only [volterraCoefficientInverse, IsUnit.unit_spec] using
      Units.inv_mul (isUnit_one_sub_volterraL2CoefficientOperator hK hM hb).unit,
    by simpa only [volterraCoefficientInverse, IsUnit.unit_spec] using
      Units.mul_inv (isUnit_one_sub_volterraL2CoefficientOperator hK hM hb).unit⟩

Definition 6.1.42 Lifted second-kind Volterra sections

✓ 🤖

#

For a continuous kernel \(K\) and a natural cutoff \(N\), put \(B_{K,N}=I-P_NA_K\) on normalized coefficient space.

Lean Formalisation

def Real.volterraCoefficientSection {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (N : ℕ) : ↥(lp (fun x => ℝ) 2) →L[ℝ] ↥(lp (fun x => ℝ) 2)

Lean definition

/-- Lifted normalized finite-section equations retain the identity on unresolved rows. -/
def volterraCoefficientSection (N : ℕ) :
    lp (fun _ : ℕ ↦ ℝ) 2 →L[ℝ] lp (fun _ : ℕ ↦ ℝ) 2 :=
  liftedFiniteSection (lp.initialL2Projection N) (-volterraL2CoefficientOperator hK hM hb)

Theorem 6.1.43 Action of lifted Volterra sections

✓ 🤖

#

For every \(u\in \ell ^2\), \(B_{K,N}u=u-P_NA_Ku\).

Lean Formalisation

theorem Real.volterraCoefficientSection_apply {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (N : ℕ) (u : ↥(lp (fun x => ℝ) 2)) :
  (Real.volterraCoefficientSection hK hM hb N) u =
    u - (lp.initialL2Projection N) ((Real.volterraL2CoefficientOperator hK hM hb) u)

Lean proof

/-- The lifted section keeps the identity on unresolved output coordinates. -/
theorem volterraCoefficientSection_apply (N : ℕ) (u : lp (fun _ : ℕ ↦ ℝ) 2) :
    volterraCoefficientSection hK hM hb N u =
      u - lp.initialL2Projection N (volterraL2CoefficientOperator hK hM hb u) := by
  simp only [volterraCoefficientSection, liftedFiniteSection, add_apply, one_apply_eq_self,
    comp_apply, _root_.neg_apply, map_neg, sub_eq_add_neg]

Theorem 6.1.44 Stable normalized finite-section Volterra solves

✓ 🤖

#

Let \(A=A_K\) and \(B_N=I-P_NA\). The operator \(I-A\) is invertible. For sufficiently large \(N\), \(B_N\) is invertible with \(\| B_N^{-1}\| \le \| (I-A)^{-1}\| +1\). For every \(f\in \ell ^2\), the finite system has exactly one solution

\[ u_N\in \operatorname {ran}P_N,\qquad P_N(I-A)u_N=P_Nf. \]

For every cutoff \(N\) at which \(B_N\) is invertible, the solution is \(u_N=B_N^{-1}P_Nf\). Such cutoffs include every sufficiently large \(N\). As \(N\to \infty \) through these cutoffs, \(u_N\) converges in \(\ell ^2\) to \(u=(I-A)^{-1}f\). Eventually, for every exact solution \(u\),

\[ \| B_N^{-1}P_N(I-A)u-u\| \le (\| (I-A)^{-1}\| +1)\| P_Nu-u\| . \]

On \(\operatorname {ran}P_N\), the projected equation is precisely the finite matrix equation with \(I-P_NAP_N\). All coordinates here are normalized shifted Legendre coordinates of the physical output.

Lean Formalisation

theorem Real.volterraCoefficientSection_filter_neBot {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  (Ring.invertibleIndexFilter (Real.volterraCoefficientSection hK hM hb) Filter.atTop).NeBot

Lean proof

/-- The domain of invertible second-kind sections is cofinal and nontrivial. -/
theorem volterraCoefficientSection_filter_neBot :
    NeBot (Ring.invertibleIndexFilter (volterraCoefficientSection hK hM hb) atTop) :=
  Ring.invertibleIndexFilter_neBot _ _
    ((eventually_stable_volterraCoefficientSection_ringInverse hK hM hb).mono (fun _ h ↦ h.1))

4 related Lean declarations

theorem Real.eventually_stable_volterraCoefficientSection {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  ∀ᶠ (N : ℕ) in Filter.atTop,
    ∃ (hN : IsUnit (Real.volterraCoefficientSection hK hM hb N)),
      ‖Ring.inverseAt (Real.volterraCoefficientSection hK hM hb) ⟨N, hN⟩‖ ≤
        ‖Real.volterraCoefficientInverse hK hM hb‖ + 1

Lean proof

/-- Stable second-kind sections provide an inverse certificate and a uniform bound. -/
theorem eventually_stable_volterraCoefficientSection :
    ∀ᶠ N in atTop, ∃ hN : IsUnit (volterraCoefficientSection hK hM hb N),
      ‖Ring.inverseAt (volterraCoefficientSection hK hM hb) ⟨N, hN⟩‖ ≤
        ‖volterraCoefficientInverse hK hM hb‖ + 1 := by
  filter_upwards [eventually_stable_volterraCoefficientSection_ringInverse hK hM hb] with N hN
  refine ⟨hN.1, ?_⟩
  simpa only [Ring.inverseAt_eq_ringInverse, volterraCoefficientInverse_eq_ringInverse] using hN.2

theorem Real.eventually_existsUnique_volterra_projected_solution {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  ∀ᶠ (N : ℕ) in Filter.atTop,
    ∀ (f : ↥(lp (fun x => ℝ) 2)),
      ∃! u,
        (lp.initialL2Projection N) u = u ∧
          (lp.initialL2Projection N) (u - (Real.volterraL2CoefficientOperator hK hM hb) u) =
            (lp.initialL2Projection N) f

Lean proof

/-- Sufficiently large finite matrices have a unique solution within their coordinate range. -/
theorem eventually_existsUnique_volterra_projected_solution :
    ∀ᶠ N in atTop, ∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
      ∃! u, lp.initialL2Projection N u = u ∧
        lp.initialL2Projection N (u - volterraL2CoefficientOperator hK hM hb u) =
          lp.initialL2Projection N f := by
  filter_upwards [eventually_stable_volterraCoefficientSection_ringInverse hK hM hb] with N hN f
  simpa only [add_apply, one_apply_eq_self, _root_.neg_apply, sub_eq_add_neg] using
    existsUnique_projected_solution (lp.initialL2Projection N)
      (-volterraL2CoefficientOperator hK hM hb)
      (lp.initialL2Projection_idempotent N)
      (show IsUnit (liftedFiniteSection (lp.initialL2Projection N)
        (-volterraL2CoefficientOperator hK hM hb)) from hN.1) f

theorem Real.eventually_norm_volterraCoefficientSection_error_le {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  ∀ᶠ (N : ℕ) in Filter.atTop,
    ∃ (hN : IsUnit (Real.volterraCoefficientSection hK hM hb N)),
      ∀ (u : ↥(lp (fun x => ℝ) 2)),
        ‖(Ring.inverseAt (Real.volterraCoefficientSection hK hM hb) ⟨N, hN⟩)
                ((lp.initialL2Projection N) (u - (Real.volterraL2CoefficientOperator hK hM hb) u)) -
              u‖ ≤
          (‖Real.volterraCoefficientInverse hK hM hb‖ + 1) * ‖(lp.initialL2Projection N) u - u‖

Lean proof

/-- The classical section error is controlled by the exact solution tail. -/
theorem eventually_norm_volterraCoefficientSection_error_le :
    ∀ᶠ N in atTop, ∃ hN : IsUnit (volterraCoefficientSection hK hM hb N),
      ∀ u : lp (fun _ : ℕ ↦ ℝ) 2,
      ‖Ring.inverseAt (volterraCoefficientSection hK hM hb) ⟨N, hN⟩
        (lp.initialL2Projection N (u - volterraL2CoefficientOperator hK hM hb u)) - u‖ ≤
        (‖volterraCoefficientInverse hK hM hb‖ + 1) * ‖lp.initialL2Projection N u - u‖ := by
  filter_upwards [eventually_stable_volterraCoefficientSection_ringInverse hK hM hb,
    eventually_norm_volterraCoefficientSection_error_le_ringInverse hK hM hb] with N hN he
  refine ⟨hN.1, fun u ↦ ?_⟩
  simpa only [Ring.inverseAt_eq_ringInverse, volterraCoefficientInverse_eq_ringInverse] using he u

theorem Real.tendsto_volterraCoefficientSection_solution {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (f : ↥(lp (fun x => ℝ) 2)) :
  Filter.Tendsto
    (fun N => (Ring.inverseAt (Real.volterraCoefficientSection hK hM hb) N) ((lp.initialL2Projection ↑N) f))
    (Ring.invertibleIndexFilter (Real.volterraCoefficientSection hK hM hb) Filter.atTop)
    (nhds ((Real.volterraCoefficientInverse hK hM hb) f))

Lean proof

/-- Second-kind solutions converge through the invertible-cutoff domain. -/
theorem tendsto_volterraCoefficientSection_solution (f : lp (fun _ : ℕ ↦ ℝ) 2) :
    Tendsto (fun N : Ring.InvertibleIndex (volterraCoefficientSection hK hM hb) ↦
      Ring.inverseAt (volterraCoefficientSection hK hM hb) N (lp.initialL2Projection N f))
      (Ring.invertibleIndexFilter (volterraCoefficientSection hK hM hb) atTop)
      (𝓝 (volterraCoefficientInverse hK hM hb f)) := by
  have h := (tendsto_volterraCoefficientSection_solution_ringInverse hK hM hb f).comp
    (Filter.tendsto_comap : Tendsto
      (Subtype.val : Ring.InvertibleIndex (volterraCoefficientSection hK hM hb) → ℕ)
      (Filter.comap Subtype.val atTop) atTop)
  simpa only [Ring.invertibleIndexFilter, Function.comp_def, Ring.inverseAt_eq_ringInverse,
    volterraCoefficientInverse_eq_ringInverse] using h

Reference details: Algebraic and normalized shifted Jacobi coordinates and related results

Theorem 6.1.45 Algebraic and normalized shifted Jacobi coordinates

✓ 🤖

#

For \(\alpha ,\beta {\gt}-1\), the shifted Jacobi polynomials form an algebraic basis of \(\mathbb R[x]\); synthesis of a polynomial’s finite coordinates recovers that polynomial. Write \(h_j\) for its squared norm in the affine Jacobi measure. The polynomial \(\widehat P_j=h_j^{-1/2}P_j\) represents exactly the \(j\)th vector of the normalized shifted Jacobi Hilbert basis.

Lean Formalisation

theorem Polynomial.shiftedJacobiBasis_apply {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) (n : ℕ) :
  (Polynomial.shiftedJacobiBasis hα hβ) n = Polynomial.shiftedJacobi α β n

Lean proof

/-- Algebraic basis vectors are the existing shifted Jacobi polynomials. -/
@[simp] theorem shiftedJacobiBasis_apply (n : ℕ) :
    shiftedJacobiBasis hα hβ n = shiftedJacobi α β n := by
  exact (shiftedJacobiSequence hα hβ).basis_eq_self _ n

4 related Lean declarations

def Polynomial.shiftedJacobiBasis {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) : Module.Basis ℕ ℝ (Polynomial ℝ)

Lean definition

/-- The shifted Jacobi sequence as an algebraic polynomial basis. -/
def shiftedJacobiBasis : Module.Basis ℕ ℝ ℝ[X] :=
  (shiftedJacobiSequence hα hβ).basis (shiftedJacobiSequence hα hβ).isUnit_leadingCoeff

theorem Polynomial.linearCombination_shiftedJacobi_repr {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) (p : Polynomial ℝ) :
  (Finsupp.linearCombination ℝ (Polynomial.shiftedJacobi α β)) ((Polynomial.shiftedJacobiBasis hα hβ).repr p) = p

Lean proof

/-- Finite shifted Jacobi coordinates reconstruct the original polynomial. -/
theorem linearCombination_shiftedJacobi_repr (p : ℝ[X]) :
    Finsupp.linearCombination ℝ (shiftedJacobi α β)
      ((shiftedJacobiBasis hα hβ).repr p) = p := by
  simpa only [show shiftedJacobi α β = shiftedJacobiBasis hα hβ from
    _root_.funext (fun n ↦ (shiftedJacobiBasis_apply hα hβ n).symm)] using
    (shiftedJacobiBasis hα hβ).linearCombination_repr p

def Polynomial.normalizedShiftedJacobi {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) (n : ℕ) : Polynomial ℝ

Lean definition

/-- The polynomial representative of the normalized shifted Jacobi Hilbert vector. -/
def normalizedShiftedJacobi (n : ℕ) : ℝ[X] :=
  (Real.sqrt ((shiftedJacobiSequence hα hβ).squaredNorm (unitJacobiMeasure α β) n (Polynomial.Sequence.IntegrableSquare.of _ _)))⁻¹ •
    shiftedJacobi α β n

theorem Polynomial.polynomialToL2_normalizedShiftedJacobi {α β : ℝ} (hα : -1 < α) (hβ : -1 < β) (n : ℕ) :
  (Polynomial.polynomialToL2 ⋯) (Polynomial.normalizedShiftedJacobi hα hβ n) =
    (Polynomial.hilbertBasisShiftedJacobi hα hβ) n

Lean proof

/-- Normalizing at the polynomial level gives exactly the existing Hilbert basis. -/
@[simp] theorem polynomialToL2_normalizedShiftedJacobi (n : ℕ) :
    polynomialToL2 (hasFiniteMoments_unitJacobiMeasure hα hβ)
      (normalizedShiftedJacobi hα hβ n) = hilbertBasisShiftedJacobi hα hβ n := by
  simp only [normalizedShiftedJacobi, map_smul, hilbertBasisShiftedJacobi_apply,
    Sequence.normalizedToL2, shiftedJacobiSequence_apply]

Theorem 6.1.46 Finite matrices and projected coefficient equations

✓ 🤖

#

Let \(J_N:\mathbb K^N\to \ell ^2\) be zero extension, for \(\mathbb K=\mathbb R\) or \(\mathbb C\). Restriction followed by \(J_N\) is \(P_N\), and \(P_NJ_N=J_N\). For bounded \(T\), define \(G_N(i,j)=(Te_j)_i\), \(0\le i,j{\lt}N\). Then

\[ (G_Nv)_i=(TJ_Nv)_i,\qquad (I-G_N)v=(f_i)_{i{\lt}N} \iff P_N(J_Nv-TJ_Nv)=P_Nf. \]

A unique solution of the projected equation in \(\operatorname {ran}P_N\) gives a unique finite matrix solution.

Lean Formalisation

theorem lp.initialL2Vector_apply.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] {N : ℕ} (v : Fin N → 𝕜) (i : Fin N) :
  ↑(lp.initialL2Vector v) ↑i = v i

Lean proof

/-- Restriction of zero extension recovers each finite coordinate. -/
@[simp] theorem initialL2Vector_apply {N : ℕ} (v : Fin N → 𝕜) (i : Fin N) :
    initialL2Vector v i = v i := by
  classical
  change (lp.evalCLM 𝕜 (fun _ : ℕ ↦ 𝕜) 2 i) (∑ j : Fin N, lp.single 2 (j : ℕ) (v j)) = _
  rw [map_sum]
  change (∑ j : Fin N, (lp.single 2 (j : ℕ) (v j) : lp (fun _ : ℕ ↦ 𝕜) 2) i) = v i
  simp [Pi.single_apply, Fin.val_inj]

7 related Lean declarations

def lp.initialL2Vector.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] {N : ℕ} (v : Fin N → 𝕜) : ↥(lp (fun x => 𝕜) 2)

Lean definition

/-- Embed a finite vector by extending it with zeros. -/
def initialL2Vector {N : ℕ} (v : Fin N → 𝕜) : lp (fun _ : ℕ ↦ 𝕜) 2 :=
  ∑ j : Fin N, lp.single 2 (j : ℕ) (v j)

theorem lp.initialL2Vector_restrict.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (N : ℕ) (c : ↥(lp (fun x => 𝕜) 2)) :
  (lp.initialL2Vector fun i => ↑c ↑i) = (lp.initialL2Projection N) c

Lean proof

/-- Embedding the first coordinates is exactly the initial orthogonal projection. -/
theorem initialL2Vector_restrict (N : ℕ) (c : lp (fun _ : ℕ ↦ 𝕜) 2) :
    initialL2Vector (fun i : Fin N ↦ c i) = initialL2Projection N c := by
  rw [initialL2Vector, initialL2Projection_apply]
  exact Fin.sum_univ_eq_sum_range (fun j ↦ lp.single 2 j (c j)) N

theorem lp.initialL2Projection_vector.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] {N : ℕ} (v : Fin N → 𝕜) :
  (lp.initialL2Projection N) (lp.initialL2Vector v) = lp.initialL2Vector v

Lean proof

/-- Initial projection fixes every embedded finite vector. -/
@[simp] theorem initialL2Projection_vector {N : ℕ} (v : Fin N → 𝕜) :
    initialL2Projection N (initialL2Vector v) = initialL2Vector v := by
  rw [← initialL2Vector_restrict]
  simp only [initialL2Vector_apply]

def lp.initialL2Matrix.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) (N : ℕ) :
  Matrix (Fin N) (Fin N) 𝕜

Lean definition

/-- Matrix entries in the standard orthonormal coordinates. -/
def initialL2Matrix (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (N : ℕ) : Matrix (Fin N) (Fin N) 𝕜 :=
  fun i j ↦ T (lp.single 2 (j : ℕ) 1) i

theorem lp.initialL2Matrix_mulVec.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) {N : ℕ}
  (v : Fin N → 𝕜) (i : Fin N) : (lp.initialL2Matrix T N).mulVec v i = ↑(T (lp.initialL2Vector v)) ↑i

Lean proof

/-- Matrix multiplication is the coordinate restriction of the bounded operator. -/
theorem initialL2Matrix_mulVec
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    {N : ℕ} (v : Fin N → 𝕜) (i : Fin N) :
    (initialL2Matrix T N *ᵥ v) i = T (initialL2Vector v) i := by
  classical
  simp only [Matrix.mulVec, dotProduct, initialL2Matrix, initialL2Vector, map_sum,
    lp.coeFn_sum, Finset.sum_apply]
  apply Finset.sum_congr rfl
  intro j _
  change T (lp.single 2 (j : ℕ) 1) i * v j = T (lp.single 2 (j : ℕ) (v j)) i
  have he : (lp.single 2 (j : ℕ) (v j) : lp (fun _ : ℕ ↦ 𝕜) 2) =
      v j • lp.single 2 (j : ℕ) 1 := by
    simpa only [smul_eq_mul, mul_one] using lp.single_smul (E := fun _ : ℕ ↦ 𝕜) 2 (j : ℕ) (v j) (1 : 𝕜)
  rw [he, map_smul]
  change _ = v j * _
  exact mul_comm _ _

theorem lp.initialL2Matrix_equation_iff.{u_1} {𝕜 : Type u_1} [RCLike 𝕜] (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2))
  {N : ℕ} (v : Fin N → 𝕜) (f : ↥(lp (fun x => 𝕜) 2)) :
  ((1 - lp.initialL2Matrix T N).mulVec v = fun i => ↑f ↑i) ↔
    (lp.initialL2Projection N) (lp.initialL2Vector v - T (lp.initialL2Vector v)) = (lp.initialL2Projection N) f

Lean proof

/-- The finite second-kind matrix equation is equivalent to the projected equation. -/
theorem initialL2Matrix_equation_iff
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    {N : ℕ} (v : Fin N → 𝕜) (f : lp (fun _ : ℕ ↦ 𝕜) 2) :
    (1 - initialL2Matrix T N) *ᵥ v = (fun i : Fin N ↦ f i) ↔
      initialL2Projection N (initialL2Vector v - T (initialL2Vector v)) =
        initialL2Projection N f := by
  rw [← initialL2Vector_restrict, ← initialL2Vector_restrict]
  constructor
  · intro h
    congr 1
    funext i
    have hi := congrFun h i
    simpa only [Matrix.sub_mulVec, Matrix.one_mulVec, Pi.sub_apply,
      initialL2Matrix_mulVec, lp.coeFn_sub, initialL2Vector_apply] using hi
  · intro h
    funext i
    have hi := congrArg (fun c : lp (fun _ : ℕ ↦ 𝕜) 2 ↦ c i) h
    simpa only [initialL2Vector_apply, lp.coeFn_sub, Pi.sub_apply,
      Matrix.sub_mulVec, Matrix.one_mulVec, initialL2Matrix_mulVec] using hi

theorem lp.existsUnique_initialL2Matrix_solution.{u_1} {𝕜 : Type u_1} [RCLike 𝕜]
  (T : ↥(lp (fun x => 𝕜) 2) →L[𝕜] ↥(lp (fun x => 𝕜) 2)) (N : ℕ) (f : ↥(lp (fun x => 𝕜) 2))
  (h : ∃! u, (lp.initialL2Projection N) u = u ∧ (lp.initialL2Projection N) (u - T u) = (lp.initialL2Projection N) f) :
  ∃! v, (1 - lp.initialL2Matrix T N).mulVec v = fun i => ↑f ↑i

Lean proof

/-- A unique projected solution gives a unique solution of the actual finite matrix. -/
theorem existsUnique_initialL2Matrix_solution
    (T : lp (fun _ : ℕ ↦ 𝕜) 2 →L[𝕜] lp (fun _ : ℕ ↦ 𝕜) 2)
    (N : ℕ) (f : lp (fun _ : ℕ ↦ 𝕜) 2)
    (h : ∃! u, initialL2Projection N u = u ∧
      initialL2Projection N (u - T u) = initialL2Projection N f) :
    ∃! v : Fin N → 𝕜, (1 - initialL2Matrix T N) *ᵥ v = (fun i : Fin N ↦ f i) := by
  obtain ⟨u, hu, huniq⟩ := h
  refine ⟨fun i ↦ u i, ?_, ?_⟩
  · apply (initialL2Matrix_equation_iff T (fun i : Fin N ↦ u i) f).mpr
    simpa only [initialL2Vector_restrict, hu.1] using hu.2
  · intro v hv
    have he := huniq (initialL2Vector v)
      ⟨initialL2Projection_vector v, (initialL2Matrix_equation_iff T v f).mp hv⟩
    funext i
    simpa only [initialL2Vector_apply] using
      congrArg (fun c : lp (fun _ : ℕ ↦ 𝕜) 2 ↦ c i) he

Theorem 6.1.47 Finite sections with norm-consistent operator approximations

✓ 🤖

#

Let \(P_n\) be contractions on a real or complex Banach space, converging strongly to \(I\), let \(K\) be compact, and suppose \(L_n\to K\) in operator norm. Then \(B_n=I+P_nL_n\to I+K\) in operator norm. If \(I+K\) is invertible, then eventually \(B_n\) is invertible and \(\| B_n^{-1}\| \le \| (I+K)^{-1}\| +1\). For any contraction \(P\) and bounded \(K,L\), whenever \(B=I+PL\) is invertible,

\[ B^{-1}P(I+K)u-u=B^{-1}\bigl(Pu-u+P(K-L)u\bigr), \]

\[ \| B^{-1}P(I+K)u-u\| \le \| B^{-1}\| \bigl(\| Pu-u\| +\| K-L\| \| u\| \bigr). \]

The fixed-section inverse \((I+PL)^{-1}\) is defined for operators \(L\) such that \(I+PL\) is invertible. The indices \(n\) for which \(B_n\) is invertible include every sufficiently large integer. The error identity and estimate do not require compactness.

Lean Formalisation

theorem ContinuousLinearMap.approximateLiftedFiniteSection_filter_neBot.{u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] {E : Type u_2}
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] [CompleteSpace E] (P : ℕ → E →L[𝕜] E) (hC : ∀ (n : ℕ), ‖P n‖ ≤ 1)
  (hP : ∀ (x : E), Filter.Tendsto (fun n => (P n) x) Filter.atTop (nhds x)) (K : E →L[𝕜] E) (hK : IsCompactOperator ⇑K)
  (hT : IsUnit (1 + K)) (L : ℕ → E →L[𝕜] E) (hL : Filter.Tendsto L Filter.atTop (nhds K)) :
  (Ring.invertibleIndexFilter (fun n => (P n).liftedFiniteSection (L n)) Filter.atTop).NeBot

Lean proof

/-- Norm-consistent sections have a nontrivial invertible-cutoff filter. -/
theorem approximateLiftedFiniteSection_filter_neBot
    (P : ℕ → E →L[𝕜] E) (hC : ∀ n, ‖P n‖ ≤ 1)
    (hP : ∀ x, Tendsto (fun n ↦ P n x) atTop (𝓝 x))
    (K : E →L[𝕜] E) (hK : IsCompactOperator K) (hT : IsUnit (1 + K))
    (L : ℕ → E →L[𝕜] E) (hL : Tendsto L atTop (𝓝 K)) :
    NeBot (Ring.invertibleIndexFilter (fun n ↦ liftedFiniteSection (P n) (L n)) atTop) :=
  Ring.invertibleIndexFilter_neBot _ _
    ((eventually_stable_approximateLiftedFiniteSection_ringInverse P hC hP K hK hT L hL).mono
      (fun _ h ↦ h.1))

4 related Lean declarations

theorem ContinuousLinearMap.tendsto_approximateLiftedFiniteSection.{u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] {E : Type u_2}
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (P : ℕ → E →L[𝕜] E) (hC : ∀ (n : ℕ), ‖P n‖ ≤ 1)
  (hP : ∀ (x : E), Filter.Tendsto (fun n => (P n) x) Filter.atTop (nhds x)) (K : E →L[𝕜] E) (hK : IsCompactOperator ⇑K)
  (L : ℕ → E →L[𝕜] E) (hL : Filter.Tendsto L Filter.atTop (nhds K)) :
  Filter.Tendsto (fun n => (P n).liftedFiniteSection (L n)) Filter.atTop (nhds (1 + K))

Lean proof

/-- Contractive sections remain norm-consistent when the compact operator is
itself approximated in norm. -/
theorem tendsto_approximateLiftedFiniteSection
    (P : ℕ → E →L[𝕜] E) (hC : ∀ n, ‖P n‖ ≤ 1)
    (hP : ∀ x, Tendsto (fun n ↦ P n x) atTop (𝓝 x))
    (K : E →L[𝕜] E) (hK : IsCompactOperator K)
    (L : ℕ → E →L[𝕜] E) (hL : Tendsto L atTop (𝓝 K)) :
    Tendsto (fun n ↦ liftedFiniteSection (P n) (L n)) atTop (𝓝 (1 + K)) := by
  have he : Tendsto (fun n ↦ (P n).comp (L n - K)) atTop (𝓝 0) := by
    apply squeeze_zero_norm (fun n ↦ ?_) (by
      simpa using (hL.sub (tendsto_const_nhds (x := K))).norm)
    exact (opNorm_comp_le _ _).trans (by
      simpa using mul_le_mul_of_nonneg_right (hC n) (norm_nonneg (L n - K)))
  have ht := (tendsto_liftedFiniteSection P hC hP K hK).add he
  simpa only [liftedFiniteSection, comp_sub, add_sub_cancel_right, add_zero,
    add_add_sub_cancel] using ht

theorem ContinuousLinearMap.approximateLiftedFiniteSection_error_eq.{u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] {E : Type u_2}
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (P K : E →L[𝕜] E) (L : Ring.InvertibleIndex P.liftedFiniteSection) (x : E) :
  (Ring.inverseAt P.liftedFiniteSection L) (P ((1 + K) x)) - x =
    (Ring.inverseAt P.liftedFiniteSection L) (P x - x + P ((K - ↑L) x))

Lean proof

/-- Classical error identity on the exact domain of invertible lifted sections. -/
theorem approximateLiftedFiniteSection_error_eq (P K : E →L[𝕜] E)
    (L : Ring.InvertibleIndex (liftedFiniteSection P)) (x : E) :
    Ring.inverseAt (liftedFiniteSection P) L (P ((1 + K) x)) - x =
      Ring.inverseAt (liftedFiniteSection P) L (P x - x + P ((K - L.val) x)) := by
  simpa only [Ring.inverseAt_eq_ringInverse] using
    approximateLiftedFiniteSection_error_eq_ringInverse P K L.val L.property x

theorem ContinuousLinearMap.norm_approximateLiftedFiniteSection_error_le.{u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] {E : Type u_2}
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] (P K : E →L[𝕜] E) (L : Ring.InvertibleIndex P.liftedFiniteSection)
  (hP : ‖P‖ ≤ 1) (x : E) :
  ‖(Ring.inverseAt P.liftedFiniteSection L) (P ((1 + K) x)) - x‖ ≤
    ‖Ring.inverseAt P.liftedFiniteSection L‖ * (‖P x - x‖ + ‖K - ↑L‖ * ‖x‖)

Lean proof

/-- Classical projection-tail and operator-error estimate. -/
theorem norm_approximateLiftedFiniteSection_error_le (P K : E →L[𝕜] E)
    (L : Ring.InvertibleIndex (liftedFiniteSection P)) (hP : ‖P‖ ≤ 1) (x : E) :
    ‖Ring.inverseAt (liftedFiniteSection P) L (P ((1 + K) x)) - x‖ ≤
      ‖Ring.inverseAt (liftedFiniteSection P) L‖ * (‖P x - x‖ + ‖K - L.val‖ * ‖x‖) := by
  simpa only [Ring.inverseAt_eq_ringInverse] using
    norm_approximateLiftedFiniteSection_error_le_ringInverse P K L.val hP L.property x

theorem ContinuousLinearMap.eventually_stable_approximateLiftedFiniteSection.{u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] {E : Type u_2}
  [NormedAddCommGroup E] [NormedSpace 𝕜 E] [CompleteSpace E] (P : ℕ → E →L[𝕜] E) (hC : ∀ (n : ℕ), ‖P n‖ ≤ 1)
  (hP : ∀ (x : E), Filter.Tendsto (fun n => (P n) x) Filter.atTop (nhds x)) (K : E →L[𝕜] E) (hK : IsCompactOperator ⇑K)
  (hT : IsUnit (1 + K)) (L : ℕ → E →L[𝕜] E) (hL : Filter.Tendsto L Filter.atTop (nhds K)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∃ (hn : IsUnit ((P n).liftedFiniteSection (L n))),
      ‖Ring.inverseAt (fun n => (P n).liftedFiniteSection (L n)) ⟨n, hn⟩‖ ≤ ‖↑hT.unit⁻¹‖ + 1

Lean proof

/-- Approximate-section stability supplies actual inverse values. -/
theorem eventually_stable_approximateLiftedFiniteSection
    (P : ℕ → E →L[𝕜] E) (hC : ∀ n, ‖P n‖ ≤ 1)
    (hP : ∀ x, Tendsto (fun n ↦ P n x) atTop (𝓝 x))
    (K : E →L[𝕜] E) (hK : IsCompactOperator K) (hT : IsUnit (1 + K))
    (L : ℕ → E →L[𝕜] E) (hL : Tendsto L atTop (𝓝 K)) :
    ∀ᶠ n in atTop, ∃ hn : IsUnit (liftedFiniteSection (P n) (L n)),
      ‖Ring.inverseAt (fun n ↦ liftedFiniteSection (P n) (L n)) ⟨n, hn⟩‖ ≤
        ‖(↑(hT.unit⁻¹) : E →L[𝕜] E)‖ + 1 := by
  filter_upwards [eventually_stable_approximateLiftedFiniteSection_ringInverse P hC hP K hK hT L hL]
    with n hn
  refine ⟨hn.1, ?_⟩
  have hunit : Ring.inverse (1 + K) = (↑(hT.unit⁻¹) : E →L[𝕜] E) := by
    simpa only [IsUnit.unit_spec] using Ring.inverse_unit hT.unit
  simpa only [Ring.inverseAt_eq_ringInverse, hunit] using hn.2

Definition 6.1.48 Volterra sections with varying kernels

✓ 🤖

#

For continuous kernels \(K_n\) on the closed Volterra triangle, define \(B_n=I-P_nA_{K_n}\) on normalized coefficient space.

Lean Formalisation

def Real.approximateVolterraCoefficientSection {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (N : ℕ) :
  ↥(lp (fun x => ℝ) 2) →L[ℝ] ↥(lp (fun x => ℝ) 2)

Lean definition

/-- The section family for simultaneously varying kernels and cutoffs. -/
def approximateVolterraCoefficientSection (N : ℕ) :
    lp (fun _ : ℕ ↦ ℝ) 2 →L[ℝ] lp (fun _ : ℕ ↦ ℝ) 2 :=
  volterraCoefficientSection (hs N) (hB N) (bs N) N

Theorem 6.1.49 Action of varying-kernel Volterra sections

✓ 🤖

#

For every \(u\in \ell ^2\), \(B_nu=u-P_nA_{K_n}u\).

Lean Formalisation

theorem Real.approximateVolterraCoefficientSection_apply {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (N : ℕ) (u : ↥(lp (fun x => ℝ) 2)) :
  (Real.approximateVolterraCoefficientSection hs hB bs N) u =
    u - (lp.initialL2Projection N) ((Real.volterraL2CoefficientOperator ⋯ ⋯ ⋯) u)

Lean proof

/-- Each approximate section keeps the identity on unresolved output coordinates. -/
theorem approximateVolterraCoefficientSection_apply (N : ℕ) (u : lp (fun _ : ℕ ↦ ℝ) 2) :
    approximateVolterraCoefficientSection hs hB bs N u =
      u - lp.initialL2Projection N (volterraL2CoefficientOperator (hs N) (hB N) (bs N) u) := by
  simp only [approximateVolterraCoefficientSection, volterraCoefficientSection,
    liftedFiniteSection, add_apply, one_apply_eq_self, comp_apply, _root_.neg_apply, map_neg,
    sub_eq_add_neg]

Theorem 6.1.50 Volterra solves with simultaneous kernel approximation

✓ 🤖

#

Let \(K,K_n\) be continuous on the closed Volterra triangle, with finite nonnegative uniform bounds, and suppose \(|K_n-K|\le \varepsilon _n\) there, where \(\varepsilon _n\ge 0\) and \(\varepsilon _n\to 0\). In normalized physical coordinates, \(\| A_{K_n}-A_K\| \le \varepsilon _n\). Put \(B_n=I-P_nA_{K_n}\) and \(C=\| (I-A_K)^{-1}\| +1\). Eventually \(B_n\) is invertible with \(\| B_n^{-1}\| \le C\), and for every \(f\in \ell ^2\) the projected system has a unique solution. The invertible-cutoff domain contains a tail, and along its induced nontrivial filter,

\[ B_n^{-1}P_nf\longrightarrow (I-A_K)^{-1}f, \]

and eventually, for every \(u\in \ell ^2\),

\[ \| B_n^{-1}P_n(I-A_K)u-u\| \le C\bigl(\| P_nu-u\| +\varepsilon _n\| u\| \bigr). \]

No smallness restriction on \(K\) or common bound on all \(K_n\) is required.

Lean Formalisation

theorem Real.approximateVolterraSection_filter_neBot {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  (Ring.invertibleIndexFilter (Real.approximateVolterraCoefficientSection hs hB bs) Filter.atTop).NeBot

Lean proof

/-- The approximate-section limiting filter is nontrivial. -/
theorem approximateVolterraSection_filter_neBot :
    NeBot (Ring.invertibleIndexFilter (approximateVolterraCoefficientSection hs hB bs) atTop) :=
  Ring.invertibleIndexFilter_neBot _ _
    ((eventually_stable_approximateVolterraSection_ringInverse hK hM bK hs hB bs he err hte).mono
      (fun _ h ↦ h.1))

6 related Lean declarations

theorem Real.norm_volterraL2CoefficientOperator_sub_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {L : (Fin 2 → ℝ) → ℝ}
  (hL : ContinuousOn L Real.volterraTriangle) {B δ : ℝ} (hB : 0 ≤ B) (bL : ∀ z ∈ Real.volterraTriangle, |L z| ≤ B)
  (hδ : 0 ≤ δ) (err : ∀ z ∈ Real.volterraTriangle, |K z - L z| ≤ δ) :
  ‖Real.volterraL2CoefficientOperator hK hM bK - Real.volterraL2CoefficientOperator hL hB bL‖ ≤ δ

Lean proof

/-- Uniform kernel errors retain their bound in normalized coefficient coordinates. -/
theorem norm_volterraL2CoefficientOperator_sub_le
    {L : (Fin 2 → ℝ) → ℝ} (hL : ContinuousOn L volterraTriangle)
    {B δ : ℝ} (hB : 0 ≤ B) (bL : ∀ z ∈ volterraTriangle, |L z| ≤ B)
    (hδ : 0 ≤ δ) (err : ∀ z ∈ volterraTriangle, |K z - L z| ≤ δ) :
    ‖volterraL2CoefficientOperator hK hM bK - volterraL2CoefficientOperator hL hB bL‖ ≤ δ := by
  rw [volterraL2CoefficientOperator, volterraL2CoefficientOperator,
    HilbertBasis.norm_coefficientOperator_sub]
  exact norm_volterraL2Operator_sub_le hK hL hM hB bK bL hδ err

theorem Real.tendsto_volterraL2CoefficientOperator_of_error_bounds {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  {Ks : ℕ → (Fin 2 → ℝ) → ℝ} (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ}
  (hB : ∀ (n : ℕ), 0 ≤ B n) (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  Filter.Tendsto (fun n => Real.volterraL2CoefficientOperator ⋯ ⋯ ⋯) Filter.atTop
    (nhds (Real.volterraL2CoefficientOperator hK hM bK))

Lean proof

/-- Vanishing kernel errors give norm convergence of normalized coefficient operators. -/
theorem tendsto_volterraL2CoefficientOperator_of_error_bounds :
    Tendsto (fun n ↦ volterraL2CoefficientOperator (hs n) (hB n) (bs n)) atTop
      (𝓝 (volterraL2CoefficientOperator hK hM bK)) := by
  rw [tendsto_iff_norm_sub_tendsto_zero]
  exact squeeze_zero (fun _ ↦ norm_nonneg _)
    (fun n ↦ norm_volterraL2CoefficientOperator_sub_le (hs n) (hB n) (bs n)
      hK hM bK (he n) (err n)) hte

theorem Real.eventually_stable_approximateVolterraSection {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∃ (hn : IsUnit (Real.approximateVolterraCoefficientSection hs hB bs n)),
      ‖Ring.inverseAt (Real.approximateVolterraCoefficientSection hs hB bs) ⟨n, hn⟩‖ ≤
        ‖Real.volterraCoefficientInverse hK hM bK‖ + 1

Lean proof

/-- Approximate section stability includes the existence of each inverse value. -/
theorem eventually_stable_approximateVolterraSection :
    ∀ᶠ n in atTop, ∃ hn : IsUnit (approximateVolterraCoefficientSection hs hB bs n),
      ‖Ring.inverseAt (approximateVolterraCoefficientSection hs hB bs) ⟨n, hn⟩‖ ≤
        ‖volterraCoefficientInverse hK hM bK‖ + 1 := by
  filter_upwards [eventually_stable_approximateVolterraSection_ringInverse hK hM bK hs hB bs he err hte]
    with n hn
  have hu : IsUnit (approximateVolterraCoefficientSection hs hB bs n) := hn.1
  refine ⟨hu, ?_⟩
  rw [Ring.inverseAt_eq_ringInverse]
  simpa only [approximateVolterraCoefficientSection, volterraCoefficientInverse_eq_ringInverse] using hn.2

theorem Real.eventually_existsUnique_approximateVolterra_solution {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  {Ks : ℕ → (Fin 2 → ℝ) → ℝ} (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ}
  (hB : ∀ (n : ℕ), 0 ≤ B n) (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∀ (f : ↥(lp (fun x => ℝ) 2)),
      ∃! u,
        (lp.initialL2Projection n) u = u ∧
          (lp.initialL2Projection n) (u - (Real.volterraL2CoefficientOperator ⋯ ⋯ ⋯) u) = (lp.initialL2Projection n) f

Lean proof

/-- Each sufficiently large approximating finite system has a unique solution. -/
theorem eventually_existsUnique_approximateVolterra_solution :
    ∀ᶠ n in atTop, ∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
      ∃! u, lp.initialL2Projection n u = u ∧
        lp.initialL2Projection n (u - volterraL2CoefficientOperator (hs n) (hB n) (bs n) u) =
          lp.initialL2Projection n f := by
  filter_upwards [eventually_stable_approximateVolterraSection_ringInverse hK hM bK hs hB bs he err hte] with n hn f
  simpa only [add_apply, one_apply_eq_self, _root_.neg_apply, sub_eq_add_neg] using
    existsUnique_projected_solution (lp.initialL2Projection n)
      (-volterraL2CoefficientOperator (hs n) (hB n) (bs n))
      (lp.initialL2Projection_idempotent n)
      (show IsUnit (liftedFiniteSection (lp.initialL2Projection n)
        (-volterraL2CoefficientOperator (hs n) (hB n) (bs n))) from hn.1) f

theorem Real.eventually_norm_approximateVolterra_error_le {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∃ (hn : IsUnit (Real.approximateVolterraCoefficientSection hs hB bs n)),
      ∀ (u : ↥(lp (fun x => ℝ) 2)),
        ‖(Ring.inverseAt (Real.approximateVolterraCoefficientSection hs hB bs) ⟨n, hn⟩)
                ((lp.initialL2Projection n) (u - (Real.volterraL2CoefficientOperator hK hM bK) u)) -
              u‖ ≤
          (‖Real.volterraCoefficientInverse hK hM bK‖ + 1) * (‖(lp.initialL2Projection n) u - u‖ + e n * ‖u‖)

Lean proof

/-- Projection and kernel errors control every sufficiently large classical section solve. -/
theorem eventually_norm_approximateVolterra_error_le :
    ∀ᶠ n in atTop, ∃ hn : IsUnit (approximateVolterraCoefficientSection hs hB bs n),
      ∀ u : lp (fun _ : ℕ ↦ ℝ) 2,
      ‖Ring.inverseAt (approximateVolterraCoefficientSection hs hB bs) ⟨n, hn⟩
        (lp.initialL2Projection n (u - volterraL2CoefficientOperator hK hM bK u)) - u‖ ≤
        (‖volterraCoefficientInverse hK hM bK‖ + 1) *
          (‖lp.initialL2Projection n u - u‖ + e n * ‖u‖) := by
  filter_upwards [eventually_stable_approximateVolterraSection_ringInverse hK hM bK hs hB bs he err hte,
    eventually_norm_approximateVolterra_error_le_ringInverse hK hM bK hs hB bs he err hte]
      with n hn heN
  have hu : IsUnit (approximateVolterraCoefficientSection hs hB bs n) := hn.1
  refine ⟨hu, fun u ↦ ?_⟩
  rw [Ring.inverseAt_eq_ringInverse]
  simpa only [approximateVolterraCoefficientSection, volterraCoefficientInverse_eq_ringInverse] using heN u

theorem Real.tendsto_approximateVolterra_solution {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ}
  (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) {Ks : ℕ → (Fin 2 → ℝ) → ℝ}
  (hs : ∀ (n : ℕ), ContinuousOn (Ks n) Real.volterraTriangle) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bs : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |Ks n z - K z| ≤ e n) (hte : Filter.Tendsto e Filter.atTop (nhds 0))
  (f : ↥(lp (fun x => ℝ) 2)) :
  Filter.Tendsto
    (fun n => (Ring.inverseAt (Real.approximateVolterraCoefficientSection hs hB bs) n) ((lp.initialL2Projection ↑n) f))
    (Ring.invertibleIndexFilter (Real.approximateVolterraCoefficientSection hs hB bs) Filter.atTop)
    (nhds ((Real.volterraCoefficientInverse hK hM bK) f))

Lean proof

/-- Simultaneous kernel approximation and finite solves converge on their actual domain. -/
theorem tendsto_approximateVolterra_solution (f : lp (fun _ : ℕ ↦ ℝ) 2) :
    Tendsto (fun n : Ring.InvertibleIndex (approximateVolterraCoefficientSection hs hB bs) ↦
      Ring.inverseAt (approximateVolterraCoefficientSection hs hB bs) n (lp.initialL2Projection n f))
      (Ring.invertibleIndexFilter (approximateVolterraCoefficientSection hs hB bs) atTop)
      (𝓝 (volterraCoefficientInverse hK hM bK f)) := by
  have h := (tendsto_approximateVolterra_solution_ringInverse hK hM bK hs hB bs he err hte f).comp
    (Filter.tendsto_comap : Tendsto
      (Subtype.val : Ring.InvertibleIndex (approximateVolterraCoefficientSection hs hB bs) → ℕ)
      (Filter.comap Subtype.val atTop) atTop)
  rw [volterraCoefficientInverse_eq_ringInverse]
  apply h.congr'
  exact Filter.Eventually.of_forall (fun n ↦ by
    dsimp only [Function.comp_def]
    rw [Ring.inverseAt_eq_ringInverse]
    rfl)

Theorem 6.1.51 Normalized Galerkin matrices from finite Proriol assembly

✓ 🤖

#

For a polynomial kernel \(p\), let \(c_j\) be the finite shifted-Jacobi \((1,0)\) coordinates of the normalized shifted Legendre polynomial \(\widehat P_j\). Let \(q_j\) be the physical polynomial reconstructed from \(D M_p E c_j\), including reflection and multiplication by \(x\). With \(\mu =2\, dx\) on \([0,1]\), define the actual \(N\times N\) matrix

\[ G_{p,N}(i,j)=\int \widehat P_i(x)q_j(x)\, d\mu (x). \]

Then \(G_{p,N}(i,j)=(A_pe_j)_i\); its multiplication is exactly the finite restriction of \(A_pJ_Nv\), and

\[ (I-G_{p,N})v=(f_i)_{i{\lt}N} \iff P_N(J_Nv-A_pJ_Nv)=P_Nf. \]

For all sufficiently large \(N\), this finite matrix equation has exactly one solution for every coefficient right-hand side.

Lean Formalisation

theorem MvPolynomial.volterraProriolMatrix_eq (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) :
  K.volterraProriolMatrix N = lp.initialL2Matrix (Real.volterraL2CoefficientOperator ⋯ hM hb) N

Lean proof

/-- Exact equality of assembled entries and the bounded normalized coefficient matrix. -/
theorem volterraProriolMatrix_eq (K : MvPolynomial (Fin 2) ℝ) (N : ℕ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M) :
    volterraProriolMatrix K N = lp.initialL2Matrix
      (volterraL2CoefficientOperator K.continuous_eval.continuousOn hM hb) N := by
  funext i j
  change Polynomial.integralInner _ (Polynomial.IntegrablePair.of _ _ _ (h := (Polynomial.hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _)) =
    (hilbertBasisShiftedJacobi (by norm_num : (-1 : ℝ) < 0)
      (by norm_num : (-1 : ℝ) < 0)).coefficientOperator _ _ _
  rw [HilbertBasis.coefficientOperator_single,
    ← polynomialToL2_normalizedShiftedJacobi, ← polynomialToL2_normalizedShiftedJacobi]
  have he := volterraL2Operator_proriol K (volterraNormalizedInput j) hM hb
  simp only [volterraNormalizedInput, linearCombination_shiftedJacobi_repr] at he
  rw [he, Polynomial.inner_polynomialToL2]
  rfl

5 related Lean declarations

def MvPolynomial.volterraNormalizedInput (j : ℕ) : ℕ →₀ ℝ

Lean definition

/-- Finite shifted-Jacobi (1,0) coordinates of a normalized shifted Legendre input. -/
def volterraNormalizedInput (j : ℕ) : ℕ →₀ ℝ :=
  (shiftedJacobiBasis (by norm_num : (-1 : ℝ) < 1) (by norm_num : (-1 : ℝ) < 0)).repr
    (normalizedShiftedJacobi (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) j)

def MvPolynomial.volterraProriolMatrix (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) : Matrix (Fin N) (Fin N) ℝ

Lean definition

/-- The normalized Galerkin matrix computed by finite polynomial Proriol assembly. -/
def volterraProriolMatrix (K : MvPolynomial (Fin 2) ℝ) (N : ℕ) : Matrix (Fin N) (Fin N) ℝ :=
  fun i j ↦ Polynomial.integralInner (unitJacobiMeasure 0 0) (Polynomial.IntegrablePair.of (unitJacobiMeasure 0 0) (normalizedShiftedJacobi (by norm_num : (-1 : ℝ) < 0) (by norm_num : (-1 : ℝ) < 0) i) (volterraProriolOutput K (volterraNormalizedInput j)) (h := (Polynomial.hasFiniteMoments_unitJacobiMeasure (by norm_num) (by norm_num)).integrable_mul _ _))

theorem MvPolynomial.volterraProriolMatrix_mulVec (K : MvPolynomial (Fin 2) ℝ) {N : ℕ} {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) (v : Fin N → ℝ) (i : Fin N) :
  (K.volterraProriolMatrix N).mulVec v i = ↑((Real.volterraL2CoefficientOperator ⋯ hM hb) (lp.initialL2Vector v)) ↑i

Lean proof

/-- Matrix multiplication by the assembled matrix is precisely the physical coefficient action. -/
theorem volterraProriolMatrix_mulVec (K : MvPolynomial (Fin 2) ℝ) {N : ℕ}
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M)
    (v : Fin N → ℝ) (i : Fin N) :
    (volterraProriolMatrix K N *ᵥ v) i =
      volterraL2CoefficientOperator K.continuous_eval.continuousOn hM hb (lp.initialL2Vector v) i := by
  rw [volterraProriolMatrix_eq K N hM hb]
  exact lp.initialL2Matrix_mulVec _ v i

theorem MvPolynomial.volterraProriolMatrix_equation_iff (K : MvPolynomial (Fin 2) ℝ) {N : ℕ} {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) (v : Fin N → ℝ) (f : ↥(lp (fun x => ℝ) 2)) :
  ((1 - K.volterraProriolMatrix N).mulVec v = fun i => ↑f ↑i) ↔
    (lp.initialL2Projection N)
        (lp.initialL2Vector v - (Real.volterraL2CoefficientOperator ⋯ hM hb) (lp.initialL2Vector v)) =
      (lp.initialL2Projection N) f

Lean proof

/-- The assembled second-kind matrix solves exactly the normalized projected equation. -/
theorem volterraProriolMatrix_equation_iff (K : MvPolynomial (Fin 2) ℝ) {N : ℕ}
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M)
    (v : Fin N → ℝ) (f : lp (fun _ : ℕ ↦ ℝ) 2) :
    (1 - volterraProriolMatrix K N) *ᵥ v = (fun i : Fin N ↦ f i) ↔
      lp.initialL2Projection N (lp.initialL2Vector v -
        volterraL2CoefficientOperator K.continuous_eval.continuousOn hM hb (lp.initialL2Vector v)) =
          lp.initialL2Projection N f := by
  rw [volterraProriolMatrix_eq K N hM hb]
  exact lp.initialL2Matrix_equation_iff _ v f

theorem MvPolynomial.eventually_existsUnique_volterraProriolMatrix_solution (K : MvPolynomial (Fin 2) ℝ) {M : ℝ} (hM : 0 ≤ M)
  (hb : ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) K| ≤ M) :
  ∀ᶠ (N : ℕ) in Filter.atTop,
    ∀ (f : ↥(lp (fun x => ℝ) 2)), ∃! v, (1 - K.volterraProriolMatrix N).mulVec v = fun i => ↑f ↑i

Lean proof

/-- All sufficiently large assembled polynomial-kernel matrices have unique solutions. -/
theorem eventually_existsUnique_volterraProriolMatrix_solution (K : MvPolynomial (Fin 2) ℝ)
    {M : ℝ} (hM : 0 ≤ M) (hb : ∀ z ∈ volterraTriangle, |eval z K| ≤ M) :
    ∀ᶠ N in atTop, ∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
      ∃! v : Fin N → ℝ, (1 - volterraProriolMatrix K N) *ᵥ v = (fun i : Fin N ↦ f i) := by
  filter_upwards [eventually_existsUnique_volterra_projected_solution
    K.continuous_eval.continuousOn hM hb] with N hN f
  rw [volterraProriolMatrix_eq K N hM hb]
  exact lp.existsUnique_initialL2Matrix_solution _ N f (hN f)

Definition 6.1.52 Classical assembled Proriol solutions

✓ 🤖

#

For polynomial kernels \(p_n\), let \(B_n=I-P_nA_{p_n}\). For an invertible cutoff \(n\) and \(f\in \ell ^2\), define \(v_n\) by restricting \(B_n^{-1}P_nf\) to its first \(n\) coordinates.

Lean Formalisation

def MvPolynomial.volterraProriolMatrixSolution (p : ℕ → MvPolynomial (Fin 2) ℝ) {B : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n) (f : ↥(lp (fun x => ℝ) 2))
  (n : Ring.InvertibleIndex (Real.approximateVolterraCoefficientSection ⋯ hB bp)) : Fin ↑n → ℝ

Lean definition

/-- Finite coordinates of the classical lifted solution at an invertible cutoff. -/
def volterraProriolMatrixSolution (f : lp (fun _ : ℕ ↦ ℝ) 2)
    (n : Ring.InvertibleIndex (approximateVolterraCoefficientSection
      (fun n ↦ (p n).continuous_eval.continuousOn) hB bp)) : Fin n.val → ℝ :=
  fun i ↦ Ring.inverseAt (approximateVolterraCoefficientSection
    (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) n
      (lp.initialL2Projection n.val f) i

Theorem 6.1.53 Characterization of assembled Proriol solutions

✓ 🤖

#

At every invertible cutoff, \(J_nv_n=B_n^{-1}P_nf\) and \((I-G_{p_n,n})v_n=(f_i)_{i{\lt}n}\).

Lean Formalisation

theorem MvPolynomial.volterraProriolMatrixSolution_spec (p : ℕ → MvPolynomial (Fin 2) ℝ) {B : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n)
  (n : Ring.InvertibleIndex (Real.approximateVolterraCoefficientSection ⋯ hB bp)) (f : ↥(lp (fun x => ℝ) 2)) :
  lp.initialL2Vector (MvPolynomial.volterraProriolMatrixSolution p hB bp f n) =
      (Ring.inverseAt (Real.approximateVolterraCoefficientSection ⋯ hB bp) n) ((lp.initialL2Projection ↑n) f) ∧
    (1 - (p ↑n).volterraProriolMatrix ↑n).mulVec (MvPolynomial.volterraProriolMatrixSolution p hB bp f n) = fun i =>
      ↑f ↑i

Lean proof

/-- At every invertible cutoff, zero extension recovers the lifted solution
and the finite coordinates solve the assembled matrix equation. -/
theorem volterraProriolMatrixSolution_spec
    (n : Ring.InvertibleIndex (approximateVolterraCoefficientSection
      (fun n ↦ (p n).continuous_eval.continuousOn) hB bp))
    (f : lp (fun _ : ℕ ↦ ℝ) 2) :
    lp.initialL2Vector (volterraProriolMatrixSolution p hB bp f n) =
      Ring.inverseAt (approximateVolterraCoefficientSection
        (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) n
        (lp.initialL2Projection n.val f) ∧
    (1 - volterraProriolMatrix (p n.val) n.val) *ᵥ
      volterraProriolMatrixSolution p hB bp f n = (fun i : Fin n.val ↦ f i) := by
  have hs := liftedFiniteSection_solution_mem (lp.initialL2Projection n.val)
    (-volterraL2CoefficientOperator (p n.val).continuous_eval.continuousOn
      (hB n.val) (bp n.val)) (lp.initialL2Projection_idempotent n.val)
    (by simpa only [approximateVolterraCoefficientSection, volterraCoefficientSection]
      using n.property) f
  have hv : lp.initialL2Vector (volterraProriolMatrixSolution p hB bp f n) =
      Ring.inverseAt (approximateVolterraCoefficientSection
        (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) n
        (lp.initialL2Projection n.val f) := by
    unfold volterraProriolMatrixSolution
    rw [lp.initialL2Vector_restrict, Ring.inverseAt_eq_ringInverse]
    exact hs.1
  refine ⟨hv, (volterraProriolMatrix_equation_iff (p n.val) (hB n.val) (bp n.val) _ f).mpr ?_⟩
  rw [hv, Ring.inverseAt_eq_ringInverse]
  simpa only [approximateVolterraCoefficientSection, volterraCoefficientSection,
    sub_eq_add_neg, add_apply, one_apply_eq_self, _root_.neg_apply] using hs.2

Theorem 6.1.54 Convergent assembled Proriol solves for continuous kernels

✓ 🤖

#

Let \(K\) be continuous on the closed Volterra triangle and let \(p_n\) be polynomial kernels with finite nonnegative bounds and uniform errors \(|p_n-K|\le \varepsilon _n\to 0\), \(\varepsilon _n\ge 0\). For all sufficiently large \(n\), the assembled system

\[ (I-G_{p_n,n})v_n=(f_i)_{i{\lt}n} \]

has a unique solution. For every cutoff \(n\) at which \(B_n=I-P_nA_{p_n}\) is invertible, define \(v_n\) as in Definition 6.1.52; its zero extension equals the lifted solution and solves the matrix equation at every such cutoff. These cutoffs include every sufficiently large \(n\). For every \(f\in \ell ^2\), with \(u=(I-A_K)^{-1}f\), the zero extensions converge to \(u\) as \(n\to \infty \) through these cutoffs, and eventually

\[ \| J_nv_n-u\| \le (\| (I-A_K)^{-1}\| +1) \bigl(\| P_nu-u\| +\varepsilon _n\| u\| \bigr). \]

Every continuous \(K\) admits such a sequence with error at most \(1/(n+1)\) and convergent solves for every \(f\). No relation between the polynomial kernel degrees and section sizes is assumed; the columns use the full finite polynomial assembly before the final row restriction.

Lean Formalisation

theorem MvPolynomial.eventually_existsUnique_approximateProriolMatrix_solution {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (p : ℕ → MvPolynomial (Fin 2) ℝ) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n) - K z| ≤ e n)
  (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∀ (f : ↥(lp (fun x => ℝ) 2)), ∃! v, (1 - (p n).volterraProriolMatrix n).mulVec v = fun i => ↑f ↑i

Lean proof

/-- Eventually every approximating assembled matrix has a unique finite solution. -/
theorem eventually_existsUnique_approximateProriolMatrix_solution :
    ∀ᶠ n in atTop, ∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
      ∃! v : Fin n → ℝ, (1 - volterraProriolMatrix (p n) n) *ᵥ v = (fun i : Fin n ↦ f i) := by
  filter_upwards [eventually_existsUnique_approximateVolterra_solution hK hM bK
    (fun n ↦ (p n).continuous_eval.continuousOn) hB bp he err hte] with n hn f
  rw [volterraProriolMatrix_eq (p n) n (hB n) (bp n)]
  exact lp.existsUnique_initialL2Matrix_solution _ n f (hn f)

4 related Lean declarations

theorem MvPolynomial.eventually_volterraProriolMatrixSolution_spec {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (p : ℕ → MvPolynomial (Fin 2) ℝ) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n) - K z| ≤ e n)
  (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∃ (hn : IsUnit (Real.approximateVolterraCoefficientSection ⋯ hB bp n)),
      ∀ (f : ↥(lp (fun x => ℝ) 2)),
        lp.initialL2Vector (MvPolynomial.volterraProriolMatrixSolution p hB bp f ⟨n, hn⟩) =
            (Ring.inverseAt (Real.approximateVolterraCoefficientSection ⋯ hB bp) ⟨n, hn⟩)
              ((lp.initialL2Projection n) f) ∧
          (1 - (p n).volterraProriolMatrix n).mulVec (MvPolynomial.volterraProriolMatrixSolution p hB bp f ⟨n, hn⟩) =
            fun i => ↑f ↑i

Lean proof

/-- All sufficiently large cutoffs admit classical assembled solves. -/
theorem eventually_volterraProriolMatrixSolution_spec :
    ∀ᶠ n in atTop, ∃ hn : IsUnit (approximateVolterraCoefficientSection
      (fun n ↦ (p n).continuous_eval.continuousOn) hB bp n),
      ∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
      lp.initialL2Vector (volterraProriolMatrixSolution p hB bp f ⟨n, hn⟩) =
        Ring.inverseAt (approximateVolterraCoefficientSection
          (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) ⟨n, hn⟩
          (lp.initialL2Projection n f) ∧
      (1 - volterraProriolMatrix (p n) n) *ᵥ
        volterraProriolMatrixSolution p hB bp f ⟨n, hn⟩ = (fun i : Fin n ↦ f i) := by
  filter_upwards [eventually_stable_approximateVolterraSection hK hM bK
    (fun n ↦ (p n).continuous_eval.continuousOn) hB bp he err hte] with n hn
  obtain ⟨hn, _⟩ := hn
  exact ⟨hn, fun f ↦ volterraProriolMatrixSolution_spec p hB bp ⟨n, hn⟩ f⟩

theorem MvPolynomial.tendsto_volterraProriolMatrixSolution {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) (p : ℕ → MvPolynomial (Fin 2) ℝ) {B e : ℕ → ℝ}
  (hB : ∀ (n : ℕ), 0 ≤ B n) (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n)
  (he : ∀ (n : ℕ), 0 ≤ e n) (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n) - K z| ≤ e n)
  (hte : Filter.Tendsto e Filter.atTop (nhds 0)) (f : ↥(lp (fun x => ℝ) 2)) :
  Filter.Tendsto (fun n => lp.initialL2Vector (MvPolynomial.volterraProriolMatrixSolution p hB bp f n))
    (Ring.invertibleIndexFilter (Real.approximateVolterraCoefficientSection ⋯ hB bp) Filter.atTop)
    (nhds ((Real.volterraCoefficientInverse hK hM bK) f))

Lean proof

/-- Zero-extended classical finite solutions converge through invertible cutoffs. -/
theorem tendsto_volterraProriolMatrixSolution (f : lp (fun _ : ℕ ↦ ℝ) 2) :
    Tendsto (fun n : Ring.InvertibleIndex (approximateVolterraCoefficientSection
      (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) ↦
      lp.initialL2Vector (volterraProriolMatrixSolution p hB bp f n))
      (Ring.invertibleIndexFilter (approximateVolterraCoefficientSection
        (fun n ↦ (p n).continuous_eval.continuousOn) hB bp) atTop)
      (𝓝 (volterraCoefficientInverse hK hM bK f)) := by
  apply (tendsto_approximateVolterra_solution hK hM bK
    (fun n ↦ (p n).continuous_eval.continuousOn) hB bp he err hte f).congr'
  exact Filter.Eventually.of_forall (fun n ↦ (volterraProriolMatrixSolution_spec p hB bp n f).1.symm)

theorem MvPolynomial.eventually_norm_volterraProriolMatrixSolution_error_le {K : (Fin 2 → ℝ) → ℝ}
  (hK : ContinuousOn K Real.volterraTriangle) {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M)
  (p : ℕ → MvPolynomial (Fin 2) ℝ) {B e : ℕ → ℝ} (hB : ∀ (n : ℕ), 0 ≤ B n)
  (bp : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n)| ≤ B n) (he : ∀ (n : ℕ), 0 ≤ e n)
  (err : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (p n) - K z| ≤ e n)
  (hte : Filter.Tendsto e Filter.atTop (nhds 0)) :
  ∀ᶠ (n : ℕ) in Filter.atTop,
    ∃ (hn : IsUnit (Real.approximateVolterraCoefficientSection ⋯ hB bp n)),
      ∀ (u : ↥(lp (fun x => ℝ) 2)),
        ‖lp.initialL2Vector
                (MvPolynomial.volterraProriolMatrixSolution p hB bp
                  (u - (Real.volterraL2CoefficientOperator hK hM bK) u) ⟨n, hn⟩) -
              u‖ ≤
          (‖Real.volterraCoefficientInverse hK hM bK‖ + 1) * (‖(lp.initialL2Projection n) u - u‖ + e n * ‖u‖)

Lean proof

/-- Combined finite matrix error: coefficient tail plus uniform kernel error. -/
theorem eventually_norm_volterraProriolMatrixSolution_error_le :
    ∀ᶠ n in atTop, ∃ hn : IsUnit (approximateVolterraCoefficientSection
      (fun n ↦ (p n).continuous_eval.continuousOn) hB bp n),
      ∀ u : lp (fun _ : ℕ ↦ ℝ) 2,
      ‖lp.initialL2Vector (volterraProriolMatrixSolution p hB bp
        (u - volterraL2CoefficientOperator hK hM bK u) ⟨n, hn⟩) - u‖ ≤
        (‖volterraCoefficientInverse hK hM bK‖ + 1) *
          (‖lp.initialL2Projection n u - u‖ + e n * ‖u‖) := by
  filter_upwards [eventually_norm_approximateVolterra_error_le hK hM bK
    (fun n ↦ (p n).continuous_eval.continuousOn) hB bp he err hte] with n hn
  obtain ⟨hn, heN⟩ := hn
  refine ⟨hn, fun u ↦ ?_⟩
  rw [(volterraProriolMatrixSolution_spec p hB bp ⟨n, hn⟩ _).1]
  exact heN u

theorem MvPolynomial.exists_volterraPolynomialKernel_sequence {K : (Fin 2 → ℝ) → ℝ} (hK : ContinuousOn K Real.volterraTriangle)
  {M : ℝ} (hM : 0 ≤ M) (bK : ∀ z ∈ Real.volterraTriangle, |K z| ≤ M) :
  ∃ q C,
    ∃ (hC : ∀ (n : ℕ), 0 ≤ C n) (bq : ∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (q n)| ≤ C n),
      (∀ (n : ℕ), ∀ z ∈ Real.volterraTriangle, |(MvPolynomial.eval z) (q n) - K z| ≤ 1 / (↑n + 1)) ∧
        ∀ (f : ↥(lp (fun x => ℝ) 2)),
          Filter.Tendsto (fun n => lp.initialL2Vector (MvPolynomial.volterraProriolMatrixSolution q hC bq f n))
            (Ring.invertibleIndexFilter (Real.approximateVolterraCoefficientSection ⋯ hC bq) Filter.atTop)
            (nhds ((Real.volterraCoefficientInverse hK hM bK) f))

Lean proof

/-- Every continuous kernel admits a sequence of bounded polynomial kernels
with a certified vanishing uniform error on the Volterra triangle. -/
theorem exists_volterraPolynomialKernel_sequence :
    ∃ (q : ℕ → MvPolynomial (Fin 2) ℝ) (C : ℕ → ℝ) (hC : ∀ n, 0 ≤ C n)
      (bq : ∀ n z, z ∈ volterraTriangle → |eval z (q n)| ≤ C n),
      (∀ n z, z ∈ volterraTriangle → |eval z (q n) - K z| ≤ 1 / ((n : ℝ) + 1)) ∧
      (∀ f : lp (fun _ : ℕ ↦ ℝ) 2,
        Tendsto (fun n : Ring.InvertibleIndex (approximateVolterraCoefficientSection
          (fun n ↦ (q n).continuous_eval.continuousOn) hC bq) ↦
          lp.initialL2Vector (volterraProriolMatrixSolution q hC bq f n))
          (Ring.invertibleIndexFilter (approximateVolterraCoefficientSection
            (fun n ↦ (q n).continuous_eval.continuousOn) hC bq) atTop)
          (𝓝 (volterraCoefficientInverse hK hM bK f))) := by
  have hp : ∀ n : ℕ, ∃ q : MvPolynomial (Fin 2) ℝ,
      ∀ z ∈ volterraTriangle, |eval z q - K z| < 1 / ((n : ℝ) + 1) :=
    fun n ↦ exists_polynomial_near_volterraKernel hK (by positivity)
  choose q hq using hp
  have hC : ∀ n : ℕ, 0 ≤ M + 1 / ((n : ℝ) + 1) := fun n ↦ by positivity
  have bq : ∀ n z, z ∈ volterraTriangle → |eval z (q n)| ≤ M + 1 / ((n : ℝ) + 1) := by
    intro n z hz
    calc
      _ ≤ |eval z (q n) - K z| + |K z| := by
        simpa only [sub_add_cancel] using abs_add_le (eval z (q n) - K z) (K z)
      _ ≤ 1 / ((n : ℝ) + 1) + M := add_le_add (hq n z hz).le (bK z hz)
      _ = _ := add_comm _ _
  refine ⟨q, _, hC, bq, (fun n z hz ↦ (hq n z hz).le), fun f ↦ ?_⟩
  exact tendsto_volterraProriolMatrixSolution hK hM bK q hC bq
    (fun n ↦ by positivity) (fun n z hz ↦ (hq n z hz).le)
    tendsto_one_div_add_atTop_nhds_zero_nat f