Lean Ridgelet Blueprint

2.1. L1 theory: arXiv:1505.03654v2 implementation map🔗

This chapter lists the definitions and the main results of Sonoda--Murata, Neural network with unbounded activation functions is universal approximator (arXiv:1505.03654v2), in the publication order of the article, each linked to the Lean declaration that carries it. It is the place to check what is formalized; the machinery behind the proofs is the following chapter, organized by Lean dependency. It corresponds to plan milestone M7.

The pass is at function level. The parameter space is realized in Euclidean coordinates (\boldsymbol{a},b)\in\mathbb R^m\times\mathbb R; the polar coordinates (\boldsymbol{u},\alpha,\beta) of the article enter through the Radon transform. The ridgelet function is integrable rather than Schwartz, and the distributional Fourier transform of an activation \eta is carried by a function F_\eta representing \widehat\eta away from the origin, so that point masses at the origin — the polynomial part of \eta, i.e. the kernel of the Lizorkin quotient \mathcal S'(\mathbb R)/\mathcal P\cong\mathcal S_0'(\mathbb R) — are invisible.

Wherever the formalized statement differs from the article, the node says so in one sentence and the reason is recorded in the docstring of the declaration and in the module docstring of the file holding it, under the heading Deviations from the article. A node without a Lean link records deferred mathematical scope and creates no Lean assumption. Every linked declaration is proved: the L1 development contains no sorry.

Section 2--3: coordinates, transforms, and the Lizorkin quotient

Definition2.1.1
uses 0
Used by 4
Reverse dependency previews
Preview
Definition 2.1.2
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Parameter space and reference measure. The parameter space \mathbb Y^{m+1}=\mathbb R^m\times\mathbb R carries the measure \|\boldsymbol{a}\|^{-2}\,d\boldsymbol{a}\,db, the Euclidean expression of the article's fixed measure \alpha^{-m}\,d\alpha\,d\beta\,d\boldsymbol{u} under \boldsymbol{a}=\boldsymbol{u}/\alpha, b=\beta/\alpha. The one-dimensional article Fourier convention \widehat\psi(\zeta)=\int\psi(z)e^{-iz\zeta}\,dz is the V=\mathbb R case of the shared convention module, with the rescaling bridge \widehat g(\zeta)=\mathcal Fg(\zeta/2\pi) to Mathlib's transform.

Lean code for Definition2.1.14 declarations
  • abbrevdefined in LeanRidgelet/L1/Defs.lean
    complete
    abbrev LeanRidgelet.RidgeletParameterSpace (m : ) : Type
    abbrev LeanRidgelet.RidgeletParameterSpace
      (m : ) : Type
    Implementation after :=
    := InputSpace m × ℝ
    The parameter space `𝕐^{m+1} = ℝ^m × ℝ` of hidden parameters `(a, b)` in Euclidean
    coordinates. 
  • complete
    def LeanRidgelet.ridgeletParameterMeasure (m : ) :
      MeasureTheory.Measure (LeanRidgelet.RidgeletParameterSpace m)
    def LeanRidgelet.ridgeletParameterMeasure
      (m : ) :
      MeasureTheory.Measure
        (LeanRidgelet.RidgeletParameterSpace
          m)
    Implementation after :=
    :=
      volume.withDensity fun p => ENNReal.ofReal ((‖p.1‖ ^ 2)⁻¹)
    The measure `‖a‖⁻² da db` on `𝕐^{m+1}`, the Euclidean-coordinate expression of the fixed
    measure `α^{-m} dα dβ du` used for `L²(𝕐^{m+1})` in Section 5.3 of the manuscript. 
  • complete
    def LeanRidgelet.angularFourier1D (g :   ) :   
    def LeanRidgelet.angularFourier1D
      (g :   ) :   
    Implementation after :=
    :=
      Fourier.angularFourierIntegralInner g
    The one-dimensional manuscript Fourier integral `ψ̂(ζ) = ∫ z, exp (-i z ζ) ψ z`, the
    `V = ℝ` case of `LeanRidgelet.Fourier.angularFourierIntegralInner`. 
  • theoremdefined in LeanRidgelet/L1/Defs.lean
    complete
    theorem LeanRidgelet.angularFourier1D_eq_mathlib (g :   ) (ζ : ) :
      LeanRidgelet.angularFourier1D g ζ =
        FourierTransform.fourier g ((2 * Real.pi)⁻¹  ζ)
    theorem LeanRidgelet.angularFourier1D_eq_mathlib
      (g :   ) (ζ : ) :
      LeanRidgelet.angularFourier1D g ζ =
        FourierTransform.fourier g
          ((2 * Real.pi)⁻¹  ζ)
    The article convention in terms of Mathlib's `𝓕`: rescaling the frequency by `(2π)⁻¹`
    turns `ĝ(ζ) = ∫ g(z) e^{-i z ζ} dz` into `𝓕 g`. This is the bridge used whenever a Mathlib
    Fourier theorem has to be transported to the angular convention. 
Definition2.1.2
uses 1
Used by 7
Reverse dependency previews
Preview
Definition 2.1.3
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Ridgelet and dual ridgelet transforms (eq:eucrid). With homogeneity index s (the article fixes s=1 from Section 4 on), \mathscr R_\psi f(\boldsymbol{a},b)=\int f(\boldsymbol{x})\overline{\psi(\boldsymbol{a}\cdot\boldsymbol{x}-b)}\,\|\boldsymbol{a}\|^s\,d\boldsymbol{x},\qquad \mathscr R^\dagger_\eta T(\boldsymbol{x})=\int T(\boldsymbol{a},b)\,\eta(\boldsymbol{a}\cdot\boldsymbol{x}-b)\,\|\boldsymbol{a}\|^{-s}\,d\boldsymbol{a}\,db. The truncated dual transform integrates over the annulus \varepsilon\le\|\boldsymbol{a}\|\le\delta, and the reconstruction limit is taken along the product filter \varepsilon\to0^+, \delta\to\infty. Scoped Lean notation: 𝓡[s; ψ], 𝓡†[s; η].

Lean code for Definition2.1.24 definitions
  • complete
    def LeanRidgelet.euclideanRidgeletTransform (m : ) (s : ) (ψ :   )
      (f : LeanRidgelet.InputSpace m  ) :
      LeanRidgelet.RidgeletParameterSpace m  
    def LeanRidgelet.euclideanRidgeletTransform
      (m : ) (s : ) (ψ :   )
      (f : LeanRidgelet.InputSpace m  ) :
      LeanRidgelet.RidgeletParameterSpace m 
        
    Implementation after :=
    :=
      fun p => ∫ x, f x * conj (ψ (inner ℝ p.1 x - p.2)) * ((‖p.1‖ ^ s : ℝ) : ℂ)
    The classical ridgelet transform in Euclidean coordinates with homogeneity index `s`
    (`eq:eucrid`): `R_ψ f (a, b) = ∫ x, f x * conj (ψ (⟪a, x⟫ - b)) * ‖a‖^s`. The manuscript fixes
    `s = 1` from Section 4 on. 
  • complete
    def LeanRidgelet.euclideanDualRidgeletTransform (m : ) (s : ) (η :   )
      (T : LeanRidgelet.RidgeletParameterSpace m  )
      (x : LeanRidgelet.InputSpace m) : 
    def LeanRidgelet.euclideanDualRidgeletTransform
      (m : ) (s : ) (η :   )
      (T :
        LeanRidgelet.RidgeletParameterSpace
            m 
          )
      (x : LeanRidgelet.InputSpace m) : 
    Implementation after :=
    :=
      ∫ p : RidgeletParameterSpace m, T p * η (inner ℝ p.1 x - p.2) * ((‖p.1‖ ^ s : ℝ) : ℂ)⁻¹
    The classical dual ridgelet transform in Euclidean coordinates with homogeneity index `s`
    (`eq:drid`): `R†_η T (x) = ∫ (a, b), T (a, b) * η (⟪a, x⟫ - b) * ‖a‖^{-s}`, as an absolutely
    convergent integral. 
  • complete
    def LeanRidgelet.truncatedDualRidgeletTransform (m : ) (s : ) (η :   )
      (T : LeanRidgelet.RidgeletParameterSpace m  ) (ε δ : )
      (x : LeanRidgelet.InputSpace m) : 
    def LeanRidgelet.truncatedDualRidgeletTransform
      (m : ) (s : ) (η :   )
      (T :
        LeanRidgelet.RidgeletParameterSpace
            m 
          )
      (ε δ : )
      (x : LeanRidgelet.InputSpace m) : 
    Implementation after :=
    :=
      ∫ p in {p : RidgeletParameterSpace m | ε ≤ ‖p.1‖ ∧ ‖p.1‖ ≤ δ},
        T p * η (inner ℝ p.1 x - p.2) * ((‖p.1‖ ^ s : ℝ) : ℂ)⁻¹
    The dual ridgelet transform truncated to the annulus `ε ≤ ‖a‖ ≤ δ`. In the polar
    coordinates of the manuscript's definition the truncation reads `1/δ ≤ α ≤ 1/ε`, so the limit
    `ε → 0⁺`, `δ → ∞` below is the manuscript's limit `ε → 0⁺`, `δ → ∞` after the substitution
    `(ε, δ) ← (1/δ, 1/ε)`. 
  • complete
    def LeanRidgelet.ridgeletTruncationFilter : Filter ( × )
    def LeanRidgelet.ridgeletTruncationFilter :
      Filter ( × )
    Implementation after :=
    :=
      (𝓝[>] (0 : ℝ)) ×ˢ Filter.atTop
    The filter governing the truncation limit `ε → 0⁺`, `δ → ∞` of the dual ridgelet
    transform. 
Definition2.1.3
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1L∃∀N

Weak ridgelet transform (Definition 4.1). For a locally integrable ridgelet function, \mathscr R_\psi f(\boldsymbol{u},\alpha,\beta)=\int_{\mathbb R}\mathscr Rf(\boldsymbol{u},\alpha z+\beta)\,\overline{\psi(z)}\,dz. Deviation. The article reads the integral as the action of a distribution \psi\in\mathcal S'(\mathbb R); that reading is deferred with the distributional pass.

Lean code for Definition2.1.31 definition
  • complete
    def LeanRidgelet.weakRidgeletTransform (m : ) (ψ :   )
      (f : LeanRidgelet.InputSpace m  ) (u : LeanRidgelet.InputSpace m)
      (α β : ) : 
    def LeanRidgelet.weakRidgeletTransform (m : )
      (ψ :   )
      (f : LeanRidgelet.InputSpace m  )
      (u : LeanRidgelet.InputSpace m)
      (α β : ) : 
    Implementation after :=
    :=
      ∫ z, radonTransform f u (α * z + β) * conj (ψ z)
    The weak ridgelet transform with respect to a locally integrable ridgelet function
    (Definition 4.1 in polar coordinates):
    `R_ψ f (u, α, β) = ∫ z, Radon f (u, α z + β) * conj (ψ z)`. The genuinely distributional
    version, where `∫ · conj (ψ z) dz` is the action of `ψ ∈ 𝒮'(ℝ)` on a Schwartz function of `z`,
    is deferred to the distributional pass. 
Definition2.1.4
Statement uses 2
Statement dependency previews
Preview
Definition 5.2.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 4
Reverse dependency previews
Preview
Theorem 2.1.15
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

