Documentation

LeanPool.EllipticPDE.Extension.LocalExtension

Local boundary extension #

Guo's Theorem III.2.2 reaches its third step with a local extension for each chart: a class on the chart's neighbourhood agreeing with the original on the part of the domain that neighbourhood meets. This file proves that statement, which is the whole content of his step 2 once the chart is in hand.

The proof composes what the chapter has built. A cutoff between two balls makes the class reach the whole region above the chart's graph, the rigid motion of the chart takes it into the coordinates the graph is written in, the reflection extends it across the graph, and the motion takes the result back. Guo's step 2 works with a function smooth up to the boundary and reads the chain rule off it; here every step is a weak gradient.

Two points where the statement is narrower than the machinery. The chart asks nothing of the gradient of its graph, as Evans' definition does not, so the proof runs on the bounded graph exists_bounded_graph supplies, whose region agrees with the chart's on exactly the ball in play. The conclusion is on a ball strictly inside the chart's, which is where the cutoff is one, and is what a partition of unity subordinate to the cover asks for anyway.

Constant before the class #

Clause (iii) of the theorem asks for a constant quantified before the class, and the chain the construction runs through re-chooses data at three places: the bounded graph of exists_bounded_graph, the cutoff between the two balls, and the bound each supplies. All three depend on the chart and the two radii alone, so exists_localExtension_bound fixes them first and lets the class come after. The bound then threads the five estimates the chain has: the cutoff's supremum, the rigid motion, the reflection, the shear, and the sum over the coordinates the motion mixes.

Main declarations #

References #

James Guo, Partial Differential Equations (Course Lecture Notes), Theorem III.2.2 (p. 20), proof step 2 (p. 21); L. C. Evans, Partial Differential Equations (2nd ed.), §5.4 Theorem 1 (p. 253).

Two seminorm estimates the chain threads #

theorem EllipticPdes.Extension.eLpNorm_sum_coord_le {d : ℕ} {p : ENNReal} (hp : 1 ≤ p) {μ : MeasureTheory.Measure (EuclideanSpace ℝ (Fin d))} {a : Fin d → ℝ} (ha : ∀ (i : Fin d), |a i| ≤ 1) {w : Fin d → EuclideanSpace ℝ (Fin d) → ℝ} (hw : ∀ (i : Fin d), MeasureTheory.AEStronglyMeasurable (w i) μ) :
MeasureTheory.eLpNorm (fun (y : EuclideanSpace ℝ (Fin d)) => ∑ i : Fin d, a i * w i y) p μ ≤ ∑ i : Fin d, MeasureTheory.eLpNorm (w i) p μ

Seminorm of a coordinate combination. A combination of finitely many classes whose coefficients are at most one in absolute value has seminorm at most the sum of theirs. This is what the rigid motion of a chart contributes, the coordinates of the image of a unit direction being at most one.

theorem EllipticPdes.Extension.eLpNorm_mul_cutoff_le {d : ℕ} {S W T : Set (EuclideanSpace ℝ (Fin d))} (hS : MeasurableSet S) (hT : MeasurableSet T) {ξ v : EuclideanSpace ℝ (Fin d) → ℝ} {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ (y : EuclideanSpace ℝ (Fin d)), ‖ξ y‖ ≤ C) (hoff : ∀ y ∉ W, ξ y = 0) (hSW : S ∩ W ⊆ T) {p : ENNReal} (hξv : MeasureTheory.AEStronglyMeasurable (fun (y : EuclideanSpace ℝ (Fin d)) => ξ y * v y) (MeasureTheory.volume.restrict S)) :

Seminorm of a class cut off inside a neighbourhood. The cutoff vanishes off W, and on S ∩ W the class is read on T, so the product over S is bounded by the supremum of the cutoff against the seminorm over T. This is what lets an estimate taken over the region above a chart's graph be stated against the domain.

theorem EllipticPdes.Extension.eLpNorm_bounded_mul_le {d : ℕ} {μ : MeasureTheory.Measure (EuclideanSpace ℝ (Fin d))} {h v : EuclideanSpace ℝ (Fin d) → ℝ} {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ (y : EuclideanSpace ℝ (Fin d)), ‖h y‖ ≤ C) {p : ENNReal} (hhv : MeasureTheory.AEStronglyMeasurable (fun (y : EuclideanSpace ℝ (Fin d)) => h y * v y) μ) :

