math / data /lean /OAI /AlgebraicGeometry /ComplexMultiplication /HodgeComparison /CompactKernel.lean
Download data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/HodgeComparison/CompactKernel.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.98 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/HodgeComparison/CompactKernel.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/HodgeComparison/CompactKernel.lean
-
curl -L -o CompactKernel.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/ComplexMultiplication/HodgeComparison/CompactKernel.lean
4.98 kB
| 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 | |