The filter of filtered backprojection (eq:bp). Formalized as the m-th power of the standard Lambda operator \Lambda=\sqrt{-d^2/dz^2} (in tomography also the fractional Laplacian or the Calderón operator; Natterer's Riesz potential I^{-m}; the ramp filter |\omega| for m=1): \Lambda^m=(-1)^{\lfloor m/2\rfloor}\partial_z^m for even m and (-1)^{\lfloor m/2\rfloor}\mathscr H\partial_z^m for odd m, with intended Fourier multiplier |\omega|^m. Scoped Lean notation: Λ^m. Deviation. This corrects the article, whose filter eq:bp (\partial_p^m / H\partial_p^m with H=i\mathscr H) equals i^m\Lambda^m and carries the spurious phase i^m; see the docstring of lambdaOperatorPow. The affected statements (thm:eq.ac, cor:const.ap, thm:formula.radon, Section 6.2) are equivalent up to a nonzero scalar, except that the sign of the inversion formula is fixed.

Lean code for Definition2.1.43 definitions
  • def MeasureTheory.pvHilbertTransform (g :   ) (x : ) : 
    def MeasureTheory.pvHilbertTransform
      (g :   ) (x : ) : 
    Implementation after :=
    :=
      Filter.limUnder (𝓝[>] (0 : ℝ)) fun ε =>
        (1 / (Real.pi : ℂ)) * ∫ t in {t : ℝ | ε < |x - t|}, g t / ((x : ℂ) - (t : ℂ))
    The principal-value Hilbert transform in the classical normalization
    `𝓗 g (x) = (1/π) p.v. ∫ g t / (x - t) dt`. 
  • complete
    def LeanRidgelet.lambdaOperatorPow (m : ) (g :   ) :   
    def LeanRidgelet.lambdaOperatorPow (m : )
      (g :   ) :   
    Implementation after :=
    :=
      fun z => (-1 : ℂ) ^ (m / 2) *
        (if Even m then iteratedDeriv m g z else pvHilbertTransform (iteratedDeriv m g) z)
    The `m`-th power `Λ^m` of the **Lambda operator** `Λ = √(-d²/dz²)` (also known in
    tomography as the fractional Laplacian or the Calderón operator), the filter of filtered
    backprojection: `(-1)^{⌊m/2⌋} ∂^m` for even `m` and `(-1)^{⌊m/2⌋} 𝓗 ∂^m` for odd `m`, with
    one-dimensional Fourier multiplier `|ω|^m`, so that Radon's inversion formula
    `R† Λ^{m-1} R = 2 (2π)^{m-1}` holds with a positive constant. In the tomography literature
    `Λ^m` is Natterer's Riesz potential `I^{-m}`, and for `m = 1` on the plane the multiplier
    `|ω|` is the ramp filter.
    
    **Correction to the article.** The article's backprojection filter (`eq:bp`) is `∂^m` for
    even `m` and `H ∂^m` for odd `m` with `H = i 𝓗`, which equals `i^m Λ^m`: its multiplier
    `i^m |ω|^m` carries the spurious phase `i^m` (equal to `-1` for `m ≡ 2 (mod 4)` and `±i` for
    odd `m`), so with `eq:bp` the inversion formula `R† Λ^{m-1} R = 2 (2π)^{m-1}` would acquire
    the factor `i^{m-1}`. This formalization uses the standard `Λ^m` throughout; the other
    affected statements (`thm:eq.ac`, `cor:const.ap`, Section 6.2) are equivalent up to a nonzero
    scalar rescaling of the solution or of the constructed ridgelet function. 
  • complete
    def LeanRidgelet.reflectedConjConvolution (ψ η :   ) :   
    def LeanRidgelet.reflectedConjConvolution
      (ψ η :   ) :   
    Implementation after :=
    :=
      (fun z => conj (ψ (-z))) ⋆[ContinuousLinearMap.mul ℂ ℂ] η
    The convolution `conj (ψ~) ⋆ η` with the reflection `ψ~(z) = ψ (-z)`, appearing in the
    structure theorem for admissible pairs (`thm:eq.ac`). 
Definition2.1.5
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 7
Reverse dependency previews
Preview
Definition 2.1.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Fourier data away from the origin (Section 2.3, function-level form). A locally integrable, polynomially bounded activation \eta has Fourier data F_\eta away from the origin when \int F_\eta\varphi=\int\eta\widehat\varphi for every Schwartz \varphi supported away from 0. Deviation. The article takes \eta\in\mathcal S_0'(\mathbb R); this predicate is the function-level realization of the same quotient, and is exactly the pairing a Lizorkin distribution sees. The Lizorkin space itself is available as a type in the upstream-candidates chapter (mathlib_lizorkin_space).

Lean code for Definition2.1.52 definitions
  • def MeasureTheory.PolynomiallyBounded (η :   ) : Prop
    def MeasureTheory.PolynomiallyBounded
      (η :   ) : Prop
    Implementation after :=
    :=
      ∃ (C : ℝ) (k : ℕ), ∀ z : ℝ, ‖η z‖ ≤ C * (1 + |z|) ^ k
    Polynomial growth bound: `‖η z‖ ≤ C (1 + |z|)^k`.  Together with local integrability this
    is the classical criterion for a function to define a tempered distribution. 
  • complete
    def LeanRidgelet.HasFourierAwayFromOrigin (η  :   ) : Prop
    def LeanRidgelet.HasFourierAwayFromOrigin
      (η  :   ) : Prop
    Implementation after :=
    :=
      MeasureTheory.LocallyIntegrable η volume ∧ PolynomiallyBounded η ∧
      MeasureTheory.LocallyIntegrableOn Fη {(0 : ℝ)}ᶜ volume ∧
      ∀ φ : SchwartzMap ℝ ℂ, tsupport ⇑φ ⊆ {(0 : ℝ)}ᶜ →
        ∫ ζ, Fη ζ * φ ζ = ∫ z, η z * angularFourier1D (⇑φ) z
    `Fη` represents the distributional Fourier transform of `η` away from the origin: for every
    Schwartz test function `φ` whose support avoids `0`, the pairing `⟨η̂, φ⟩ = ⟨η, φ̂⟩` is computed
    by integrating `Fη` against `φ`. Point masses `δ^{(j)}` at the origin — equivalently, polynomial
    components of `η` — are invisible to `Fη`, which realizes the Lizorkin quotient
    `𝒮₀'(ℝ) ≅ 𝒮'(ℝ)/polynomials` at function level. 
Definition2.1.6
uses 1
Used by 7
Reverse dependency previews
Preview
Proposition 2.1.7
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Admissibility (eq:defK, Section 5.3). The pair (\psi,\eta) with Fourier data F_\eta is admissible when \psi is integrable, the integrand of K_{\psi,\eta}=(2\pi)^{m-1}\int_{\mathbb R\setminus\{0\}}\frac{\overline{\widehat\psi(\zeta)}\,F_\eta(\zeta)}{|\zeta|^m}\,d\zeta is integrable on \mathbb R\setminus\{0\}, and K_{\psi,\eta}\ne0. Self-admissible, equivalent, and admissibly decomposable pairs are as in Section 5.3, with equivalence expressed on the Fourier side. Scoped Lean notation: K[m; ψ, Fη]. The article motivates excising the origin with its Examples 5.2 and 5.3; see l1_admissibility_examples.

Lean code for Definition2.1.65 definitions
  • complete
    def LeanRidgelet.admissibilityConstant (m : ) (ψ  :   ) : 
    def LeanRidgelet.admissibilityConstant (m : )
      (ψ  :   ) : 
    Implementation after :=
    :=
      (2 * Real.pi) ^ (m - 1) *
        ∫ ζ in {(0 : ℝ)}ᶜ, conj (angularFourier1D ψ ζ) * Fη ζ / ((|ζ| ^ m : ℝ) : ℂ)
    The admissibility constant `K_{ψ,η} = (2π)^{m-1} ∫_{ℝ \ {0}} conj (ψ̂ ζ) * Fη ζ / |ζ|^m dζ`
    (`eq:defK`), with the Fourier transform of `η` away from the origin given by `Fη`. 
  • complete
    def LeanRidgelet.IsAdmissiblePair (m : ) (ψ η  :   ) : Prop
    def LeanRidgelet.IsAdmissiblePair (m : )
      (ψ η  :   ) : Prop
    Implementation after :=
    :=
      Integrable ψ volume ∧ HasFourierAwayFromOrigin η Fη ∧
      IntegrableOn (fun ζ => conj (angularFourier1D ψ ζ) * Fη ζ / ((|ζ| ^ m : ℝ) : ℂ))
        {(0 : ℝ)}ᶜ volume ∧
      admissibilityConstant m ψ Fη ≠ 0
    The admissibility condition for a pair `(ψ, η)` whose Fourier transform away from the origin
    is `Fη`: the ridgelet function is integrable (so `ψ̂` is an honest integral), the defining
    integrand of `K_{ψ,η}` is integrable on `ℝ \ {0}`, and `K_{ψ,η} ≠ 0`. 
  • complete
    def LeanRidgelet.IsSelfAdmissible (m : ) (ψ :   ) : Prop
    def LeanRidgelet.IsSelfAdmissible (m : )
      (ψ :   ) : Prop
    Implementation after :=
    :=
      IsAdmissiblePair m ψ ψ (angularFourier1D ψ)
    `ψ` is self-admissible when the pair `(ψ, ψ)` is admissible (Section 5.3). 
  • complete
    def LeanRidgelet.IsEquivalentPair (ψ  ψ' Fη' :   ) : Prop
    def LeanRidgelet.IsEquivalentPair
      (ψ  ψ' Fη' :   ) : Prop
    Implementation after :=
    :=
      ∀ ζ : ℝ, ζ ≠ 0 → conj (angularFourier1D ψ ζ) * Fη ζ = conj (angularFourier1D ψ' ζ) * Fη' ζ
    Two pairs are equivalent when they define the same convolution `conj (ψ~) ⋆ η`
    (Section 5.3), expressed here on the Fourier side: the products `conj (ψ̂) * Fη` agree away from
    the origin. 
  • complete
    def LeanRidgelet.IsAdmissiblyDecomposable (m : ) (ψ η  :   ) : Prop
    def LeanRidgelet.IsAdmissiblyDecomposable
      (m : ) (ψ η  :   ) : Prop
    Implementation after :=
    :=
      IsAdmissiblePair m ψ η Fη ∧
      ∃ ψs ηs : ℝ → ℂ, IsSelfAdmissible m ψs ∧ IsSelfAdmissible m ηs ∧
        IsEquivalentPair ψ Fη ψs (angularFourier1D ηs)
    An admissible pair `(ψ, η)` is admissibly decomposable when it is equivalent to a cross pair
    `(ψ⋆, η⋆)` of two self-admissible functions (Section 5.3). 
Proposition2.1.7
Statement uses 4
Statement dependency previews
Preview
Definition 2.1.6
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0L∃∀N

Examples 5.2 and 5.3: where admissibility fails. The article exhibits two pairs for which the naive product \overline{\widehat\psi}\,\widehat\eta\,|\zeta|^{-m} of tempered distributions is not associative, the two groupings of \mathrm{p.v.}(1/|\zeta|)\times|\zeta|G(\zeta)\times\delta(\zeta) differing by G(0), and uses them to motivate excising the origin in eq:defK. At function level no such ambiguity can arise: F_\eta is a function on \mathbb R\setminus\{0\} and the admissibility density is a pointwise product of complex numbers. What survives is the verdict, and it agrees with the article's. Example 5.2 (\eta(z)=z, \psi=\Lambda G): a polynomial activation is never admissible, since its Fourier data away from the origin vanishes (second declaration, from the first) and hence K_{\psi,\eta}=0 for every \psi. This is why activations are taken in \mathcal S'(\mathbb R)/\mathcal P\cong\mathcal S_0'(\mathbb R). Example 5.3 (\eta(z)=z_+^0+(2\pi)^{-1}e^{iz}, \psi=\Lambda G): removing the origin is not by itself enough. The unit step is inadmissible with any filtered ridgelet function \Lambda^m\varphi whose window satisfies \widehat\varphi(0)\ne0, because by l1_construction_admissible the density is \overline{\widehat\varphi(\zeta)}/(i\zeta), which is not absolutely integrable at the origin (third declaration). The second summand of the article's \eta puts a point mass of \widehat\eta away from the origin and lies outside the function-level framework, but it is not the source of the divergence.

Lean code for Proposition2.1.73 theorems
  • complete
    theorem LeanRidgelet.l1_hasFourierAwayFromOrigin_polynomial (Q : Polynomial ) :
      LeanRidgelet.HasFourierAwayFromOrigin (fun z  Polynomial.eval (↑z) Q)
        0
    theorem LeanRidgelet.l1_hasFourierAwayFromOrigin_polynomial
      (Q : Polynomial ) :
      LeanRidgelet.HasFourierAwayFromOrigin
        (fun z  Polynomial.eval (↑z) Q) 0
    A polynomial has vanishing Fourier data away from the origin: its distributional Fourier
    transform is a combination of derivatives of `δ`, all supported at the origin. 
  • complete
    theorem LeanRidgelet.l1_polynomial_not_isAdmissiblePair (m : ) (ψ :   )
      (Q : Polynomial ) :
      ¬LeanRidgelet.IsAdmissiblePair m ψ (fun z  Polynomial.eval (↑z) Q) 0
    theorem LeanRidgelet.l1_polynomial_not_isAdmissiblePair
      (m : ) (ψ :   ) (Q : Polynomial ) :
      ¬LeanRidgelet.IsAdmissiblePair m ψ
          (fun z  Polynomial.eval (↑z) Q) 0
    **Example 5.2**: a polynomial activation is never admissible, `K_{ψ,η} = 0` for every `ψ`.
    
    The manuscript exhibits `η(z) = z`, `ψ = Λ G` with `G` the Gaussian, for which the two
    groupings of `pv (1/|ζ|) × |ζ| G(ζ) × δ(ζ)` give `0` and `G(0) ≠ 0`; the admissibility integral
    `eq:defK`, which removes the origin, gives `0`. In the Lizorkin quotient the reason is
    structural and needs no computation: the Fourier data of a polynomial away from the origin
    vanishes, so the admissibility density does too. This is why the article takes activations in
    `𝒮'(ℝ)/𝒫 ≅ 𝒮₀'(ℝ)`. 
  • complete
    theorem LeanRidgelet.l1_step_not_isAdmissiblePair_lambdaOperatorPow (m : )
      [NeZero m] (φ : SchwartzMap  )
      ( : LeanRidgelet.angularFourier1D (⇑φ) 0  0) :
      ¬LeanRidgelet.IsAdmissiblePair m (LeanRidgelet.lambdaOperatorPow m φ)
          (LeanRidgelet.truncatedPower 0)
          (LeanRidgelet.truncatedPowerFourier 0)
    theorem LeanRidgelet.l1_step_not_isAdmissiblePair_lambdaOperatorPow
      (m : ) [NeZero m] (φ : SchwartzMap  )
      ( :
        LeanRidgelet.angularFourier1D (⇑φ) 0 
          0) :
      ¬LeanRidgelet.IsAdmissiblePair m
          (LeanRidgelet.lambdaOperatorPow m
            φ)
          (LeanRidgelet.truncatedPower 0)
          (LeanRidgelet.truncatedPowerFourier
            0)
    **Example 5.3**: the unit step `z₊^0` is not admissible with a filtered ridgelet function
    `Λ^m φ` whose window has `φ̂ (0) ≠ 0`; the admissibility integral diverges at the origin.
    
    The manuscript's instance is `m = 1`, `φ = G` the Gaussian and
    `η(z) = z₊^0 + (2π)^{-1} e^{iz}`, where `K_{ψ,η} = ∞ + G(1)`. The second summand of `η` has a
    point mass of `η̂` away from the origin and is outside the function-level framework, but it is
    not the source of the divergence: by `l1_isAdmissiblePair_lambdaOperatorPow` the admissibility
    density of `(Λ^m φ, z₊^0)` is `conj (φ̂ ζ) / (i ζ)`, which is not absolutely integrable at the
    origin as soon as `φ̂ (0) ≠ 0`. Removing the origin from the integral, as `eq:defK` does, is
    therefore not enough to make every pair admissible — the manuscript's point. 
Definition2.1.8
uses 0
Used by 4
Reverse dependency previews
Preview
Proposition 2.1.23
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Standard unbounded activations (Section 6). The truncated powers z_+^k contain the step function (k=0) and the ReLU (k=1); their distributional Fourier transforms away from the origin are k!/(i\zeta)^{k+1}. The Gaussian window generates the admissible ridgelet functions of Section 6.2. Deviation. truncatedPower is defined by cases rather than as (\max(z,0))^k, which would be the constant 1 at k=0 instead of the unit step.

Lean code for Definition2.1.83 definitions
  • complete
    def LeanRidgelet.truncatedPower (k : ) (z : ) : 
    def LeanRidgelet.truncatedPower (k : )
      (z : ) : 
    Implementation after :=
    :=
      if 0 < z then ((z ^ k : ℝ) : ℂ) else 0
    The truncated power function `z₊^k`, containing the step function (`k = 0`) and the ReLU
    (`k = 1`). The if-then-else form (rather than `(max z 0) ^ k`) is deliberate: with natural
    powers `(max z 0) ^ 0 = 1` everywhere, which would be the constant function rather than the
    unit step. 
  • complete
    def LeanRidgelet.truncatedPowerFourier (k : ) (ζ : ) : 
    def LeanRidgelet.truncatedPowerFourier (k : )
      (ζ : ) : 
    Implementation after :=
    :=
      (k.factorial : ℂ) / (Complex.I * (ζ : ℂ)) ^ (k + 1)
    The function part `k! / (i ζ)^{k+1}` of the distributional Fourier transform
    `(z₊^k)^ = k!/(iζ)^{k+1} + π i^k δ^{(k)}` of the truncated power (Gel'fand--Shilov). 
  • complete
    def LeanRidgelet.gaussianWindow (z : ) : 
    def LeanRidgelet.gaussianWindow (z : ) : 
    Implementation after :=
    :=
      (Real.exp (-z ^ 2 / 2) : ℂ)
    The Gaussian window `G(z) = exp (-z²/2)` used to construct admissible ridgelet functions in
    Section 6.2. 
Definition2.1.9
uses 0
Used by 2
Reverse dependency previews
Preview
Theorem 2.1.11
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Distribution classes on the half-space (deferred). The classes \mathcal S(\mathbb H), \mathcal S'(\mathbb H) and \mathcal D'(\mathbb Y^{m+1}) on the open half-space, needed to state the transforms as distribution actions, remain to be formalized as types for the distributional pass.

Section 4: well-definedness and duality

Theorem2.1.10
Statement uses 5
Statement dependency previews
Preview
Definition 2.1.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Theorem 2.1.11
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Balancing theorem (thm:existence), formalized rows. For f\in L^1(\mathbb R^m) and a bounded continuous \psi, the ridgelet integral converges absolutely at every parameter with \|\mathscr R_\psi f(\boldsymbol{a},b)\|\le\|f\|_1\|\psi\|_\infty\|\boldsymbol{a}\|^s, and the weak (Radon) definition agrees with the strong Euclidean one at s=1. For continuous \psi\in L^p(\mathbb R), the weak transform lies in L^p in the shift \beta, for every direction and scale. Deviation. The L^p row adds 1\le p, implicit in the article's use of L^p as a Banach space; the conclusion holds for every direction, not almost every.

Lean code for Theorem2.1.103 theorems
  • complete
    theorem LeanRidgelet.l1_ridgelet_pointwise_convergent_L1_bounded (m : )
      [NeZero m] (s : ) {f : LeanRidgelet.InputSpace m  } {ψ :   }
      {C : } (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (hψc : Continuous ψ) (hψb :  (z : ), ψ z  C)
      (p : LeanRidgelet.RidgeletParameterSpace m) :
      MeasureTheory.Integrable
          (fun x 
            f x * (starRingEnd ) (ψ (inner  p.1 x - p.2)) * (p.1 ^ s))
          MeasureTheory.volume 
        LeanRidgelet.euclideanRidgeletTransform m s ψ f p 
          ( (x : LeanRidgelet.InputSpace m), f x) * C * p.1 ^ s
    theorem LeanRidgelet.l1_ridgelet_pointwise_convergent_L1_bounded
      (m : ) [NeZero m] (s : )
      {f : LeanRidgelet.InputSpace m  }
      {ψ :   } {C : }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hψc : Continuous ψ)
      (hψb :  (z : ), ψ z  C)
      (p :
        LeanRidgelet.RidgeletParameterSpace
          m) :
      MeasureTheory.Integrable
          (fun x 
            f x *
                (starRingEnd )
                  (ψ (inner  p.1 x - p.2)) *
              (p.1 ^ s))
          MeasureTheory.volume 
        LeanRidgelet.euclideanRidgeletTransform
              m s ψ f p 
          ( (x : LeanRidgelet.InputSpace m),
                f x) *
              C *
            p.1 ^ s
    Section 3.1 and the `L¹ × (L^p ∩ C⁰)` row of the balancing theorem `thm:existence`, strong
    form: for `f ∈ L¹(ℝ^m)` and a bounded continuous `ψ`, the Euclidean ridgelet integral converges
    absolutely at every parameter and satisfies `‖R_ψ f (a, b)‖ ≤ ‖f‖₁ ‖ψ‖_∞ ‖a‖^s`. 
  • complete
    theorem LeanRidgelet.l1_weakRidgeletTransform_eq_euclidean (m : ) [NeZero m]
      {f : LeanRidgelet.InputSpace m  } {ψ :   }
      (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      {u : LeanRidgelet.InputSpace m} (hu : u = 1) {α β : }
      ( : 0 < α) :
      LeanRidgelet.weakRidgeletTransform m ψ f u α β =
        LeanRidgelet.euclideanRidgeletTransform m 1 ψ f (α⁻¹  u, β / α)
    theorem LeanRidgelet.l1_weakRidgeletTransform_eq_euclidean
      (m : ) [NeZero m]
      {f : LeanRidgelet.InputSpace m  }
      {ψ :   }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      {u : LeanRidgelet.InputSpace m}
      (hu : u = 1) {α β : } ( : 0 < α) :
      LeanRidgelet.weakRidgeletTransform m ψ f
          u α β =
        LeanRidgelet.euclideanRidgeletTransform
          m 1 ψ f (α⁻¹  u, β / α)
    Remark after Definition 4.1: for a locally integrable ridgelet function the weak (Radon)
    definition of the ridgelet transform coincides with the strong Euclidean one at `s = 1`, via
    `a = u / α`, `b = β / α`. 
  • complete
    theorem LeanRidgelet.l1_balancing_weakRidgeletTransform_memLp (m : ) [NeZero m]
      (p : ENNReal) (hp : 1  p) {f : LeanRidgelet.InputSpace m  }
      {ψ :   } (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (_hψc : Continuous ψ)
      (hψp : MeasureTheory.MemLp ψ p MeasureTheory.volume)
      {u : LeanRidgelet.InputSpace m} (hu : u = 1) {α : } ( : 0 < α) :
      MeasureTheory.MemLp
        (fun β  LeanRidgelet.weakRidgeletTransform m ψ f u α β) p
        MeasureTheory.volume
    theorem LeanRidgelet.l1_balancing_weakRidgeletTransform_memLp
      (m : ) [NeZero m] (p : ENNReal)
      (hp : 1  p)
      {f : LeanRidgelet.InputSpace m  }
      {ψ :   }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (_hψc : Continuous ψ)
      (hψp :
        MeasureTheory.MemLp ψ p
          MeasureTheory.volume)
      {u : LeanRidgelet.InputSpace m}
      (hu : u = 1) {α : } ( : 0 < α) :
      MeasureTheory.MemLp
        (fun β 
          LeanRidgelet.weakRidgeletTransform m
            ψ f u α β)
        p MeasureTheory.volume
    Balancing theorem `thm:existence`, `L¹ × (L^p ∩ C⁰)` row, range statement: for `f ∈ L¹(ℝ^m)`
    and a continuous `ψ ∈ L^p(ℝ)` with `1 ≤ p`, the weak ridgelet transform belongs to `L^p` in the
    shift `β`, uniformly in the direction `u` and the scale `α`.
    
    The proof is the convolution form `eq:convridge`,
    `R_ψ f (u, α, β) = (R[f](u, ·) ⋆ conj ψ~_α)(β)`: the Radon factor is integrable on `ℝ` by
    `integrable_radonTransform` and the dilated reflected kernel is in `L^p`, so Young's inequality
    `L¹ ⋆ L^p ⊆ L^p` (`MeasureTheory.Integrable.convolution_memLp`) applies. The hypothesis
    `1 ≤ p` is implicit in the manuscript's use of `L^p` as a Banach space; the continuity of `ψ`
    belongs to the manuscript's class `L^p ∩ C⁰` but is not needed for the membership conclusion.
    The remaining rows of `tab:weakridge` require the distribution classes on `𝕐^{m+1}` and are
    deferred. 
Theorem2.1.11
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Balancing theorem, remaining rows (deferred). The rows \mathcal D\times\mathcal D', \mathcal E'\times\mathcal D', \mathcal S\times\mathcal S', \mathcal O_C'\times\mathcal S', and \mathcal D_{L^1}'\times\mathcal D_{L^p}' of the article's Table 3 require the distribution classes on \mathbb Y^{m+1}.

Proposition2.1.12
uses 1used by 0L∃∀N

Continuity (prop:conti.L1). For a Schwartz ridgelet function the ridgelet transform is bounded from L^1(\mathbb R^m) to L^\infty(\mathbb Y^{m+1}); the bound holds at every parameter point, with the explicit constant \|\psi\|_\infty (the Schwartz seminorm (0,0)) in the first declaration and the existential operator-norm form of the article in the second. Deviation (author decision 2026-07-22). The article states the proposition at s=1, where its constant \sup_{r,\beta}|r\psi(r\beta)| diverges and the statement is false even with vanishing-moment hypotheses; it is read here in the s=0 normalization (Murata's Euclidean normalization, the remark after eq:eucrid), and wherever boundedness matters the theory may be read at s=0 throughout, with d\boldsymbol{a}\,db replacing \|\boldsymbol{a}\|^{-2}d\boldsymbol{a}\,db. The counterexample is in the docstring.

Lean code for Proposition2.1.122 theorems
  • complete
    theorem LeanRidgelet.norm_euclideanRidgeletTransform_zero_le (m : ) [NeZero m]
      (ψ : SchwartzMap  ) {f : LeanRidgelet.InputSpace m  }
      (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (q : LeanRidgelet.RidgeletParameterSpace m) :
      LeanRidgelet.euclideanRidgeletTransform m 0 (⇑ψ) f q 
        (SchwartzMap.seminorm  0 0) ψ *
           (x : LeanRidgelet.InputSpace m), f x
    theorem LeanRidgelet.norm_euclideanRidgeletTransform_zero_le
      (m : ) [NeZero m] (ψ : SchwartzMap  )
      {f : LeanRidgelet.InputSpace m  }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (q :
        LeanRidgelet.RidgeletParameterSpace
          m) :
      LeanRidgelet.euclideanRidgeletTransform
            m 0 (⇑ψ) f q 
        (SchwartzMap.seminorm  0 0) ψ *
           (x : LeanRidgelet.InputSpace m),
            f x
    The explicit constant behind `prop:conti.L1`: in the `s = 0` normalization the ridgelet
    transform of an integrable signal is bounded at *every* parameter point by the sup norm of the
    ridgelet function, `‖R⁰_ψ f (a, b)‖ ≤ ‖ψ‖_∞ ‖f‖₁`, with `‖ψ‖_∞` the Schwartz seminorm `(0, 0)`.
    This is the witness used by `l1_ridgeletTransform_bounded_L1_Linfty`, and it is what makes the
    value of the operator-norm bound checkable rather than existential. 
  • complete
    theorem LeanRidgelet.l1_ridgeletTransform_bounded_L1_Linfty (m : ) [NeZero m]
      (ψ : SchwartzMap  ) :
       C,
         (f : LeanRidgelet.InputSpace m  ),
          MeasureTheory.Integrable f MeasureTheory.volume 
             (q : LeanRidgelet.RidgeletParameterSpace m),
              LeanRidgelet.euclideanRidgeletTransform m 0 (⇑ψ) f q 
                C *  (x : LeanRidgelet.InputSpace m), f x
    theorem LeanRidgelet.l1_ridgeletTransform_bounded_L1_Linfty
      (m : ) [NeZero m]
      (ψ : SchwartzMap  ) :
       C,
         (f : LeanRidgelet.InputSpace m  ),
          MeasureTheory.Integrable f
              MeasureTheory.volume 
            
              (q :
                LeanRidgelet.RidgeletParameterSpace
                  m),
              LeanRidgelet.euclideanRidgeletTransform
                    m 0 (⇑ψ) f q 
                C *
                   (x :
                    LeanRidgelet.InputSpace
                      m),
                    f x
    Proposition 4.3 (`prop:conti.L1`) in the `s = 0` normalization: for a Schwartz ridgelet
    function, the ridgelet transform is bounded from `L¹(ℝ^m)` to `L^∞(𝕐^{m+1})` with operator
    norm at most `‖ψ‖_∞`; the bound in fact holds at every parameter point, which is stronger
    than the essential supremum with respect to any reference measure on `𝕐^{m+1}`.
    
    **Normalization memo (author decision 2026-07-22).** The manuscript states this proposition
    in the `s = 1` normalization, where its proof bounds the operator norm by
    `sup_{r,β} |r ψ(r β)|`, which is infinite for every `ψ ≠ 0`. Adding `ψ 0 = 0` and all integer
    vanishing moments does not repair it: in `m = 1` take `f (x) = |x|^{-1/2} 𝟙_{|x| ≤ 1} ∈ L¹`;
    then `R_ψ f (a, 0) = a^{1/2} ∫_{-a}^{a} |z|^{-1/2} conj (ψ z) dz` for `a > 0`, and a `ψ` with
    `ψ̂ ∈ C_c^∞` supported away from `0`, `∫ ψ̂ = 0`, and `∫ |ζ|^{-1/2} ψ̂ ζ dζ ≠ 0` has all
    integer moments vanishing while the fractional moment `∫ |z|^{-1/2} conj (ψ z) dz` is nonzero,
    so `|R_ψ f (a, 0)| → ∞` as `a → ∞`. Following the author's decision, the statement is read in
    the `s = 0` normalization of Section 3 (Murata's Euclidean normalization, see the remark after
    `eq:eucrid`), with no moment conditions; wherever boundedness of the ridgelet transform
    matters, the L1 theory may be read in the `s = 0` normalization throughout, replacing the
    weighted measure `‖a‖⁻² da db` of the `s = 1` pairing by the unweighted `da db`. 
Theorem2.1.13
uses 1
Used by 2
Reverse dependency previews
Preview
Theorem 2.1.22
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Dual operator (thm:dual). Under absolute integrability, the dual ridgelet transform is the dual of the ridgelet transform with respect to the pairing of L^2(\mathbb Y^{m+1},\|\boldsymbol{a}\|^{-2}d\boldsymbol{a}\,db) and L^2(\mathbb R^m).

Lean code for Theorem2.1.131 theorem
  • complete
    theorem LeanRidgelet.l1_dualRidgeletTransform_pairing (m : ) [NeZero m]
      {ψ :   } {f : LeanRidgelet.InputSpace m  }
      {T : LeanRidgelet.RidgeletParameterSpace m  }
      (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      (hT :
        MeasureTheory.Integrable (fun q  T q * (↑q.1)⁻¹)
          MeasureTheory.volume) :
       (q : LeanRidgelet.RidgeletParameterSpace m),
          LeanRidgelet.euclideanRidgeletTransform m 1 ψ f q *
            (starRingEnd ) (T q) LeanRidgelet.ridgeletParameterMeasure m =
         (x : LeanRidgelet.InputSpace m),
          f x *
            (starRingEnd )
              (LeanRidgelet.euclideanDualRidgeletTransform m 1 ψ T x)
    theorem LeanRidgelet.l1_dualRidgeletTransform_pairing
      (m : ) [NeZero m] {ψ :   }
      {f : LeanRidgelet.InputSpace m  }
      {T :
        LeanRidgelet.RidgeletParameterSpace
            m 
          }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      (hT :
        MeasureTheory.Integrable
          (fun q  T q * (↑q.1)⁻¹)
          MeasureTheory.volume) :
       (q :
          LeanRidgelet.RidgeletParameterSpace
            m),
          LeanRidgelet.euclideanRidgeletTransform
              m 1 ψ f q *
            (starRingEnd )
              (T
                q) LeanRidgelet.ridgeletParameterMeasure
            m =
         (x : LeanRidgelet.InputSpace m),
          f x *
            (starRingEnd )
              (LeanRidgelet.euclideanDualRidgeletTransform
                m 1 ψ T x)
    Theorem 4.5 (`thm:dual`) at function level: the dual ridgelet transform is the dual operator
    of the ridgelet transform with respect to the pairing of `L²(𝕐^{m+1}, ‖a‖⁻² da db)` and
    `L²(ℝ^m)`. 

Section 5: admissible pairs and reconstruction

Proposition2.1.14
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.5
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Proposition 2.1.7
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Polynomial invisibility. Adding a polynomial to the activation changes neither its Fourier data away from the origin nor the admissibility constant: admissibility is a property of the Lizorkin class of \eta.

Lean code for Proposition2.1.141 theorem
  • complete
    theorem LeanRidgelet.l1_hasFourierAwayFromOrigin_add_polynomial {η  :   }
      (h : LeanRidgelet.HasFourierAwayFromOrigin η ) (Q : Polynomial ) :
      LeanRidgelet.HasFourierAwayFromOrigin
        (fun z  η z + Polynomial.eval (↑z) Q) 
    theorem LeanRidgelet.l1_hasFourierAwayFromOrigin_add_polynomial
      {η  :   }
      (h :
        LeanRidgelet.HasFourierAwayFromOrigin
          η )
      (Q : Polynomial ) :
      LeanRidgelet.HasFourierAwayFromOrigin
        (fun z  η z + Polynomial.eval (↑z) Q)
        
    Section 5.1: the Fourier data away from the origin, hence the admissibility constant
    `K_{ψ,η}`, is invariant under adding a polynomial to the activation. This is the function-level
    form of working in the Lizorkin quotient `𝒮'(ℝ)/polynomials ≅ 𝒮₀'(ℝ)`. 
Theorem2.1.15
Statement uses 5
Statement dependency previews
Preview
Definition 2.1.4
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0L∃∀N

Structure theorem for admissible pairs (thm:eq.ac). The article characterizes admissibility of (\psi,\eta) by the solvability of the backprojection equation \Lambda^mu=\overline{\widetilde\psi}\ast(\eta-Q) with \int\widehat u\ne0. Proved (first declaration), with the equation imposed on the Fourier data of both sides. Sufficiency is l1_fourier_data_convolution together with the admissibility constant K_{\psi,\eta}=(2\pi)^{m-1}\int\widehat u (second declaration, an identity needing no integrability hypothesis); necessity takes \widehat u:=\overline{\widehat\psi}F_\eta|\zeta|^{-m}, integrable by admissibility, and realizes it as the Fourier data of the bounded continuous function u=(2\pi)^{-1}\mathcal F^{-1}\widehat u. The polynomial Q is invisible by l1_lizorkin_quotient_invariance. Where the equation is a pointwise identity — a Schwartz solution u, in spectral or in the article's physical form — the third and fourth declarations state it directly. Deviations. The article writes the equation pointwise for u\in\mathcal O_M, with \Lambda^m read as the Fourier multiplier |\zeta|^m; that is the only available reading, since for a slowly increasing u the pointwise principal value generally diverges and, when it converges, only agrees modulo polynomials. The formalized statement therefore imposes the equation on Fourier data, weakens u\in\mathcal O_M to "u carries the Fourier data \widehat u", and drops the continuity hypothesis on \widehat\eta near the origin. The manuscript's theorem itself needs no correction.

Lean code for Theorem2.1.154 theorems
  • complete
    theorem LeanRidgelet.l1_structure_theorem_admissible_pairs (m : ) [NeZero m]
      (ψ : SchwartzMap  ) {η  :   }
      ( : LeanRidgelet.HasFourierAwayFromOrigin η ) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η  
         u Fu Q,
          LeanRidgelet.HasFourierAwayFromOrigin u Fu 
            (LeanRidgelet.HasFourierAwayFromOrigin
                (LeanRidgelet.reflectedConjConvolution ψ fun t 
                  η t - Polynomial.eval (↑t) Q)
                fun ζ  (|ζ| ^ m) * Fu ζ) 
              MeasureTheory.IntegrableOn Fu {0} MeasureTheory.volume 
                 (ζ : ) in {0}, Fu ζ  0
    theorem LeanRidgelet.l1_structure_theorem_admissible_pairs
      (m : ) [NeZero m] (ψ : SchwartzMap  )
      {η  :   }
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η ) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η
           
         u Fu Q,
          LeanRidgelet.HasFourierAwayFromOrigin
              u Fu 
            (LeanRidgelet.HasFourierAwayFromOrigin
                (LeanRidgelet.reflectedConjConvolution
                  ψ fun t 
                  η t -
                    Polynomial.eval (↑t) Q)
                fun ζ  (|ζ| ^ m) * Fu ζ) 
              MeasureTheory.IntegrableOn Fu
                  {0} MeasureTheory.volume 
                 (ζ : ) in {0}, Fu ζ  0
    **Theorem 5.4 (`thm:eq.ac`), the structure theorem for admissible pairs**, at function
    level: the pair `(ψ, η)` is admissible if and only if the backprojection equation
    `Λ^m u = conj (ψ~) ⋆ (η - Q)` is solvable by a function `u` carrying Fourier data `Fu` that is
    integrable away from the origin with nonzero integral.
    
    The equation appears in the form "the Fourier data of `conj (ψ~) ⋆ (η - Q)` is `|ζ|^m Fu`",
    which is the multiplier reading of `Λ^m u = conj (ψ~) ⋆ (η - Q)`; see the *Deviations* section
    of this module. The content of the right-hand side is the existence of `u` **as a function**:
    by `hasFourierAwayFromOrigin_reflectedConjConvolution` and `hasFourierAwayFromOrigin_ae_eq` the
    second conjunct alone is equivalent to the spectral equation `conj (ψ̂) Fη = |ζ|^m Fu`, which
    merely renames the admissibility density, whereas the first conjunct is the function-level
    substitute for the manuscript's Fourier duality `𝒪_M ≅ 𝒪'_C`.
    
    Here `Λ^m` is the standard Lambda-operator power (`lambdaOperatorPow`); relative to the
    article's filter `eq:bp` this rescales the solution `u` by `i^{-m}`, which affects none of the
    stated conditions. 
  • theoremdefined in LeanRidgelet/L1/Defs.lean
    complete
    theorem LeanRidgelet.admissibilityConstant_of_backprojection {m : }
      {ψ  Fu :   }
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd ) (LeanRidgelet.angularFourier1D ψ ζ) *  ζ =
              (|ζ| ^ m) * Fu ζ) :
      LeanRidgelet.admissibilityConstant m ψ  =
        (2 * Real.pi) ^ (m - 1) *  (ζ : ) in {0}, Fu ζ
    theorem LeanRidgelet.admissibilityConstant_of_backprojection
      {m : } {ψ  Fu :   }
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    ψ ζ) *
                 ζ =
              (|ζ| ^ m) * Fu ζ) :
      LeanRidgelet.admissibilityConstant m ψ
           =
        (2 * Real.pi) ^ (m - 1) *
           (ζ : ) in {0}, Fu ζ
    **The admissibility constant of a pair solving the backprojection equation in spectral
    form**: `K_{ψ,η} = (2π)^{m-1} ∫ û`. This is the identity that fixes the normalization of
    `eq:radon.ac`; see `LeanRidgelet.l1_reconstruction_formula_radon`. 
  • complete
    theorem LeanRidgelet.l1_structure_theorem_sufficiency (m : ) [NeZero m]
      (ψ : SchwartzMap  ) {η  :   }
      ( : LeanRidgelet.HasFourierAwayFromOrigin η )
      (u : SchwartzMap  )
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑ψ) ζ) *  ζ =
              (|ζ| ^ m) * LeanRidgelet.angularFourier1D (⇑u) ζ)
      (hK :  (ζ : ), LeanRidgelet.angularFourier1D (⇑u) ζ  0) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η 
    theorem LeanRidgelet.l1_structure_theorem_sufficiency
      (m : ) [NeZero m] (ψ : SchwartzMap  )
      {η  :   }
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η )
      (u : SchwartzMap  )
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    (⇑ψ) ζ) *
                 ζ =
              (|ζ| ^ m) *
                LeanRidgelet.angularFourier1D
                  (⇑u) ζ)
      (hK :
         (ζ : ),
            LeanRidgelet.angularFourier1D (⇑u)
              ζ 
          0) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η
        
    **Sufficiency half of the structure theorem `thm:eq.ac`, spectral form.** If the
    backprojection equation holds in the Fourier data sense — `conj (ψ̂) Fη = |ζ|^m û` away from the
    origin — with a Schwartz solution `u` whose transform has a nonzero total integral, then the pair
    `(ψ, η)` is admissible, with `K_{ψ,η} = (2π)^{m-1} ∫ û`. 
  • complete
    theorem LeanRidgelet.l1_structure_theorem_sufficiency_physical (m : )
      [NeZero m] (ψ : SchwartzMap  ) {η  :   }
      ( : LeanRidgelet.HasFourierAwayFromOrigin η )
      (u : SchwartzMap  ) (Q : Polynomial )
      (hbp :
         (z : ),
          LeanRidgelet.lambdaOperatorPow m (⇑u) z =
            LeanRidgelet.reflectedConjConvolution (⇑ψ)
              (fun t  η t - Polynomial.eval (↑t) Q) z)
      (hK :  (ζ : ), LeanRidgelet.angularFourier1D (⇑u) ζ  0) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η 
    theorem LeanRidgelet.l1_structure_theorem_sufficiency_physical
      (m : ) [NeZero m] (ψ : SchwartzMap  )
      {η  :   }
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η )
      (u : SchwartzMap  ) (Q : Polynomial )
      (hbp :
         (z : ),
          LeanRidgelet.lambdaOperatorPow m
              (⇑u) z =
            LeanRidgelet.reflectedConjConvolution
              (⇑ψ)
              (fun t 
                η t - Polynomial.eval (↑t) Q)
              z)
      (hK :
         (ζ : ),
            LeanRidgelet.angularFourier1D (⇑u)
              ζ 
          0) :
      LeanRidgelet.IsAdmissiblePair m (⇑ψ) η
        
    **Sufficiency half of the structure theorem `thm:eq.ac`, physical form.** If the
    manuscript's backprojection equation `Λ^m u = conj (ψ~) ⋆ (η - Q)` holds pointwise for a
    Schwartz solution `u` with `∫ û ≠ 0`, then the pair `(ψ, η)` is admissible, with
    `K_{ψ,η} = (2π)^{m-1} ∫ û`.
    
    For a Schwartz `u` the pointwise principal value defining `Λ^m u` converges, so the physical
    form is available; the translation to the spectral form is the convolution theorem away from
    the origin (`hasFourierAwayFromOrigin_reflectedConjConvolution`) together with the multiplier
    property (`hasFourierAwayFromOrigin_lambdaOperatorPow`) and the uniqueness of Fourier data
    (`hasFourierAwayFromOrigin_ae_eq`). The polynomial `Q` is invisible throughout
    (`l1_hasFourierAwayFromOrigin_add_polynomial`), as it must be in the Lizorkin quotient. 
Corollary2.1.16
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.6
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Proposition 2.1.7
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Construction of admissible pairs (cor:const.ap), sharpened to a criterion. For a Schwartz \varphi, the pair (\Lambda^m\varphi,\eta) is admissible if and only if \overline{\widehat\varphi}F_\eta is integrable away from the origin with nonzero integral (first declaration): the factor |\zeta|^m of \widehat{\Lambda^m\varphi} cancels the factor |\zeta|^{-m} of the admissibility density exactly, which is the whole mechanism of the construction. The article's statement — \psi=\Lambda^m\psi_0^{(k)} is admissible with \eta when \int\zeta^k\overline{\widehat{\psi_0}}F_\eta\ne0 — is the case \varphi=\psi_0^{(k)} (second declaration), through the iterated angular derivative rule \widehat{\varphi^{(k)}}=(i\zeta)^k\widehat\varphi (third). The structure theorem is not used. Integrability of the constructed ridgelet function is not a hypothesis: l1_lambda_multiplier supplies it for every m\ge1. Deviations. For odd m the constructed \psi leaves the Schwartz class, which is why admissibility only requires integrability of \psi. The article's continuity hypothesis on \zeta^k\widehat\eta near the origin is dropped, the explicit integrability of the admissibility density replacing it.

Lean code for Corollary2.1.163 theorems
  • complete
    theorem LeanRidgelet.l1_isAdmissiblePair_lambdaOperatorPow (m : ) [NeZero m]
      (φ : SchwartzMap  ) {η  :   }
      ( : LeanRidgelet.HasFourierAwayFromOrigin η ) :
      LeanRidgelet.IsAdmissiblePair m (LeanRidgelet.lambdaOperatorPow m φ)
          η  
        MeasureTheory.IntegrableOn
            (fun ζ 
              (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑φ) ζ) *  ζ)
            {0} MeasureTheory.volume 
           (ζ : ) in {0},
              (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑φ) ζ) *
                 ζ 
            0
    theorem LeanRidgelet.l1_isAdmissiblePair_lambdaOperatorPow
      (m : ) [NeZero m] (φ : SchwartzMap  )
      {η  :   }
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η ) :
      LeanRidgelet.IsAdmissiblePair m
          (LeanRidgelet.lambdaOperatorPow m
            φ)
          η  
        MeasureTheory.IntegrableOn
            (fun ζ 
              (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    (⇑φ) ζ) *
                 ζ)
            {0} MeasureTheory.volume 
           (ζ : ) in {0},
              (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    (⇑φ) ζ) *
                 ζ 
            0
    **`cor:const.ap` in sharpened form: exact criterion for a filtered ridgelet function.**
    For a Schwartz `φ` whose filtered version `Λ^m φ` is integrable, the pair `(Λ^m φ, η)` is
    admissible *if and only if* `conj (φ̂) Fη` is integrable away from the origin with nonzero
    integral. The factor `|ζ|^m` of `(Λ^m φ)^` cancels the factor `|ζ|^{-m}` of the admissibility
    density exactly, which is the whole mechanism of the manuscript's construction.
    
    Integrability of `Λ^m φ` is automatic (`integrable_lambdaOperatorPow`): for even `m` the
    filtered function is Schwartz, and for odd `m` it is the Hilbert transform of a derivative,
    whose integral vanishes. 
  • complete
    theorem LeanRidgelet.l1_construction_of_admissible_pairs (m : ) [NeZero m]
      {η  :   } ( : LeanRidgelet.HasFourierAwayFromOrigin η )
      (k : ) (ψ₀ : SchwartzMap  )
      (hint :
        MeasureTheory.IntegrableOn
          (fun ζ 
            ζ ^ k *
                (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑ψ₀) ζ) *
               ζ)
          {0} MeasureTheory.volume)
      (hne :
         (ζ : ) in {0},
            ζ ^ k *
                (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑ψ₀) ζ) *
               ζ 
          0) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m (iteratedDeriv k ψ₀)) η 
    theorem LeanRidgelet.l1_construction_of_admissible_pairs
      (m : ) [NeZero m] {η  :   }
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η )
      (k : ) (ψ₀ : SchwartzMap  )
      (hint :
        MeasureTheory.IntegrableOn
          (fun ζ 
            ζ ^ k *
                (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    (⇑ψ₀) ζ) *
               ζ)
          {0} MeasureTheory.volume)
      (hne :
         (ζ : ) in {0},
            ζ ^ k *
                (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    (⇑ψ₀) ζ) *
               ζ 
          0) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m
          (iteratedDeriv k ψ₀))
        η 
    **Corollary 5.5 (`cor:const.ap`), construction of admissible pairs**: if `ψ₀` is a Schwartz
    function with `∫ ζ^k conj (ψ̂₀ ζ) Fη ζ dζ` absolutely convergent and nonzero, then
    `ψ = Λ^m ψ₀^{(k)}` is admissible with `η`.
    
    **Deviations from the article (2026-08-05).**
    * The integrability of the constructed ridgelet function is a hypothesis. It is automatic for
      even `m` (`Λ^m ψ₀^{(k)} = ± ψ₀^{(m+k)}` is Schwartz) and, for odd `m`, is the `L¹` decay
      estimate for the Hilbert transform of a Schwartz function still missing from the development;
      it also holds whenever `ψ̂₀` vanishes near the origin, since then `Λ^m ψ₀^{(k)}` is Schwartz.
      The manuscript takes admissible pairs in `𝒮(ℝ) × 𝒮'(ℝ)`, but for odd `m` the constructed
      `ψ` is *not* Schwartz: its Fourier transform `|ζ|^m (iζ)^k ψ̂₀ ζ` is continuous and rapidly
      decreasing yet not smooth at the origin, so `ψ` only decays algebraically. This is why
      `IsAdmissiblePair` asks for `Integrable ψ` (paper gap memo, 2026-07-19).
    * The manuscript's continuity hypothesis on `ζ^k η̂ (ζ)` near the origin is dropped: it serves
      to make the admissibility integral converge near the origin, which the explicit integrability
      hypothesis already provides. 
  • complete
    theorem LeanRidgelet.angularFourier1D_iteratedDeriv (k : )
      (φ : SchwartzMap  ) (ζ : ) :
      LeanRidgelet.angularFourier1D (iteratedDeriv k φ) ζ =
        (Complex.I * ζ) ^ k * LeanRidgelet.angularFourier1D (⇑φ) ζ
    theorem LeanRidgelet.angularFourier1D_iteratedDeriv
      (k : ) (φ : SchwartzMap  ) (ζ : ) :
      LeanRidgelet.angularFourier1D
          (iteratedDeriv k φ) ζ =
        (Complex.I * ζ) ^ k *
          LeanRidgelet.angularFourier1D (⇑φ) ζ
    The angular derivative rule iterated: `(φ^{(k)})^(ζ) = (i ζ)^k φ̂(ζ)`. 
Theorem2.1.17
Statement uses 4
Statement dependency previews
Preview
Definition 2.1.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Theorem 2.1.18
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Reconstruction formula (thm:formula). For an admissible pair whose activation has polynomial growth of degree k, a ridgelet function with finite k-th moment and k vanishing moments, and f\in L^1 with finite k-th moment and \widehat f\in L^1, \mathscr R^\dagger_\eta\mathscr R_\psi f=K_{\psi,\eta}\,f in the truncation limit, at almost every point and at every continuity point of f. Deviation (author decision 2026-07-22). The article states the theorem for (\psi,\eta)\in\mathcal S(\mathbb R)\times\mathcal S_0'(\mathbb R) with a distributional pairing. At function level the growth/moment matching is necessary for absolute convergence — for growth degree k\ge1 there are f\in L^1 with \widehat f\in L^1 whose reconstruction integrand is not Bochner integrable — and the vanishing moments (the article's own remark after thm:eq.ac) hide the polynomial part of \eta. All three added hypotheses are vacuous in the deferred distributional pass.

Lean code for Theorem2.1.171 theorem
  • complete
    theorem LeanRidgelet.l1_reconstruction_formula (m k : ) [NeZero m]
      {ψ η  :   } {f : LeanRidgelet.InputSpace m  } { : }
      (hadm : LeanRidgelet.IsAdmissiblePair m ψ η )
      (hηk :  (z : ), η z   * (1 + |z|) ^ k)
      (hψk :
        MeasureTheory.Integrable (fun s  (1 + |s|) ^ k * ψ s)
          MeasureTheory.volume)
      (hψvm :  j  k,  (s : ), s ^ j * ψ s = 0)
      (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (hfk :
        MeasureTheory.Integrable (fun y  (1 + y) ^ k * f y)
          MeasureTheory.volume)
      (hfhat :
        MeasureTheory.Integrable
          (LeanRidgelet.Fourier.angularFourierIntegralInner f)
          MeasureTheory.volume) :
      (∀ᵐ (x : LeanRidgelet.InputSpace m),
          Filter.Tendsto
            (fun q 
              LeanRidgelet.truncatedDualRidgeletTransform m 1 η
                (LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) q.1 q.2 x)
            LeanRidgelet.ridgeletTruncationFilter
            (nhds (LeanRidgelet.admissibilityConstant m ψ  * f x))) 
         (x : LeanRidgelet.InputSpace m),
          ContinuousAt f x 
            Filter.Tendsto
              (fun q 
                LeanRidgelet.truncatedDualRidgeletTransform m 1 η
                  (LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) q.1 q.2
                  x)
              LeanRidgelet.ridgeletTruncationFilter
              (nhds (LeanRidgelet.admissibilityConstant m ψ  * f x))
    theorem LeanRidgelet.l1_reconstruction_formula
      (m k : ) [NeZero m] {ψ η  :   }
      {f : LeanRidgelet.InputSpace m  }
      { : }
      (hadm :
        LeanRidgelet.IsAdmissiblePair m ψ η
          )
      (hηk :
         (z : ), η z   * (1 + |z|) ^ k)
      (hψk :
        MeasureTheory.Integrable
          (fun s  (1 + |s|) ^ k * ψ s)
          MeasureTheory.volume)
      (hψvm :
         j  k,  (s : ), s ^ j * ψ s = 0)
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hfk :
        MeasureTheory.Integrable
          (fun y  (1 + y) ^ k * f y)
          MeasureTheory.volume)
      (hfhat :
        MeasureTheory.Integrable
          (LeanRidgelet.Fourier.angularFourierIntegralInner
            f)
          MeasureTheory.volume) :
      (∀ᵐ (x : LeanRidgelet.InputSpace m),
          Filter.Tendsto
            (fun q 
              LeanRidgelet.truncatedDualRidgeletTransform
                m 1 η
                (LeanRidgelet.euclideanRidgeletTransform
                  m 1 ψ f)
                q.1 q.2 x)
            LeanRidgelet.ridgeletTruncationFilter
            (nhds
              (LeanRidgelet.admissibilityConstant
                  m ψ  *
                f x))) 
         (x : LeanRidgelet.InputSpace m),
          ContinuousAt f x 
            Filter.Tendsto
              (fun q 
                LeanRidgelet.truncatedDualRidgeletTransform
                  m 1 η
                  (LeanRidgelet.euclideanRidgeletTransform
                    m 1 ψ f)
                  q.1 q.2 x)
              LeanRidgelet.ridgeletTruncationFilter
              (nhds
                (LeanRidgelet.admissibilityConstant
                    m ψ  *
                  f x))
    Theorem 5.6 (`thm:formula`), the reconstruction formula, in the amended function-level
    form: for an admissible pair `(ψ, η)` whose activation has polynomial growth of degree `k`,
    a ridgelet function with finite `k`-th moment and `k` vanishing moments, and `f ∈ L¹(ℝ^m)`
    with finite `k`-th moment and `f̂ ∈ L¹(ℝ^m)`, the truncated dual ridgelet transform of
    `R_ψ f` converges to `K_{ψ,η} f (x)` at almost every `x` and at every continuity point of
    `f`.
    
    **Amendment to the article (author decision 2026-07-22).** The article states the theorem
    for `(ψ, η) ∈ 𝒮(ℝ) × 𝒮₀'(ℝ)` with a distributional pairing. At function level the added
    hypotheses are necessary: for growth degree `k ≥ 1` there are `f ∈ L¹` with `f̂ ∈ L¹`
    (Gaussian bumps of weight `2⁻ⁿ` at distance `4ⁿ`) whose truncated reconstruction integrand
    is not Bochner integrable, and without vanishing moments the function-level pairing sees the
    polynomial part of `η`, which the Lizorkin quotient hides (the article's remark after
    `thm:eq.ac` imposes the same vanishing moments). All three added hypotheses are vacuous in
    the deferred distributional pass. 
Theorem2.1.18
Statement uses 5
Statement dependency previews
Preview
Definition 2.1.4
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1L∃∀N

Reconstruction via the Radon transform (thm:formula.radon). Under the backprojection admissibility eq:radon.ac in spectral form — \overline{\widehat\psi(\zeta)}F_\eta(\zeta)=|\zeta|^m\widehat u(\zeta) on \zeta\ne0 with \widehat u\in L^1 — the truncated ridgelet reconstruction of a Schwartz function converges at every point to 2(2\pi)^{m-1}f(x), the value of the filtered backprojection \mathscr R^\dagger\Lambda^{m-1}\mathscr Rf (second declaration, Radon's classical inversion formula, proved). Deviations. The filter is the standard \Lambda^{m-1} (see l1_radon_backprojection), and the normalization of eq:radon.ac is \int\widehat u=2, not the article's \int\widehat u=-1: the truncation limit is (2\pi)^{m-1}\int\widehat u\cdot f(x), and the article's own approximate-identity kernel k(z)=\mathscr Hu(z)/z has \int k=\int\widehat u/2, so both routes force \int\widehat u=2. At function level the radon route also needs vanishing moments of \psi, for the same Lizorkin-quotient reason as thm:formula. The fractional Laplacian identity cor:radon.d is deferred.

Lean code for Theorem2.1.182 theorems
  • theoremdefined in LeanRidgelet/L1/Radon.lean
    complete
    theorem LeanRidgelet.l1_reconstruction_formula_radon (m k : ) [NeZero m]
      {ψ η  u :   } { : }
      (f : SchwartzMap (LeanRidgelet.InputSpace m) )
      ( : MeasureTheory.Integrable ψ MeasureTheory.volume)
      (hψk :
        MeasureTheory.Integrable (fun s  (1 + |s|) ^ k * ψ s)
          MeasureTheory.volume)
      (hψvm :  j  k,  (s : ), s ^ j * ψ s = 0)
      ( : LeanRidgelet.HasFourierAwayFromOrigin η )
      (hηk :  (z : ), η z   * (1 + |z|) ^ k)
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd ) (LeanRidgelet.angularFourier1D ψ ζ) *  ζ =
              (|ζ| ^ m) * LeanRidgelet.angularFourier1D u ζ)
      (huhat :
        MeasureTheory.Integrable (LeanRidgelet.angularFourier1D u)
          MeasureTheory.volume)
      (hnorm :  (ζ : ), LeanRidgelet.angularFourier1D u ζ = 2)
      (x : LeanRidgelet.InputSpace m) :
      Filter.Tendsto
        (fun q 
          LeanRidgelet.truncatedDualRidgeletTransform m 1 η
            (LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) q.1 q.2 x)
        LeanRidgelet.ridgeletTruncationFilter
        (nhds ((2 * (2 * Real.pi) ^ (m - 1)) * f x))
    theorem LeanRidgelet.l1_reconstruction_formula_radon
      (m k : ) [NeZero m] {ψ η  u :   }
      { : }
      (f :
        SchwartzMap
          (LeanRidgelet.InputSpace m) )
      ( :
        MeasureTheory.Integrable ψ
          MeasureTheory.volume)
      (hψk :
        MeasureTheory.Integrable
          (fun s  (1 + |s|) ^ k * ψ s)
          MeasureTheory.volume)
      (hψvm :
         j  k,  (s : ), s ^ j * ψ s = 0)
      ( :
        LeanRidgelet.HasFourierAwayFromOrigin
          η )
      (hηk :
         (z : ), η z   * (1 + |z|) ^ k)
      (hbp :
         (ζ : ),
          ζ  0 
            (starRingEnd )
                  (LeanRidgelet.angularFourier1D
                    ψ ζ) *
                 ζ =
              (|ζ| ^ m) *
                LeanRidgelet.angularFourier1D
                  u ζ)
      (huhat :
        MeasureTheory.Integrable
          (LeanRidgelet.angularFourier1D u)
          MeasureTheory.volume)
      (hnorm :
         (ζ : ),
            LeanRidgelet.angularFourier1D u
              ζ =
          2)
      (x : LeanRidgelet.InputSpace m) :
      Filter.Tendsto
        (fun q 
          LeanRidgelet.truncatedDualRidgeletTransform
            m 1 η
            (LeanRidgelet.euclideanRidgeletTransform
              m 1 ψ f)
            q.1 q.2 x)
        LeanRidgelet.ridgeletTruncationFilter
        (nhds
          ((2 * (2 * Real.pi) ^ (m - 1)) *
            f x))
    Theorem 5.7 (`thm:formula.radon`), the reconstruction formula via the Radon transform:
    under the backprojection admissibility `eq:radon.ac`, the truncated ridgelet reconstruction
    of a Schwartz function converges at every point to `2 (2π)^{m-1} f(x)` — the value of the
    filtered backprojection `R† Λ^{m-1} R f` (stated separately as
    `l1_radon_filtered_backprojection`). The proof computes the admissibility constant from the
    backprojection data, `K_{ψ,η} = (2π)^{m-1} ∫ û = 2 (2π)^{m-1}`, and applies the
    reconstruction formula `l1_reconstruction_formula` to the resulting admissible pair.
    
    **Corrections and amendments to the article.**
    * (2026-07-21) The statement uses the standard Lambda-operator power (multiplier
      `|ω|^{m-1}`); see `lambdaOperatorPow`.
    * (2026-07-23) **Normalization of `eq:radon.ac` corrected to `∫ û = 2`**, replacing the
      article's `∫ û = -1`, settling the check recorded here previously. The truncation limit is
      `K_{ψ,η} f(x)` with `K_{ψ,η} = (2π)^{m-1} ∫ û` (by `tendsto_truncatedDualRidgeletTransform`
      and the spectral form of the backprojection equation), so the claimed agreement with the
      filtered backprojection `2 (2π)^{m-1} f` forces `∫ û = 2`. The article's own
      approximate-identity computation, redone with consistent constants, confirms this: for its
      kernel `k(z) = 𝓗u(z)/z` one has `∫ k = -π 𝓗²u(0) = π u(0) = ∫ û / 2`, so the
      normalization `∫ k = 1` also forces `∫ û = 2` (the article's chain
      `∫ k = -∫ 𝓗u(z)/(0-z) dz = -u(0) = 1` drops the factor `π` of the principal-value kernel
      and is inconsistent with `∫ û = -1`).
    * (2026-07-22/23) As with `l1_reconstruction_formula`, the activation carries an explicit
      polynomial growth degree `k`, matched by a finite `k`-th moment and vanishing moments of
      `ψ`, and its Fourier data away from the origin is hypothesized
      (`HasFourierAwayFromOrigin`). The backprojection equation enters through its spectral form
      `conj (ψ̂ ζ) Fη ζ = |ζ|^m û(ζ)` on `ζ ≠ 0` together with `û ∈ L¹`; the physical form
      `Λ^m u = conj (ψ~) ⋆ η` reduces to it once the `L¹` Hilbert symbol is available (plan item
      A-3), and the smoothness and realness of `u` are not needed at this level. 
  • theoremdefined in LeanRidgelet/L1/Radon.lean
    complete
    theorem LeanRidgelet.l1_radon_filtered_backprojection (m : ) [NeZero m]
      (f : SchwartzMap (LeanRidgelet.InputSpace m) )
      (x : LeanRidgelet.InputSpace m) :
      MeasureTheory.dualRadonTransform
          (fun v 
            LeanRidgelet.lambdaOperatorPow (m - 1)
              (MeasureTheory.radonTransform (⇑f) v))
          x =
        (2 * (2 * Real.pi) ^ (m - 1)) * f x
    theorem LeanRidgelet.l1_radon_filtered_backprojection
      (m : ) [NeZero m]
      (f :
        SchwartzMap
          (LeanRidgelet.InputSpace m) )
      (x : LeanRidgelet.InputSpace m) :
      MeasureTheory.dualRadonTransform
          (fun v 
            LeanRidgelet.lambdaOperatorPow
              (m - 1)
              (MeasureTheory.radonTransform
                (⇑f) v))
          x =
        (2 * (2 * Real.pi) ^ (m - 1)) * f x
    **Radon's inversion formula as filtered backprojection** (plan item A-4): for a Schwartz
    function on `ℝ^m`, `R† Λ^{m-1} R f = 2 (2π)^{m-1} f`, with the standard Lambda-operator power
    (one-dimensional multiplier `|ω|^{m-1}`). The manuscript uses this classical identity as a known
    result (Helgason).
    
    The proof follows the route recorded in the development plan. The Radon section of a Schwartz
    function *is* a Schwartz function (`MeasureTheory.radonTransform_eq_radonSchwartzSection`), so
    the multiplier property of `Λ^{m-1}` (`lambdaOperatorPow_eq_fourier_multiplier`, which for even
    `m` rests on the Fourier symbol `-i sign ξ` of the principal-value Hilbert transform) applies to
    it and, through the Fourier slice theorem, turns the filtered section at `⟪u, x⟫` into the
    frequency integral `∫ |2πω|^{m-1} 𝓕f(ω u) e^{2πi⟪ω u, x⟫} dω` along the ray through `u`. Splitting
    that integral at the origin and reflecting the negative half gives two rays, each of which the
    polar-coordinate formula (`MeasureTheory.integral_eq_integral_toSphere_integral_Ioi`) reassembles
    over the sphere into `∫_{ℝ^m} 𝓕f(ξ) e^{2πi⟪ξ, x⟫} dξ` — the second one after the reflection
    `ξ ↦ -ξ`, which the Lebesgue measure preserves, so that no antipodal symmetry of the sphere
    measure is needed. Fourier inversion evaluates each copy as `f x`, whence the constant
    `2 (2π)^{m-1}`. 
Corollary2.1.19
Statement uses 2
Statement dependency previews
Preview
Definition 2.1.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Intertwining with the fractional Laplacian (cor:radon.d, deferred). The article's Corollary 5.8 reads \mathscr R^\dagger_\eta\mathscr R_\psi=\mathscr R^*\Lambda^{m-1}\mathscr R=(-\Delta)^{(m-1)/2}\mathscr R^*\mathscr R=\mathscr R^*\mathscr R(-\Delta)^{(m-1)/2}. The first equality is the content of l1_reconstruction_radon; the remaining two identify the filtered backprojection with a fractional power of the Laplacian on \mathbb R^m and require the fractional Laplacian as an operator on tempered distributions, which is part of the deferred distributional pass.

Section 5.3--5.4: extension to L^2

Theorem2.1.20
Statement uses 6
Statement dependency previews
Preview
Theorem 1.1.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Theorem 2.1.21
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Parseval and Plancherel (thm:parseval). For a self-admissible \psi with K_{\psi,\psi}=1 and f\in L^1\cap L^2(\mathbb R^m), \|\mathscr R_\psi f\|_2=\|f\|_2; for normalized self-admissible \psi, \eta with cross normalization K_{\psi,\eta}=1, \langle\mathscr R_\psi f,\mathscr R_\eta g\rangle=\langle f,g\rangle. Both are proved by a direct Fourier computation that does not pass through the reconstruction formula. Standing hypotheses. Both members are integrable (through self-admissibility), continuous and bounded, so at function level the layer speaks about a pair of ridgelet functions, not about an unbounded activation: the ReLU, the truncated powers, the unit step, the sigmoid and Dirac's \delta all fall outside it. The article has no such restriction because it pairs in \mathcal S\times\mathcal S_0'. The restriction is an artefact of the function-level Euclidean formulation, not a gap in the project: since a tempered distribution lies in a weighted Sobolev space, an unbounded activation enters the companion L2 theory through its coordinate in \mathcal A_{s,t} — the ReLU as LeanRidgelet.reluActivation for t>3/2 — where the corresponding statements are proved, and in the sharper form of an exact operator identity rather than a truncation limit: abstract_reconstruction gives SS^*=c_LI and \|S^*f\|^2=c_L\|f\|^2, and relu_operator_theory the reconstruction. Connecting the two formulations is plan item M7 (R4). Universality with an unbounded activation is in any case reached here through the L^1 route (l1_relu_universality). Deviation. The article asserts the relation for (\psi,\eta)\in\mathcal S\times\mathcal S_0', "immediate by duality"; at function level the parameter-space pairing must converge absolutely, which requires both transforms in L^2(\mathbb Y^{m+1}), so self-admissibility of both members with the diagonal normalizations K_{\psi,\psi}=K_{\eta,\eta}=1 is taken as a hypothesis.

Lean code for Theorem2.1.202 theorems
  • complete
    theorem LeanRidgelet.l1_plancherel_identity (m : ) [NeZero m] {ψ :   }
      {f : LeanRidgelet.InputSpace m  }
      (hself : LeanRidgelet.IsSelfAdmissible m ψ)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D ψ) =
          1)
      (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      (hf1 : MeasureTheory.Integrable f MeasureTheory.volume)
      (hf2 : MeasureTheory.MemLp f 2 MeasureTheory.volume) :
       (q : LeanRidgelet.RidgeletParameterSpace m),
          LeanRidgelet.euclideanRidgeletTransform m 1 ψ f q ^
            2 LeanRidgelet.ridgeletParameterMeasure m =
         (x : LeanRidgelet.InputSpace m), f x ^ 2
    theorem LeanRidgelet.l1_plancherel_identity
      (m : ) [NeZero m] {ψ :   }
      {f : LeanRidgelet.InputSpace m  }
      (hself :
        LeanRidgelet.IsSelfAdmissible m ψ)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              ψ) =
          1)
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      (hf1 :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hf2 :
        MeasureTheory.MemLp f 2
          MeasureTheory.volume) :
       (q :
          LeanRidgelet.RidgeletParameterSpace
            m),
          LeanRidgelet.euclideanRidgeletTransform
                m 1 ψ f q ^
            2 LeanRidgelet.ridgeletParameterMeasure
            m =
         (x : LeanRidgelet.InputSpace m),
          f x ^ 2
    Theorem 5.9 (`thm:parseval`), Plancherel's identity: for a self-admissible `ψ` normalized by
    `K_{ψ,ψ} = 1` and `f ∈ L¹ ∩ L²(ℝ^m)`, the ridgelet transform is an `L²`-isometry:
    `‖R_ψ f‖_{L²(𝕐^{m+1})} = ‖f‖₂`. 
  • complete
    theorem LeanRidgelet.l1_parseval_relation (m : ) [NeZero m] {ψ η :   }
      {f g : LeanRidgelet.InputSpace m  }
      (hψself : LeanRidgelet.IsSelfAdmissible m ψ)
      (hKψ :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D ψ) =
          1)
      (hηself : LeanRidgelet.IsSelfAdmissible m η)
      (hKη :
        LeanRidgelet.admissibilityConstant m η
            (LeanRidgelet.angularFourier1D η) =
          1)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D η) =
          1)
      (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      (hηc : Continuous η) (hηb :  C,  (z : ), η z  C)
      (hf1 : MeasureTheory.Integrable f MeasureTheory.volume)
      (hf2 : MeasureTheory.MemLp f 2 MeasureTheory.volume)
      (hg1 : MeasureTheory.Integrable g MeasureTheory.volume)
      (hg2 : MeasureTheory.MemLp g 2 MeasureTheory.volume) :
       (q : LeanRidgelet.RidgeletParameterSpace m),
          LeanRidgelet.euclideanRidgeletTransform m 1 ψ f q *
            (starRingEnd )
              (LeanRidgelet.euclideanRidgeletTransform m 1 η g
                q) LeanRidgelet.ridgeletParameterMeasure m =
         (x : LeanRidgelet.InputSpace m), f x * (starRingEnd ) (g x)
    theorem LeanRidgelet.l1_parseval_relation (m : )
      [NeZero m] {ψ η :   }
      {f g : LeanRidgelet.InputSpace m  }
      (hψself :
        LeanRidgelet.IsSelfAdmissible m ψ)
      (hKψ :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              ψ) =
          1)
      (hηself :
        LeanRidgelet.IsSelfAdmissible m η)
      (hKη :
        LeanRidgelet.admissibilityConstant m η
            (LeanRidgelet.angularFourier1D
              η) =
          1)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              η) =
          1)
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      (hηc : Continuous η)
      (hηb :  C,  (z : ), η z  C)
      (hf1 :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hf2 :
        MeasureTheory.MemLp f 2
          MeasureTheory.volume)
      (hg1 :
        MeasureTheory.Integrable g
          MeasureTheory.volume)
      (hg2 :
        MeasureTheory.MemLp g 2
          MeasureTheory.volume) :
       (q :
          LeanRidgelet.RidgeletParameterSpace
            m),
          LeanRidgelet.euclideanRidgeletTransform
              m 1 ψ f q *
            (starRingEnd )
              (LeanRidgelet.euclideanRidgeletTransform
                m 1 η g
                q) LeanRidgelet.ridgeletParameterMeasure
            m =
         (x : LeanRidgelet.InputSpace m),
          f x * (starRingEnd ) (g x)
    Theorem 5.9 (`thm:parseval`), Parseval's relation: for admissibly paired, normalized
    self-admissible `ψ` and `η` and `f, g ∈ L¹ ∩ L²(ℝ^m)`,
    `⟨R_ψ f, R_η g⟩_{L²(𝕐^{m+1})} = ⟨f, g⟩_{L²(ℝ^m)}`. The proof applies the fiberwise polarized
    Plancherel identity in the bias variable, cancels the parameter weight, and evaluates the
    spectral pairing by the dilation `ξ = ζa` and the `m`-dimensional polarized Plancherel
    identity, producing the cross admissibility constant `K_{ψ,η}`.
    
    **Amendment (author-style decision 2026-07-24).** The manuscript states the relation for an
    admissible pair `(ψ, η) ∈ 𝒮 × 𝒮₀'` with `K_{ψ,η} = 1`, "immediate by duality". At function
    level the parameter-space pairing must converge absolutely, which requires both transforms to
    be square-integrable on `𝕐^{m+1}`; by the Plancherel theory this holds when `ψ` **and** `η`
    are each self-admissible (their diagonal admissibility integrals are finite — by
    Cauchy–Schwarz and AM–GM this also subsumes the absolute convergence of the cross
    admissibility integral), and the diagonal normalizations `K_{ψ,ψ} = K_{η,η} = 1` are imposed
    to reuse the normalized `L²`-membership `memLp_two_euclideanRidgeletTransform`. The
    activation `η` is accordingly integrable and bounded, and its Fourier data is the classical
    `η̂`; the cross normalization `K_{ψ,η} = 1` is the manuscript's. 
