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