File size: 7,525 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
import OAI.Dynamics.EntropyCounterexample.ClockCharts
import OAI.Dynamics.EntropyCounterexample.C1Coordinates

namespace OAI

noncomputable section

open scoped ContDiff

namespace Problem340

def clockLocalLift (tβ‚€ : ℝ) (x : ClockAmbient) : ℝ :=
  tβ‚€ + (100 / (2 * Real.pi)) *
    Complex.arg (complexClockLinearIsometry.symm x /
      Complex.exp ((2 * Real.pi / 100 * tβ‚€ : ℝ) * Complex.I))

theorem clockHomeomorph_clockLocalLift (tβ‚€ : ℝ) (x : StandardClock) :
    clockHomeomorph ((clockLocalLift tβ‚€ x.1 : ℝ) : AddCircle (100 : ℝ)) = x := by
  let c : Circle := circleClockHomeomorph.symm x
  let cβ‚€ : Circle := AddCircle.toCircle (tβ‚€ : AddCircle (100 : ℝ))
  have hc : (c : β„‚) = complexClockLinearIsometry.symm x.1 := rfl
  have hcβ‚€ : (cβ‚€ : β„‚) = Complex.exp ((2 * Real.pi / 100 * tβ‚€ : ℝ) * Complex.I) := rfl
  have hlift : clockLocalLift tβ‚€ x.1 =
      tβ‚€ + (100 / (2 * Real.pi)) * Complex.arg ((c / cβ‚€ : Circle) : β„‚) := by
    simp only [clockLocalLift, Circle.coe_div, hc, hcβ‚€]
  have hangle : (2 * Real.pi / 100) *
      (tβ‚€ + (100 / (2 * Real.pi)) * Complex.arg ((c / cβ‚€ : Circle) : β„‚)) =
      (2 * Real.pi / 100) * tβ‚€ + Complex.arg ((c / cβ‚€ : Circle) : β„‚) := by
    field_simp
  rw [clockHomeomorph_apply, hlift, AddCircle.toCircle_apply_mk, hangle, Circle.exp_add,
    Circle.exp_arg]
  change circleClockHomeomorph (cβ‚€ * (c / cβ‚€)) = x
  simp [c, div_eq_mul_inv, mul_comm]

theorem contDiffOn_arg_slitPlane {n : β„•βˆžΟ‰} :
    ContDiffOn ℝ n Complex.arg Complex.slitPlane := by
  intro z hz
  have hlog : ContDiffAt ℝ n Complex.log z :=
    (Complex.contDiffAt_log hz).restrict_scalars ℝ
  have h := Complex.imCLM.contDiff.contDiffAt.comp z hlog
  have heq : (Complex.imCLM ∘ Complex.log) = Complex.arg := by
    funext w
    exact Complex.log_im w
  rw [heq] at h
  exact h.contDiffWithinAt

theorem clockLocalLift_extension (tβ‚€ : ℝ) {n : β„•βˆžΟ‰} :
    βˆƒ U : Set ClockAmbient, IsOpen U ∧ clockParam tβ‚€ ∈ U ∧
      ContDiffOn ℝ n (clockLocalLift tβ‚€) U := by
  let D : ClockAmbient β†’ β„‚ := fun x => complexClockLinearIsometry.symm x /
    Complex.exp ((2 * Real.pi / 100 * tβ‚€ : ℝ) * Complex.I)
  have hD : ContDiff ℝ n D :=
    complexClockLinearIsometry.symm.toContinuousLinearEquiv.contDiff.div_const _
  have hbase : D (clockParam tβ‚€) = 1 := by
    simp [D, clockParam, Complex.exp_ne_zero]
  refine ⟨D ⁻¹' Complex.slitPlane, Complex.isOpen_slitPlane.preimage hD.continuous,
    ?_, ?_⟩
  Β· change D (clockParam tβ‚€) ∈ Complex.slitPlane
    rw [hbase]
    exact Complex.one_mem_slitPlane
  Β· exact contDiffOn_const.add (contDiffOn_const.mul
      (contDiffOn_arg_slitPlane.comp hD.contDiffOn fun _ hx => hx))

theorem hasLocalC1Extension_of_clock_lift
    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
    (f : StandardClock β†’ F)
    (hf : ContDiff ℝ 1 (fun t : ℝ => f (clockHomeomorph (t : AddCircle (100 : ℝ))))) :
    HasLocalC1Extension (fun x : StandardClock => x.1) f := by
  intro x
  obtain ⟨t, rfl⟩ := clockHomeomorph.surjective x
  induction t using QuotientAddGroup.induction_on with
  | H t =>
    obtain ⟨U, hU, htU, hlocal⟩ := clockLocalLift_extension t (n := 1)
    refine ⟨U, hU, ?_,
      fun y => f (clockHomeomorph ((clockLocalLift t y : ℝ) : AddCircle (100 : ℝ))),
      hf.comp_contDiffOn hlocal, ?_⟩
    Β· simpa only [clockHomeomorph_coe] using htU
    Β· intro y _
      change f y = f (clockHomeomorph ((clockLocalLift t y.1 : ℝ) : AddCircle (100 : ℝ)))
      rw [clockHomeomorph_clockLocalLift]

