InformationTheory

InformationTheory.Shannon.TimeBandLimiting.Operator

source

The time-and-band-limiting operator on L²(ℝ;ℂ) — the operator itself #

Cover–Thomas (Shannon–Hartley). The base module for the Shannon/TimeBandLimiting/ family: the Hilbert space E = L²(ℝ;ℂ), the time- and band-limited closed subspaces, the operator A = P_W ∘ Q_T ∘ P_W, its self-adjointness, positivity, norm bound ‖A‖ ≤ 1, compactness, and the parameter-boundary degeneracy (A = 0 for T ≤ 0 or W ≤ 0). See the umbrella TimeBandLimiting.lean for the full overview.

abbrev

InformationTheory.Shannon.TimeBandLimiting.E

source
@[reducible, inline]

The L²(ℝ;ℂ) Hilbert space the operator acts on.

Equations
Instances For
    Used by
      def

      InformationTheory.Shannon.TimeBandLimiting.zeroOnLp

      source

      The closed subspace of L²(ℝ;ℂ) functions that vanish almost everywhere on a set S. It is a closed submodule: closedness comes from the fact that convergence has an almost-everywhere convergent subsequence, and an a.e.-limit of functions vanishing a.e. on S again vanishes a.e. on S.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        Used by
          theorem

          InformationTheory.Shannon.TimeBandLimiting.zeroOnLp_isClosed

          source
          (S : Set ) :
          Used by
            instance

            InformationTheory.Shannon.TimeBandLimiting.instCompleteSpaceZeroOnLp

            source
            Used by
              def

              InformationTheory.Shannon.TimeBandLimiting.timeLimitSubspace

              source

              Time-limited subspace: functions a.e.-supported in [0,T] (i.e. vanishing a.e. outside [0,T]). Closed.

              Equations
              Instances For
                Used by
                  instance

                  InformationTheory.Shannon.TimeBandLimiting.instCompleteSpaceTimeLimit

                  source
                  Used by
                    noncomputable def

                    InformationTheory.Shannon.TimeBandLimiting.bandLimitSubspace

                    source

                    Band-limited subspace: functions whose L²-Fourier transform is a.e.-supported in [-W,W] (i.e. vanishes a.e. on {ξ | W < |ξ|}). Closed, as the preimage of the closed subspace zeroOnLp {ξ | W < |ξ|} under the continuous Plancherel isometry.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      Used by
                        theorem

                        InformationTheory.Shannon.TimeBandLimiting.bandLimitSubspace_isClosed

                        source
                        Used by
                          instance

                          InformationTheory.Shannon.TimeBandLimiting.instCompleteSpaceBandLimit

                          source
                          Used by
                            noncomputable def

                            InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp

                            source
                            (T W : ) :

                            The time-and-band limiting operator A = P_W ∘ Q_T ∘ P_W.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              Used by
                                theorem

                                InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_isSelfAdjoint

                                source

                                The time-and-band limiting operator is self-adjoint.

                                Used by
                                  theorem

                                  InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_isPositive

                                  source

                                  The time-and-band limiting operator is a positive operator.

                                  Used by
                                    theorem

                                    InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_norm_le_one

                                    source

                                    The time-and-band limiting operator is a contraction: ‖A‖ ≤ 1.

                                    Used by

                                      Compactness #

                                      Compactness of A = P_W ∘ Q_T ∘ P_W is reduced to compactness of the sinc integral operator C = Q_T ∘ P_W. Since A = P_W ∘ C (the definition, reassociated) and P_W is bounded, A is compact as soon as C is (IsCompactOperator.clm_comp). The operator C is Hilbert–Schmidt: its integral kernel

                                      `sincConvKernel T W t s = 𝟙_[0,T](t) · 2W · sincN(2W(t − s))`
                                      

                                      lies in L²(ℝ × ℝ) (the t-indicator confines the mass to [0,T], and Plancherel of the ideal low-pass gives ∫_ℝ (2W sincN(2W u))² du = 2W, so ‖k‖₂² = 2WT < ∞), and an kernel yields a compact operator because the kernels with compact operator form a closed submodule containing the rectangle indicators, which generate L²(ℝ × ℝ). The analytic content lives in four leaves:

                                      The remaining declarations (timeBandLimitingComp_apply_ae, timeBandLimitingComp_isCompact, timeBandLimitingOp_isCompact) are reductions that compose the four leaves, so the headline timeBandLimitingOp_isCompact is unconditional.

                                      Note the sign asymmetry: the kernel representation needs 0 ≤ W (sincN is even, so a negative W flips the sign of the kernel while P_W collapses to 0), but the compactness headlines hold for every real W, the degenerate band being handled separately via bandLimitSubspace_eq_bot_of_nonpos.

                                      noncomputable def

                                      InformationTheory.Shannon.TimeBandLimiting.sincConvKernel

                                      source
                                      (T W t s : ) :

                                      The Hilbert–Schmidt kernel of the sinc integral operator C = Q_T ∘ P_W: 𝟙_[0,T](t) · 2W · sincN(2W(t − s)). The t-indicator encodes the time-limiting Q_T; the 2W sincN(2W·) factor is the ideal low-pass whose Fourier transform is 𝟙_[-W,W], i.e. the convolution kernel of the band-limiting P_W.

                                      Equations
                                      Instances For
                                        Used by
                                          noncomputable def

                                          InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingComp

                                          source
                                          (T W : ) :

                                          The sinc integral operator C = Q_T ∘ P_W (band-limit, then time-limit). A = P_W ∘ C.

                                          Equations
                                          • One or more equations did not get rendered due to their size.
                                          Instances For
                                            Used by
                                              theorem

                                              InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_eq_bandProj_comp

                                              source
                                              Used by
                                                theorem

                                                InformationTheory.Shannon.TimeBandLimiting.zeroOnLp_starProjection_apply_ae

                                                source
                                                {S : Set } (hS : MeasurableSet S) (g : E) :
                                                ((zeroOnLp S).starProjection g) =ᵐ[MeasureTheory.volume] (S.indicator fun (x : ) => 1) * g

                                                The orthogonal projection onto zeroOnLp S acts, a.e., as multiplication by the indicator of Sᶜ. Proven via the uniqueness of the orthogonal projection: the candidate 𝟙_{Sᶜ}·g lies in the subspace, and the residual 𝟙_S·g is orthogonal to it. Both the time-limiting Q_T (S = [0,T]ᶜ) and the frequency-side multiplier (S = {|ξ| > W}, giving 𝟙_[-W,W]·𝓕f) are instances, so the projection-uniqueness argument is written once here. @audit:ok

                                                Used by
                                                  theorem

                                                  InformationTheory.Shannon.TimeBandLimiting.timeLimitProj_apply_ae

                                                  source
                                                  (T : ) (g : E) :

                                                  The orthogonal projection Q_T onto the time-limited subspace acts, a.e., as multiplication by the indicator of [0,T]. The instance S = [0,T]ᶜ of zeroOnLp_starProjection_apply_ae. @audit:ok

                                                  Used by
                                                    theorem

                                                    InformationTheory.Shannon.TimeBandLimiting.starProjection_comap_linearIsometryEquiv

                                                    source
                                                    {𝕜 : Type u_1} {X : Type u_2} {Y : Type u_3} [RCLike 𝕜] [NormedAddCommGroup X] [InnerProductSpace 𝕜 X] [NormedAddCommGroup Y] [InnerProductSpace 𝕜 Y] (L : X ≃ₗᵢ[𝕜] Y) (U : Submodule 𝕜 Y) [U.HasOrthogonalProjection] [(Submodule.comap (↑L.toLinearEquiv) U).HasOrthogonalProjection] (x : X) :

                                                    Conjugating an orthogonal projection by a surjective linear isometry: the projection onto a comapped subspace is the projection onto the subspace, conjugated. Mathlib has the map form (LinearIsometry.map_starProjection); this is the comap form, which is what a Fourier-multiplier subspace such as bandLimitSubspace is literally defined by. @audit:ok

                                                    Used by
                                                      instance

                                                      InformationTheory.Shannon.TimeBandLimiting.instHasOrthogonalProjectionBandLimitComap

                                                      source
                                                      Used by
                                                        theorem

                                                        InformationTheory.Shannon.TimeBandLimiting.bandLimitProj_eq_fourier_conj

                                                        source

                                                        The band-limiting projection is the Fourier multiplier by 𝟙_[-W,W]: conjugate the projection onto zeroOnLp {ξ | W < |ξ|} by the Plancherel isometry. Immediate from starProjection_comap_linearIsometryEquiv and the definition of bandLimitSubspace. @audit:ok

                                                        Used by
                                                          theorem

                                                          InformationTheory.Shannon.TimeBandLimiting.compl_setOf_lt_abs

                                                          source
                                                          (W : ) :
                                                          {ξ : | W < |ξ|} = Set.Icc (-W) W
                                                          Used by
                                                            theorem

                                                            InformationTheory.Shannon.TimeBandLimiting.measurableSet_setOf_lt_abs

                                                            source
                                                            (W : ) :
                                                            Used by
                                                              theorem

                                                              InformationTheory.Shannon.TimeBandLimiting.fourier_bandLimitProj_apply_ae

                                                              source

                                                              The band-limiting projection is the Fourier multiplier by 𝟙_[-W,W], obtained by combining the conjugation identity bandLimitProj_eq_fourier_conj with the projection-uniqueness computation zeroOnLp_starProjection_apply_ae on the frequency side. This is the "half" of bandLimitProj_apply_ae that lives entirely inside the abstract projection API; the remaining half is the identification of the multiplier's action with sinc convolution, which needs the Fourier transform to be evaluated concretely. Note this half needs no sign condition on W: for W < 0 the interval [-W,W] is empty and both sides vanish, so the sign asymmetry is localized entirely in the passage from the multiplier 𝟙_[-W,W] to the kernel 2W sincN(2W·). @audit:ok

                                                              Used by

                                                                Degeneracy at the parameter boundary #

                                                                The one place the degeneracy story is told. Both subspaces collapse to as soon as their parameter is nonpositive, and for structurally identical reasons: the set on which the functions are required to vanish becomes co-null — all of for a strictly negative parameter, the complement of the null set {0} at the boundary itself — and an function vanishing a.e. on a co-null set is 0. This is a true degeneracy of the geometry (the band [-W,W] is empty or null, the window [0,T] likewise), not an artifact of the definitions, and it is what lets the compactness headlines below keep their unrestricted (T W : ℝ) signatures.

                                                                The operator- and eigenvalue-level consequences are collected in section Degeneracy at the end of the file: A = 0 on either boundary, hence prolateEigenvalues is identically 0 there. Those are what make the 0 < T and 0 < W hypotheses of prolateEigenvalues_zero_pos tight.

                                                                theorem

                                                                InformationTheory.Shannon.TimeBandLimiting.ae_ne_zero

                                                                source
                                                                :
                                                                ∀ᵐ (x : ), x 0
                                                                Used by
                                                                  theorem

                                                                  InformationTheory.Shannon.TimeBandLimiting.zeroOnLp_eq_bot_of_ae_mem

                                                                  source
                                                                  {S : Set } (hS : ∀ᵐ (x : ), x S) :
                                                                  Used by
                                                                    theorem

                                                                    InformationTheory.Shannon.TimeBandLimiting.timeLimitSubspace_eq_bot_of_nonpos

                                                                    source
                                                                    {T : } (hT : T 0) :

                                                                    For a nonpositive time limit the time-limited subspace degenerates: the window [0,T] is empty (T < 0) or null (T = 0), so only the zero function is supported in it. Tightness half of the 0 < T hypothesis of prolateEigenvalues_zero_pos. @audit:ok

                                                                    Used by
                                                                      theorem

                                                                      InformationTheory.Shannon.TimeBandLimiting.bandLimitSubspace_eq_bot_of_nonpos

                                                                      source
                                                                      {W : } (hW : W 0) :

                                                                      For a nonpositive band limit the band-limited subspace degenerates: the band [-W,W] is empty (W < 0) or null (W = 0), so only the zero function has an a.e.-vanishing Fourier transform outside it. Tightness half of the 0 < W hypothesis of prolateEigenvalues_zero_pos; it also discharges the degenerate band in the compactness headlines. @audit:ok

                                                                      Used by
                                                                        noncomputable def

                                                                        InformationTheory.Shannon.TimeBandLimiting.bandLimitSpec

                                                                        source
                                                                        (W : ) (f : E) :

                                                                        The frequency-side content of the band-limiting projection: the spectral cutoff 𝟙_[-W,W] · 𝓕f. By fourier_bandLimitProj_apply_ae this is a.e. the Fourier transform of P_W f; being an function cut down to a bounded interval it is moreover integrable, which is what lets the L¹ ∩ L² Fourier bridge evaluate P_W f pointwise.

                                                                        Equations
                                                                        Instances For
                                                                          Used by
                                                                            theorem

                                                                            InformationTheory.Shannon.TimeBandLimiting.bandLimitSpec_eq_indicator

                                                                            source
                                                                            Used by
                                                                              theorem

                                                                              InformationTheory.Shannon.TimeBandLimiting.bandLimitSpec_memLp_two

                                                                              source
                                                                              Used by
                                                                                theorem

                                                                                InformationTheory.Shannon.TimeBandLimiting.bandLimitSpec_memLp_one

                                                                                source
                                                                                Used by
                                                                                  theorem

                                                                                  InformationTheory.Shannon.TimeBandLimiting.bandLimitProj_coeFn_ae_eq_fourierInv

                                                                                  source
                                                                                  Used by
                                                                                    theorem

                                                                                    InformationTheory.Shannon.TimeBandLimiting.inner_two_mul_specBoxcar_apply

                                                                                    source
                                                                                    (W t ξ : ) (hW : 0 < W) (z : ) :
                                                                                    inner (2 * W * ShannonHartley.specBoxcar t (1 / (2 * W)) ξ) z = Complex.exp (↑(2 * Real.pi * (ξ * t)) * Complex.I) * ((Set.Icc (-W) W).indicator (fun (x : ) => 1) ξ * z)
                                                                                    Used by
                                                                                      theorem

                                                                                      InformationTheory.Shannon.TimeBandLimiting.fourierInv_bandLimitSpec_eq

                                                                                      source
                                                                                      (W : ) (hW : 0 < W) (f : E) (t : ) :
                                                                                      FourierTransformInv.fourierInv (bandLimitSpec W f) t = (s : ), ↑(2 * W * NormalizedSinc.sincN (2 * W * (t - s))) * f s
                                                                                      Used by
                                                                                        theorem

                                                                                        InformationTheory.Shannon.TimeBandLimiting.bandLimitProj_apply_ae

                                                                                        source
                                                                                        (W : ) (hW : 0 W) (f : E) :
                                                                                        ((bandLimitSubspace W).starProjection f) =ᵐ[MeasureTheory.volume] fun (t : ) => (s : ), ↑(2 * W * NormalizedSinc.sincN (2 * W * (t - s))) * f s

                                                                                        The orthogonal projection P_W onto the band-limited subspace acts, a.e., as convolution with the ideal low-pass 2W sincN(2W·) (whose Fourier transform is 𝟙_[-W,W]). This is the abstract starProjection-of-a-comap-under-𝓕 ↔ concrete sinc-convolution identity, and it is what turns the operator C = Q_T ∘ P_W into an integral operator with the Hilbert–Schmidt kernel sincConvKernel.

                                                                                        The sign precondition 0 ≤ W is necessary, not cosmetic: sincN is even, so for W < 0 the stated kernel 2W sincN(2W·) is minus the ideal low-pass at |W|, while the left-hand side collapses to 0 (bandLimitSubspace_eq_bot_of_nonpos). Concretely at W = -1, f = 𝟙_[0,1], t = 1/2 the right-hand side is -∫_(-1)^(1) sincN ≈ -1.179 ≠ 0, so the unrestricted statement is false; 0 ≤ W is a precondition on the parameter, not a hypothesis carrying the proof.

                                                                                        The proof factors through the spectral cutoff bandLimitSpec W f = 𝟙_[-W,W]·𝓕f: the abstract half fourier_bandLimitProj_apply_ae identifies 𝓕(P_W f) with it, and since it is supported in a bounded interval it lies in L¹ ∩ L², so the Fourier bridge ShannonHartley.l2FourierInv_eq_fourierIntegralInv evaluates P_W f = 𝓕⁻¹(bandLimitSpec W f) pointwise as an integral (bandLimitProj_coeFn_ae_eq_fourierInv). That integral is then identified with the sinc convolution by Plancherel against the spectral boxcar, whose inverse transform is already known to be a shifted sinc (ShannonHartley.fourier_shiftSinc_toLp). The degenerate W = 0 band is a null set, where both sides vanish. @audit:ok

                                                                                        Used by
                                                                                          theorem

                                                                                          InformationTheory.Shannon.TimeBandLimiting.star_zero_Lp

                                                                                          source
                                                                                          :
                                                                                          star 0 = 0
                                                                                          Used by
                                                                                            theorem

                                                                                            InformationTheory.Shannon.TimeBandLimiting.star_add_Lp

                                                                                            source
                                                                                            (f g : E) :
                                                                                            star (f + g) = star f + star g
                                                                                            Used by
                                                                                              theorem

                                                                                              InformationTheory.Shannon.TimeBandLimiting.star_smul_Lp

                                                                                              source
                                                                                              (c : ) (f : E) :
                                                                                              Used by
                                                                                                noncomputable def

                                                                                                InformationTheory.Shannon.TimeBandLimiting.starₗE

                                                                                                source

                                                                                                Complex conjugation on L²(ℝ;ℂ) as a conjugate-linear map. Mathlib equips Lp with a bare Star instance only (no StarAddMonoid / StarModule), so the additivity and conjugate-homogeneity that bundle it into a semilinear map are supplied here by star_add_Lp / star_smul_Lp.

                                                                                                Equations
                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                Instances For
                                                                                                  Used by
                                                                                                    theorem

                                                                                                    InformationTheory.Shannon.TimeBandLimiting.timeLimitProj_star

                                                                                                    source
                                                                                                    Used by
                                                                                                      theorem

                                                                                                      InformationTheory.Shannon.TimeBandLimiting.bandLimitProj_star

                                                                                                      source
                                                                                                      Used by
                                                                                                        theorem

                                                                                                        InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_star_comm

                                                                                                        source
                                                                                                        (T W : ) (f : E) :

                                                                                                        A = P_W ∘ Q_T ∘ P_W commutes with complex conjugation: each factor does, since the time window [0,T] and the symmetric band [-W,W] are conjugation-invariant. Stated for all W; for W < 0 the band is empty and both sides collapse to 0. sorryAx-free, no hypotheses (no hW) so the statement is universal, not weakened. @audit:ok

                                                                                                        Used by
                                                                                                          theorem

                                                                                                          InformationTheory.Shannon.TimeBandLimiting.sincN_memLp_two

                                                                                                          source

                                                                                                          The normalized sinc is square-integrable on . The reusable crux for the kernel- bound: its Lebesgue -membership follows from the elementary majorant sincN(x)² ≤ 2/(1 + x²) (|sincN| ≤ 1 near 0, sincN(x)² = sin²(πx)/(πx)² ≤ 1/(πx)² away from it) against the integrable 2/(1 + x²). Mathlib's Real.integrable_sinc is finite-measure-only, so the Lebesgue fact is built here. @audit:ok

                                                                                                          Used by
                                                                                                            theorem

                                                                                                            InformationTheory.Shannon.TimeBandLimiting.sincConvKernel_memLp

                                                                                                            source

                                                                                                            sincConvKernel is square-integrable on ℝ × ℝ: the t-indicator confines the mass to [0,T] and the inner mass ∫_ℝ (2W sincN(2W(t−s)))² ds is a finite constant C (independent of t, by translation invariance of Lebesgue measure), so ‖k‖₂² ≤ C · vol[0,T] < ∞. The finite mass of the ideal low-pass 2W sincN(2W·) is obtained by rescaling the 1-D crux sincN ∈ L² (sincN_memLp_two) through integrable_comp_mul_left_iff, and the 2-D lift is a Tonelli (lintegral_prod_le) + lintegral_sub_left_eq_self computation. Hypothesis-free in T and W: the degenerate T < 0 (empty [0,T], zero mass) and 2W = 0 (zero kernel) cases are both covered. @audit:ok

                                                                                                            Used by

                                                                                                              The Hilbert–Schmidt machinery #

                                                                                                              Mathlib has no Hilbert–Schmidt / Schatten API, so the " kernel ⟹ compact operator" implication is built here from scratch. The construction is deliberately reusable: l2KernelOp is the continuous linear map sending a kernel κ ∈ L²(ℝ × ℝ) to the integral operator it induces on L²(ℝ), with the Hilbert–Schmidt bound ‖l2KernelOp κ‖ ≤ ‖κ‖ built into its construction.

                                                                                                              Compactness then follows from a soft argument: {κ | IsCompactOperator (l2KernelOp κ)} is a closed submodule of L²(ℝ × ℝ) (closed because l2KernelOp is continuous and the compact operators are closed in the operator norm), it contains every rectangle indicator 𝟙_{A×B} (those induce rank-one operators), and rectangles generate the product σ-algebra — so a π-λ induction plus Lp.induction push membership to the whole space.

                                                                                                              abbrev

                                                                                                              InformationTheory.Shannon.TimeBandLimiting.L2Kernel

                                                                                                              source
                                                                                                              @[reducible, inline]

                                                                                                              The L²(ℝ × ℝ; ℂ) space of Hilbert–Schmidt kernels.

                                                                                                              Equations
                                                                                                              Instances For
                                                                                                                Used by
                                                                                                                  noncomputable def

                                                                                                                  InformationTheory.Shannon.TimeBandLimiting.l2KernelApply

                                                                                                                  source
                                                                                                                  (κ : L2Kernel) (f : E) :

                                                                                                                  The integral operator attached to a kernel, at the level of raw functions: f ↦ (t ↦ ∫ k(t,s) f(s) ds).

                                                                                                                  Equations
                                                                                                                  Instances For
                                                                                                                    Used by
                                                                                                                      theorem

                                                                                                                      InformationTheory.Shannon.TimeBandLimiting.l2Kernel_slice_memLp

                                                                                                                      source
                                                                                                                      (κ : L2Kernel) :
                                                                                                                      ∀ᵐ (t : ), MeasureTheory.MemLp (fun (s : ) => κ (t, s)) 2 MeasureTheory.volume
                                                                                                                      Used by
                                                                                                                        theorem

                                                                                                                        InformationTheory.Shannon.TimeBandLimiting.l2Kernel_integrable

                                                                                                                        source
                                                                                                                        (κ : L2Kernel) (f : E) :
                                                                                                                        ∀ᵐ (t : ), MeasureTheory.Integrable (fun (s : ) => κ (t, s) * f s) MeasureTheory.volume
                                                                                                                        Used by
                                                                                                                          theorem

                                                                                                                          InformationTheory.Shannon.TimeBandLimiting.l2KernelApply_aestronglyMeasurable

                                                                                                                          source
                                                                                                                          Used by
                                                                                                                            theorem

                                                                                                                            InformationTheory.Shannon.TimeBandLimiting.l2KernelApply_eLpNorm_le

                                                                                                                            source
                                                                                                                            Used by
                                                                                                                              theorem

                                                                                                                              InformationTheory.Shannon.TimeBandLimiting.l2KernelApply_memLp

                                                                                                                              source
                                                                                                                              Used by
                                                                                                                                noncomputable def

                                                                                                                                InformationTheory.Shannon.TimeBandLimiting.l2KernelLin

                                                                                                                                source

                                                                                                                                The integral operator of a kernel, as a linear map on L²(ℝ;ℂ).

                                                                                                                                Equations
                                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                                Instances For
                                                                                                                                  Used by
                                                                                                                                    theorem

                                                                                                                                    InformationTheory.Shannon.TimeBandLimiting.l2KernelLin_coeFn

                                                                                                                                    source
                                                                                                                                    Used by
                                                                                                                                      noncomputable def

                                                                                                                                      InformationTheory.Shannon.TimeBandLimiting.l2KernelBilin

                                                                                                                                      source

                                                                                                                                      The kernel-to-operator map, as a bilinear map.

                                                                                                                                      Equations
                                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                                      Instances For
                                                                                                                                        Used by
                                                                                                                                          noncomputable def

                                                                                                                                          InformationTheory.Shannon.TimeBandLimiting.l2KernelOp

                                                                                                                                          source

                                                                                                                                          The kernel-to-operator map κ ↦ (f ↦ ∫ κ(·,s) f(s) ds), as a continuous linear map. Its continuity is exactly the Hilbert–Schmidt bound ‖l2KernelOp κ‖ ≤ ‖κ‖. @audit:ok

                                                                                                                                          Equations
                                                                                                                                          Instances For
                                                                                                                                            Used by
                                                                                                                                              theorem

                                                                                                                                              InformationTheory.Shannon.TimeBandLimiting.l2KernelOp_apply_ae

                                                                                                                                              source
                                                                                                                                              Used by
                                                                                                                                                theorem

                                                                                                                                                InformationTheory.Shannon.TimeBandLimiting.l2KernelOp_indicator_prod_isCompact

                                                                                                                                                source

                                                                                                                                                A rectangle kernel c · 𝟙_{A×B} induces a rank-one operator, hence a compact one. The degenerate branch (vol A * vol B = 0, which by 0 * ∞ = 0 in ℝ≥0∞ also covers a null side paired with an infinite one) is not an escape: Measure.prod_prod makes the rectangle product-null, so the kernel is the zero element of L²(ℝ × ℝ) and the induced operator really is 0. @audit:ok

                                                                                                                                                Used by

                                                                                                                                                  Reduction of a general kernel to rectangle indicators #

                                                                                                                                                  Three small generic indicatorConstLp facts, then the exhausting squares [-R,R]².

                                                                                                                                                  theorem

                                                                                                                                                  InformationTheory.Shannon.TimeBandLimiting.indicatorConstLp_congr_set

                                                                                                                                                  source
                                                                                                                                                  {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α} (hs : MeasurableSet s) (hμs : μ s ) (ht : MeasurableSet t) (hμt : μ t ) (h : s = t) (c : ) :
                                                                                                                                                  Used by
                                                                                                                                                    theorem

                                                                                                                                                    InformationTheory.Shannon.TimeBandLimiting.indicatorConstLp_of_measure_zero

                                                                                                                                                    source
                                                                                                                                                    {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} (hs : MeasurableSet s) (hμs : μ s ) (h0 : μ s = 0) (c : ) :
                                                                                                                                                    Used by
                                                                                                                                                      theorem

                                                                                                                                                      InformationTheory.Shannon.TimeBandLimiting.indicatorConstLp_eq_smul_one

                                                                                                                                                      source
                                                                                                                                                      {α : Type u_1} [MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} (hs : MeasurableSet s) (hμs : μ s ) (c : ) :
                                                                                                                                                      Used by
                                                                                                                                                        def

                                                                                                                                                        InformationTheory.Shannon.TimeBandLimiting.kernelBox

                                                                                                                                                        source
                                                                                                                                                        (R : ) :

                                                                                                                                                        The exhausting family of squares [-R,R] × [-R,R] in ℝ × ℝ. Each is a rectangle of finite measure, and they increase to the whole plane; intersecting with them reduces the kernel density argument to sets of finite measure.

                                                                                                                                                        Equations
                                                                                                                                                        Instances For
                                                                                                                                                          Used by
                                                                                                                                                            theorem

                                                                                                                                                            InformationTheory.Shannon.TimeBandLimiting.kernelBox_measurableSet

                                                                                                                                                            source
                                                                                                                                                            Used by
                                                                                                                                                              theorem

                                                                                                                                                              InformationTheory.Shannon.TimeBandLimiting.kernelBox_ne_top

                                                                                                                                                              source
                                                                                                                                                              Used by
                                                                                                                                                                theorem

                                                                                                                                                                InformationTheory.Shannon.TimeBandLimiting.kernelBox_inter_ne_top

                                                                                                                                                                source
                                                                                                                                                                Used by
                                                                                                                                                                  theorem

                                                                                                                                                                  InformationTheory.Shannon.TimeBandLimiting.kernelBox_mono

                                                                                                                                                                  source
                                                                                                                                                                  Used by
                                                                                                                                                                    theorem

                                                                                                                                                                    InformationTheory.Shannon.TimeBandLimiting.iUnion_kernelBox

                                                                                                                                                                    source
                                                                                                                                                                    :
                                                                                                                                                                    ⋃ (R : ), kernelBox R = Set.univ
                                                                                                                                                                    Used by
                                                                                                                                                                      theorem

                                                                                                                                                                      InformationTheory.Shannon.TimeBandLimiting.l2KernelOp_isCompact

                                                                                                                                                                      source
                                                                                                                                                                      Used by
                                                                                                                                                                        theorem

                                                                                                                                                                        InformationTheory.Shannon.TimeBandLimiting.l2KernelOperator_isCompact

                                                                                                                                                                        source
                                                                                                                                                                        {k : } (hk : MeasureTheory.MemLp (fun (p : × ) => k p.1 p.2) 2 (MeasureTheory.volume.prod MeasureTheory.volume)) :
                                                                                                                                                                        ∃ (Op : E →L[] E), (∀ (f : E), (Op f) =ᵐ[MeasureTheory.volume] fun (t : ) => (s : ), k t s * f s) IsCompactOperator Op

                                                                                                                                                                        An integral operator on L²(ℝ;ℂ) whose kernel is on ℝ × ℝ is a compact operator; it is realized a.e. as f ↦ ∫ k(·,s) f(s) ds. Built via the reusable l2KernelOp Hilbert–Schmidt machinery above (Mathlib has no Hilbert–Schmidt API). Stated existentially so the operator object is constructed together with its compactness rather than assumed; the a.e.-representation clause pins Op uniquely (an Lp element is an a.e. class), so the existential is not weakened by it. @audit:ok

                                                                                                                                                                        Used by
                                                                                                                                                                          theorem

                                                                                                                                                                          InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingComp_apply_ae

                                                                                                                                                                          source
                                                                                                                                                                          (T W : ) (hW : 0 W) (f : E) :
                                                                                                                                                                          ((timeBandLimitingComp T W) f) =ᵐ[MeasureTheory.volume] fun (t : ) => (s : ), sincConvKernel T W t s * f s

                                                                                                                                                                          The sinc integral operator C = Q_T ∘ P_W acts a.e. as the integral operator of sincConvKernel. Composition of timeLimitProj_apply_ae and bandLimitProj_apply_ae. The 0 ≤ W hypothesis is inherited from the latter as a parameter precondition and is discharged by the caller's case split. @audit:ok

                                                                                                                                                                          Used by
                                                                                                                                                                            theorem

                                                                                                                                                                            InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingComp_isCompact

                                                                                                                                                                            source

                                                                                                                                                                            The sinc integral operator C = Q_T ∘ P_W is compact. Reduction: the operator built by l2KernelOperator_isCompact for sincConvKernel coincides with C (both have the same a.e. representative, hence are equal in Lp). No sign restriction on W: for W < 0 the kernel representation is unavailable (and false), but there P_W = 0, so C = 0 is compact outright. @audit:ok

                                                                                                                                                                            Used by
                                                                                                                                                                              theorem

                                                                                                                                                                              InformationTheory.Shannon.TimeBandLimiting.timeBandLimitingOp_isCompact

                                                                                                                                                                              source

                                                                                                                                                                              The time-and-band limiting operator is compact: A = P_W ∘ C with C = Q_T ∘ P_W compact (the sinc integral operator) and P_W bounded, so A is compact by clm_comp.

                                                                                                                                                                              Unconditional: the signature carries no hypothesis on T or W, and both degenerate parameter ranges are discharged by real proofs rather than assumed away — W < 0 via bandLimitSubspace_eq_bot_of_nonpos (P_W = 0, so C = 0), T < 0 via the empty [0,T] (Q_T = 0), and W = 0 inside bandLimitProj_apply_ae as a null-band case. @audit:ok

                                                                                                                                                                              Used by