Theorem2.1.21
Statement uses 3
Statement dependency previews
Preview
Theorem 2.1.20
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1L∃∀N

Bounded extension to (thm:L2). For a self-admissible \psi with K_{\psi,\psi}=1, the ridgelet transform on L^1\cap L^2(\mathbb R^m) admits a unique bounded extension to L^2(\mathbb R^m), and the extension is an isometry into L^2(\mathbb Y^{m+1}).

Lean code for Theorem2.1.211 theorem
  • complete
    theorem LeanRidgelet.l1_ridgeletTransform_L2_extension (m : ) [NeZero m]
      {ψ :   } (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      (hself : LeanRidgelet.IsSelfAdmissible m ψ)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D ψ) =
          1) :
      ∃! R,
        (∀ (f : (LeanRidgelet.TargetSpace m)),
            MeasureTheory.Integrable (↑f) MeasureTheory.volume 
              (R f) =ᵐ[LeanRidgelet.ridgeletParameterMeasure m]
                LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) 
           (f : (LeanRidgelet.TargetSpace m)), R f = f
    theorem LeanRidgelet.l1_ridgeletTransform_L2_extension
      (m : ) [NeZero m] {ψ :   }
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      (hself :
        LeanRidgelet.IsSelfAdmissible m ψ)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              ψ) =
          1) :
      ∃! R,
        (∀
            (f :
              (LeanRidgelet.TargetSpace m)),
            MeasureTheory.Integrable (↑f)
                MeasureTheory.volume 
              (R
                      f) =ᵐ[LeanRidgelet.ridgeletParameterMeasure
                  m]
                LeanRidgelet.euclideanRidgeletTransform
                  m 1 ψ f) 
          
            (f :
              (LeanRidgelet.TargetSpace m)),
            R f = f
    Theorem 5.10 (`thm:L2`), bounded extension of the ridgelet transform to `L²(ℝ^m)`: for a
    self-admissible `ψ` with `K_{ψ,ψ} = 1`, there is a unique bounded operator
    `L²(ℝ^m) → L²(𝕐^{m+1})` that agrees with the integral transform on `L¹ ∩ L²(ℝ^m)`, and it is an
    isometry. 
