Documentation

Frourio.Analysis.MellinParsevalCore

Mellin-Parseval Identity and its Relation to Fourier-Parseval #

This file establishes the explicit relationship between the Mellin-Plancherel formula and the classical Fourier-Parseval identity through logarithmic change of variables.

Main Results #

Implementation Notes #

The key insight is that the multiplicative Haar measure dx/x on (0,∞) corresponds to the Lebesgue measure dt on ℝ under the logarithmic change of variables x = e^t.

noncomputable def Frourio.logMap :
(Set.Ioi 0)

The logarithmic change of variables map

Equations
Instances For
    noncomputable def Frourio.expMap :
    (Set.Ioi 0)

    The exponential change of variables map

    Equations
    Instances For

      The logarithmic map is a measurable equivalence

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem Frourio.mellin_kernel_transform (s : ) (t : ) :
        (Real.exp t) ^ (s - 1) = Complex.exp ((s - 1) * t)

        The Mellin kernel x^(s-1) becomes e^((s-1)t) under logarithmic change

        theorem Frourio.mellin_change_of_variables (f : ) (s : ) :
        (x : ) in Set.Ioi 0, f x * x ^ (s - 1) = (t : ), f (Real.exp t) * (Real.exp t) ^ (s - 1) * (Real.exp t)

        Change of variables lemma for Mellin transform: x = exp(t)

        Under x = e^t, the Mellin transform becomes a Fourier-type transform

        Change of variables formula for exponential transformation

        Simplification lemma: (1/exp(t)) * exp(t) = 1 in ENNReal

        The multiplicative Haar measure corresponds to Lebesgue measure

        noncomputable def Frourio.logPushforward (f : ) :

        The transformed function under logarithmic change

        Equations
        Instances For
          noncomputable def Frourio.mellinWeight (σ : ) :

          The weight function for the transformed inner product

          Equations
          Instances For
            theorem Frourio.mellin_as_weighted_fourier (f : ) (σ τ : ) :
            mellinTransform f (σ + Complex.I * τ) = (t : ), logPushforward f t * Complex.exp (σ * t) * Complex.exp (Complex.I * τ * t)

            The Mellin transform at σ + iτ corresponds to weighted Fourier transform

            theorem Frourio.complex_polarization_identity {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace E] (f g : E) :
            4 * inner f g = ↑(f + g ^ 2) - ↑(f - g ^ 2) - Complex.I * ↑(f + Complex.I g ^ 2) + Complex.I * ↑(f - Complex.I g ^ 2)

            The polarization identity for complex inner products

            theorem Frourio.mellin_logpull_relation (σ : ) (f : ( σ)) (τ : ) :
            mellinTransform (↑f) (σ + Complex.I * τ) = (t : ), LogPull σ f t * Complex.exp (Complex.I * τ * t) * Complex.exp ((1 / 2) * t)

            The Mellin transform relates to LogPull through change of variables

            theorem Frourio.norm_simplification_logpull (σ : ) (f : ( σ)) :
            (t : ), LogPull σ f t * Complex.exp ((1 / 2) * t) ^ 2 = (t : ), LogPull σ f t ^ 2 * Real.exp t

            Norm simplification for weighted LogPull

            theorem Frourio.weighted_LogPull_integral_eq (σ : ) (f : ( σ)) :
            ∫⁻ (t : ), ENNReal.ofReal (LogPull σ f t * Complex.exp ((1 / 2) * t) ^ 2) = ∫⁻ (x : ) in Set.Ioi 0, ENNReal.ofReal (f x ^ 2 * x ^ (2 * σ - 1))

            The L² norm of weighted LogPull equals the weighted L² norm of f, assuming the integral converges

            def Frourio.has_weighted_L2_norm (σ : ) (f : ( σ)) :

            Additional L² integrability condition for functions in Hσ σ

            Equations
            Instances For

              Helper: relate ‖z‖ₑ squared (with real exponent) to ENNReal.ofReal (‖z‖^2).

              theorem Frourio.weighted_LogPull_memLp (σ : ) (f : ( σ)) (h_extra : has_weighted_L2_norm σ f) :
              MeasureTheory.MemLp (fun (t : ) => LogPull σ f t * Complex.exp ((1 / 2) * t)) 2 MeasureTheory.volume

              The weighted LogPull function is in L² under suitable conditions

              theorem Frourio.mellin_transform_linear (σ : ) (h k : ( σ)) (c s : ) (hh_int : MeasureTheory.Integrable (fun (t : ) => h t * t ^ (s - 1)) (MeasureTheory.volume.restrict (Set.Ioi 0))) (hk_int : MeasureTheory.Integrable (fun (t : ) => k t * t ^ (s - 1)) (MeasureTheory.volume.restrict (Set.Ioi 0))) :
              mellinTransform (h + c k) s = mellinTransform (↑h) s + c * mellinTransform (↑k) s

              Linearity of the Mellin transform (assuming convergence)