Documentation

LeanPool.AbstractLinearControl.Background.Lp

Inputs: the space L^p(ℝ₊; U), concatenation, shifts and truncations #

This file contains the measure-theoretic plumbing on inputs used throughout the development. Nothing here is specific to control systems.

Conventions #

Main declarations #

@[reducible, inline]

Lebesgue measure on ℝ₊ = [0, ∞).

Equations
Instances For
    noncomputable def AbstractLinearControl.concat {U : Type u_1} (τ : ℝ) (u v : ℝ → U) :
    ℝ → U

    The τ-concatenation u ⋄_τ v of the paper: equal to u s for s < τ and to v (s - τ) for s ≥ τ ("play u on [0, τ), then play v").

    Equations
    Instances For

      Translations of the half-line #

      s ↦ a + s sends ℝ₊ to [a, ∞), preserving Lebesgue measure.

      s ↦ -a + s sends [a, ∞) to ℝ₊, preserving Lebesgue measure.

      Concatenation #

      theorem AbstractLinearControl.ALCS.concat_congr {U : Type u_1} {f f' g g' : ℝ → U} (a : ℝ) (hf : f =ᵐ[muPlus] f') (hg : g =ᵐ[muPlus] g') :
      concat a f g =ᵐ[muPlus] concat a f' g'

      The concatenation does not depend on the chosen representatives. For the second argument, the null set has to be transported by a translation.

      Extension by zero to the whole line #

      noncomputable def AbstractLinearControl.ALCS.zeroExt {U : Type u_1} [NormedAddCommGroup U] (f : ℝ → U) :
      ℝ → U

      Extension by zero to ℝ of a function on ℝ₊.

      Equations
      Instances For
        theorem AbstractLinearControl.ALCS.zeroExt_of_nonneg {U : Type u_1} [NormedAddCommGroup U] (f : ℝ → U) {s : ℝ} (hs : 0 ≤ s) :
        zeroExt f s = f s
        theorem AbstractLinearControl.ALCS.zeroExt_of_neg {U : Type u_1} [NormedAddCommGroup U] (f : ℝ → U) {s : ℝ} (hs : s < 0) :
        zeroExt f s = 0

        If φ preserves Lebesgue measure on ℝ, then ‖(zeroExt u) ∘ φ‖_{L^p(ℝ₊)} ≤ ‖u‖.

        An element of L^p defined from a raw function has norm at most ‖u‖ as soon as the eLpNorm of the raw function is at most that of u.

        Left shifts u ↦ u (a + ·) #

        noncomputable def AbstractLinearControl.ALCS.shiftLeft {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (a : ℝ) (u : ↥(MeasureTheory.Lp U p muPlus)) :

        The left shift s ↦ u (a + s) of an input. (For a < 0, the input is first extended by zero to negative times.)

        Equations
        Instances For
          theorem AbstractLinearControl.ALCS.shiftLeft_ae {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (a : ℝ) (u : ↥(MeasureTheory.Lp U p muPlus)) :
          ↑↑(shiftLeft a u) =ᵐ[muPlus] zeroExt ↑↑u ∘ fun (s : ℝ) => a + s
          theorem AbstractLinearControl.ALCS.concat_shiftLeft {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (a : ℝ) (ha : 0 ≤ a) (u : ↥(MeasureTheory.Lp U p muPlus)) :
          ↑↑u =ᵐ[muPlus] concat a ↑↑u ↑↑(shiftLeft a u)

          For a ≥ 0, u = u ⋄_a (shiftLeft a u).

          theorem AbstractLinearControl.ALCS.exists_shift {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (a : ℝ) (ha : 0 ≤ a) (u : ↥(MeasureTheory.Lp U p muPlus)) :
          ∃ (u₁ : ↥(MeasureTheory.Lp U p muPlus)), ‖u₁‖ ≤ ‖u‖ ∧ ↑↑u =ᵐ[muPlus] concat a ↑↑u ↑↑u₁

          Shifted input (used with τ := a in the composition property): for a ≥ 0, u₁ := u (a + ·) satisfies ‖u₁‖ ≤ ‖u‖ and u = u ⋄_a u₁.

          Delays u ↦ 0 ⋄_a u #

          theorem AbstractLinearControl.ALCS.exists_delay {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (a : ℝ) (u : ↥(MeasureTheory.Lp U p muPlus)) :
          ∃ (w : ↥(MeasureTheory.Lp U p muPlus)), ‖w‖ ≤ ‖u‖ ∧ ↑↑w =ᵐ[muPlus] concat a ↑↑0 ↑↑u

          Delayed input: the input 0 ⋄_a u (zero on [0, a), then u) belongs to L^p(ℝ₊; U), with norm at most ‖u‖.

          Truncations u ↦ u ⋄_τ 0 #

          noncomputable def AbstractLinearControl.ALCS.truncate {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (τ : ℝ) (u : ↥(MeasureTheory.Lp U p muPlus)) :

          The truncated input u ⋄_τ 0: equal to u on [0, τ) and to zero afterwards.

          Equations
          Instances For
            theorem AbstractLinearControl.ALCS.concat_truncate {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} (τ : ℝ) (u : ↥(MeasureTheory.Lp U p muPlus)) :
            ↑↑(truncate τ u) =ᵐ[muPlus] concat τ ↑↑u ↑↑0
            theorem AbstractLinearControl.ALCS.tendsto_norm_truncate {U : Type u_1} [NormedAddCommGroup U] {p : ENNReal} [Fact (1 ≤ p)] (hp : p ≠ ⊤) (u : ↥(MeasureTheory.Lp U p muPlus)) :
            Filter.Tendsto (fun (τ : ℝ) => ‖truncate τ u‖) (nhds 0) (nhds 0)

            For p < ∞, ‖u‖_{L^p(0, τ)} → 0 as τ → 0.

            Continuity of left shifts for p < ∞ #

            The translations s ↦ a + s, as continuous maps depending continuously on a.

            Equations
            Instances For

              The zero extension of u, as an element of L^p(ℝ).

              Equations
              Instances For

                The zero extension of u, translated by a, as an element of L^p(ℝ).

                Equations
                Instances For

                  ‖u (a + ·) - u‖_{L^p(ℝ₊)} ≤ ‖Z (a + ·) - Z‖_{L^p(ℝ)}, where Z is the zero extension of u.

                  Continuity of translations in L^p(ℝ₊; U) for p < ∞: u (a + ·) → u as a → 0.

                  Inputs in L^∞(ℝ₊; U) #

                  A pointwise bound gives membership in L^∞, without a finite-measure assumption.

                  theorem AbstractLinearControl.ALCS.exists_bounded_rep {U : Type u_1} [NormedAddCommGroup U] (u : ↥(MeasureTheory.Lp U ⊤ muPlus)) {C : ℝ} (hC : 0 ≤ C) (hu : ‖u‖ ≤ C) :
                  ∃ (f : ℝ → U), MeasureTheory.StronglyMeasurable f ∧ (∀ (t : ℝ), ‖f t‖ ≤ C) ∧ ↑↑u =ᵐ[muPlus] f

                  An everywhere bounded, strongly measurable representative. The representative is only modified where it exceeds C.

                  theorem AbstractLinearControl.ALCS.exists_concat {U : Type u_1} [NormedAddCommGroup U] (a : ℝ) (u v : ↥(MeasureTheory.Lp U ⊤ muPlus)) {C : ℝ} (hC : 0 ≤ C) (hu : ‖u‖ ≤ C) (hv : ‖v‖ ≤ C) :
                  ∃ (w : ↥(MeasureTheory.Lp U ⊤ muPlus)), ‖w‖ ≤ C ∧ ↑↑w =ᵐ[muPlus] concat a ↑↑u ↑↑v

                  For p = ∞, concatenation preserves a common norm bound: if ‖u‖, ‖v‖ ≤ C, then u ⋄_a v is an input of norm at most C.

                  theorem AbstractLinearControl.ALCS.norm_toLp_le {U : Type u_1} [NormedAddCommGroup U] {f : ℝ → U} (hf : MeasureTheory.MemLp f ⊤ muPlus) {C : ℝ} (hC : 0 ≤ C) (hb : ∀ (t : ℝ), ‖f t‖ ≤ C) :

                  The L^∞ class of a bounded raw function has the same bound.

                  ‖(a + b) - (c + d)‖ ≤ ‖a - c‖ + ‖b‖ + ‖d‖