Theorem2.1.22
Statement uses 4
Statement dependency previews
Preview
Theorem 2.1.13
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0L∃∀N

Reconstruction in (thm:formula.L2). For normalized self-admissible \psi, \eta with cross normalization K_{\psi,\eta}=1 and f\in L^1\cap L^2(\mathbb R^m), the truncated reconstruction converges to f in L^2(\mathbb R^m) — the compatibility statement between the L1 and L2 reconstructions on L^1\cap L^2. The general f\in L^2 case follows from thm:L2. Standing hypotheses. As in l1_parseval_plancherel, on which this rests, both \psi and \eta are integrable, continuous and bounded, so this Euclidean form of the reconstruction does not cover the unbounded activations of Section 6; those are covered by the L2 theory in weighted Sobolev coordinates (see l1_parseval_plancherel). Deviation (author decision 2026-07-25). The article assumes admissible decomposability and then opens its proof with "assume without loss of generality that (\psi,\psi) and (\eta,\eta) are self-admissible"; that reduction needs the equivalence-invariance of the composite \mathscr R^\dagger_\eta\mathscr R_\psi, a distributional statement absent from the function-level development, so self-admissibility of both members is a hypothesis, exactly as in the amended Parseval relation the proof rests on.

Lean code for Theorem2.1.221 theorem
  • complete
    theorem LeanRidgelet.l1_reconstruction_formula_L2 (m : ) [NeZero m]
      {ψ η :   } {f : LeanRidgelet.InputSpace m  }
      (hψself : LeanRidgelet.IsSelfAdmissible m ψ)
      (hKψ :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D ψ) =
          1)
      (hηself : LeanRidgelet.IsSelfAdmissible m η)
      (hKη :
        LeanRidgelet.admissibilityConstant m η
            (LeanRidgelet.angularFourier1D η) =
          1)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D η) =
          1)
      (hψc : Continuous ψ) (hψb :  C,  (z : ), ψ z  C)
      (hηc : Continuous η) (hηb :  C,  (z : ), η z  C)
      (hf1 : MeasureTheory.Integrable f MeasureTheory.volume)
      (hf2 : MeasureTheory.MemLp f 2 MeasureTheory.volume) :
      Filter.Tendsto
        (fun q 
          MeasureTheory.eLpNorm
            (fun x 
              LeanRidgelet.truncatedDualRidgeletTransform m 1 η
                  (LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) q.1 q.2
                  x -
                f x)
            2 MeasureTheory.volume)
        LeanRidgelet.ridgeletTruncationFilter (nhds 0)
    theorem LeanRidgelet.l1_reconstruction_formula_L2
      (m : ) [NeZero m] {ψ η :   }
      {f : LeanRidgelet.InputSpace m  }
      (hψself :
        LeanRidgelet.IsSelfAdmissible m ψ)
      (hKψ :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              ψ) =
          1)
      (hηself :
        LeanRidgelet.IsSelfAdmissible m η)
      (hKη :
        LeanRidgelet.admissibilityConstant m η
            (LeanRidgelet.angularFourier1D
              η) =
          1)
      (hK :
        LeanRidgelet.admissibilityConstant m ψ
            (LeanRidgelet.angularFourier1D
              η) =
          1)
      (hψc : Continuous ψ)
      (hψb :  C,  (z : ), ψ z  C)
      (hηc : Continuous η)
      (hηb :  C,  (z : ), η z  C)
      (hf1 :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hf2 :
        MeasureTheory.MemLp f 2
          MeasureTheory.volume) :
      Filter.Tendsto
        (fun q 
          MeasureTheory.eLpNorm
            (fun x 
              LeanRidgelet.truncatedDualRidgeletTransform
                  m 1 η
                  (LeanRidgelet.euclideanRidgeletTransform
                    m 1 ψ f)
                  q.1 q.2 x -
                f x)
            2 MeasureTheory.volume)
        LeanRidgelet.ridgeletTruncationFilter
        (nhds 0)
    Theorem 5.11 (`thm:formula.L2`), the reconstruction formula in `L²`: for normalized
    self-admissible `ψ` and `η` with cross normalization `K_{ψ,η} = 1` and `f ∈ L¹ ∩ L²(ℝ^m)`, the
    truncated reconstruction converges to `f` in `L²(ℝ^m)`. Together with
    `l1_ridgeletTransform_L2_extension` this expresses the compatibility of the L1 and L2
    reconstructions on `L¹ ∩ L²`.
    
    The proof is the manuscript's duality argument made quantitative:
    `eLpNorm_truncatedDualRidgeletTransform_sub_le` bounds the error norm by the ridgelet energy
    outside the scale annulus, and `tendsto_setIntegral_compl_annulus_norm_sq` sends that energy to
    zero along the truncation filter (the annulus exhausts `𝕐^{m+1}` up to the null set of vanishing
    weights).
    
    **Amendment (author-style decision 2026-07-25).** The manuscript states the theorem for an
    admissibly decomposable pair and then opens its proof with "assume without loss of generality
    that `(ψ, ψ)` and `(η, η)` are self-admissible respectively". That reduction is what carries the
    decomposability hypothesis, and it needs the equivalence-invariance of the composite operator
    `R†_η R_ψ` (which depends on the pair only through `conj (ψ~) ⋆ η`) — a distributional
    statement about equivalent pairs that the function-level development does not have. The
    self-admissibility of both members is therefore taken as a hypothesis, exactly as in the
    amended Parseval relation `l1_parseval_relation` on which this proof rests, together with the
    diagonal normalizations `K_{ψ,ψ} = K_{η,η} = 1`. The hypothesis `f ∈ L¹ ∩ L²(ℝ^m)` (rather than
    `f ∈ L²`) is the one already present in the staged statement: it is what makes the ridgelet
    transform of `f` a classical integral; the general `f ∈ L²` case follows from the bounded
    extension `l1_ridgeletTransform_L2_extension`. 

