File size: 4,979 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | import Mathlib.Topology.ContinuousMap.Bounded.ArzelaAscoli
import Mathlib.Topology.ContinuousMap.Bounded.Normed
import Mathlib.Analysis.Normed.Operator.Compact.Basic
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Normed.Operator.Bilinear
import Mathlib.MeasureTheory.Function.L2Space
/-! # Compact Kernel -/
namespace OAI.AlgebraicGeometry.ComplexMultiplication.HodgeComparison.CompactKernel.CM.Construction
noncomputable section
/-! Compact operators obtained from norm-continuous families of scalar kernels. -/
open Set Filter _root_.Metric _root_.MeasureTheory
open scoped _root_.Topology BoundedContinuousFunction
variable {K H : Type*} [TopologicalSpace K] [CompactSpace K]
[NormedAddCommGroup H] [NormedSpace β H]
/-- Evaluation against a bounded continuous family of linear functionals. -/
def compactKernelMap (k : K βα΅ (H βL[β] β)) : H βL[β] (K βα΅ β) :=
LinearMap.mkContinuous
{ toFun u := (ContinuousLinearMap.apply β β u).compLeftContinuousBounded K k
map_add' u v := by ext x; exact map_add (k x) u v
map_smul' c u := by ext x; exact map_smul (k x) c u }
βkβ (by
intro u
change β(ContinuousLinearMap.apply β β u).compLeftContinuousBounded K kβ β€ βkβ * βuβ
apply (BoundedContinuousFunction.norm_le (mul_nonneg (norm_nonneg k) (norm_nonneg u))).mpr
intro x
change βk x uβ β€ βkβ * βuβ
exact ((k x).le_opNorm u).trans
(mul_le_mul_of_nonneg_right (k.norm_coe_le_norm x) (norm_nonneg _)))
omit [CompactSpace K] in
@[simp]
theorem compactKernelMap_apply (k : K βα΅ (H βL[β] β)) (u : H) (x : K) :
compactKernelMap k u x = k x u := rfl
/-- A norm-continuous family over a compact parameter space gives a compact operator. -/
theorem compactKernelMap_isCompact (k : K βα΅ (H βL[β] β)) :
IsCompactOperator (compactKernelMap k) := by
apply (isCompactOperator_iff_isCompact_closure_image_closedBall
(compactKernelMap k).toLinearMap (by norm_num : (0 : β) < 1)).mpr
let A : Set (K βα΅ β) := compactKernelMap k '' closedBall (0 : H) 1
apply BoundedContinuousFunction.arzela_ascoli (closedBall (0 : β) βkβ)
(isCompact_closedBall _ _) A
Β· intro f x hf
obtain β¨u, hu, rflβ© := hf
rw [mem_closedBall_zero_iff] at hu β’
change βk x uβ β€ βkβ
exact ((k x).le_opNorm u).trans
((mul_le_mul_of_nonneg_right (k.norm_coe_le_norm x) (norm_nonneg _)).trans
(mul_le_of_le_one_right (norm_nonneg _) hu))
Β· intro x
apply Metric.equicontinuousAt_of_continuity_modulus (fun y => βk x - k yβ)
Β· simpa only [Pi.sub_apply, sub_self, norm_zero] using
((continuous_const.sub k.continuous).norm.continuousAt.tendsto :
Tendsto (fun y => βk x - k yβ) (π x) (π βk x - k xβ))
Β· apply Filter.Eventually.of_forall
intro y f
obtain β¨u, hu, heqβ© := f.property
have hnorm : βuβ β€ 1 := mem_closedBall_zero_iff.mp hu
change dist (f.val x) (f.val y) β€ βk x - k yβ
rw [β heq, compactKernelMap_apply, compactKernelMap_apply, dist_eq_norm]
change β(k x - k y) uβ β€ βk x - k yβ
exact ((k x - k y).le_opNorm u).trans
(mul_le_of_le_one_right (norm_nonneg _) hnorm)
variable {X : Type*} [TopologicalSpace X] [CompactSpace X]
[MeasurableSpace X] [BorelSpace X] (ΞΌ : Measure X) [IsFiniteMeasure ΞΌ]
/-- A continuous scalar kernel gives a norm-continuous family of LΒ² functionals. -/
def continuousKernelFunctionals (k : C(K, C(X, β))) :
K βα΅ (Lp β 2 ΞΌ βL[β] β) :=
BoundedContinuousFunction.mkOfCompact
β¨fun y => innerSL β (ContinuousMap.toLp 2 ΞΌ β (star (k y))),
(innerSL β).continuous.comp
((ContinuousMap.toLp 2 ΞΌ β).continuous.comp k.continuous.star)β©
/-- Integrating a continuous kernel against an LΒ² function defines a bounded operator. -/
def continuousIntegralKernelMap (k : C(K, C(X, β))) :
Lp β 2 ΞΌ βL[β] (K βα΅ β) :=
compactKernelMap (continuousKernelFunctionals ΞΌ k)
/-- The operator uses the literal integral of its kernel against the input. -/
theorem continuousIntegralKernelMap_apply (k : C(K, C(X, β))) (u : Lp β 2 ΞΌ) (y : K) :
continuousIntegralKernelMap ΞΌ k u y = β« x, k y x * u x βΞΌ := by
change inner β (ContinuousMap.toLp 2 ΞΌ β (star (k y))) u = _
rw [L2.inner_def]
apply integral_congr_ae
filter_upwards [ContinuousMap.coeFn_toLp (π := β) (p := 2) (ΞΌ := ΞΌ) (star (k y))] with x hx
rw [hx, RCLike.inner_apply']
simp
/-- Continuous integral kernels on compact parameter spaces define compact operators. -/
theorem continuousIntegralKernelMap_isCompact (k : C(K, C(X, β))) :
IsCompactOperator (continuousIntegralKernelMap ΞΌ k) :=
compactKernelMap_isCompact (continuousKernelFunctionals ΞΌ k)
end
end OAI.AlgebraicGeometry.ComplexMultiplication.HodgeComparison.CompactKernel.CM.Construction
|