| import OAI.Dynamics.TriangleBilliards.Koopman | |
| namespace OAI | |
| universe uH | |
| open MeasureTheory Set | |
| open scoped ENNReal symmDiff | |
| noncomputable section | |
| open MeasureTheory Set Filter Function Metric | |
| open scoped Topology Convolution ContDiff | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| noncomputable section | |
| open MeasureTheory Set Filter BoundedContinuousFunction | |
| open scoped ENNReal Topology ComplexConjugate | |
| noncomputable section | |
| /-! Strongly continuous unitary dynamics and the closed generator graph. | |
| All hypotheses here are structural flow properties; the billiard instance | |
| is constructed from its geometric flow, not postulated. -/ | |
| open MeasureTheory Set Filter | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| namespace TriangularBilliards.Analysis | |
| variable (H : Type uH) [NormedAddCommGroup H] [InnerProductSpace ℂ H] | |
| structure HilbertFlow where | |
| act : ℝ → H →ₗᵢ[ℂ] H | |
| zero : ∀ u, act 0 u = u | |
| add : ∀ s t u, act (s + t) u = act s (act t u) | |
| continuous : ∀ u, Continuous (fun t => act t u) | |
| namespace HilbertFlow | |
| variable {H} (W : HilbertFlow H) | |
| @[simp] lemma act_zero (u : H) : W.act 0 u = u := W.zero u | |
| lemma act_neg (t : ℝ) (u : H) : W.act (-t) (W.act t u) = u := by | |
| rw [← W.add, neg_add_cancel, W.zero] | |
| lemma inner_act (t : ℝ) (u v : H) : inner ℂ (W.act t u) (W.act t v) = inner ℂ u v := | |
| (W.act t).inner_map_map u v | |
| lemma continuous_joint : Continuous (fun tu : ℝ × H => W.act tu.1 tu.2) := by | |
| have h : Continuous (fun ut : H × ℝ => W.act ut.2 ut.1) := | |
| continuous_prod_of_continuous_lipschitzWith _ 1 W.continuous | |
| (fun t => (W.act t).isometry.lipschitzWith) | |
| exact h.comp continuous_swap | |
| /-- Conjugating by a second genuine unitary flow preserves all structural | |
| properties. For billiards the second flow is angular rotation. -/ | |
| def conjugate (V : HilbertFlow H) (θ : ℝ) : HilbertFlow H where | |
| act t := (V.act θ).comp ((W.act t).comp (V.act (-θ))) | |
| zero u := by | |
| change V.act θ (W.act 0 (V.act (-θ) u)) = u | |
| rw [W.zero, ← V.add, add_neg_cancel, V.zero] | |
| add s t u := by | |
| change V.act θ (W.act (s + t) (V.act (-θ) u)) = | |
| V.act θ (W.act s (V.act (-θ) (V.act θ (W.act t (V.act (-θ) u))))) | |
| rw [← V.add, neg_add_cancel, V.zero, W.add] | |
| continuous u := (V.act θ).continuous.comp (W.continuous (V.act (-θ) u)) | |
| lemma conjugate_joint (V : HilbertFlow H) : | |
| Continuous (fun p : ℝ × ℝ × H => (W.conjugate V p.1).act p.2.1 p.2.2) := by | |
| change Continuous (fun p : ℝ × ℝ × H => V.act p.1 (W.act p.2.1 (V.act (-p.1) p.2.2))) | |
| exact V.continuous_joint.comp (continuous_fst.prodMk | |
| (W.continuous_joint.comp (continuous_snd.fst.prodMk | |
| (V.continuous_joint.comp (continuous_fst.neg.prodMk continuous_snd.snd))))) | |
| variable [CompleteSpace H] | |
| omit [CompleteSpace H] in | |
| lemma intervalIntegrable (u : H) (a b : ℝ) : | |
| IntervalIntegrable (fun t => W.act t u) volume a b := | |
| (W.continuous u).intervalIntegrable _ _ | |
| /-- Integration in time, as a genuine bounded linear operator. No | |
| operator-norm continuity of the unitary group is presupposed. -/ | |
| def timeIntegral (a b : ℝ) : H →L[ℂ] H := | |
| LinearMap.mkContinuous | |
| { toFun := fun u => ∫ t in a..b, W.act t u | |
| map_add' := fun u v => by | |
| simp only [map_add] | |
| exact intervalIntegral.integral_add (W.intervalIntegrable u a b) (W.intervalIntegrable v a b) | |
| map_smul' := fun r u => by | |
| simp only [map_smul, RingHom.id_apply] | |
| exact intervalIntegral.integral_smul r (fun t => W.act t u) } | |
| |b - a| | |
| (fun u => by | |
| calc | |
| ‖∫ t in a..b, W.act t u‖ ≤ ‖u‖ * |b - a| := | |
| intervalIntegral.norm_integral_le_of_norm_le_const (fun t _ => (W.act t).norm_map u |>.le) | |
| _ = |b - a| * ‖u‖ := mul_comm _ _) | |
| omit [CompleteSpace H] in | |
| @[simp] lemma timeIntegral_apply (a b : ℝ) (u : H) : | |
| W.timeIntegral a b u = ∫ t in a..b, W.act t u := rfl | |
| /-- The generator domain encoded by the exact orbit integral identity. | |
| This formulation makes weak closedness an immediate linear-test fact. -/ | |
| def HasGenerator (u v : H) : Prop := | |
| ∀ t : ℝ, W.act t u - u = W.timeIntegral 0 t v | |
| lemma HasGenerator.hasDerivAt {u v : H} (h : W.HasGenerator u v) (t : ℝ) : | |
| HasDerivAt (fun s => W.act s u) (W.act t v) t := by | |
| have hi := W.intervalIntegrable v 0 t | |
| have hd := intervalIntegral.integral_hasDerivAt_right hi | |
| (W.continuous v).stronglyMeasurable.stronglyMeasurableAtFilter (W.continuous v).continuousAt | |
| have he : (fun s => W.act s u) = (fun s => u + ∫ r in 0..s, W.act r v) := by | |
| funext s | |
| have hh := h s | |
| change W.act s u - u = ∫ r in 0..s, W.act r v at hh | |
| exact eq_add_of_sub_eq' hh | |
| rw [he] | |
| exact hd.const_add u | |
| lemma hasGenerator_of_hasDerivAt {u v : H} | |
| (h : ∀ t, HasDerivAt (fun s => W.act s u) (W.act t v) t) : W.HasGenerator u v := by | |
| intro t | |
| rw [timeIntegral_apply, intervalIntegral.integral_eq_sub_of_hasDerivAt | |
| (fun s _ => h s) (W.intervalIntegrable v 0 t), W.zero] | |
| lemma generator_unique {u v v' : H} (h : W.HasGenerator u v) (h' : W.HasGenerator u v') : | |
| v = v' := by | |
| have he := (HasGenerator.hasDerivAt W h 0).unique (HasGenerator.hasDerivAt W h' 0) | |
| simpa only [W.zero] using he | |
| lemma generator_skew {u v a b : H} (hu : W.HasGenerator u a) (hv : W.HasGenerator v b) : | |
| inner ℂ u b + inner ℂ a v = 0 := by | |
| have hd := (HasGenerator.hasDerivAt W hu 0).inner ℂ (HasGenerator.hasDerivAt W hv 0) | |
| have heq : (fun t => inner ℂ (W.act t u) (W.act t v)) = (fun _ : ℝ => inner ℂ u v) := | |
| funext fun t => W.inner_act t u v | |
| rw [heq] at hd | |
| simpa only [W.zero] using hd.unique (hasDerivAt_const 0 (inner ℂ u v)) | |
| omit [CompleteSpace H] in | |
| lemma generatorGraph_closed : IsClosed {p : H × H | W.HasGenerator p.1 p.2} := by | |
| have he : {p : H × H | W.HasGenerator p.1 p.2} = | |
| ⋂ t : ℝ, {p : H × H | W.act t p.1 - p.1 = W.timeIntegral 0 t p.2} := by | |
| ext p | |
| simp only [HasGenerator, mem_ofPred_eq, mem_iInter] | |
| rw [he] | |
| exact isClosed_iInter fun t => isClosed_eq | |
| (((W.act t).continuous.comp continuous_fst).sub continuous_fst) | |
| ((W.timeIntegral 0 t).continuous.comp continuous_snd) | |
| omit [CompleteSpace H] in | |
| lemma generatorGraph_convex : Convex ℝ {p : H × H | W.HasGenerator p.1 p.2} := by | |
| intro p hp q hq a b _ _ _ t | |
| simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, | |
| map_add] | |
| change ((W.act t).toLinearMap (a • p.1) + (W.act t).toLinearMap (b • q.1)) - | |
| (a • p.1 + b • q.1) = W.timeIntegral 0 t (a • p.2) + W.timeIntegral 0 t (b • q.2) | |
| rw [LinearMap.map_smul_of_tower, LinearMap.map_smul_of_tower, | |
| ContinuousLinearMap.map_smul_of_tower, ContinuousLinearMap.map_smul_of_tower] | |
| rw [add_sub_add_comm, ← smul_sub, ← smul_sub] | |
| change a • (W.act t p.1 - p.1) + b • (W.act t q.1 - q.1) = _ | |
| rw [hp t, hq t] | |
| lemma timeIntegral_translate (a b τ : ℝ) (u : H) : | |
| W.act τ (W.timeIntegral a b u) = W.timeIntegral (τ + a) (τ + b) u := by | |
| simp only [timeIntegral_apply] | |
| rw [← (W.act τ).intervalIntegral_comp_comm] | |
| have he : (fun t => W.act τ (W.act t u)) = (fun t => W.act (τ + t) u) := | |
| funext fun t => (W.add τ t u).symm | |
| rw [he] | |
| exact intervalIntegral.integral_comp_add_left (fun t => W.act t u) τ | |
| /-- The finite negative-time average. -/ | |
| def negativeAverage (T : ℝ) : H →L[ℂ] H := (T⁻¹ : ℝ) • W.timeIntegral (-T) 0 | |
| omit [CompleteSpace H] in | |
| lemma negativeAverage_eq (T : ℝ) (u : H) : | |
| W.negativeAverage T u = (T⁻¹ : ℝ) • ∫ t in 0..T, W.act (-t) u := by | |
| change (T⁻¹ : ℝ) • (∫ t in -T..0, W.act t u) = | |
| (T⁻¹ : ℝ) • ∫ t in 0..T, W.act (-t) u | |
| rw [intervalIntegral.integral_comp_neg (fun t => W.act t u)] | |
| simp only [neg_zero] | |
| omit [CompleteSpace H] in | |
| lemma negativeAverage_norm_le {T : ℝ} (hT : 0 < T) (u : H) : | |
| ‖W.negativeAverage T u‖ ≤ ‖u‖ := by | |
| rw [negativeAverage_eq, norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hT)] | |
| calc | |
| T⁻¹ * ‖∫ t in 0..T, W.act (-t) u‖ ≤ T⁻¹ * (‖u‖ * T) := by | |
| gcongr | |
| simpa only [sub_zero, abs_of_pos hT] using | |
| intervalIntegral.norm_integral_le_of_norm_le_const | |
| (f := fun t => W.act (-t) u) (a := 0) (b := T) | |
| (fun t _ => (W.act (-t)).norm_map u |>.le) | |
| _ = ‖u‖ := by field_simp | |
| lemma timeIntegral_hasDerivAt_right (u : H) (a t : ℝ) : | |
| HasDerivAt (fun s => W.timeIntegral a s u) (W.act t u) t := by | |
| exact intervalIntegral.integral_hasDerivAt_right (W.intervalIntegrable u a t) | |
| (W.continuous u).stronglyMeasurable.stronglyMeasurableAtFilter (W.continuous u).continuousAt | |
| lemma timeIntegral_hasDerivAt_translate (u : H) (a b t : ℝ) : | |
| HasDerivAt (fun s => W.timeIntegral (s + a) (s + b) u) | |
| (W.act (t + b) u - W.act (t + a) u) t := by | |
| have hb := (W.timeIntegral_hasDerivAt_right u 0 (t + b)).scomp t | |
| ((hasDerivAt_id t).add_const b) | |
| have ha := (W.timeIntegral_hasDerivAt_right u 0 (t + a)).scomp t | |
| ((hasDerivAt_id t).add_const a) | |
| have he : (fun s => W.timeIntegral (s + a) (s + b) u) = | |
| (fun s => W.timeIntegral 0 (s + b) u - W.timeIntegral 0 (s + a) u) := by | |
| funext s | |
| exact (intervalIntegral.integral_interval_sub_left | |
| (W.intervalIntegrable u 0 (s + b)) (W.intervalIntegrable u 0 (s + a))).symm | |
| rw [he] | |
| convert hb.sub ha using 1 <;> simp only [Function.comp_def, one_smul, id_eq, Pi.sub_def] | |
| lemma negativeAverage_generator (T : ℝ) (u : H) : | |
| W.HasGenerator (W.negativeAverage T u) ((T⁻¹ : ℝ) • (u - W.act (-T) u)) := by | |
| apply W.hasGenerator_of_hasDerivAt | |
| intro t | |
| have he : (fun s => W.act s (W.negativeAverage T u)) = | |
| (fun s => (T⁻¹ : ℝ) • W.timeIntegral (s + -T) (s + 0) u) := by | |
| funext s | |
| change (W.act s).toLinearMap ((T⁻¹ : ℝ) • W.timeIntegral (-T) 0 u) = _ | |
| rw [LinearMap.map_smul_of_tower] | |
| change (T⁻¹ : ℝ) • W.act s (W.timeIntegral (-T) 0 u) = _ | |
| rw [W.timeIntegral_translate] | |
| rw [he] | |
| have hd := (W.timeIntegral_hasDerivAt_translate u (-T) 0 t).const_smul (T⁻¹ : ℝ) | |
| have hv : W.act t ((T⁻¹ : ℝ) • (u - W.act (-T) u)) = | |
| (T⁻¹ : ℝ) • (W.act (t + 0) u - W.act (t + -T) u) := by | |
| change (W.act t).toLinearMap ((T⁻¹ : ℝ) • (u - W.act (-T) u)) = _ | |
| rw [LinearMap.map_smul_of_tower] | |
| change (T⁻¹ : ℝ) • W.act t (u - W.act (-T) u) = _ | |
| rw [map_sub, ← W.add, add_zero] | |
| rw [hv] | |
| exact hd | |
| omit [CompleteSpace H] in | |
| lemma negativeAverage_generator_norm {T : ℝ} (hT : 0 < T) (u : H) : | |
| ‖(T⁻¹ : ℝ) • (u - W.act (-T) u)‖ ≤ 2 * ‖u‖ / T := by | |
| rw [norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hT)] | |
| calc | |
| T⁻¹ * ‖u - W.act (-T) u‖ ≤ T⁻¹ * (‖u‖ + ‖W.act (-T) u‖) := by | |
| gcongr | |
| exact norm_sub_le _ _ | |
| _ = 2 * ‖u‖ / T := by rw [(W.act (-T)).norm_map]; ring | |
| lemma negativeAverage_invariant {u : H} (hu : ∀ t, W.act t u = u) {T : ℝ} (hT : T ≠ 0) : | |
| W.negativeAverage T u = u := by | |
| change (T⁻¹ : ℝ) • (∫ t in -T..0, W.act t u) = u | |
| simp_rw [hu] | |
| rw [intervalIntegral.integral_const, ← smul_assoc] | |
| simp only [sub_neg_eq_add, zero_add, smul_eq_mul, inv_mul_cancel₀ hT, one_smul] | |
| lemma negativeAverage_dist_invariant {u : H} (hu : ∀ t, W.act t u = u) | |
| {T : ℝ} (hT : 0 < T) (a : H) : | |
| ‖W.negativeAverage T a - u‖ ≤ ‖a - u‖ := by | |
| calc | |
| ‖W.negativeAverage T a - u‖ = ‖W.negativeAverage T (a - u)‖ := by | |
| rw [map_sub, W.negativeAverage_invariant hu hT.ne'] | |
| _ ≤ ‖a - u‖ := by | |
| exact W.negativeAverage_norm_le hT (a - u) | |
| end HilbertFlow | |
| end TriangularBilliards.Analysis | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end OAI | |