Section 6: unbounded activation functions

Proposition2.1.23
Statement uses 3
Statement dependency previews
Preview
Definition 2.1.5
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Proposition 2.1.7
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
L∃∀N

Truncated powers as Lizorkin distributions. By the Gel'fand--Shilov formula \widehat{z_+^k}=k!/(i\zeta)^{k+1}+\pi i^k\delta^{(k)}, the truncated power z_+^k has Fourier data k!/(i\zeta)^{k+1} away from the origin.

Lean code for Proposition2.1.231 theorem
  • complete
    theorem LeanRidgelet.l1_truncatedPower_hasFourierAwayFromOrigin (k : ) :
      LeanRidgelet.HasFourierAwayFromOrigin (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    theorem LeanRidgelet.l1_truncatedPower_hasFourierAwayFromOrigin
      (k : ) :
      LeanRidgelet.HasFourierAwayFromOrigin
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    Section 6.1 with Gel'fand--Shilov: the truncated power `z₊^k` (step function, ReLU, ...) is
    a Lizorkin distribution whose Fourier transform away from the origin is the function
    `k! / (iζ)^{k+1}`; the point mass `π i^k δ^{(k)}` at the origin is invisible away from `0`. 
Proposition2.1.24
Statement uses 5
Statement dependency previews
Preview
Corollary 2.1.16
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1L∃∀N

Admissibility of truncated powers (Section 6.2). For every dimension m and degree k there is an integrable ridgelet function, with weighted integrability and vanishing moments of every order, admissible against z_+^k (first declaration). The article's construction is available for an arbitrary Schwartz window (sixth declaration): (\Lambda^mw^{(\ell+k+1)},z_+^k) is admissible as soon as \int\zeta^\ell\overline{\widehat w(\zeta)}\,d\zeta\ne0, because the factor |\zeta|^m cancels the |\zeta|^{-m} of the admissibility density and the factor (i\zeta)^{\ell+k+1} cancels the pole k!/(i\zeta)^{k+1} down to \zeta^\ell. The article's own Gaussian witness \psi=\Lambda^mG^{(\ell+k+1)} is the last declaration: its angular Fourier transform is \widehat G(\zeta)=\sqrt{2\pi}e^{-\zeta^2/2}>0 (Mathlib's Gaussian Fourier transform at b=1/2, no frequency rescaling being needed in the article convention), so \int\zeta^\ell\overline{\widehat G} is a positive integral exactly for even \ell, and the integrability of the filtered function comes from mathlib_hilbert_symbol through l1_lambda_multiplier. The Gaussian is realized as a Schwartz function in mathlib_gaussian_schwartz. Deviation. The witness used for the universality corollary is not the article's but an explicit one: the inverse Fourier transform of a smooth bump supported in (5\pi/2,7\pi/2). Because its spectrum is compactly supported away from the origin, the admissibility integrand is a nonzero constant times a nonnegative continuous compactly supported density on the positive half-line, so integrability and K\ne0 come together, and all moments vanish — the witness is a Lizorkin test function. The Dirac-delta and sigmoid examples of Section 6 are deferred with the distributional pass.

Lean code for Proposition2.1.248 declarations
  • complete
    theorem LeanRidgelet.l1_truncatedPower_admissible_exists (m k : ) :
       ψ,
        MeasureTheory.Integrable ψ MeasureTheory.volume 
          MeasureTheory.Integrable (fun s  (1 + |s|) ^ k * ψ s)
              MeasureTheory.volume 
            (∀ j  k,  (s : ), s ^ j * ψ s = 0) 
              LeanRidgelet.IsAdmissiblePair m ψ
                (LeanRidgelet.truncatedPower k)
                (LeanRidgelet.truncatedPowerFourier k)
    theorem LeanRidgelet.l1_truncatedPower_admissible_exists
      (m k : ) :
       ψ,
        MeasureTheory.Integrable ψ
            MeasureTheory.volume 
          MeasureTheory.Integrable
              (fun s  (1 + |s|) ^ k * ψ s)
              MeasureTheory.volume 
            (∀ j  k,
                 (s : ), s ^ j * ψ s = 0) 
              LeanRidgelet.IsAdmissiblePair m
                ψ
                (LeanRidgelet.truncatedPower
                  k)
                (LeanRidgelet.truncatedPowerFourier
                  k)
    **Admissibility of the truncated powers** (Section 6.1--6.2), in the form the function-level
    development proves: for every dimension `m` and every degree `k` there is an integrable ridgelet
    function with `k`-weighted integrability and vanishing moments of every order which is admissible
    against `z₊^k`. The witness is `bumpRidgelet`; see the section header for why the manuscript's
    `ψ = Λ^m G^{(ℓ+k+1)}` (`l1_truncatedPower_admissible`) is not the witness used here. 
  • complete
    def LeanRidgelet.bumpRidgelet :   
    def LeanRidgelet.bumpRidgelet :   
    Implementation after :=
    := ⇑bumpRidgeletSchwartz
  • complete
    theorem LeanRidgelet.isAdmissiblePair_bumpRidgelet (m k : ) :
      LeanRidgelet.IsAdmissiblePair m LeanRidgelet.bumpRidgelet
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    theorem LeanRidgelet.isAdmissiblePair_bumpRidgelet
      (m k : ) :
      LeanRidgelet.IsAdmissiblePair m
        LeanRidgelet.bumpRidgelet
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    **The explicit ridgelet function is admissible against every truncated power.** 
  • complete
    theorem LeanRidgelet.integral_pow_mul_bumpRidgelet (n : ) :
       (s : ), s ^ n * LeanRidgelet.bumpRidgelet s = 0
    theorem LeanRidgelet.integral_pow_mul_bumpRidgelet
      (n : ) :
       (s : ),
          s ^ n *
            LeanRidgelet.bumpRidgelet s =
        0
    The explicit ridgelet function has vanishing moments of every order: its spectrum is
    supported away from the origin. 
  • complete
    theorem LeanRidgelet.bumpRidgeletSchwartz_mem_lizorkinSpace :
      LeanRidgelet.bumpRidgeletSchwartz  LizorkinSpace
    theorem LeanRidgelet.bumpRidgeletSchwartz_mem_lizorkinSpace :
      LeanRidgelet.bumpRidgeletSchwartz 
        LizorkinSpace
    The explicit ridgelet function is a **Lizorkin test function**: all of its moments vanish,
    because its spectrum is supported away from the origin. 
  • complete
    theorem LeanRidgelet.l1_truncatedPower_isAdmissiblePair_of_window (m : )
      [NeZero m] (k  : ) (w : SchwartzMap  )
      (hne :
         (ζ : ) in {0},
            ζ ^  *
              (starRingEnd ) (LeanRidgelet.angularFourier1D (⇑w) ζ) 
          0) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m (iteratedDeriv ( + k + 1) w))
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    theorem LeanRidgelet.l1_truncatedPower_isAdmissiblePair_of_window
      (m : ) [NeZero m] (k  : )
      (w : SchwartzMap  )
      (hne :
         (ζ : ) in {0},
            ζ ^  *
              (starRingEnd )
                (LeanRidgelet.angularFourier1D
                  (⇑w) ζ) 
          0) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m
          (iteratedDeriv ( + k + 1) w))
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    **Section 6.2 in general form**: for any Schwartz window `w`, the truncated power `z₊^k` is
    admissible with the filtered ridgelet function `ψ = Λ^m w^{(ℓ+k+1)}` as soon as the `ℓ`-th
    moment of `conj (ŵ)` is nonzero.
    
    The admissibility density collapses to a constant multiple of `ζ^ℓ conj (ŵ (ζ))`: the factor
    `|ζ|^m` of `(Λ^m w^{(ℓ+k+1)})^` cancels the `|ζ|^{-m}` of the density
    (`l1_isAdmissiblePair_lambdaOperatorPow`), the factor `(iζ)^{ℓ+k+1}` of the `(ℓ+k+1)`-st
    derivative (`angularFourier1D_iteratedDeriv`) cancels the pole `k!/(iζ)^{k+1}` of the
    Gel'fand--Shilov data of `z₊^k` down to `ζ^ℓ`, and the surviving constant
    `(-1)^{ℓ+k+1} i^ℓ k!` is nonzero. This is the whole mechanism of the manuscript's construction,
    with the window left free. 
  • complete
    theorem LeanRidgelet.angularFourier1D_gaussianWindow (ζ : ) :
      LeanRidgelet.angularFourier1D LeanRidgelet.gaussianWindow ζ =
        ((2 * Real.pi) * Real.exp (-ζ ^ 2 / 2))
    theorem LeanRidgelet.angularFourier1D_gaussianWindow
      (ζ : ) :
      LeanRidgelet.angularFourier1D
          LeanRidgelet.gaussianWindow ζ =
        ((2 * Real.pi) *
            Real.exp (-ζ ^ 2 / 2))
    **The angular Fourier transform of the Gaussian**: `Ĝ(ζ) = √(2π) e^{-ζ²/2}`, positive at
    every frequency. In the article convention no `2π` rescaling of the frequency is needed, so this
    is Mathlib's `fourierIntegral_gaussian` with `b = 1/2` and `t = -ζ`. 
  • complete
    theorem LeanRidgelet.l1_truncatedPower_admissible (m : ) [NeZero m] (k  : )
      (hℓ : Even ) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m
          (iteratedDeriv ( + k + 1) LeanRidgelet.gaussianWindow))
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    theorem LeanRidgelet.l1_truncatedPower_admissible
      (m : ) [NeZero m] (k  : )
      (hℓ : Even ) :
      LeanRidgelet.IsAdmissiblePair m
        (LeanRidgelet.lambdaOperatorPow m
          (iteratedDeriv ( + k + 1)
            LeanRidgelet.gaussianWindow))
        (LeanRidgelet.truncatedPower k)
        (LeanRidgelet.truncatedPowerFourier k)
    Section 6.2: the truncated power `z₊^k` is admissible with the Gaussian-derivative ridgelet
    function `ψ = Λ^m G^{(ℓ+k+1)}` for every even `ℓ`.
    
    **Deviations from the article.** The filter is the standard Lambda operator (`lambdaOperatorPow`)
    rather than the article's `eq:bp`; for odd `m` the constructed `ψ` leaves the Schwartz class, so
    `IsAdmissiblePair` asks only for its integrability (paper gap memo, 2026-07-19). 