theorem hasLocalC1Extension_of_clock_lift_with_parameters
    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [NormedAddCommGroup F] [NormedSpace ℝ F]
    (f : StandardClock Γ— E β†’ F)
    (hf : ContDiff ℝ 1 (fun p : ℝ Γ— E =>
      f (clockHomeomorph (p.1 : AddCircle (100 : ℝ)), p.2))) :
    HasLocalC1Extension (fun x : StandardClock Γ— E => (x.1.1, x.2)) f := by
  rintro ⟨x, a⟩
  obtain ⟨t, rfl⟩ := clockHomeomorph.surjective x
  induction t using QuotientAddGroup.induction_on with
  | H t =>
    obtain ⟨U, hU, htU, hlocal⟩ := clockLocalLift_extension t (n := 1)
    refine ⟨U Γ—Λ’ Set.univ, hU.prod isOpen_univ,
      ⟨?_, Set.mem_univ a⟩,
      fun p : ClockAmbient Γ— E =>
        f (clockHomeomorph ((clockLocalLift t p.1 : ℝ) : AddCircle (100 : ℝ)), p.2),
      ?_, ?_⟩
    Β· simpa only [clockHomeomorph_coe] using htU
    Β· have hfst : ContDiffOn ℝ 1 (fun p : ClockAmbient Γ— E => clockLocalLift t p.1)
          (U Γ—Λ’ Set.univ) :=
        hlocal.comp contDiffOn_fst (fun _ hx => hx.1)
      have hpair : ContDiffOn ℝ 1
          (fun p : ClockAmbient Γ— E => (clockLocalLift t p.1, p.2))
          (U Γ—Λ’ Set.univ) := hfst.prodMk contDiffOn_snd
      convert hf.comp_contDiffOn hpair using 1
      rfl
    · rintro ⟨y, b⟩ _
      change f (y, b) =
        f (clockHomeomorph ((clockLocalLift t y.1 : ℝ) : AddCircle (100 : ℝ)), b)
      rw [clockHomeomorph_clockLocalLift]

def clockFunction {F : Type*} (b : ℝ β†’ F) (hb : Function.Periodic b 100) :
    StandardClock β†’ F := hb.lift ∘ clockHomeomorph.symm

@[simp]
theorem clockFunction_param {F : Type*} (b : ℝ β†’ F)
    (hb : Function.Periodic b 100) (t : ℝ) :
    clockFunction b hb (clockHomeomorph (t : AddCircle (100 : ℝ))) = b t := by
  change hb.lift (clockHomeomorph.symm (clockHomeomorph (t : AddCircle (100 : ℝ)))) = b t
  rw [clockHomeomorph.symm_apply_apply]
  rfl

theorem hasLocalC1Extension_clockFunction
    {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
    (b : ℝ β†’ F) (hb : Function.Periodic b 100) (hcont : ContDiff ℝ 1 b) :
    HasLocalC1Extension (fun x : StandardClock => x.1) (clockFunction b hb) := by
  apply hasLocalC1Extension_of_clock_lift
  simpa only [clockFunction_param] using hcont

theorem hasLocalC1Extension_of_clock_lift_on
    {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [NormedAddCommGroup F] [NormedSpace ℝ F]
    {V : Set E} (hV : IsOpen V) (f : StandardClock Γ— E β†’ F)
    (hf : ContDiffOn ℝ 1 (fun p : ℝ Γ— E =>
      f (clockHomeomorph (p.1 : AddCircle (100 : ℝ)), p.2)) (Set.univ Γ—Λ’ V)) :
    HasLocalC1Extension (fun x : StandardClock Γ— V => (x.1.1, x.2.1))
      (fun x => f (x.1, x.2.1)) := by
  rintro ⟨x, a⟩
  obtain ⟨t, rfl⟩ := clockHomeomorph.surjective x
  induction t using QuotientAddGroup.induction_on with
  | H t =>
    obtain ⟨U, hU, htU, hlocal⟩ := clockLocalLift_extension t (n := 1)
    refine ⟨U Γ—Λ’ V, hU.prod hV, ⟨?_, a.2⟩,
      fun p : ClockAmbient Γ— E =>
        f (clockHomeomorph ((clockLocalLift t p.1 : ℝ) : AddCircle (100 : ℝ)), p.2),
      ?_, ?_⟩
    Β· simpa only [clockHomeomorph_coe] using htU
    Β· have hfst : ContDiffOn ℝ 1 (fun p : ClockAmbient Γ— E => clockLocalLift t p.1)
          (U Γ—Λ’ V) := hlocal.comp contDiffOn_fst (fun _ hx => hx.1)
      have hpair : ContDiffOn ℝ 1
          (fun p : ClockAmbient Γ— E => (clockLocalLift t p.1, p.2)) (U Γ—Λ’ V) :=
        hfst.prodMk contDiffOn_snd
      have hmaps : Set.MapsTo (fun p : ClockAmbient Γ— E => (clockLocalLift t p.1, p.2))
          (U Γ—Λ’ V) (Set.univ Γ—Λ’ V) := fun _ hp => ⟨Set.mem_univ _, hp.2⟩
      convert hf.comp hpair hmaps using 1
      rfl
    · rintro ⟨y, b⟩ _
      change f (y, b.1) =
        f (clockHomeomorph ((clockLocalLift t y.1 : ℝ) : AddCircle (100 : ℝ)), b.1)
      rw [clockHomeomorph_clockLocalLift]

end Problem340

end

end OAI