Seminorm of a class scaled by a bounded factor, the factor written first.

The local extension #

noncomputable def EllipticPdes.Extension.localExtFun {d : ℕ} (c : C1Chart d) (γ ξ u : EuclideanSpace ℝ (Fin d) → ℝ) :

Local extension as a formula in the class. The class is read in the chart's coordinates, cut off there, extended across the flattened boundary, and returned. Every step but the class itself is fixed by the chart, its graph γ and the cutoff ξ, so the whole is linear in the class.

Equations
Instances For
    noncomputable def EllipticPdes.Extension.localExtGradFun {d : ℕ} (c : C1Chart d) (γ ξ u : EuclideanSpace ℝ (Fin d) → ℝ) (g : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) (k : Fin d) :

    Gradient of the local extension. The cutoff contributes its own derivative by the product rule, the chart's rigid motion mixes the coordinates on the way in and on the way out, and the shear and the reflection supply the rest.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      noncomputable def EllipticPdes.Extension.chartGraph {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) :

      The bounded graph the chart's extension runs on. A chart's own graph need not have a bounded gradient, which every statement about the shear asks for, and exists_bounded_graph supplies one agreeing with it on the chart's ball. The choice is made from the chart alone, before any class appears, which is what keeps the extension linear.

      Equations
      Instances For
        noncomputable def EllipticPdes.Extension.chartCutoff {d : ℕ} (x : EuclideanSpace ℝ (Fin d)) {r R : ℝ} (hrR : r < R) :

        The cutoff between the ball the extension is asked for and the chart's own. Chosen from the two radii alone, before any class appears.

        Equations
        Instances For
          theorem EllipticPdes.Extension.chartCutoff_spec {d : ℕ} (x : EuclideanSpace ℝ (Fin d)) {r R : ℝ} (hrR : r < R) :
          ContDiff ℝ (↑⊤) (chartCutoff x hrR) ∧ (∀ y ∈ Metric.closedBall x r, chartCutoff x hrR y = 1) ∧ tsupport (chartCutoff x hrR) ⊆ Metric.ball x R

          What chartCutoff was chosen for.

          noncomputable def EllipticPdes.Extension.localExt {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (u : EuclideanSpace ℝ (Fin d) → ℝ) :

          Local extension of a class. localExtFun at the graph and the cutoff the chart fixes, so the only argument left is the class.

          Equations
          Instances For
            noncomputable def EllipticPdes.Extension.localExtGrad {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (u : EuclideanSpace ℝ (Fin d) → ℝ) (g : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) :
            Fin d → EuclideanSpace ℝ (Fin d) → ℝ

            Gradient of the local extension of a class.

            Equations
            Instances For

              Guo's local boundary extension with its constant (Theorem III.2.2, proof step 2, p. 21). Near a boundary point the class extends across the boundary: on any ball strictly inside the chart's, localExt has a weak gradient there and agrees with the original on the part of the domain the ball meets, and both it and its gradient are bounded in every Lᵖ seminorm by the class and its gradient over the domain, with one constant taken before the class.

              The extension is named rather than existentially quantified, which is what lets the operator be assembled as a linear map.

              Linearity of the local extension #

              theorem EllipticPdes.Extension.localExtFun_add {d : ℕ} (c : C1Chart d) (γ ξ u v : EuclideanSpace ℝ (Fin d) → ℝ) :
              (localExtFun c γ ξ fun (y : EuclideanSpace ℝ (Fin d)) => u y + v y) = fun (y : EuclideanSpace ℝ (Fin d)) => localExtFun c γ ξ u y + localExtFun c γ ξ v y

              The chart extension of a class read through the chart is additive in the class.

              theorem EllipticPdes.Extension.localExtFun_smul {d : ℕ} (c : C1Chart d) (a : ℝ) (γ ξ u : EuclideanSpace ℝ (Fin d) → ℝ) :
              (localExtFun c γ ξ fun (y : EuclideanSpace ℝ (Fin d)) => a * u y) = fun (y : EuclideanSpace ℝ (Fin d)) => a * localExtFun c γ ξ u y

              The chart extension of a class read through the chart commutes with a scalar.

              theorem EllipticPdes.Extension.localExtGradFun_add {d : ℕ} (c : C1Chart d) (γ ξ u v : EuclideanSpace ℝ (Fin d) → ℝ) (g h : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) (k : Fin d) :
              localExtGradFun c γ ξ (fun (y : EuclideanSpace ℝ (Fin d)) => u y + v y) (fun (i : Fin d) (y : EuclideanSpace ℝ (Fin d)) => g i y + h i y) k = fun (y : EuclideanSpace ℝ (Fin d)) => localExtGradFun c γ ξ u g k y + localExtGradFun c γ ξ v h k y

              The gradient of that extension is additive in the class and its gradient.

              theorem EllipticPdes.Extension.localExtGradFun_smul {d : ℕ} (c : C1Chart d) (a : ℝ) (γ ξ u : EuclideanSpace ℝ (Fin d) → ℝ) (g : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) (k : Fin d) :
              localExtGradFun c γ ξ (fun (y : EuclideanSpace ℝ (Fin d)) => a * u y) (fun (i : Fin d) (y : EuclideanSpace ℝ (Fin d)) => a * g i y) k = fun (y : EuclideanSpace ℝ (Fin d)) => a * localExtGradFun c γ ξ u g k y

              The gradient of that extension commutes with a scalar.

              theorem EllipticPdes.Extension.localExt_add {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (u v : EuclideanSpace ℝ (Fin d) → ℝ) :
              (localExt c x hrc fun (y : EuclideanSpace ℝ (Fin d)) => u y + v y) = fun (y : EuclideanSpace ℝ (Fin d)) => localExt c x hrc u y + localExt c x hrc v y

              Local extension is additive in the class.

              theorem EllipticPdes.Extension.localExt_smul {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (a : ℝ) (u : EuclideanSpace ℝ (Fin d) → ℝ) :
              (localExt c x hrc fun (y : EuclideanSpace ℝ (Fin d)) => a * u y) = fun (y : EuclideanSpace ℝ (Fin d)) => a * localExt c x hrc u y

              Local extension commutes with a scalar.

              theorem EllipticPdes.Extension.localExtGrad_add {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (u v : EuclideanSpace ℝ (Fin d) → ℝ) (g h : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) (k : Fin d) :
              localExtGrad c x hrc (fun (y : EuclideanSpace ℝ (Fin d)) => u y + v y) (fun (i : Fin d) (y : EuclideanSpace ℝ (Fin d)) => g i y + h i y) k = fun (y : EuclideanSpace ℝ (Fin d)) => localExtGrad c x hrc u g k y + localExtGrad c x hrc v h k y

              Gradient of the local extension is additive in the class and its gradient.

              theorem EllipticPdes.Extension.localExtGrad_smul {d : ℕ} (c : C1Chart d) (x : EuclideanSpace ℝ (Fin d)) {r : ℝ} (hrc : r < c.radius) (a : ℝ) (u : EuclideanSpace ℝ (Fin d) → ℝ) (g : Fin d → EuclideanSpace ℝ (Fin d) → ℝ) (k : Fin d) :
              localExtGrad c x hrc (fun (y : EuclideanSpace ℝ (Fin d)) => a * u y) (fun (i : Fin d) (y : EuclideanSpace ℝ (Fin d)) => a * g i y) k = fun (y : EuclideanSpace ℝ (Fin d)) => a * localExtGrad c x hrc u g k y

              Gradient of the local extension commutes with a scalar.

              Guo's local boundary extension with its constant, with the extension quantified away. This is the form the gluing of step 3 consumes.

              theorem EllipticPdes.Extension.exists_localExtension {d : ℕ} (c : C1Chart d) {Ω : Set (EuclideanSpace ℝ (Fin d))} (hΩm : MeasurableSet Ω) {x : EuclideanSpace ℝ (Fin d)} (hfits : c.Fits Ω x) {r : ℝ} (hrc : r < c.radius) {u : EuclideanSpace ℝ (Fin d) → ℝ} {g : Fin d → EuclideanSpace ℝ (Fin d) → ℝ} (hu : MeasureTheory.IntegrableOn u Ω MeasureTheory.volume) (hgi : ∀ (k : Fin d), MeasureTheory.IntegrableOn (g k) Ω MeasureTheory.volume) (hwg : Embedding.HasWeakGradOn Ω u g) :

              Guo's local boundary extension (Theorem III.2.2, proof step 2, p. 21). Near a boundary point the class extends across the boundary: on any ball strictly inside the chart's, there is a class with a weak gradient there agreeing with the original on the part of the domain the ball meets.