Theorem2.1.25
Statement uses 2
Statement dependency previews
Preview
Theorem 2.1.17
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0L∃∀N

Universal approximation with ReLU networks. For every f\in L^1(\mathbb R^m) with a finite first moment and \widehat f\in L^1(\mathbb R^m) there are an integrable ridgelet function \psi and a nonzero constant K such that the continuous ReLU network with coefficient \mathscr R_\psi f reconstructs Kf in the truncation limit, almost everywhere. Deviation. The first-moment hypothesis is inherited from the amended reconstruction formula with the ReLU growth degree k=1; it is vacuous in the deferred distributional pass.

Lean code for Theorem2.1.251 theorem
  • complete
    theorem LeanRidgelet.l1_relu_network_universal_approximation (m : ) [NeZero m]
      {f : LeanRidgelet.InputSpace m  }
      (hf : MeasureTheory.Integrable f MeasureTheory.volume)
      (hf1 :
        MeasureTheory.Integrable (fun y  (1 + y) * f y)
          MeasureTheory.volume)
      (hfhat :
        MeasureTheory.Integrable
          (LeanRidgelet.Fourier.angularFourierIntegralInner f)
          MeasureTheory.volume) :
       ψ K,
        MeasureTheory.Integrable ψ MeasureTheory.volume 
          K  0 
            ∀ᵐ (x : LeanRidgelet.InputSpace m),
              Filter.Tendsto
                (fun q 
                  LeanRidgelet.truncatedDualRidgeletTransform m 1
                    (LeanRidgelet.truncatedPower 1)
                    (LeanRidgelet.euclideanRidgeletTransform m 1 ψ f) q.1
                    q.2 x)
                LeanRidgelet.ridgeletTruncationFilter (nhds (K * f x))
    theorem LeanRidgelet.l1_relu_network_universal_approximation
      (m : ) [NeZero m]
      {f : LeanRidgelet.InputSpace m  }
      (hf :
        MeasureTheory.Integrable f
          MeasureTheory.volume)
      (hf1 :
        MeasureTheory.Integrable
          (fun y  (1 + y) * f y)
          MeasureTheory.volume)
      (hfhat :
        MeasureTheory.Integrable
          (LeanRidgelet.Fourier.angularFourierIntegralInner
            f)
          MeasureTheory.volume) :
       ψ K,
        MeasureTheory.Integrable ψ
            MeasureTheory.volume 
          K  0 
            ∀ᵐ (x :
              LeanRidgelet.InputSpace m),
              Filter.Tendsto
                (fun q 
                  LeanRidgelet.truncatedDualRidgeletTransform
                    m 1
                    (LeanRidgelet.truncatedPower
                      1)
                    (LeanRidgelet.euclideanRidgeletTransform
                      m 1 ψ f)
                    q.1 q.2 x)
                LeanRidgelet.ridgeletTruncationFilter
                (nhds (K * f x))
    Headline corollary of the L1 theory: neural networks with the unbounded ReLU activation are
    universal approximators. For every `f ∈ L¹(ℝ^m)` with a finite first moment and
    `f̂ ∈ L¹(ℝ^m)` there exist an integrable ridgelet function `ψ` and a nonzero constant `K`
    such that the network `x ↦ ∫ R_ψ f (a, b) relu (⟪a, x⟫ - b) ‖a‖⁻¹ da db` reconstructs `K f`.
    
    **Amendment to the article (author decision 2026-07-22).** The first-moment hypothesis on
    `f` is inherited from the amended `l1_reconstruction_formula` with the ReLU growth degree
    `k = 1`; it is necessary at function level and vacuous in the deferred distributional
    pass. 
