File size: 6,911 Bytes
92416a2 | 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 | import OAI.Dynamics.EntropyCounterexample.Clock
import OAI.Dynamics.EntropyCounterexample.Embedding
namespace OAI
noncomputable section
namespace Problem340.Clock
def rotate (x : ClockAmbient) (a : ℝ) : ClockAmbient :=
WithLp.toLp 2 ![x 0 * Real.cos a - x 1 * Real.sin a,
x 0 * Real.sin a + x 1 * Real.cos a]
@[simp] lemma rotate_zero_apply (x : ClockAmbient) (a : ℝ) :
rotate x a 0 = x 0 * Real.cos a - x 1 * Real.sin a := rfl
@[simp] lemma rotate_one_apply (x : ClockAmbient) (a : ℝ) :
rotate x a 1 = x 0 * Real.sin a + x 1 * Real.cos a := rfl
lemma norm_rotate (x : ClockAmbient) (a : ℝ) : ‖rotate x a‖ = ‖x‖ := by
apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
rw [EuclideanSpace.real_norm_sq_eq, EuclideanSpace.real_norm_sq_eq]
simp only [Fin.sum_univ_two, rotate_zero_apply, rotate_one_apply]
have hc := Real.sin_sq_add_cos_sq a
nlinarith [sq_nonneg (x 0), sq_nonneg (x 1)]
lemma contDiff_rotate {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
{n : ℕ∞} {x : E → ClockAmbient} {a : E → ℝ}
(hx : ContDiff ℝ n x) (ha : ContDiff ℝ n a) :
ContDiff ℝ n (fun y => rotate (x y) (a y)) := by
apply (contDiff_piLp 2).mpr
intro i
fin_cases i
· exact (((EuclideanSpace.proj (𝕜 := ℝ) (0 : Fin 2)).contDiff.comp hx).mul ha.cos).sub
(((EuclideanSpace.proj (𝕜 := ℝ) (1 : Fin 2)).contDiff.comp hx).mul ha.sin)
· exact (((EuclideanSpace.proj (𝕜 := ℝ) (0 : Fin 2)).contDiff.comp hx).mul ha.sin).add
(((EuclideanSpace.proj (𝕜 := ℝ) (1 : Fin 2)).contDiff.comp hx).mul ha.cos)
def parametrization (t : ℝ) : ClockAmbient :=
WithLp.toLp 2 ![Real.cos (2 * Real.pi * t / 100), Real.sin (2 * Real.pi * t / 100)]
@[simp] lemma parametrization_zero (t : ℝ) :
parametrization t 0 = Real.cos (2 * Real.pi * t / 100) := rfl
@[simp] lemma parametrization_one (t : ℝ) :
parametrization t 1 = Real.sin (2 * Real.pi * t / 100) := rfl
lemma norm_parametrization (t : ℝ) : ‖parametrization t‖ = 1 := by
apply (sq_eq_sq₀ (norm_nonneg _) (by norm_num)).mp
rw [EuclideanSpace.real_norm_sq_eq]
simp only [Fin.sum_univ_two, parametrization_zero, parametrization_one, one_pow]
nlinarith [Real.sin_sq_add_cos_sq (2 * Real.pi * t / 100)]
lemma rotate_parametrization (t h : ℝ) :
rotate (parametrization t) (2 * Real.pi * h / 100) = parametrization (t + h) := by
ext i
fin_cases i
· change Real.cos (2 * Real.pi * t / 100) * Real.cos (2 * Real.pi * h / 100) -
Real.sin (2 * Real.pi * t / 100) * Real.sin (2 * Real.pi * h / 100) =
Real.cos (2 * Real.pi * (t + h) / 100)
rw [show 2 * Real.pi * (t + h) / 100 =
2 * Real.pi * t / 100 + 2 * Real.pi * h / 100 by ring, Real.cos_add]
· change Real.cos (2 * Real.pi * t / 100) * Real.sin (2 * Real.pi * h / 100) +
Real.sin (2 * Real.pi * t / 100) * Real.cos (2 * Real.pi * h / 100) =
Real.sin (2 * Real.pi * (t + h) / 100)
rw [show 2 * Real.pi * (t + h) / 100 =
2 * Real.pi * t / 100 + 2 * Real.pi * h / 100 by ring, Real.sin_add]
ring
def advance (x : StandardClock) (h : ℝ) : StandardClock :=
⟨rotate x.1 (2 * Real.pi * h / 100), by
rw [Metric.mem_sphere, dist_zero_right, norm_rotate]
simp⟩
def ambientIncrement (x : ClockAmbient) (e : ℝ) : ℝ :=
ambientBarrier x + (1 - ambientBarrier x) * e
lemma ambientIncrement_mem_Icc (x : ClockAmbient) (hx : ‖x‖ ≤ 1)
{e : ℝ} (he : e ∈ Set.Icc (0 : ℝ) 1) :
ambientIncrement x e ∈ Set.Icc (0 : ℝ) 1 := by
have hb := ambientBarrier_mem_Icc x hx
have hp : 0 ≤ (1 - ambientBarrier x) * e := mul_nonneg (by linarith [hb.2]) he.1
have hp' := mul_le_mul_of_nonneg_left he.2 (show 0 ≤ 1 - ambientBarrier x by linarith [hb.2])
unfold ambientIncrement
constructor <;> linarith [hb.1]
lemma ambientBarrier_le_ambientIncrement (x : ClockAmbient) (hx : ‖x‖ ≤ 1)
{e : ℝ} (he : 0 ≤ e) : ambientBarrier x ≤ ambientIncrement x e := by
have hb := (ambientBarrier_mem_Icc x hx).2
have hp : 0 ≤ (1 - ambientBarrier x) * e := mul_nonneg (by linarith) he
unfold ambientIncrement
linarith
@[simp] lemma ambientIncrement_one (x : ClockAmbient) : ambientIncrement x 1 = 1 := by
simp [ambientIncrement]
@[simp] lemma ambientIncrement_zero (x : ClockAmbient) : ambientIncrement x 0 = ambientBarrier x := by
simp [ambientIncrement]
lemma contDiff_ambientIncrement {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
{n : ℕ∞} {x : E → ClockAmbient} {e : E → ℝ}
(hx : ContDiff ℝ n x) (he : ContDiff ℝ n e) :
ContDiff ℝ n (fun y => ambientIncrement (x y) (e y)) := by
exact (contDiff_ambientBarrier.comp hx).add
((contDiff_const.sub (contDiff_ambientBarrier.comp hx)).mul he)
lemma ambientIncrement_parametrization (t e : ℝ) :
ambientIncrement (parametrization t) e = increment t e := by
simp only [ambientIncrement, increment,
ambientBarrier_on_circle t (parametrization t) (parametrization_zero t)]
def ambientUpdate (x : ClockAmbient) (e : ℝ) : ClockAmbient :=
rotate x (2 * Real.pi * ambientIncrement x e / 100)
lemma contDiff_ambientUpdate {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
{n : ℕ∞} {x : E → ClockAmbient} {e : E → ℝ}
(hx : ContDiff ℝ n x) (he : ContDiff ℝ n e) :
ContDiff ℝ n (fun y => ambientUpdate (x y) (e y)) := by
apply contDiff_rotate hx
exact (contDiff_const.mul (contDiff_ambientIncrement hx he)).div_const 100
lemma ambientUpdate_parametrization (t e : ℝ) :
ambientUpdate (parametrization t) e = parametrization (t + increment t e) := by
rw [ambientUpdate, ambientIncrement_parametrization, rotate_parametrization]
lemma norm_ambientUpdate (x : ClockAmbient) (e : ℝ) : ‖ambientUpdate x e‖ = ‖x‖ :=
norm_rotate _ _
def update (x : StandardClock) (e : ℝ) : StandardClock :=
⟨ambientUpdate x.1 e, by
rw [Metric.mem_sphere, dist_zero_right, norm_ambientUpdate]
simp⟩
lemma continuous_update : Continuous (fun p : StandardClock × ℝ => update p.1 p.2) := by
apply Continuous.subtype_mk
have hc : Continuous (fun p : ClockAmbient × ℝ => ambientUpdate p.1 p.2) :=
(contDiff_ambientUpdate (n := 1) contDiff_fst contDiff_snd).continuous
exact hc.comp ((continuous_subtype_val.comp continuous_fst).prodMk continuous_snd)
def clockStep (q : ℕ) (e : CounterexampleAmbient q → ℝ)
(x : CounterexampleManifold q) : CounterexampleManifold q :=
(update x.1 (e (standardEmbedding q x)), x.2)
lemma isC1SelfMap_clockStep (q : ℕ) (e : CounterexampleAmbient q → ℝ)
(he : ContDiff ℝ 1 e) : IsC1SelfMap q (clockStep q e) := by
apply isC1SelfMap_of_contDiff (clockStep q e)
(fun p : CounterexampleAmbient q => (ambientUpdate p.1 (e p), p.2))
· exact (contDiff_ambientUpdate contDiff_fst he).prodMk contDiff_snd
· intro y
rfl
end Problem340.Clock
end
end OAI
|