File size: 4,118 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
import OAI.Analysis.CircleDomains.Sobolev.CoordinateGradientSize
import OAI.Analysis.CircleDomains.Sobolev.PriorSmoothedCompatibility

namespace OAI

/-! The real barrier in the endpoint problem, with its actual physical
representative, countable enlarged flags, and finite-torus compatibility. -/

open Set Function Filter MeasureTheory
open scoped ENNReal Topology

noncomputable section
namespace CircleDomainRigidity

attribute [local instance] sphereMetric sphereBorel
local instance : BorelSpace Sphere := ⟨rfl⟩

variable [MeasurableSpace C(PathTime, Sphere)]

structure CompatibleLevelBarrier (d : PathCodeData Sphere Sphere) (Ο€ : Sphere β†’ Sphere)
    (previous : PriorLevelFamily d.physicalDomain Ο€) (flags EStar : Set Sphere)
    (regions : β„• β†’ Set Sphere) (f : d.quotientDomain β†’ Sphere) (W₁ : Set Sphere) where
  coordinate : PhysicalRealCoordinate d Ο€
  level : β„•
  penalty : Set Sphere
  penalty_open : IsOpen penalty
  penalty_inside : closure penalty βŠ† d.quotientDomain
  penalty_disjoint : Disjoint d.anchor (closure penalty)
  penalty_avoids : βˆ€x : d.quotientDomain, x.val ∈ closure penalty β†’ f x βˆ‰ W₁
  zero : βˆ€x ∈ EStar, coordinate.quotient x = 0
  one : βˆ€x ∈ closure (regions level) ∩ d.quotientDomain, coordinate.quotient x = 1
  exclusions : Set Sphere
  exclusions_countable : exclusions.Countable
  prior_flags : flags βŠ† exclusions
  weight : Sphere β†’ ℝβ‰₯0∞
  weight_finite : (βˆ‘'s, weight s ^ 2) < ∞
  weight_support : support weight βŠ† exclusions
  band_bound : βˆ€s ∈ d.dust, ENNReal.ofReal
    (limsup coordinate.quotient (𝓝[d.quotientDomain] s) -
      liminf coordinate.quotient (𝓝[d.quotientDomain] s)) ≀ weight s
  compatible : βˆ€n labels, (volume.prod (Measure.pi (fun _ : Fin (n + 1) =>
    (volume : Measure UnitAddCircle))))
    (freeComponentFailure (d.dust \ exclusions)
      (circleBandGraph d.quotientDomain coordinate.quotient)
      (fun i => previous.graph i) labels) = 0

namespace CompatibleLevelBarrier

variable {d : PathCodeData Sphere Sphere} {Ο€ : Sphere β†’ Sphere}
  {previous : PriorLevelFamily d.physicalDomain Ο€} {flags EStar : Set Sphere}
  {regions : β„• β†’ Set Sphere} {f : d.quotientDomain β†’ Sphere} {W₁ : Set Sphere}

def controlledSize (B : CompatibleLevelBarrier d Ο€ previous flags EStar regions f W₁) : ℝβ‰₯0∞ :=
  ENNReal.ofReal (Real.sqrt (∫x in FiniteTransfer.realChartDomain d.physicalDomain \
    (fun x : ℝ Γ— ℝ => Ο€ (Complex.equivRealProdCLM.symm x : Sphere)) ⁻¹' B.penalty,
      FiniteTransfer.gradientEnergy B.coordinate.physical
        (fun z => FiniteTransfer.sphericalMetricFactor z β€’ 1) x)) +
    countingSquareNorm B.weight

theorem finite_compatibility
    (B : CompatibleLevelBarrier d Ο€ previous flags EStar regions f W₁)
    (n : β„•) (labels : Fin n β†’ β„•) :
    (volume.prod (Measure.pi (fun _ : Fin n => (volume : Measure UnitAddCircle))))
      (freeComponentFailure (d.dust \ B.exclusions)
        (circleBandGraph d.quotientDomain B.coordinate.quotient)
        (fun i => previous.graph i) labels) = 0 := by
  cases n with
  | zero => simp only [freeComponentFailure_empty_labels, measure_empty]
  | succ n => exact B.compatible n labels

theorem controlledSize_le_of_partial_bounds
    (B : CompatibleLevelBarrier d Ο€ previous flags EStar regions f W₁)
    {A : ℝβ‰₯0∞} (hA : A β‰  ∞)
    (hbound : βˆ€i : Fin 2, eLpNorm (fun x => (fderiv ℝ B.coordinate.physical x)
      (if i = 0 then (1, 0) else (0, 1))) 2
      (volume.restrict (FiniteTransfer.realChartDomain d.physicalDomain \
        (fun x : ℝ Γ— ℝ => Ο€ (Complex.equivRealProdCLM.symm x : Sphere)) ⁻¹' B.penalty)) ≀ A) :
    B.controlledSize ≀ 2 * A + countingSquareNorm B.weight := by
  refine add_le_add ?_ le_rfl
  have hb := physical_coordinate_gradient_size_le d Ο€ B.coordinate
    (fun _ hx => hx.1) hA hbound
  have h := ENNReal.ofReal_le_ofReal hb
  simpa only [ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≀ 2),
    ENNReal.ofReal_ofNat, ENNReal.ofReal_toReal hA] using h

end CompatibleLevelBarrier
end CircleDomainRigidity

end

end OAI