Proposition2.1.26
Statement uses 4
Statement dependency previews
Preview
Definition 2.1.5
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

The activation zoo of Section 6 (partly deferred). Section 6.1 classifies candidate activations: Proposition 6.1 (a locally integrable \eta with |\eta|\lesssim(1+|z|)^k is a tempered distribution) is available as the growth predicate of the upstream chapter combined with local integrability, and is what l1_fourier_away_from_origin assumes; Proposition 6.2 (the \mathcal O_M criterion) corresponds to Mathlib's Function.HasTemperateGrowth. The class memberships themselves — Example 6.4 (\sigma,\sigma^{(-1)},\tanh\in\mathcal O_M, \sigma^{(k)}\in\mathcal S), Example 6.5 (the RBF and its derivatives are Schwartz) and Example 6.6 (\delta^{(k)}\in\mathcal S') — are not formalized. Of the admissibility examples of Section 6.2, only Example 6.7 is (l1_truncated_power_admissible), and only in the direction "\ell even \Rightarrow admissible": the article's converse K_{\psi,\eta}=0 for odd \ell, and with it Table 5, is unformalized. Example 6.8 (\delta^{(k)} with \Lambda^mG) needs the distributional pass. Examples 6.9 (G^{(k)}) and the k\ge1 half of 6.10 (\sigma^{(k)}) are function-level statements blocked only by the article's witness \Lambda^mG, i.e. by the same missing L^1 decay of the Hilbert transform that keeps LeanRidgelet.l1_truncatedPower_admissible unproved; the \sigma and \sigma^{(-1)} rows of 6.10 are slowly increasing rather than integrable and need the distributional pass as well.