1.2. Proof of Metric Space Carleson, overview
This section organizes the proof of Theorem 1.2 into sections [??], [??], [??], [??], [??], [??], and [??]. These sections are mutually independent except for referring to the statements formulated in the present section. [??] proves the main Theorem 1.2, while sections [??], [??], [??], [??], [??], and [??] each prove one proposition that is stated in the present section. The present section also introduces all definitions used across these sections.
[??] proves some auxiliary lemmas that are used in more than one of the sections 3-9.
Let a, q be given as in Theorem 1.2.
Define
D:= 2^{100 a^2},
\kappa:= 2^{-10a},
and
Z := 2^{12a}.
Let \psi:\R \to \R be the unique compactly supported, piece-wise linear,
continuous function with corners precisely at \frac 1{4D},
\frac 1{2D}, \frac 14 and \frac 12 which satisfies
\sum_{s\in \mathbb{Z}} \psi(D^{-s}x)=1
for all x>0. This function vanishes outside
[\frac1{4D},\frac 12], is constant one on
[\frac1{2D},\frac 14], and is Lipschitz with constant 4D.
Let a doubling metric measure space (X,\rho,\mu,a) be given. Let a
cancellative compatible collection \Mf of functions on X be given. Let
o\in X be a point such that \mfa(o)=0 for all \mfa\in \Mf.
Let a Borel measurable function \tQ:X\to \Mf with finite range be given.
Let a one-sided Calderon-Zygmund kernel K on X be given so that for
every \mfa\in \Mf the operator T_{\tQ}^{\mfa} defined above satisfies the
assumption linnontanbound.
For s\in\mathbb{Z}, we define
K_s(x,y):=K(x,y)\psi(D^{-s}\rho(x,y)),
so that for each x,y\in X with x\neq y we have
K(x,y)=\sum_{s\in\mathbb{Z}}K_s(x,y).
In [??], we prove Theorem 1.2 and Theorem 1.3 from the finitary version, Theorem 1.4 below. Recall that a function from a measure space to a finite set is measurable if the pre-image of each of the elements in the range is measurable.
Theorem1.4
✓L∃∀N
used by 1
Associated Lean declarations
-
finitary_carleson[complete]
Uses Theorem 1.5, Lemma 1.17, Lemma 1.18, and Lemma 1.19.
Let \sigma_1,\sigma_2\colon X\to \mathbb{Z} be measurable functions with
finite range and \sigma_1\leq \sigma_2. Let F,G be bounded Borel sets in
X. Then there is a Borel set G' in X with 2\mu(G')\leq \mu(G) such
that for all Borel functions f:X\to \C with |f|\le \mathbf{1}_F,
\int_{G \setminus G'} \left|\sum_{s={\sigma_1}(x)}^{{\sigma_2}(x)} \int K_s(x,y) f(y) e(\tQ(x)(y)) \, \mathrm{d}\mu(y) \right| \mathrm{d}\mu(x) \le \frac{2^{442a^3}}{(q-1)^5} \mu(G)^{1-\frac{1}{q}} \mu(F)^{\frac 1 q}.
Lean code for Theorem1.4●1 theorem
Associated Lean declarations
-
finitary_carleson[complete]
Associated Lean declarations
-
finitary_carleson[complete]
-
theoremdefined in Carleson/FinitaryCarleson.leancomplete
theorem finitary_carleson.{u_1}
finitary_carleson.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ∃ G', MeasurableSet G' ∧ 2 * MeasureTheory.volume G' ≤ MeasureTheory.volume G ∧ ∀ (f : X → ℂ), Measurable f → (∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) → ∫⁻ (x : X) in G \ G', ‖∑ s ∈ (Set.Icc (σ₁ x) (σ₂ x)).toFinset, ∫ (y : X), Ks s x y * f y * Complex.exp (Complex.I * ↑((Q x) y))‖ₑ ≤ ↑(C2_0_1 a (nnq X)) * MeasureTheory.volume G ^ (1 - q⁻¹) * MeasureTheory.volume F ^ q⁻¹Proposition 2.0.1(XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.) {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] : ∃ G'Set X, MeasurableSetMeasurableSet.{u_1} {α : Type u_1} [MeasurableSpace α] (s : Set α) : Prop`MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`)G'Set X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.G'Set X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.∀ (fX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.), MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ→ (∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) → ∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.GSet X\SDiff.sdiff.{u} {α : Type u} [self : SDiff α] : α → α → α`a \ b` is the set difference of `a` and `b`, consisting of all elements in `a` that are not in `b`. Conventions for notations in identifiers: * The recommended spelling of `\` in identifiers is `sdiff`.G'Set X,MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∑ sℤ∈ (Set.IccSet.Icc.{u_1} {α : Type u_1} [Preorder α] (a b : α) : Set α`Icc a b` is the left-closed right-closed interval $[a, b]$.(σ₁X → ℤxX) (σ₂X → ℤxX)).toFinsetSet.toFinset.{u_1} {α : Type u_1} (s : Set α) [Fintype ↑s] : Finset αConstruct a finset enumerating a set `s`, given a `Fintype` instance., ∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(yX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integralKsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.fX → ℂyX*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.expComplex.exp (z : ℂ) : ℂThe complex exponential function, defined via its Taylor series(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.IComplex.I : ℂThe imaginary unit.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑((QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)xX) yX))HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_1C2_0_1 (a : ℕ) (q : NNReal) : NNRealThe constant used in Proposition 2.0.1. Has value `2 ^ (442 * a ^ 3) / (q - 1) ^ 5` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1 -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.FSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.theorem finitary_carleson.{u_1}
finitary_carleson.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ∃ G', MeasurableSet G' ∧ 2 * MeasureTheory.volume G' ≤ MeasureTheory.volume G ∧ ∀ (f : X → ℂ), Measurable f → (∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) → ∫⁻ (x : X) in G \ G', ‖∑ s ∈ (Set.Icc (σ₁ x) (σ₂ x)).toFinset, ∫ (y : X), Ks s x y * f y * Complex.exp (Complex.I * ↑((Q x) y))‖ₑ ≤ ↑(C2_0_1 a (nnq X)) * MeasureTheory.volume G ^ (1 - q⁻¹) * MeasureTheory.volume F ^ q⁻¹Proposition 2.0.1(XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.) {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] : ∃ G'Set X, MeasurableSetMeasurableSet.{u_1} {α : Type u_1} [MeasurableSpace α] (s : Set α) : Prop`MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`)G'Set X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.G'Set X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.∀ (fX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.), MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ→ (∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) → ∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.GSet X\SDiff.sdiff.{u} {α : Type u} [self : SDiff α] : α → α → α`a \ b` is the set difference of `a` and `b`, consisting of all elements in `a` that are not in `b`. Conventions for notations in identifiers: * The recommended spelling of `\` in identifiers is `sdiff`.G'Set X,MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∑ sℤ∈ (Set.IccSet.Icc.{u_1} {α : Type u_1} [Preorder α] (a b : α) : Set α`Icc a b` is the left-closed right-closed interval $[a, b]$.(σ₁X → ℤxX) (σ₂X → ℤxX)).toFinsetSet.toFinset.{u_1} {α : Type u_1} (s : Set α) [Fintype ↑s] : Finset αConstruct a finset enumerating a set `s`, given a `Fintype` instance., ∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(yX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integralKsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.fX → ℂyX*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.expComplex.exp (z : ℂ) : ℂThe complex exponential function, defined via its Taylor series(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.IComplex.I : ℂThe imaginary unit.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑((QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)xX) yX))HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_1C2_0_1 (a : ℕ) (q : NNReal) : NNRealThe constant used in Proposition 2.0.1. Has value `2 ^ (442 * a ^ 3) / (q - 1) ^ 5` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1 -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.FSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.Proposition 2.0.1
Let measurable functions \sigma_1\leq \sigma_2\colon X\to \mathbb{Z} with
finite range be given. Let bounded Borel sets F,G in X be given. Let
S be the smallest integer such that the ranges of \sigma_1 and
\sigma_2 are contained in [-S,S] and F and G are contained in the
ball B(o, \frac{1}{4}D^S).
In [??], we prove Theorem 1.4 using a bound for a dyadic model formulated in Theorem 1.5 below.
A grid structure (\mathcal{D}, c, s) on X consists of a finite
collection \mathcal{D} of pairs (I,k) of Borel sets in X and integers
k \in [-S,S], the projection s\colon \mathcal{D}\to [-S,S], (I,k)\mapsto
k to the second component which is assumed to be surjective and called scale
function, and a function c:\mathcal{D}\to X called center function such
that the five properties coverdyadic, dyadicproperty, subsetmaxcube,
eq-vol-sp-cube, and eq-small-boundary hold. We call the elements of
\mathcal{D} dyadic cubes. By abuse of notation, we will usually write just
I for the cube (I,k), and we will write I \subset J to mean that for
two cubes (I,k), (J,l) \in \mathcal{D} we have I \subset J and
k \le l.
For each dyadic cube I and each -S\le k<s(I) we have
I\subset \bigcup_{J\in \mathcal {D}: s(J)=k}J.
Any two non-disjoint dyadic cubes I,J with s(I)\le s(J) satisfy
I\subset J.
There exists a I_0 \in \mathcal{D} with s(I_0) = S and c(I_0) = o and
for all cubes J \in \mathcal{D}, we have
J \subset I_0.
For any dyadic cube I,
c(I)\in B(c(I), \frac{1}{4} D^{s(I)}) \subset I \subset B(c(I), 4 D^{s(I)}).
For any dyadic cube I and any t with tD^{s(I)} \ge D^{-S},
\mu(\{x \in I \ : \ \rho(x, X \setminus I) \leq t D^{s(I)}\}) \le 2 t^\kappa \mu(I).
A tile structure (\fP,\scI,\fc,\fcc,\pc,\ps) for a given grid structure
(\mathcal{D}, c, s) is a finite set \fP of elements called tiles with
five maps
\scI\colon \fP\to {\mathcal{D}}
\fc\colon \fP\to \mathcal{P}(\Mf)
\fcc \colon \fP\to \tQ(X)
\pc \colon \fP\to X
\ps \colon \fP\to \mathbb{Z}
with \scI surjective and \mathcal{P}(\Mf) denoting the power set of
\Mf such that the five properties eq-dis-freq-cover,
eq-freq-dyadic, eq-freq-comp-ball, tilecenter, and tilescale hold.
For each dyadic cube I, the restriction of the map \Omega to the set
\fP(I)=\{\fp: \scI(\fp) =I\}
is injective and we have the disjoint covering property
\tQ(X)\subset \dot{\bigcup}_{\fp\in \fP(I)}\fc(\fp).
For any tiles \fp,\fq with \scI(\fp)\subset \scI(\fq) and
\fc(\fp) \cap \fc(\fq) \neq \emptyset we have
\fc(\fq)\subset \fc(\fp).
For each tile \fp,
\fcc(\fp)\in B_{\fp}(\fcc(\fp), 0.2) \subset \fc(\fp) \subset B_{\fp}(\fcc(\fp),1),
where
B_{\fp} (\mfa, R) := \{\mfb \in \Mf \, : \, d_{\fp}(\mfa, \mfb) < R\},
and
d_{\fp} := d_{B(\pc(\fp),\frac 14 D^{\ps(\fp)})}.
We have for each tile \fp
\pc(\fp)=c(\scI(\fp)),
\ps(\fp)=s(\scI(\fp)).
Theorem1.5
✓L∃∀N
used by 1
Associated Lean declarations
-
discrete_carleson[complete]
Uses Lemma 1.32, Lemma 1.33, and Lemma 1.34.
Let (\mathcal{D}, c, s) be a grid structure and
(\fP,\scI,\fc,\fcc,\pc,\ps)
a tile structure for this grid structure. Define for \fp\in \fP
E(\fp)=\{x\in \scI(\fp): \tQ(x)\in \fc(\fp) , {\sigma_1}(x)\le \ps(\fp)\le {\sigma_2}(x)\}
and
T_{\fp} f(x)= \mathbf{1}_{E(\fp)}(x) \int K_{\ps(\fp)}(x,y) f(y) e(\tQ(x)(y)-\tQ(x)(x))\, d\mu(y).
Then there exists a Borel set G' with 2\mu(G') \leq \mu(G) such that for
all Borel functions f:X\to \C with |f|\le \mathbf{1}_F we have
\int_{G \setminus G'} \left| \sum_{\fp \in \fP} T_{\fp} f (x) \right| \, \mathrm{d}\mu(x) \le \frac{2^{442a^3}}{(q-1)^5} \mu(G)^{1-\frac{1}{q}} \mu(F)^{\frac{1}{q}}.
Lean code for Theorem1.5●1 theorem
Associated Lean declarations
-
discrete_carleson[complete]
Associated Lean declarations
-
discrete_carleson[complete]
-
theoremdefined in Carleson/Discrete/MainTheorem.leancomplete
theorem discrete_carleson.{u_1}
discrete_carleson.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] : ∃ G', MeasurableSet G' ∧ 2 * MeasureTheory.volume G' ≤ MeasureTheory.volume G ∧ ∀ (f : X → ℂ), Measurable f → (∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) → ∫⁻ (x : X) in G \ G', ‖carlesonSum Set.univ f x‖ₑ ≤ ↑(C2_0_2 a (nnq X)) * MeasureTheory.volume G ^ (1 - q⁻¹) * MeasureTheory.volume F ^ q⁻¹(XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.) {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] : ∃ G'Set X, MeasurableSetMeasurableSet.{u_1} {α : Type u_1} [MeasurableSpace α] (s : Set α) : Prop`MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`)G'Set X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.G'Set X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.∀ (fX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.), MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ→ (∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) → ∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.GSet X\SDiff.sdiff.{u} {α : Type u} [self : SDiff α] : α → α → α`a \ b` is the set difference of `a` and `b`, consisting of all elements in `a` that are not in `b`. Conventions for notations in identifiers: * The recommended spelling of `\` in identifiers is `sdiff`.G'Set X,MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.Set.univSet.univ.{u} {α : Type u} : Set αThe universal set on a type `α` is the set containing all elements of `α`. This is conceptually the "same as" `α` (in set theory, it is actually the same), but type theory makes the distinction that `α` is a type while `Set.univ` is a term of type `Set α`. `Set.univ` can itself be coerced to a type `↥Set.univ` which is in bijection with (but distinct from) `α`.fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_2C2_0_2 (a : ℕ) (q : NNReal) : NNRealThe constant used in Proposition 2.0.2. Has value `2 ^ (442 * a ^ 3) / (q - 1) ^ 5` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1 -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.FSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.theorem discrete_carleson.{u_1}
discrete_carleson.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] : ∃ G', MeasurableSet G' ∧ 2 * MeasureTheory.volume G' ≤ MeasureTheory.volume G ∧ ∀ (f : X → ℂ), Measurable f → (∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) → ∫⁻ (x : X) in G \ G', ‖carlesonSum Set.univ f x‖ₑ ≤ ↑(C2_0_2 a (nnq X)) * MeasureTheory.volume G ^ (1 - q⁻¹) * MeasureTheory.volume F ^ q⁻¹(XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.) {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] : ∃ G'Set X, MeasurableSetMeasurableSet.{u_1} {α : Type u_1} [MeasurableSpace α] (s : Set α) : Prop`MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`)G'Set X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.G'Set X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.∀ (fX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.), MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ→ (∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) → ∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.GSet X\SDiff.sdiff.{u} {α : Type u} [self : SDiff α] : α → α → α`a \ b` is the set difference of `a` and `b`, consisting of all elements in `a` that are not in `b`. Conventions for notations in identifiers: * The recommended spelling of `\` in identifiers is `sdiff`.G'Set X,MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.Set.univSet.univ.{u} {α : Type u} : Set αThe universal set on a type `α` is the set containing all elements of `α`. This is conceptually the "same as" `α` (in set theory, it is actually the same), but type theory makes the distinction that `α` is a type while `Set.univ` is a term of type `Set α`. `Set.univ` can itself be coerced to a type `↥Set.univ` which is in bijection with (but distinct from) `α`.fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_2C2_0_2 (a : ℕ) (q : NNReal) : NNRealThe constant used in Proposition 2.0.2. Has value `2 ^ (442 * a ^ 3) / (q - 1) ^ 5` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.GSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1 -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.FSet X^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.
The proof of Theorem 1.5 is done in [??] by a reduction to two further propositions that we state below.
Fix a grid structure (\mathcal{D}, c, s) and a tile structure
(\fP,\scI,\fc,\fcc,\pc,\ps) for this grid structure.
We define the relation
\fp\le \fp'
on \fP\times \fP meaning \scI(\fp)\subset \scI(\fp') and
\Omega(\fp')\subset \Omega(\fp). We further define for \lambda,\lambda' >0
the relation
\lambda \fp \lesssim \lambda' \fp'
on \fP\times \fP meaning \scI(\fp)\subset \scI(\fp') and
B_{\fp'}(\fcc(\fp'),\lambda') \subset B_{\fp}(\fcc(\fp),\lambda).
Define for a tile \fp and \lambda>0
E_1(\fp):=\{x\in \scI(\fp)\cap G: \tQ(x)\in \fc(\fp)\},
E_2(\lambda, \fp):=\{x\in \scI(\fp)\cap G: \tQ(x)\in B_{\fp}(\fcc(\fp), \lambda)\}.
Given a subset \fP' of \fP, we define \fP(\fP') to be the set of all
\fp \in \fP such that there exist \fp' \in \fP' with
\scI(\fp)\subset \scI(\fp'). Define the densities
{\dens}_1(\fP') := \sup_{\fp'\in \fP'}\sup_{\lambda \geq 2} \lambda^{-a} \sup_{\fp \in \fP(\fP'), \lambda \fp' \lesssim \lambda \fp}
\frac{\mu({E}_2(\lambda, \fp))}{\mu(\scI(\fp))},
{\dens}_2(\fP') := \sup_{\fp'\in \fP'}
\sup_{r\ge 4D^{\ps(\fp)}}
\frac{\mu(F\cap B(\pc(\fp),r))}{\mu(B(\pc(\fp),r))}.
An antichain is a subset \mathfrak{A} of \fP such that for any distinct
\fp,\fq\in \mathfrak{A} we do not have \fp\le \fq.
The following proposition is proved in [??].
Theorem1.6
✓L∃∀N
used by 1
Associated Lean declarations
-
antichain_operator[complete]
Uses Lemma 1.71 and Lemma 1.72.
For any antichain \mathfrak{A} and for all f:X\to \C with
|f|\le \mathbf{1}_F and all g:X\to\C with |g| \le \mathbf{1}_G
|\int \overline{g(x)} \sum_{\fp \in \mathfrak{A}} T_{\fp} f(x)\, d\mu(x)| \le \frac{2^{117a^3}}{q-1} \dens_1(\mathfrak{A})^{\frac {q-1}{8a^4}}\dens_2(\mathfrak{A})^{\frac 1{q}-\frac 12} \|f\|_2 \|g\|_2.
Lean code for Theorem1.6●1 theorem
Associated Lean declarations
-
antichain_operator[complete]
Associated Lean declarations
-
antichain_operator[complete]
-
theoremdefined in Carleson/Antichain/AntichainOperator.leancomplete
theorem antichain_operator.{u_1}
antichain_operator.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {𝔄 : Set (𝔓 X)} {f g : X → ℂ} (h𝔄 : IsAntichain (fun x1 x2 ↦ x1 ≤ x2) 𝔄) (hf : Measurable f) (hf1 : ∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) (hg : Measurable g) (hg1 : ∀ (x : X), ‖g x‖ ≤ G.indicator 1 x) : ‖∫ (x : X), (starRingEnd ℂ) (g x) * carlesonSum 𝔄 f x‖ₑ ≤ ↑(C2_0_3 a (nnq X)) * dens₁ 𝔄 ^ ((q - 1) / (8 * ↑a ^ 4)) * dens₂ 𝔄 ^ (q⁻¹ - 2⁻¹) * MeasureTheory.eLpNorm f 2 MeasureTheory.volume * MeasureTheory.eLpNorm g 2 MeasureTheory.volumeProposition 2.0.3.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {𝔄Set (𝔓 X): SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.(𝔓𝔓.{u, u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [FunctionDistances 𝕜 X] {Q : MeasureTheory.SimpleFunc X (Θ X)} [PreTileStructure Q D κ S o] : Type uXType u_1)} {fX → ℂgX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (h𝔄IsAntichain (fun x1 x2 ↦ x1 ≤ x2) 𝔄: IsAntichainIsAntichain.{u_1} {α : Type u_1} (r : α → α → Prop) (s : Set α) : PropAn antichain is a set such that no two distinct elements are related.(fun x1𝔓 Xx2𝔓 X↦ x1𝔓 X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.x2𝔓 X) 𝔄Set (𝔓 X)) (hfMeasurable f: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ) (hf1∀ (x : X), ‖f x‖ ≤ F.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) (hgMeasurable g: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.gX → ℂ) (hg1∀ (x : X), ‖g x‖ ≤ G.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.gX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.GSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(starRingEndstarRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R`star` as a ring endomorphism, for commutative `R`. This is used to denote complex conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`. Note that this is the preferred form (over `starRingAut`, available under the same hypotheses) because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the case for `(↑starRingAut : R →* R)`.ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.) (gX → ℂxX) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.𝔄Set (𝔓 X)fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_3C2_0_3 (a : ℕ) (q : NNReal) : NNRealThe constant appearing in Proposition 2.0.3. Has value `2 ^ (117 * a ^ 3)` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₁dens₁.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.𝔄Set (𝔓 X)^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator)./HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.8 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.4)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₂dens₂.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.𝔄Set (𝔓 X)^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).2⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.fX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.gX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.theorem antichain_operator.{u_1}
antichain_operator.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {𝔄 : Set (𝔓 X)} {f g : X → ℂ} (h𝔄 : IsAntichain (fun x1 x2 ↦ x1 ≤ x2) 𝔄) (hf : Measurable f) (hf1 : ∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) (hg : Measurable g) (hg1 : ∀ (x : X), ‖g x‖ ≤ G.indicator 1 x) : ‖∫ (x : X), (starRingEnd ℂ) (g x) * carlesonSum 𝔄 f x‖ₑ ≤ ↑(C2_0_3 a (nnq X)) * dens₁ 𝔄 ^ ((q - 1) / (8 * ↑a ^ 4)) * dens₂ 𝔄 ^ (q⁻¹ - 2⁻¹) * MeasureTheory.eLpNorm f 2 MeasureTheory.volume * MeasureTheory.eLpNorm g 2 MeasureTheory.volumeProposition 2.0.3.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {𝔄Set (𝔓 X): SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.(𝔓𝔓.{u, u_1, u_2} {𝕜 : Type u_1} [RCLike 𝕜] (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [FunctionDistances 𝕜 X] {Q : MeasureTheory.SimpleFunc X (Θ X)} [PreTileStructure Q D κ S o] : Type uXType u_1)} {fX → ℂgX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (h𝔄IsAntichain (fun x1 x2 ↦ x1 ≤ x2) 𝔄: IsAntichainIsAntichain.{u_1} {α : Type u_1} (r : α → α → Prop) (s : Set α) : PropAn antichain is a set such that no two distinct elements are related.(fun x1𝔓 Xx2𝔓 X↦ x1𝔓 X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.x2𝔓 X) 𝔄Set (𝔓 X)) (hfMeasurable f: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ) (hf1∀ (x : X), ‖f x‖ ≤ F.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) (hgMeasurable g: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.gX → ℂ) (hg1∀ (x : X), ‖g x‖ ≤ G.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.gX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.GSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(starRingEndstarRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R`star` as a ring endomorphism, for commutative `R`. This is used to denote complex conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`. Note that this is the preferred form (over `starRingAut`, available under the same hypotheses) because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the case for `(↑starRingAut : R →* R)`.ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.) (gX → ℂxX) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.𝔄Set (𝔓 X)fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_3C2_0_3 (a : ℕ) (q : NNReal) : NNRealThe constant appearing in Proposition 2.0.3. Has value `2 ^ (117 * a ^ 3)` in the blueprint.aℕ(nnqnnq.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : NNReal`q` as an element of `ℝ≥0`.XType u_1)) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₁dens₁.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.𝔄Set (𝔓 X)^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator)./HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.8 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.4)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₂dens₂.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.𝔄Set (𝔓 X)^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).2⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.fX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.gX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.Proposition 2.0.3.
Let n\ge 0. An n-forest is a pair (\fU, \mathfrak{T}) where \fU
is a subset of \fP and \mathfrak{T} is a map assigning to each
\fu\in \fU a nonempty set \fT (\fu)\subset \fP called tree such that the
following properties forest1, forest2, forest3, forest4, forest5,
and forest6 hold.
For each \fu\in \fU and each \fp\in \fT(\fu) we have
\scI(\fp) \ne \scI(\fu) and
4\fp\lesssim \fu.
For each \fu \in \fU and each \fp,\fp''\in \fT(\fu) and
\fp'\in \fP we have
\fp, \fp'' \in \mathfrak{T}(\fu), \fp \leq \fp' \leq \fp'' \implies \fp' \in \mathfrak{T}(\fu).
We have
\|\sum_{\fu\in \fU} \mathbf{1}_{\scI(\fu)}\|_\infty \leq 2^n.
We have for every \fu\in \fU
\dens_1(\fT(\fu))\le 2^{4a + 1-n}.
We have for \fu, \fu'\in \fU with \fu\neq \fu' and
\fp\in \fT(\fu') with \scI(\fp)\subset \scI(\fu) that
d_{\fp}(\fcc(\fp), \fcc(\fu))>2^{Z(n+1)}.
We have for every \fu\in \fU and \fp\in \fT(\fu) that
B(\pc(\fp), 8D^{\ps(\fp)})\subset \scI(\fu).
The following proposition is proved in [??].
Theorem1.7
✓L∃∀N
used by 1
Associated Lean declarations
-
forest_operator[complete]
Uses Lemma 1.117, Lemma 1.118, Lemma 1.119, and Lemma 1.120.
For any n\ge 0 and any n-forest (\fU,\fT) we have for all
f,g: X \to \mathbb{C} with |f| \le \mathbf{1}_F and
|g| \le \mathbf{1}_G
| \int \overline{g(x)} \sum_{\fu\in \fU} \sum_{\fp\in \fT(\fu)} T_{\fp} f(x) \, \mathrm{d}\mu(x)|
\le
2^{440a^3}2^{-\frac{q-1}{q} n} \dens_2\left(\bigcup_{\fu\in \fU}\fT(\fu)\right)^{\frac{1}{q}-\frac{1}{2}} \|f\|_2 \|g\|_2.
Lean code for Theorem1.7●1 theorem
Associated Lean declarations
-
forest_operator[complete]
Associated Lean declarations
-
forest_operator[complete]
-
theoremdefined in Carleson/ForestOperator/Forests.leancomplete
theorem forest_operator.{u_1}
forest_operator.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (𝔉 : TileStructure.Forest X n) {f g : X → ℂ} (hf : Measurable f) (h2f : ∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) (hg : Measurable g) (h2g : ∀ (x : X), ‖g x‖ ≤ G.indicator 1 x) : ‖∫ (x : X), (starRingEnd ℂ) (g x) * ∑ u with u ∈ 𝔉, carlesonSum ((fun x ↦ 𝔉.𝔗 x) u) f x‖ₑ ≤ ↑(C2_0_4 a q n) * dens₂ (⋃ u ∈ 𝔉, (fun x ↦ 𝔉.𝔗 x) u) ^ (q⁻¹ - 2⁻¹) * MeasureTheory.eLpNorm f 2 MeasureTheory.volume * MeasureTheory.eLpNorm g 2 MeasureTheory.volume{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {nℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} (𝔉TileStructure.Forest X n: TileStructure.ForestTileStructure.Forest.{u_1} (X : Type u_1) [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (n : ℕ) : Type u_1An `n`-forestXType u_1nℕ) {fX → ℂgX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (hfMeasurable f: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ) (h2f∀ (x : X), ‖f x‖ ≤ F.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) (hgMeasurable g: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.gX → ℂ) (h2g∀ (x : X), ‖g x‖ ≤ G.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.gX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.GSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(starRingEndstarRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R`star` as a ring endomorphism, for commutative `R`. This is used to denote complex conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`. Note that this is the preferred form (over `starRingAut`, available under the same hypotheses) because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the case for `(↑starRingAut : R →* R)`.ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.) (gX → ℂxX) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.∑ u𝔓 Xwith u𝔓 X∈Membership.mem.{u, v} {α : outParam (Type u)} {γ : Type v} [self : Membership α γ] : γ → α → PropThe membership relation `a ∈ s : Prop` where `a : α`, `s : γ`. Conventions for notations in identifiers: * The recommended spelling of `∈` in identifiers is `mem`.𝔉TileStructure.Forest X n, carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.((fun x𝔓 X↦ 𝔉TileStructure.Forest X n.𝔗TileStructure.Forest.𝔗.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (self : TileStructure.Forest X n) : 𝔓 X → Set (𝔓 X)The value of `𝔗 u` only matters when `u ∈ 𝔘`.x𝔓 X) u𝔓 X) fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_4C2_0_4 (a : ℕ) (q : ℝ) (n : ℕ) : NNRealThe constant used in `forest_operator`. Has value `2 ^ (440 * a ^ 3 - (q - 1) / q * n)` in the blueprint.aℕqℝnℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₂dens₂.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.(⋃ u𝔓 X∈ 𝔉TileStructure.Forest X n, (fun x𝔓 X↦ 𝔉TileStructure.Forest X n.𝔗TileStructure.Forest.𝔗.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (self : TileStructure.Forest X n) : 𝔓 X → Set (𝔓 X)The value of `𝔗 u` only matters when `u ∈ 𝔘`.x𝔓 X) u𝔓 X) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).2⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.fX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.gX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.theorem forest_operator.{u_1}
forest_operator.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (𝔉 : TileStructure.Forest X n) {f g : X → ℂ} (hf : Measurable f) (h2f : ∀ (x : X), ‖f x‖ ≤ F.indicator 1 x) (hg : Measurable g) (h2g : ∀ (x : X), ‖g x‖ ≤ G.indicator 1 x) : ‖∫ (x : X), (starRingEnd ℂ) (g x) * ∑ u with u ∈ 𝔉, carlesonSum ((fun x ↦ 𝔉.𝔗 x) u) f x‖ₑ ≤ ↑(C2_0_4 a q n) * dens₂ (⋃ u ∈ 𝔉, (fun x ↦ 𝔉.𝔗 x) u) ^ (q⁻¹ - 2⁻¹) * MeasureTheory.eLpNorm f 2 MeasureTheory.volume * MeasureTheory.eLpNorm g 2 MeasureTheory.volume{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [TileStructureTileStructure.{u} {X : Type u} {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] [FunctionDistances ℝ X] (Q : outParam (MeasureTheory.SimpleFunc X (Θ X))) (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (u + 1)A tile structure.QProofData.Q.{u_1} {X : Type u_1} {a : outParam ℕ} {q : outParam ℝ} {K : outParam (X → X → ℂ)} {σ₁ σ₂ : outParam (X → ℤ)} {F G : outParam (Set X)} {inst✝ : PseudoMetricSpace X} [self : ProofData a q K σ₁ σ₂ F G] : MeasureTheory.SimpleFunc X (Θ X)(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {nℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} (𝔉TileStructure.Forest X n: TileStructure.ForestTileStructure.Forest.{u_1} (X : Type u_1) [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (n : ℕ) : Type u_1An `n`-forestXType u_1nℕ) {fX → ℂgX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (hfMeasurable f: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.fX → ℂ) (h2f∀ (x : X), ‖f x‖ ≤ F.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.fX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.FSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) (hgMeasurable g: MeasurableMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : PropA function `f` between measurable spaces is measurable if the preimage of every measurable set is measurable.gX → ℂ) (h2g∀ (x : X), ‖g x‖ ≤ G.indicator 1 x: ∀ (xX: XType u_1), ‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.gX → ℂxX‖Norm.norm.{u_8} {E : Type u_8} [self : Norm E] : E → ℝthe `ℝ`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.GSet X.indicatorSet.indicator.{u_1, u_3} {α : Type u_1} {M : Type u_3} [Zero M] (s : Set α) (f : α → M) (x : α) : M`Set.indicator s f a` is `f a` if `a ∈ s`, `0` otherwise.1 xX) : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(starRingEndstarRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R`star` as a ring endomorphism, for commutative `R`. This is used to denote complex conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`. Note that this is the preferred form (over `starRingAut`, available under the same hypotheses) because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the case for `(↑starRingAut : R →* R)`.ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.) (gX → ℂxX) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.∑ u𝔓 Xwith u𝔓 X∈Membership.mem.{u, v} {α : outParam (Type u)} {γ : Type v} [self : Membership α γ] : γ → α → PropThe membership relation `a ∈ s : Prop` where `a : α`, `s : γ`. Conventions for notations in identifiers: * The recommended spelling of `∈` in identifiers is `mem`.𝔉TileStructure.Forest X n, carlesonSumcarlesonSum.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (ℭ : Set (𝔓 X)) (f : X → ℂ) (x : X) : ℂThe operator `T_ℭ f` defined at the bottom of Section 7.4. We will use this in other places of the formalization as well.((fun x𝔓 X↦ 𝔉TileStructure.Forest X n.𝔗TileStructure.Forest.𝔗.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (self : TileStructure.Forest X n) : 𝔓 X → Set (𝔓 X)The value of `𝔗 u` only matters when `u ∈ 𝔘`.x𝔓 X) u𝔓 X) fX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_4C2_0_4 (a : ℕ) (q : ℝ) (n : ℕ) : NNRealThe constant used in `forest_operator`. Has value `2 ^ (440 * a ^ 3 - (q - 1) / q * n)` in the blueprint.aℕqℝnℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dens₂dens₂.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] (𝔓' : Set (𝔓 X)) : ENNRealThis density is defined to live in `ℝ≥0∞`. Use `ENNReal.toReal` to get a real number.(⋃ u𝔓 X∈ 𝔉TileStructure.Forest X n, (fun x𝔓 X↦ 𝔉TileStructure.Forest X n.𝔗TileStructure.Forest.𝔗.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [TileStructure Q (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {n : ℕ} (self : TileStructure.Forest X n) : 𝔓 X → Set (𝔓 X)The value of `𝔗 u` only matters when `u ∈ 𝔘`.x𝔓 X) u𝔓 X) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).qℝ⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).2⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.fX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.eLpNormMeasureTheory.eLpNorm.{u_1, u_2} {α : Type u_1} {ε : Type u_2} [ENorm ε] {x✝ : MeasurableSpace α} (f : α → ε) (p : ENNReal) (μ : MeasureTheory.Measure α := by volume_tac) : ENNReal`ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to `essSup ‖f‖ μ` for `p = ∞`.gX → ℂ2 MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.
Theorem 1.2 is formulated at the level of generality for general
kernels satisfying the mere Holder regularity condition eqkernel-y-smooth. On
the other hand, the cancellative condition eq-vdc-cond is a testing
condition against more regular, namely Lipschitz functions. To bridge the gap,
we follow the literature to observe a variant of eq-vdc-cond that we
formulate in the following proposition proved in [??].
Define
\tau:=\frac 1a.
Define for any open ball B of radius R in X the
L^\infty-normalized \tau-Holder norm by
\|\varphi\|_{C^\tau(B)} = \sup_{x \in B} |\varphi(x)| + R^\tau \sup_{x,y \in B, x \neq y} \frac{|\varphi(x) - \varphi(y)|}{\rho(x,y)^\tau}.
Theorem1.8
✓L∃∀N
Associated Lean declarations
-
holder_van_der_corput[complete]
Used by 2
Preview
Lemma 1.73
Uses Lemma 1.121.
Let z\in X and R>0 and set B=B(z,R). Let \varphi: X \to \mathbb{C}
be supported on B and satisfy
\|{\varphi}\|_{C^\tau(B(z, 2R))}<\infty. Let \mfa, \mfb \in \Mf. Then
|\int e(\mfa(x)-{\mfb(x)})\varphi(x) dx|\le
2^{7a} \mu(B) \|{\varphi}\|_{C^\tau(B(z, 2R))}
(1 + d_{B}(\mfa,\mfb))^{-\frac{1}{2a^2+a^3}}.
Lean code for Theorem1.8●1 theorem
Associated Lean declarations
-
holder_van_der_corput[complete]
Associated Lean declarations
-
holder_van_der_corput[complete]
-
theoremdefined in Carleson/HolderVanDerCorput.leancomplete
theorem holder_van_der_corput.{u_1}
holder_van_der_corput.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] {z : X} {R : ℝ} {φ : X → ℂ} (φ_supp : Function.support φ ⊆ Metric.ball z R) {f g : Θ X} : ‖∫ (x : X), Complex.exp (Complex.I * (↑(f x) - ↑(g x))) * φ x‖ₑ ≤ ↑(C2_0_5 ↑a) * MeasureTheory.volume (Metric.ball z R) * iHolENorm φ z (2 * R) (defaultτ a) * (1 + edist_{z, R} f g) ^ (-(2 * ↑a ^ 2 + ↑a ^ 3)⁻¹)Proposition 2.0.5.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] {zX: XType u_1} {Rℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {φX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (φ_suppFunction.support φ ⊆ Metric.ball z R: Function.supportFunction.support.{u_1, u_3} {ι : Type u_1} {M : Type u_3} [Zero M] (f : ι → M) : Set ι`support` of a function is the set of points `x` such that `f x ≠ 0`.φX → ℂ⊆HasSubset.Subset.{u} {α : Type u} [self : HasSubset α] : α → α → PropSubset relation: `a ⊆ b` Conventions for notations in identifiers: * The recommended spelling of `⊆` in identifiers is `subset`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXRℝ) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integralComplex.expComplex.exp (z : ℂ) : ℂThe complex exponential function, defined via its Taylor series(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.IComplex.I : ℂThe imaginary unit.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).↑(fΘ XxX) -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).↑(gΘ XxX))HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.φX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_5C2_0_5 (a : ℝ) : NNRealThe constant occurring in Proposition 2.0.5. Has value `2 ^ (7 * a)` in the blueprint.↑aℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXRℝ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.iHolENormiHolENorm.{u_1, u_2} {𝕜 : Type u_1} {X : Type u_2} [PseudoMetricSpace X] [NormedField 𝕜] (φ : X → 𝕜) (x₀ : X) (R t : ℝ) : ENNRealthe L^∞-normalized t-Hölder norm. Defined in ℝ≥0∞ to avoid sup-related issues.φX → ℂzX(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Rℝ)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(defaultτdefaultτ (a : ℕ) : ℝ`defaultτ` is the inverse of `a`.aℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.1 +HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.edist_{EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointszX,EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsRℝ}EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsfΘ XgΘ X)HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).-Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).(HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.2 +HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.3)HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).theorem holder_van_der_corput.{u_1}
holder_van_der_corput.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [MetricSpace X] [ProofData a q K σ₁ σ₂ F G] {z : X} {R : ℝ} {φ : X → ℂ} (φ_supp : Function.support φ ⊆ Metric.ball z R) {f g : Θ X} : ‖∫ (x : X), Complex.exp (Complex.I * (↑(f x) - ↑(g x))) * φ x‖ₑ ≤ ↑(C2_0_5 ↑a) * MeasureTheory.volume (Metric.ball z R) * iHolENorm φ z (2 * R) (defaultτ a) * (1 + edist_{z, R} f g) ^ (-(2 * ↑a ^ 2 + ↑a ^ 3)⁻¹)Proposition 2.0.5.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] {zX: XType u_1} {Rℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {φX → ℂ: XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} (φ_suppFunction.support φ ⊆ Metric.ball z R: Function.supportFunction.support.{u_1, u_3} {ι : Type u_1} {M : Type u_3} [Zero M] (f : ι → M) : Set ι`support` of a function is the set of points `x` such that `f x ≠ 0`.φX → ℂ⊆HasSubset.Subset.{u} {α : Type u} [self : HasSubset α] : α → α → PropSubset relation: `a ⊆ b` Conventions for notations in identifiers: * The recommended spelling of `⊆` in identifiers is `subset`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXRℝ) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∫MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integral(xX: XType u_1),MeasureTheory.integral.{u_6, u_7} {α : Type u_6} {G : Type u_7} [NormedAddCommGroup G] [NormedSpace ℝ G] {x✝ : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G) : GThe Bochner integralComplex.expComplex.exp (z : ℂ) : ℂThe complex exponential function, defined via its Taylor series(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Complex.IComplex.I : ℂThe imaginary unit.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).↑(fΘ XxX) -HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).↑(gΘ XxX))HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.φX → ℂxX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_0_5C2_0_5 (a : ℝ) : NNRealThe constant occurring in Proposition 2.0.5. Has value `2 ^ (7 * a)` in the blueprint.↑aℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXRℝ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.iHolENormiHolENorm.{u_1, u_2} {𝕜 : Type u_1} {X : Type u_2} [PseudoMetricSpace X] [NormedField 𝕜] (φ : X → 𝕜) (x₀ : X) (R t : ℝ) : ENNRealthe L^∞-normalized t-Hölder norm. Defined in ℝ≥0∞ to avoid sup-related issues.φX → ℂzX(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.Rℝ)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(defaultτdefaultτ (a : ℕ) : ℝ`defaultτ` is the inverse of `a`.aℕ) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.1 +HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.edist_{EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointszX,EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsRℝ}EDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsfΘ XgΘ X)HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).-Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).(HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.2 +HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.↑aℕ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.3)HAdd.hAdd.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HAdd α β γ] : α → β → γ`a + b` computes the sum of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `+` in identifiers is `add`.⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.)Neg.neg.{u} {α : Type u} [self : Neg α] : α → α`-a` computes the negative or opposite of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `neg` (when used as a unary operator).Proposition 2.0.5.
We further formulate a classical Vitali covering result and maximal function
estimate that we need throughout several sections. This following proposition
will typically be applied to the absolute value of a complex valued function
and be proved in [??]. By a ball B we mean a set B(x,r) with
x\in X and r>0 as defined in eq-define-ball. For a finite collection
\mathcal{B} of balls in X and 1\le p< \infty define the measurable
function M_{\mathcal{B},p}u on X by
M_{\mathcal{B},p}u(x):=\left(\sup_{B\in \mathcal{B}} \frac{\mathbf{1}_{B}(x)}{\mu(B)}\int _{B} |u(y)|^p\, d\mu(y)\right)^\frac 1p,
Define further M_{\mathcal{B}}:=M_{\mathcal{B},1}.
Theorem1.9
✓L∃∀N
Associated Lean declarations
-
Finset.measure_biUnion_le_lintegral[complete] -
hasStrongType_maximalFunction[complete] -
MeasureTheory.AEStronglyMeasurable.globalMaximalFunction[complete] -
laverage_le_globalMaximalFunction[complete] -
hasStrongType_globalMaximalFunction[complete]
Used by 6
Preview
Lemma 1.15
Uses Lemma 1.122 and Lemma 1.123.
Let \mathcal{B} be a finite collection of balls in X. If for some
\lambda>0 and some measurable function u:X\to [0,\infty) we have
\int_{B} u(x)\, d\mu(x)\ge \lambda \mu(B)
for each B\in \mathcal{B}, then
\lambda \mu(\bigcup \mathcal{B}) \le 2^{2a}\int_X u(x)\, d\mu(x).
For every measurable function v and 1\le p_1<p_2 we have
\|M_{\mathcal{B},p_1} v\|_{p_2}\le 2^{2a}\frac{p_2}{p_2-p_1} \|v\|_{p_2}.
Moreover, given any measurable bounded function w: X \to \C there exists a
measurable function Mw: X \to [0, \infty) such that the following hold. For
each ball B \subset X and each x \in B
\frac{1}{\mu(B)} \int_{B} |w(y)| \, \mathrm{d}\mu(y) \le Mw(x)
and for all 1 \le p_1 < p_2 \le \infty
\|M(w^{p_1})^{\frac{1}{p_1}}\|_{p_2} \le 2^{4a} \frac{p_2}{p_2-p_1}\|w\|_{p_2}.
Lean code for Theorem1.9●5 theorems
Associated Lean declarations
-
Finset.measure_biUnion_le_lintegral[complete]
-
hasStrongType_maximalFunction[complete]
-
MeasureTheory.AEStronglyMeasurable.globalMaximalFunction[complete]
-
laverage_le_globalMaximalFunction[complete]
-
hasStrongType_globalMaximalFunction[complete]
Associated Lean declarations
-
Finset.measure_biUnion_le_lintegral[complete] -
hasStrongType_maximalFunction[complete] -
MeasureTheory.AEStronglyMeasurable.globalMaximalFunction[complete] -
laverage_le_globalMaximalFunction[complete] -
hasStrongType_globalMaximalFunction[complete]
-
theoremdefined in Carleson/ToMathlib/HardyLittlewood.leancomplete
theorem Finset.measure_biUnion_le_lintegral.{u_1, u_3}
Finset.measure_biUnion_le_lintegral.{u_1, u_3} {X : Type u_1} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] {ι : Type u_3} {c : ι → X} {r : ι → ℝ} [OpensMeasurableSpace X] (𝓑 : Finset ι) (l : ENNReal) (u : X → ENNReal) (h2u : ∀ i ∈ 𝓑, l * μ (Metric.ball (c i) (r i)) ≤ ∫⁻ (x : X) in Metric.ball (c i) (r i), u x ∂μ) : l * μ (⋃ i ∈ 𝓑, Metric.ball (c i) (r i)) ≤ ↑A ^ 2 * ∫⁻ (x : X), u x ∂μ{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] {ιType u_3: Type u_3A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {cι → X: ιType u_3→ XType u_1} {rι → ℝ: ιType u_3→ ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} [OpensMeasurableSpaceOpensMeasurableSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [h : MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that all open sets are measurable.XType u_1] (𝓑Finset ι: FinsetFinset.{u_4} (α : Type u_4) : Type u_4`Finset α` is the type of finite sets of elements of `α`. It is implemented as a multiset (a list up to permutation) which has no duplicate elements.ιType u_3) (lENNReal: ENNRealENNReal : TypeThe extended nonnegative real numbers. This is usually denoted [0, ∞], and is relevant as the codomain of a measure.) (uX → ENNReal: XType u_1→ ENNRealENNReal : TypeThe extended nonnegative real numbers. This is usually denoted [0, ∞], and is relevant as the codomain of a measure.) (h2u∀ i ∈ 𝓑, l * μ (Metric.ball (c i) (r i)) ≤ ∫⁻ (x : X) in Metric.ball (c i) (r i), u x ∂μ: ∀ iι∈ 𝓑Finset ι, lENNReal*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.μMeasureTheory.Measure X(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι)) ≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι),MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.uX → ENNRealxX∂MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.μMeasureTheory.Measure X) : lENNReal*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.μMeasureTheory.Measure X(⋃ iι∈ 𝓑Finset ι, Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι)) ≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑ANNReal^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1),MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.uX → ENNRealxX∂MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.μMeasureTheory.Measure Xtheorem Finset.measure_biUnion_le_lintegral.{u_1, u_3}
Finset.measure_biUnion_le_lintegral.{u_1, u_3} {X : Type u_1} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] {ι : Type u_3} {c : ι → X} {r : ι → ℝ} [OpensMeasurableSpace X] (𝓑 : Finset ι) (l : ENNReal) (u : X → ENNReal) (h2u : ∀ i ∈ 𝓑, l * μ (Metric.ball (c i) (r i)) ≤ ∫⁻ (x : X) in Metric.ball (c i) (r i), u x ∂μ) : l * μ (⋃ i ∈ 𝓑, Metric.ball (c i) (r i)) ≤ ↑A ^ 2 * ∫⁻ (x : X), u x ∂μ{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] {ιType u_3: Type u_3A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {cι → X: ιType u_3→ XType u_1} {rι → ℝ: ιType u_3→ ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} [OpensMeasurableSpaceOpensMeasurableSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [h : MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that all open sets are measurable.XType u_1] (𝓑Finset ι: FinsetFinset.{u_4} (α : Type u_4) : Type u_4`Finset α` is the type of finite sets of elements of `α`. It is implemented as a multiset (a list up to permutation) which has no duplicate elements.ιType u_3) (lENNReal: ENNRealENNReal : TypeThe extended nonnegative real numbers. This is usually denoted [0, ∞], and is relevant as the codomain of a measure.) (uX → ENNReal: XType u_1→ ENNRealENNReal : TypeThe extended nonnegative real numbers. This is usually denoted [0, ∞], and is relevant as the codomain of a measure.) (h2u∀ i ∈ 𝓑, l * μ (Metric.ball (c i) (r i)) ≤ ∫⁻ (x : X) in Metric.ball (c i) (r i), u x ∂μ: ∀ iι∈ 𝓑Finset ι, lENNReal*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.μMeasureTheory.Measure X(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι)) ≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1) inMeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι),MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.uX → ENNRealxX∂MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.μMeasureTheory.Measure X) : lENNReal*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.μMeasureTheory.Measure X(⋃ iι∈ 𝓑Finset ι, Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`(cι → Xiι) (rι → ℝiι)) ≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑ANNReal^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.2 *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.∫⁻MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.(xX: XType u_1),MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.uX → ENNRealxX∂MeasureTheory.lintegral.{u_4} {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealThe **lower Lebesgue integral** of a function `f` with respect to a measure `μ`.μMeasureTheory.Measure X -
theoremdefined in Carleson/ToMathlib/HardyLittlewood.leancomplete
theorem hasStrongType_maximalFunction.{u_1, u_2, u_3}
hasStrongType_maximalFunction.{u_1, u_2, u_3} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] {ι : Type u_3} {𝓑 : Set ι} {c : ι → X} {r : ι → ℝ} [BorelSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [ProperSpace X] [μ.IsOpenPosMeasure] {p₁ p₂ : NNReal} (h𝓑 : 𝓑.Countable) (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : MeasureTheory.HasStrongType (maximalFunction μ 𝓑 c r ↑p₁) (↑p₂) (↑p₂) μ μ ↑(C2_0_6 A p₁ p₂)`hasStrongType_maximalFunction` minus the assumption `hR`. A proof for basically this result is given in Chapter 9, everything following after equation (9.0.36).{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] {ιType u_3: Type u_3A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {𝓑Set ι: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.ιType u_3} {cι → X: ιType u_3→ XType u_1} {rι → ℝ: ιType u_3→ ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {p₁NNRealp₂NNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} (h𝓑𝓑.Countable: 𝓑Set ι.CountableSet.Countable.{u} {α : Type u} (s : Set α) : PropA set `s` is countable if the corresponding subtype is countable, i.e., there exists an injective map `f : s → ℕ`. Note that this is an abbreviation, so `hs : Set.Countable s` in the proof context is the same as an instance `Countable s`. For a constructive version, see `Encodable`.) (hp₁0 < p₁: 0 <LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₁NNReal) (hp₁₂p₁ < p₂: p₁NNReal<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₂NNReal) : MeasureTheory.HasStrongTypeMeasureTheory.HasStrongType.{u_4, u_5, u_12, u_13} {ε₁ : Type u_4} {ε₂ : Type u_5} [ENorm ε₁] [ENorm ε₂] [TopologicalSpace ε₁] [TopologicalSpace ε₂] {α : Type u_12} {α' : Type u_13} {_x : MeasurableSpace α} {_x' : MeasurableSpace α'} (T : (α → ε₁) → α' → ε₂) (p p' : ENNReal) (μ : MeasureTheory.Measure α) (ν : MeasureTheory.Measure α') (c : ENNReal) : PropAn operator has strong type `(p, q)` if it is bounded as an operator on `L^p → L^q`. `HasStrongType T p p' μ ν c` means that `T` has strong type (p, p') w.r.t. measures `μ`, `ν` and constant `c`.(maximalFunctionmaximalFunction.{u_1, u_2, u_3} {X : Type u_1} {E : Type u_2} [MetricSpace X] [MeasurableSpace X] [NormedAddCommGroup E] {ι : Type u_3} (μ : MeasureTheory.Measure X) (𝓑 : Set ι) (c : ι → X) (r : ι → ℝ) (p : ℝ) (u : X → E) (x : X) : ENNRealThe Hardy-Littlewood maximal function w.r.t. a collection of balls 𝓑. M_{𝓑, p} in the blueprint.μMeasureTheory.Measure X𝓑Set ιcι → Xrι → ℝ↑p₁NNReal) (↑p₂NNReal) (↑p₂NNReal) μMeasureTheory.Measure XμMeasureTheory.Measure X↑(C2_0_6C2_0_6 (A p₁ p₂ : NNReal) : NNRealThe constant factor in the statement that `M_{𝓑, p}` has strong type.ANNRealp₁NNRealp₂NNReal)theorem hasStrongType_maximalFunction.{u_1, u_2, u_3}
hasStrongType_maximalFunction.{u_1, u_2, u_3} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] {ι : Type u_3} {𝓑 : Set ι} {c : ι → X} {r : ι → ℝ} [BorelSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [ProperSpace X] [μ.IsOpenPosMeasure] {p₁ p₂ : NNReal} (h𝓑 : 𝓑.Countable) (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : MeasureTheory.HasStrongType (maximalFunction μ 𝓑 c r ↑p₁) (↑p₂) (↑p₂) μ μ ↑(C2_0_6 A p₁ p₂)`hasStrongType_maximalFunction` minus the assumption `hR`. A proof for basically this result is given in Chapter 9, everything following after equation (9.0.36).{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] {ιType u_3: Type u_3A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {𝓑Set ι: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.ιType u_3} {cι → X: ιType u_3→ XType u_1} {rι → ℝ: ιType u_3→ ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {p₁NNRealp₂NNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} (h𝓑𝓑.Countable: 𝓑Set ι.CountableSet.Countable.{u} {α : Type u} (s : Set α) : PropA set `s` is countable if the corresponding subtype is countable, i.e., there exists an injective map `f : s → ℕ`. Note that this is an abbreviation, so `hs : Set.Countable s` in the proof context is the same as an instance `Countable s`. For a constructive version, see `Encodable`.) (hp₁0 < p₁: 0 <LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₁NNReal) (hp₁₂p₁ < p₂: p₁NNReal<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₂NNReal) : MeasureTheory.HasStrongTypeMeasureTheory.HasStrongType.{u_4, u_5, u_12, u_13} {ε₁ : Type u_4} {ε₂ : Type u_5} [ENorm ε₁] [ENorm ε₂] [TopologicalSpace ε₁] [TopologicalSpace ε₂] {α : Type u_12} {α' : Type u_13} {_x : MeasurableSpace α} {_x' : MeasurableSpace α'} (T : (α → ε₁) → α' → ε₂) (p p' : ENNReal) (μ : MeasureTheory.Measure α) (ν : MeasureTheory.Measure α') (c : ENNReal) : PropAn operator has strong type `(p, q)` if it is bounded as an operator on `L^p → L^q`. `HasStrongType T p p' μ ν c` means that `T` has strong type (p, p') w.r.t. measures `μ`, `ν` and constant `c`.(maximalFunctionmaximalFunction.{u_1, u_2, u_3} {X : Type u_1} {E : Type u_2} [MetricSpace X] [MeasurableSpace X] [NormedAddCommGroup E] {ι : Type u_3} (μ : MeasureTheory.Measure X) (𝓑 : Set ι) (c : ι → X) (r : ι → ℝ) (p : ℝ) (u : X → E) (x : X) : ENNRealThe Hardy-Littlewood maximal function w.r.t. a collection of balls 𝓑. M_{𝓑, p} in the blueprint.μMeasureTheory.Measure X𝓑Set ιcι → Xrι → ℝ↑p₁NNReal) (↑p₂NNReal) (↑p₂NNReal) μMeasureTheory.Measure XμMeasureTheory.Measure X↑(C2_0_6C2_0_6 (A p₁ p₂ : NNReal) : NNRealThe constant factor in the statement that `M_{𝓑, p}` has strong type.ANNRealp₁NNRealp₂NNReal)`hasStrongType_maximalFunction` minus the assumption `hR`. A proof for basically this result is given in Chapter 9, everything following after equation (9.0.36).
-
theoremdefined in Carleson/ToMathlib/HardyLittlewood.leancomplete
theorem MeasureTheory.AEStronglyMeasurable.globalMaximalFunction.{u_1, u_2}
MeasureTheory.AEStronglyMeasurable.globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [BorelSpace X] {p : ℝ} {u : X → E} : MeasureTheory.AEStronglyMeasurable (globalMaximalFunction μ p u) μ{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] {pℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {uX → E: XType u_1→ EType u_2} : MeasureTheory.AEStronglyMeasurableMeasureTheory.AEStronglyMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [TopologicalSpace β] [m : MeasurableSpace α] {m₀ : MeasurableSpace α} (f : α → β) (μ : MeasureTheory.Measure α := by volume_tac) : PropA function is `AEStronglyMeasurable` with respect to a measure `μ` if it is almost everywhere equal to the limit of a sequence of simple functions. One can specify the sigma-algebra according to which simple functions are taken using the `AEStronglyMeasurable[m]` notation in the `MeasureTheory` scope.(globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure XpℝuX → E) μMeasureTheory.Measure Xtheorem MeasureTheory.AEStronglyMeasurable.globalMaximalFunction.{u_1, u_2}
MeasureTheory.AEStronglyMeasurable.globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [BorelSpace X] {p : ℝ} {u : X → E} : MeasureTheory.AEStronglyMeasurable (globalMaximalFunction μ p u) μ{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] {pℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {uX → E: XType u_1→ EType u_2} : MeasureTheory.AEStronglyMeasurableMeasureTheory.AEStronglyMeasurable.{u_1, u_2} {α : Type u_1} {β : Type u_2} [TopologicalSpace β] [m : MeasurableSpace α] {m₀ : MeasurableSpace α} (f : α → β) (μ : MeasureTheory.Measure α := by volume_tac) : PropA function is `AEStronglyMeasurable` with respect to a measure `μ` if it is almost everywhere equal to the limit of a sequence of simple functions. One can specify the sigma-algebra according to which simple functions are taken using the `AEStronglyMeasurable[m]` notation in the `MeasureTheory` scope.(globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure XpℝuX → E) μMeasureTheory.Measure X -
theoremdefined in Carleson/ToMathlib/HardyLittlewood.leancomplete
theorem laverage_le_globalMaximalFunction.{u_1, u_2}
laverage_le_globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.IsOpenPosMeasure] {u : X → E} {z x : X} {r : ℝ} (h : dist x z < r) : ⨍⁻ (y : X) in Metric.ball z r, ‖u y‖ₑ ∂μ ≤ globalMaximalFunction μ 1 u xEquation (2.0.45){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {uX → E: XType u_1→ EType u_2} {zXxX: XType u_1} {rℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} (hdist x z < r: distDist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsxXzX<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.rℝ) : ⨍⁻MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.(yX: XType u_1) inMeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXrℝ,MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.uX → EyX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∂MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.μMeasureTheory.Measure X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure X1 uX → ExXtheorem laverage_le_globalMaximalFunction.{u_1, u_2}
laverage_le_globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.IsOpenPosMeasure] {u : X → E} {z x : X} {r : ℝ} (h : dist x z < r) : ⨍⁻ (y : X) in Metric.ball z r, ‖u y‖ₑ ∂μ ≤ globalMaximalFunction μ 1 u xEquation (2.0.45){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {uX → E: XType u_1→ EType u_2} {zXxX: XType u_1} {rℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} (hdist x z < r: distDist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsxXzX<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.rℝ) : ⨍⁻MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.(yX: XType u_1) inMeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`zXrℝ,MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.uX → EyX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.∂MeasureTheory.laverage.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal) : ENNRealAverage value of an `ℝ≥0∞`-valued function `f` w.r.t. a measure `μ`, denoted `⨍⁻ x, f x ∂μ`. It is equal to `(μ univ)⁻¹ * ∫⁻ x, f x ∂μ`, so it takes value zero if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is equal to its integral. For the average on a set, use `⨍⁻ x in s, f x ∂μ`, defined as `⨍⁻ x, f x ∂(μ.restrict s)`. For the average w.r.t. the volume, one can omit `∂volume`.μMeasureTheory.Measure X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure X1 uX → ExXEquation (2.0.45)
-
theoremdefined in Carleson/ToMathlib/HardyLittlewood.leancomplete
theorem hasStrongType_globalMaximalFunction.{u_1, u_2}
hasStrongType_globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [BorelSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.IsOpenPosMeasure] {p₁ p₂ : NNReal} (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : MeasureTheory.HasStrongType (globalMaximalFunction μ ↑p₁) (↑p₂) (↑p₂) μ μ ↑(C2_0_6' A p₁ p₂)Equation (2.0.46). Easy from `hasStrongType_maximalFunction`{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {p₁NNRealp₂NNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} (hp₁0 < p₁: 0 <LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₁NNReal) (hp₁₂p₁ < p₂: p₁NNReal<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₂NNReal) : MeasureTheory.HasStrongTypeMeasureTheory.HasStrongType.{u_4, u_5, u_12, u_13} {ε₁ : Type u_4} {ε₂ : Type u_5} [ENorm ε₁] [ENorm ε₂] [TopologicalSpace ε₁] [TopologicalSpace ε₂] {α : Type u_12} {α' : Type u_13} {_x : MeasurableSpace α} {_x' : MeasurableSpace α'} (T : (α → ε₁) → α' → ε₂) (p p' : ENNReal) (μ : MeasureTheory.Measure α) (ν : MeasureTheory.Measure α') (c : ENNReal) : PropAn operator has strong type `(p, q)` if it is bounded as an operator on `L^p → L^q`. `HasStrongType T p p' μ ν c` means that `T` has strong type (p, p') w.r.t. measures `μ`, `ν` and constant `c`.(globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure X↑p₁NNReal) (↑p₂NNReal) (↑p₂NNReal) μMeasureTheory.Measure XμMeasureTheory.Measure X↑(C2_0_6'C2_0_6' (A p₁ p₂ : NNReal) : NNRealThe constant factor in the statement that `M` has strong type.ANNRealp₁NNRealp₂NNReal)theorem hasStrongType_globalMaximalFunction.{u_1, u_2}
hasStrongType_globalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] {μ : MeasureTheory.Measure X} [μ.IsDoubling A] [NormedAddCommGroup E] [ProperSpace X] [BorelSpace X] [MeasureTheory.IsFiniteMeasureOnCompacts μ] [μ.IsOpenPosMeasure] {p₁ p₂ : NNReal} (hp₁ : 0 < p₁) (hp₁₂ : p₁ < p₂) : MeasureTheory.HasStrongType (globalMaximalFunction μ ↑p₁) (↑p₂) (↑p₂) μ μ ↑(C2_0_6' A p₁ p₂)Equation (2.0.46). Easy from `hasStrongType_maximalFunction`{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {EType u_2: Type u_2A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {ANNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} [MetricSpaceMetricSpace.{u} (α : Type u) : Type uA metric space is a type endowed with a `ℝ`-valued distance `dist` satisfying `dist x y = 0 ↔ x = y`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. See pseudometric spaces (`PseudoMetricSpace`) for the similar class with the `dist x y = 0 ↔ x = y` assumption weakened to `dist x x = 0`. Any metric space is a T1 topological space and a uniform space (see `TopologicalSpace`, `T1Space`, `UniformSpace`), where the topology and uniformity come from the metric. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[MetricSpace α] [MetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [MeasurableSpaceMeasurableSpace.{u_7} (α : Type u_7) : Type u_7A measurable space is a space equipped with a σ-algebra.XType u_1] {μMeasureTheory.Measure X: MeasureTheory.MeasureMeasureTheory.Measure.{u_6} (α : Type u_6) [MeasurableSpace α] : Type u_6A measure is defined to be an outer measure that is countably additive on measurable sets, with the additional assumption that the outer measure is the canonical extension of the restricted measure. The measure of a set `s`, denoted `μ s`, is an extended nonnegative real. The real-valued version is written `μ.real s`.XType u_1} [μMeasureTheory.Measure X.IsDoublingMeasureTheory.Measure.IsDoubling.{u_1} {X : Type u_1} [MeasurableSpace X] [PseudoMetricSpace X] (μ : MeasureTheory.Measure X) (A : outParam NNReal) : PropA doubling measure is a measure on a metric space with the condition that doubling the radius of a ball only increases the volume by a constant factor, independent of the ball.ANNReal] [NormedAddCommGroupNormedAddCommGroup.{u_8} (E : Type u_8) : Type u_8A normed group is an additive group endowed with a norm for which `dist x y = ‖-x + y‖` defines a metric space structure.EType u_2] [ProperSpaceProperSpace.{u} (α : Type u) [PseudoMetricSpace α] : PropA pseudometric space is proper if all closed balls are compact.XType u_1] [BorelSpaceBorelSpace.{u_6} (α : Type u_6) [TopologicalSpace α] [MeasurableSpace α] : PropA space with `MeasurableSpace` and `TopologicalSpace` structures such that the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets.XType u_1] [MeasureTheory.IsFiniteMeasureOnCompactsMeasureTheory.IsFiniteMeasureOnCompacts.{u_1} {α : Type u_1} {m0 : MeasurableSpace α} [TopologicalSpace α] (μ : MeasureTheory.Measure α) : PropA measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`.μMeasureTheory.Measure X] [μMeasureTheory.Measure X.IsOpenPosMeasureMeasureTheory.Measure.IsOpenPosMeasure.{u_1} {X : Type u_1} [TopologicalSpace X] {m : MeasurableSpace X} (μ : MeasureTheory.Measure X) : PropA measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets.] {p₁NNRealp₂NNReal: NNRealNNReal : TypeNonnegative real numbers, denoted as `ℝ≥0` within the NNReal namespace} (hp₁0 < p₁: 0 <LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₁NNReal) (hp₁₂p₁ < p₂: p₁NNReal<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.p₂NNReal) : MeasureTheory.HasStrongTypeMeasureTheory.HasStrongType.{u_4, u_5, u_12, u_13} {ε₁ : Type u_4} {ε₂ : Type u_5} [ENorm ε₁] [ENorm ε₂] [TopologicalSpace ε₁] [TopologicalSpace ε₂] {α : Type u_12} {α' : Type u_13} {_x : MeasurableSpace α} {_x' : MeasurableSpace α'} (T : (α → ε₁) → α' → ε₂) (p p' : ENNReal) (μ : MeasureTheory.Measure α) (ν : MeasureTheory.Measure α') (c : ENNReal) : PropAn operator has strong type `(p, q)` if it is bounded as an operator on `L^p → L^q`. `HasStrongType T p p' μ ν c` means that `T` has strong type (p, p') w.r.t. measures `μ`, `ν` and constant `c`.(globalMaximalFunctionglobalMaximalFunction.{u_1, u_2} {X : Type u_1} {E : Type u_2} {A : NNReal} [MetricSpace X] [MeasurableSpace X] (μ : MeasureTheory.Measure X) [NormedAddCommGroup E] [ProperSpace X] [μ.IsDoubling A] (p : ℝ) (u : X → E) (x : X) : ENNRealThe transformation `M` characterized in Proposition 2.0.6. `p` is `1` in the blueprint, and `globalMaximalFunction μ p u = (M (u ^ p)) ^ p⁻¹ `μMeasureTheory.Measure X↑p₁NNReal) (↑p₂NNReal) (↑p₂NNReal) μMeasureTheory.Measure XμMeasureTheory.Measure X↑(C2_0_6'C2_0_6' (A p₁ p₂ : NNReal) : NNRealThe constant factor in the statement that `M` has strong type.ANNRealp₁NNRealp₂NNReal)Equation (2.0.46). Easy from `hasStrongType_maximalFunction`
This completes the overview of the proof of Theorem 1.2.
1.2.1. Auxiliary lemmas
We close this section by recording some auxiliary lemmas about the objects defined in [??], which will be used in multiple sections to follow.
First, we record an estimate for the metrical entropy numbers of balls in the
space \Mf equipped with any of the metrics d_B, following from the
doubling property thirddb.
Lemma1.10
✓L∃∀N
used by 1
Associated Lean declarations
-
Θ.finite_and_mk_le_of_le_dist[complete]
Let B' \subset X be a ball. Let r > 0, \mfa \in \Mf and
k \in \mathbb{N}. Suppose that \mathcal{Z} \subset B_{B'}(\mfa, r2^k)
satisfies that \{B_{B'}(z,r)\mid z \in \mathcal{Z}\} is a collection of
pairwise disjoint sets. Then
|\mathcal{Z}| \le 2^{ka}.
Lean code for Lemma1.10●1 theorem
Associated Lean declarations
-
Θ.finite_and_mk_le_of_le_dist[complete]
Associated Lean declarations
-
Θ.finite_and_mk_le_of_le_dist[complete]
-
theoremdefined in Carleson/ProofData.leancomplete
theorem Θ.finite_and_mk_le_of_le_dist.{u_1}
Θ.finite_and_mk_le_of_le_dist.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] {x₀ : X} {r R : ℝ} {f : Θ X} {k : ℕ} {𝓩 : Set (Θ X)} (h𝓩 : 𝓩 ⊆ ball_{x₀, R} f (r * 2 ^ k)) (h2𝓩 : 𝓩.PairwiseDisjoint fun x ↦ ball_{x₀, R} x r) : 𝓩.Finite ∧ Cardinal.mk ↑𝓩 ≤ ↑(C2_1_1 k a){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] {x₀X: XType u_1} {rℝRℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {fΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} {kℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {𝓩Set (Θ X): SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.(ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1)} (h𝓩𝓩 ⊆ ball_{x₀, R} f (r * 2 ^ k): 𝓩Set (Θ X)⊆HasSubset.Subset.{u} {α : Type u} [self : HasSubset α] : α → α → PropSubset relation: `a ⊆ b` Conventions for notations in identifiers: * The recommended spelling of `⊆` in identifiers is `subset`.ball_{Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`x₀X,Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`Rℝ}Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`fΘ X(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.rℝ*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.2 ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.kℕ)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.) (h2𝓩𝓩.PairwiseDisjoint fun x ↦ ball_{x₀, R} x r: 𝓩Set (Θ X).PairwiseDisjointSet.PairwiseDisjoint.{u_1, u_4} {α : Type u_1} {ι : Type u_4} [PartialOrder α] [OrderBot α] (s : Set ι) (f : ι → α) : PropA set is `PairwiseDisjoint` under `f`, if the images of any distinct two elements under `f` are disjoint. `s.Pairwise Disjoint` is (definitionally) the same as `s.PairwiseDisjoint id`. We prefer the latter in order to allow dot notation on `Set.PairwiseDisjoint`, even though the former unfolds more nicely.fun xΘ X↦ ball_{Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`x₀X,Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`Rℝ}Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xΘ Xrℝ) : 𝓩Set (Θ X).FiniteSet.Finite.{u} {α : Type u} (s : Set α) : PropA set is finite if the corresponding `Subtype` is finite, i.e., if there exists a natural `n : ℕ` and an equivalence `s ≃ Fin n`.∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.Cardinal.mkCardinal.mk.{u} : Type u → Cardinal.{u}The cardinal number of a type↑𝓩Set (Θ X)≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_1_1C2_1_1 (k a : ℕ) : ℕkℕaℕ)theorem Θ.finite_and_mk_le_of_le_dist.{u_1}
Θ.finite_and_mk_le_of_le_dist.{u_1} {X : Type u_1} {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] {x₀ : X} {r R : ℝ} {f : Θ X} {k : ℕ} {𝓩 : Set (Θ X)} (h𝓩 : 𝓩 ⊆ ball_{x₀, R} f (r * 2 ^ k)) (h2𝓩 : 𝓩.PairwiseDisjoint fun x ↦ ball_{x₀, R} x r) : 𝓩.Finite ∧ Cardinal.mk ↑𝓩 ≤ ↑(C2_1_1 k a){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] {x₀X: XType u_1} {rℝRℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {fΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} {kℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {𝓩Set (Θ X): SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.(ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1)} (h𝓩𝓩 ⊆ ball_{x₀, R} f (r * 2 ^ k): 𝓩Set (Θ X)⊆HasSubset.Subset.{u} {α : Type u} [self : HasSubset α] : α → α → PropSubset relation: `a ⊆ b` Conventions for notations in identifiers: * The recommended spelling of `⊆` in identifiers is `subset`.ball_{Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`x₀X,Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`Rℝ}Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`fΘ X(HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.rℝ*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.2 ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.kℕ)HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.) (h2𝓩𝓩.PairwiseDisjoint fun x ↦ ball_{x₀, R} x r: 𝓩Set (Θ X).PairwiseDisjointSet.PairwiseDisjoint.{u_1, u_4} {α : Type u_1} {ι : Type u_4} [PartialOrder α] [OrderBot α] (s : Set ι) (f : ι → α) : PropA set is `PairwiseDisjoint` under `f`, if the images of any distinct two elements under `f` are disjoint. `s.Pairwise Disjoint` is (definitionally) the same as `s.PairwiseDisjoint id`. We prefer the latter in order to allow dot notation on `Set.PairwiseDisjoint`, even though the former unfolds more nicely.fun xΘ X↦ ball_{Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`x₀X,Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`Rℝ}Metric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xΘ Xrℝ) : 𝓩Set (Θ X).FiniteSet.Finite.{u} {α : Type u} (s : Set α) : PropA set is finite if the corresponding `Subtype` is finite, i.e., if there exists a natural `n : ℕ` and an equivalence `s ≃ Fin n`.∧And (a b : Prop) : Prop`And a b`, or `a ∧ b`, is the conjunction of propositions. It can be constructed and destructed like a pair: if `ha : a` and `hb : b` then `⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. Conventions for notations in identifiers: * The recommended spelling of `∧` in identifiers is `and`.Cardinal.mkCardinal.mk.{u} : Type u → Cardinal.{u}The cardinal number of a type↑𝓩Set (Θ X)≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_1_1C2_1_1 (k a : ℕ) : ℕkℕaℕ)
Proof. By applying property thirddb k times, we obtain a collection
\mathcal{Z}' \subset \Mf with |\mathcal{Z}'| = 2^{ka} and
B_{B'}(\mfa,r2^k) \subset \bigcup_{z' \in \mathcal{Z}'} B_{B'}(z', \frac{r}{2}).
Then each z \in \mathcal{Z} is contained in one of the balls
B(z', \frac{r}{2}), but by the separation assumption no such ball contains
more than one element of \mathcal{Z}. Thus
|\mathcal{Z}| \le |\mathcal{Z}'| = 2^{ka}.
The next lemma concerns monotonicity of the metrics
d_{B(c(I), \frac 14 D^{s(I)})} with respect to inclusion of cubes I in a
grid.
Lemma1.11
✓L∃∀N
Associated Lean declarations
-
Grid.dist_mono[complete] -
Grid.dist_strictMono[complete]
Used by 7
Preview
Lemma 1.46
Let (\mathcal{D}, c, s) be a grid structure. Denote for cubes
I \in \mathcal{D}
I^\circ := B(c(I), \frac{1}{4} D^{s(I)}).
Let I, J \in \mathcal{D} with I \subset J. Then for all
\mfa, \mfb \in\Mf we have
d_{I^\circ}(\mfa, \mfb) \le d_{J^\circ}(\mfa, \mfb),
and if I \ne J then we have
d_{I^\circ}(\mfa, \mfb) \le 2^{-95a} d_{J^\circ}(\mfa, \mfb).
Lean code for Lemma1.11●2 theorems
Associated Lean declarations
-
Grid.dist_mono[complete]
-
Grid.dist_strictMono[complete]
Associated Lean declarations
-
Grid.dist_mono[complete] -
Grid.dist_strictMono[complete]
-
theoremdefined in Carleson/GridStructure.leancomplete
theorem Grid.dist_mono.{u_1}
Grid.dist_mono.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [GridStructure X (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {I J : Grid X} (hpq : I ≤ J) {f g : Θ X} : dist_{c I, ↑(defaultD a) ^ s I / 4} f g ≤ dist_{c J, ↑(defaultD a) ^ s J / 4} f gWeaker version of Lemma 2.1.2.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [GridStructureGridStructure.{u, u_2} (X : Type u_2) {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (max (u + 1) u_2)A grid structure on `X`. We prefer `coeGrid : Grid → Set X` over `Grid : Set (Set X)` Note: the `s` in this paper is `-s` of Christ's paper.XType u_1(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {IGrid XJGrid X: GridGrid.{u} (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Type uThe indexing type of the grid structure. Elements are called (dyadic) cubes. Note that this type has instances for both `≤` and `⊆`, but they do *not* coincide.XType u_1} (hpqI ≤ J: IGrid X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.JGrid X) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XIGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤIGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XJGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤJGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ Xtheorem Grid.dist_mono.{u_1}
Grid.dist_mono.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [GridStructure X (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {I J : Grid X} (hpq : I ≤ J) {f g : Θ X} : dist_{c I, ↑(defaultD a) ^ s I / 4} f g ≤ dist_{c J, ↑(defaultD a) ^ s J / 4} f gWeaker version of Lemma 2.1.2.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [GridStructureGridStructure.{u, u_2} (X : Type u_2) {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (max (u + 1) u_2)A grid structure on `X`. We prefer `coeGrid : Grid → Set X` over `Grid : Set (Set X)` Note: the `s` in this paper is `-s` of Christ's paper.XType u_1(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {IGrid XJGrid X: GridGrid.{u} (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Type uThe indexing type of the grid structure. Elements are called (dyadic) cubes. Note that this type has instances for both `≤` and `⊆`, but they do *not* coincide.XType u_1} (hpqI ≤ J: IGrid X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.JGrid X) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XIGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤIGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XJGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤJGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ XWeaker version of Lemma 2.1.2.
-
theoremdefined in Carleson/GridStructure.leancomplete
theorem Grid.dist_strictMono.{u_1}
Grid.dist_strictMono.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [GridStructure X (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {I J : Grid X} (hpq : I < J) {f g : Θ X} : dist_{c I, ↑(defaultD a) ^ s I / 4} f g ≤ C2_1_2 a * dist_{c J, ↑(defaultD a) ^ s J / 4} f gStronger version of Lemma 2.1.2.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [GridStructureGridStructure.{u, u_2} (X : Type u_2) {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (max (u + 1) u_2)A grid structure on `X`. We prefer `coeGrid : Grid → Set X` over `Grid : Set (Set X)` Note: the `s` in this paper is `-s` of Christ's paper.XType u_1(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {IGrid XJGrid X: GridGrid.{u} (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Type uThe indexing type of the grid structure. Elements are called (dyadic) cubes. Note that this type has instances for both `≤` and `⊆`, but they do *not* coincide.XType u_1} (hpqI < J: IGrid X<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.JGrid X) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XIGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤIGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.C2_1_2C2_1_2 (a : ℕ) : ℝThe constant appearing in Lemma 2.1.2, `2 ^ {-95a}`.aℕ*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XJGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤJGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ Xtheorem Grid.dist_strictMono.{u_1}
Grid.dist_strictMono.{u_1} {X : Type u_1} [PseudoMetricSpace X] {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [ProofData a q K σ₁ σ₂ F G] [GridStructure X (defaultD a) (defaultκ a) (defaultS X) (cancelPt X)] {I J : Grid X} (hpq : I < J) {f g : Θ X} : dist_{c I, ↑(defaultD a) ^ s I / 4} f g ≤ C2_1_2 a * dist_{c J, ↑(defaultD a) ^ s J / 4} f gStronger version of Lemma 2.1.2.{XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {qℝ: ℝReal : TypeThe type `ℝ` of real numbers constructed as equivalence classes of Cauchy sequences of rational numbers.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} {σ₁X → ℤσ₂X → ℤ: XType u_1→ ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {FSet XGSet X: SetSet.{u} (α : Type u) : Type uA set is a collection of elements of some type `α`. Although `Set` is defined as `α → Prop`, this is an implementation detail which should not be relied on. Instead, `setOf` and membership of a set (`∈`) should be used to convert between sets and predicates.XType u_1} [ProofDataProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (q : outParam ℝ) (K : outParam (X → X → ℂ)) (σ₁ σ₂ : outParam (X → ℤ)) (F G : outParam (Set X)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7 (except 3).aℕqℝKX → X → ℂσ₁X → ℤσ₂X → ℤFSet XGSet X] [GridStructureGridStructure.{u, u_2} (X : Type u_2) {A : outParam NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] (D : outParam ℕ) (κ : outParam ℝ) (S : outParam ℕ) (o : outParam X) : Type (max (u + 1) u_2)A grid structure on `X`. We prefer `coeGrid : Grid → Set X` over `Grid : Set (Set X)` Note: the `s` in this paper is `-s` of Christ's paper.XType u_1(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) (defaultκdefaultκ (a : ℕ) : ℝThe constant `κ` from (2.0.2).aℕ) (defaultSdefaultS.{u_1} (X : Type u_1) {a : ℕ} {q : ℝ} {K : X → X → ℂ} {σ₁ σ₂ : X → ℤ} {F G : Set X} [PseudoMetricSpace X] [ProofData a q K σ₁ σ₂ F G] : ℕXType u_1) (cancelPtcancelPt.{u_1, u_2} {𝕜 : Type u_1} (X : Type u_2) {A : ℕ} [RCLike 𝕜] [PseudoMetricSpace X] [CompatibleFunctions 𝕜 X A] : XThe point `o` in the blueprintXType u_1)] {IGrid XJGrid X: GridGrid.{u} (X : Type u) {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Type uThe indexing type of the grid structure. Elements are called (dyadic) cubes. Note that this type has instances for both `≤` and `⊆`, but they do *not* coincide.XType u_1} (hpqI < J: IGrid X<LT.lt.{u} {α : Type u} [self : LT α] : α → α → PropThe less-than relation: `x < y` Conventions for notations in identifiers: * The recommended spelling of `<` in identifiers is `lt`.JGrid X) {fΘ XgΘ X: ΘFunctionDistances.Θ.{u, u_3} {𝕜 : outParam (Type u_3)} (X : Type u) {inst✝ : NormedField 𝕜} {inst✝¹ : TopologicalSpace X} [self : FunctionDistances 𝕜 X] : Type uA type of continuous functions from `X` to `𝕜`.XType u_1} : dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XIGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤIGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ X≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.C2_1_2C2_1_2 (a : ℕ) : ℝThe constant appearing in Lemma 2.1.2, `2 ^ {-95a}`.aℕ*HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.dist_{Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointscc.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → XJGrid X,Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two points↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.ss.{u} {X : Type u} {A : NNReal} [PseudoMetricSpace X] [MeasureTheory.DoublingMeasure X A] {D : ℕ} {κ : ℝ} {S : ℕ} {o : X} [GridStructure X D κ S o] : Grid X → ℤJGrid X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4}Dist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsfΘ XgΘ XStronger version of Lemma 2.1.2.
Proof. If s(I) \ge s(J) then dyadicproperty and the assumption
I\subset J imply I = J. Then the lemma holds by reflexivity.
If s(J) \ge s(I)+1, then using the monotonicity property monotonedb,
defineD and seconddb, we get
d_{I^\circ}(\mfa, \mfb) \le d_{B(c(I), 4 D^{s(I)})}(\mfa, \mfb) \le 2^{-100a} d_{B(c(I), 4D^{s(J)})}(\mfa, \mfb).
Using eq-vol-sp-cube, together with the inclusion I \subset J, we obtain
c(I) \in I \subset J \subset B(c(J), 4 D^{s(J)})
and consequently by the triangle inequality
B(c(I), 4 D^{s(J)}) \subset B(c(J), 8 D^{s(J)}).
Using this together with the monotonicity property monotonedb and firstdb
in the previous estimate, we obtain
d_{I^\circ}(\mfa, \mfb) \le 2^{-100a} d_{B(c(J), 8D^{s(J)})}(\mfa, \mfb)
\le 2^{-100a + 5a} d_{B(c(J), \frac{1}{4}D^{s(J)})}(\mfa, \mfb)
= 2^{-95a}d_{J^\circ}(\mfa, \mfb).
This proves the second inequality claimed in the Lemma, from which the first
follows since a \ge 4 and hence 2^{-95a} \le 1.
We also record the following basic estimates for the kernels K_s.
Lemma1.12
✓L∃∀N
Associated Lean declarations
-
dist_mem_Icc_of_Ks_ne_zero[complete] -
enorm_Ks_le[complete] -
enorm_Ks_sub_Ks_le[complete]
Used by 2
Preview
Lemma 1.85
Let -S\le s\le S and x,y,y'\in X. If K_s(x,y)\neq 0, then we have
\frac{1}{4} D^{s-1} \leq \rho(x,y) \leq \frac{1}{2} D^s.
We have
|K_s(x,y)|\le \frac{2^{102 a^3}}{\mu(B(x, D^{s}))},
and
|K_s(x,y)-K_s(x, y')|\le \frac{2^{127a^3}}{\mu(B(x, D^{s}))}
\left(\frac{ \rho(y,y')}{D^s}\right)^{\frac 1a}.
Lean code for Lemma1.12●3 theorems
Associated Lean declarations
-
dist_mem_Icc_of_Ks_ne_zero[complete]
-
enorm_Ks_le[complete]
-
enorm_Ks_sub_Ks_le[complete]
Associated Lean declarations
-
dist_mem_Icc_of_Ks_ne_zero[complete] -
enorm_Ks_le[complete] -
enorm_Ks_sub_Ks_le[complete]
-
theoremdefined in Carleson/Psi.leancomplete
theorem dist_mem_Icc_of_Ks_ne_zero.{u_1}
dist_mem_Icc_of_Ks_ne_zero.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y : X} (h : Ks s x y ≠ 0) : dist x y ∈ Set.Icc (↑(defaultD a) ^ (s - 1) / 4) (↑(defaultD a) ^ s / 2)Lemma 2.1.3 part 1, equation (2.1.2){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyX: XType u_1} (hKs s x y ≠ 0: KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX≠Ne.{u} {α : Sort u} (a b : α) : Prop`a ≠ b`, or `Ne a b` is defined as `¬ (a = b)` or `a = b → False`, and asserts that `a` and `b` are not equal. Conventions for notations in identifiers: * The recommended spelling of `≠` in identifiers is `ne`.0) : distDist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsxXyX∈Membership.mem.{u, v} {α : outParam (Type u)} {γ : Type v} [self : Membership α γ] : γ → α → PropThe membership relation `a ∈ s : Prop` where `a : α`, `s : γ`. Conventions for notations in identifiers: * The recommended spelling of `∈` in identifiers is `mem`.Set.IccSet.Icc.{u_1} {α : Type u_1} [Preorder α] (a b : α) : Set α`Icc a b` is the left-closed right-closed interval $[a, b]$.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).sℤ-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator)./HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.2)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.theorem dist_mem_Icc_of_Ks_ne_zero.{u_1}
dist_mem_Icc_of_Ks_ne_zero.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y : X} (h : Ks s x y ≠ 0) : dist x y ∈ Set.Icc (↑(defaultD a) ^ (s - 1) / 4) (↑(defaultD a) ^ s / 2)Lemma 2.1.3 part 1, equation (2.1.2){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyX: XType u_1} (hKs s x y ≠ 0: KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX≠Ne.{u} {α : Sort u} (a b : α) : Prop`a ≠ b`, or `Ne a b` is defined as `¬ (a = b)` or `a = b → False`, and asserts that `a` and `b` are not equal. Conventions for notations in identifiers: * The recommended spelling of `≠` in identifiers is `ne`.0) : distDist.dist.{u_3} {α : Type u_3} [self : Dist α] : α → α → ℝDistance between two pointsxXyX∈Membership.mem.{u, v} {α : outParam (Type u)} {γ : Type v} [self : Membership α γ] : γ → α → PropThe membership relation `a ∈ s : Prop` where `a : α`, `s : γ`. Conventions for notations in identifiers: * The recommended spelling of `∈` in identifiers is `mem`.Set.IccSet.Icc.{u_1} {α : Type u_1} [Preorder α] (a b : α) : Set α`Icc a b` is the left-closed right-closed interval $[a, b]$.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).sℤ-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).1)HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator)./HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.4)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.2)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.Lemma 2.1.3 part 1, equation (2.1.2)
-
theoremdefined in Carleson/Psi.leancomplete
theorem enorm_Ks_le.{u_1}
enorm_Ks_le.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y : X} : ‖Ks s x y‖ₑ ≤ ↑(C2_1_3 a) / MeasureTheory.volume (Metric.ball x (↑(defaultD a) ^ s))Lemma 2.1.3 part 2, equation (2.1.3){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyX: XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_1_3C2_1_3 (a : ℕ) : NNRealThe constant appearing in part 2 of Lemma 2.1.3. Equal to `2 ^ (102 * a ^ 3)` in the blueprint.aℕ) /HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xX(HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.)theorem enorm_Ks_le.{u_1}
enorm_Ks_le.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y : X} : ‖Ks s x y‖ₑ ≤ ↑(C2_1_3 a) / MeasureTheory.volume (Metric.ball x (↑(defaultD a) ^ s))Lemma 2.1.3 part 2, equation (2.1.3){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyX: XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(C2_1_3C2_1_3 (a : ℕ) : NNRealThe constant appearing in part 2 of Lemma 2.1.3. Equal to `2 ^ (102 * a ^ 3)` in the blueprint.aℕ) /HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xX(HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.)Lemma 2.1.3 part 2, equation (2.1.3)
-
theoremdefined in Carleson/Psi.leancomplete
theorem enorm_Ks_sub_Ks_le.{u_1}
enorm_Ks_sub_Ks_le.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y y' : X} : ‖Ks s x y - Ks s x y'‖ₑ ≤ ↑(D2_1_3 a) / MeasureTheory.volume (Metric.ball x (↑(defaultD a) ^ s)) * (edist y y' / ↑(defaultD a) ^ s) ^ (↑a)⁻¹Lemma 2.1.3 part 3, equation (2.1.4){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyXy'X: XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXy'X‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(D2_1_3D2_1_3 (a : ℕ) : NNRealThe constant appearing in part 3 of Lemma 2.1.3. Equal to `2 ^ (127 * a ^ 3)` in the blueprint.aℕ) /HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xX(HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.edistEDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsyXy'X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(↑aℕ)⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.theorem enorm_Ks_sub_Ks_le.{u_1}
enorm_Ks_sub_Ks_le.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] {s : ℤ} {x y y' : X} : ‖Ks s x y - Ks s x y'‖ₑ ≤ ↑(D2_1_3 a) / MeasureTheory.volume (Metric.ball x (↑(defaultD a) ^ s)) * (edist y y' / ↑(defaultD a) ^ s) ^ (↑a)⁻¹Lemma 2.1.3 part 3, equation (2.1.4){XType u_1: Type u_1A type universe. `Type ≡ Type 0`, `Type u ≡ Sort (u + 1)`.} {aℕ: ℕNat : TypeThe natural numbers, starting at zero. This type is special-cased by both the kernel and the compiler, and overridden with an efficient implementation. Both use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.} {KX → X → ℂ: XType u_1→ XType u_1→ ℂComplex : TypeComplex numbers consist of two `Real`s: a real part `re` and an imaginary part `im`.} [PseudoMetricSpacePseudoMetricSpace.{u} (α : Type u) : Type uA pseudometric space is a type endowed with a `ℝ`-valued distance `dist` satisfying reflexivity `dist x x = 0`, commutativity `dist x y = dist y x`, and the triangle inequality `dist x z ≤ dist x y + dist y z`. Note that we do not require `dist x y = 0 → x = y`. See metric spaces (`MetricSpace`) for the similar class with that stronger assumption. Any pseudometric space is a topological space and a uniform space (see `TopologicalSpace`, `UniformSpace`), where the topology and uniformity come from the metric. Note that a T1 pseudometric space is just a metric space. We make the uniformity/topology part of the data instead of deriving it from the metric. This e.g. ensures that we do not get a diamond when doing `[PseudoMetricSpace α] [PseudoMetricSpace β] : TopologicalSpace (α × β)`: The product metric and product topology agree, but not definitionally so. See Note [forgetful inheritance].XType u_1] [KernelProofDataKernelProofData.{u_1} {X : Type u_1} (a : outParam ℕ) (K : outParam (X → X → ℂ)) [PseudoMetricSpace X] : Type (u_1 + 1)Data common through most of chapters 2-7. These contain the minimal axioms for `kernel-summand`'s proof. This is used in chapter 3 when we don't have all other fields from `ProofData`.aℕKX → X → ℂ] {sℤ: ℤInt : TypeThe integers. This type is special-cased by the compiler and overridden with an efficient implementation. The runtime has a special representation for `Int` that stores “small” signed numbers directly, while larger numbers use a fast arbitrary-precision arithmetic library (usually [GMP](https://gmplib.org/)). A “small number” is an integer that can be encoded with one fewer bits than the platform's pointer size (i.e. 63 bits on 64-bit architectures and 31 bits on 32-bit architectures).} {xXyXy'X: XType u_1} : ‖ENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXyX-HSub.hSub.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HSub α β γ] : α → β → γ`a - b` computes the difference of `a` and `b`. The meaning of this notation is type-dependent. * For natural numbers, this operator saturates at 0: `a - b = 0` when `a ≤ b`. Conventions for notations in identifiers: * The recommended spelling of `-` in identifiers is `sub` (when used as a binary operator).KsKs.{u_1} {X : Type u_1} {a : ℕ} {K : X → X → ℂ} [PseudoMetricSpace X] [KernelProofData a K] (s : ℤ) (x y : X) : ℂK_s in the blueprintsℤxXy'X‖ₑENorm.enorm.{u_8} {E : Type u_8} [self : ENorm E] : E → ENNRealthe `ℝ≥0∞`-valued norm function.≤LE.le.{u} {α : Type u} [self : LE α] : α → α → PropThe less-equal relation: `x ≤ y` Conventions for notations in identifiers: * The recommended spelling of `≤` in identifiers is `le`.↑(D2_1_3D2_1_3 (a : ℕ) : NNRealThe constant appearing in part 3 of Lemma 2.1.3. Equal to `2 ^ (127 * a ^ 3)` in the blueprint.aℕ) /HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.MeasureTheory.volumeMeasureTheory.MeasureSpace.volume.{u_6} {α : Type u_6} [self : MeasureTheory.MeasureSpace α] : MeasureTheory.Measure α`volume` is the canonical measure on `α`.(Metric.ballMetric.ball.{u} {α : Type u} [PseudoMetricSpace α] (x : α) (ε : ℝ) : Set α`ball x ε` is the set of all points `y` with `dist y x < ε`xX(HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.) *HMul.hMul.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HMul α β γ] : α → β → γ`a * b` computes the product of `a` and `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `*` in identifiers is `mul`.(HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.edistEDist.edist.{u_2} {α : Type u_2} [self : EDist α] : α → α → ENNRealExtended distance between two pointsyXy'X/HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.↑(defaultDdefaultD (a : ℕ) : ℕThe constant `D` from (2.0.1).aℕ) ^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.sℤ)HDiv.hDiv.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HDiv α β γ] : α → β → γ`a / b` computes the result of dividing `a` by `b`. The meaning of this notation is type-dependent. * For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`. * For `Nat`, `a / b` rounds downwards. * For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative. It is implemented as `Int.ediv`, the unique function satisfying `a % b + b * (a / b) = a` and `0 ≤ a % b < natAbs b` for `b ≠ 0`. Other rounding conventions are available using the functions `Int.fdiv` (floor rounding) and `Int.tdiv` (truncation rounding). * For `Float`, `a / 0` follows the IEEE 754 semantics for division, usually resulting in `inf` or `nan`. Conventions for notations in identifiers: * The recommended spelling of `/` in identifiers is `div`.^HPow.hPow.{u, v, w} {α : Type u} {β : Type v} {γ : outParam (Type w)} [self : HPow α β γ] : α → β → γ`a ^ b` computes `a` to the power of `b`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `^` in identifiers is `pow`.(↑aℕ)⁻¹Inv.inv.{u} {α : Type u} [self : Inv α] : α → α`a⁻¹` computes the inverse of `a`. The meaning of this notation is type-dependent. Conventions for notations in identifiers: * The recommended spelling of `⁻¹` in identifiers is `inv`.Lemma 2.1.3 part 3, equation (2.1.4)
Proof. By Definition defks, the function K_s is the product of K with a
function which is supported in the set of all x,y satisfying supp-Ks.
This proves supp-Ks.
Using eqkernel-size and the lower bound in supp-Ks we obtain
|K_s(x,y)|\le |K(x,y)|\le \frac{2^{a^3}}{\mu(B(x,\frac 14 D^{s-1}))}.
Using D=2^{100a^2} and the doubling property doublingx 2 +100a^2 times
estimates the last display by
\le \frac{2^{2a+101a^3}}{\mu(B(x, D^{s}))}.
Using a\ge 4 proves eq-Ks-size.
To prove eq-Ks-smooth when 2\rho(y,y') > \rho(x,y), use the lower bound
in supp-Ks and the inequality
2\rho(y,y') > \frac{1}{4}D^{s-1}. Then eq-Ks-smooth follows from the
triangle inequality, eq-Ks-size and a \ge 4.
If 2\rho(y,y') \le \rho(x,y), we rewrite
|K_s(x,y)-K_s(x, y')| as
|(K(x,y)-K(x,y')) \psi(D^{-s}\rho(x,y)) +
K(x,y)(\psi(D^{-s}\rho(x,y))-\psi(D^{-s}\rho(x,y')))|.
An upper bound for |K(x,y)-K(x, y')| is obtained similarly to the proof of
eq-Ks-size, using eqkernel-y-smooth and the lower bound in supp-Ks
|K(x,y)-K(x, y')|\le \frac{2^{a^3}}{\mu(B(x, \frac 14 D^{s-1}))}
\left(\frac{ \rho(y,y')}{\frac 14 D^{s-1}}\right)^{\frac 1a}.
As above, this is estimated by
\le \frac{4D 2^{2a+101a^3}}{\mu(B(x, D^{s}))}
\left(\frac{ \rho(y,y')}{D^{s}}\right)^{\frac 1a}
= \frac{2^{2+2a+100a^2+101a^3}}{\mu(B(x, D^{s}))}
\left(\frac{ \rho(y,y')}{D^{s}}\right)^{\frac 1a}.
We have the trivial bound |\psi(D^{-s}\rho(x,y))| \leq 1, and eq-Ks-aux
provides a bound for |K(x,y)|. Finally, we show that
|\psi(D^{-s}\rho(x,y))-\psi(D^{-s}\rho(x,y'))|\le
4D \left(\frac{\rho(y, y')}{D ^ s}\right)^{\frac 1a}
by considering separately the cases \rho(y,y')/D^s \ge 1 and
\rho(y,y')/D^s < 1. In the former case, the inequality is trivial; in the
latter case, it follows from the fact that \psi is Lipschitz with constant
4D.
Combining the above bounds and using a\ge 4 proves eq-Ks-smooth when
2\rho(y,y') \le \rho(x,y).