| import OAI.Dynamics.TriangleBilliards.RegularRays |
|
|
| namespace OAI |
|
|
| open MeasureTheory Set |
| open scoped ENNReal symmDiff |
| noncomputable section |
| namespace TriangularBilliards |
|
|
| open Filter |
| open scoped Topology |
|
|
| lemma crossMap_flight (p x v : ℂ) (t : ℝ) : |
| crossMap v (x + t • v - p) = crossMap v (x - p) := by |
| rw [show x + t • v - p = (x - p) + t • v by abel, |
| map_add, map_smul, crossMap_self, smul_zero, add_zero] |
|
|
| lemma crossMap_abs_le (v : Circle) (x : ℂ) : |crossMap v x| ≤ ‖x‖ := by |
| calc |
| |crossMap v x| ≤ ‖x * star (v : ℂ)‖ := Complex.abs_im_le_norm _ |
| _ = ‖x‖ := by rw [norm_mul, norm_star, Circle.norm_coe, mul_one] |
|
|
| lemma wallReflection_fixed_vertex (Q : Triangle) (i k : Fin 3) (hk : k ≠ i + 2) : |
| wallReflection Q i (Q.vertex k) = Q.vertex k := by |
| have h : k = i ∨ k = i + 1 ∨ k = i + 2 := by fin_cases i <;> fin_cases k <;> decide |
| rcases h with rfl | rfl | h |
| · simp [wallReflection, reflect] |
| · change Q.vertex i + reflect (Q.tangent i) (Q.tangent i) = Q.vertex (i + 1) |
| rw [reflect_tangent (Q.tangent_ne_zero i), Triangle.tangent] |
| abel |
| · exact False.elim (hk h) |
|
|
| namespace Admissible |
|
|
| lemma wall_ne_next {Q : Triangle} (z : Admissible Q) (n : ℕ) : |
| (z.iterate n).collision.wall ≠ (z.iterate (n + 1)).collision.wall := by |
| intro he |
| let i := (z.iterate n).collision.wall |
| have h0 : Q.basis.coord (i + 2) (z.iterate (n + 1)).pos = 0 := |
| (Q.side_coord_zero_iff (z.iterate_on_side n) (i + 2)).mpr rfl |
| have hp : 0 < Q.slope (i + 2) (z.iterate (n + 1)).vel := |
| (z.iterate (n + 1)).inward.2 (i + 2) h0 |
| have h1 : Q.basis.coord (i + 2) (z.iterate (n + 2)).pos = 0 := by |
| apply (Q.side_coord_zero_iff (z.iterate_on_side (n + 1)) (i + 2)).mpr |
| rw [← he] |
| change Q.basis.coord (i + 2) ((z.iterate (n + 1)).pos + |
| (z.iterate (n + 1)).collision.delay • ((z.iterate (n + 1)).vel : ℂ)) = 0 at h1 |
| rw [Q.coord_shift, h0, zero_add] at h1 |
| exact (ne_of_gt (mul_pos (z.iterate (n + 1)).collision.positive hp)) h1 |
|
|
| lemma dist_iterate_le_dist_time {Q : Triangle} (z : Admissible Q) (m n : ℕ) : |
| dist (z.iterate m).pos (z.iterate n).pos ≤ dist (z.time m) (z.time n) := by |
| rcases le_total m n with h | h |
| · rw [Real.dist_eq, abs_sub_comm, abs_of_nonneg (sub_nonneg.mpr (z.time_strictMono.monotone h))] |
| exact z.dist_iterate_le_time h |
| · rw [dist_comm (z.iterate m).pos, dist_comm (z.time m), Real.dist_eq, abs_sub_comm, |
| abs_of_nonneg (sub_nonneg.mpr (z.time_strictMono.monotone h))] |
| exact z.dist_iterate_le_time h |
|
|
| lemma positions_converge_of_bounded_time {Q : Triangle} (z : Admissible Q) |
| (hb : BddAbove (range z.time)) : |
| ∃ p : ℂ, Tendsto (fun n => (z.iterate n).pos) atTop (𝓝 p) := by |
| have ht := tendsto_atTop_ciSup z.time_strictMono.monotone hb |
| apply cauchySeq_tendsto_of_complete |
| rw [Metric.cauchySeq_iff] |
| intro ε hε |
| obtain ⟨N, hN⟩ := Metric.cauchySeq_iff.mp ht.cauchySeq ε hε |
| exact ⟨N, fun m hm n hn => lt_of_le_of_lt (z.dist_iterate_le_dist_time m n) (hN m hm n hn)⟩ |
|
|
| /-- If infinitely many collisions accumulated in finite distance, their |
| common limit would have to be a vertex, not an arbitrary boundary point. -/ |
| lemma limit_is_vertex {Q : Triangle} (z : Admissible Q) {p : ℂ} |
| (hp : Tendsto (fun n => (z.iterate n).pos) atTop (𝓝 p)) : ∃ k, p = Q.vertex k := by |
| have hc (i : Fin 3) : Tendsto (fun n => Q.basis.coord i (z.iterate n).pos) atTop |
| (𝓝 (Q.basis.coord i p)) := |
| (Q.basis.coord i).continuous_of_finiteDimensional.continuousAt.tendsto.comp hp |
| have hnonneg (i : Fin 3) : 0 ≤ Q.basis.coord i p := |
| ge_of_tendsto' (hc i) (fun n => (z.iterate n).inward.1 i) |
| have hz : ∃ i, Q.basis.coord i p = 0 := by |
| by_contra hn |
| push Not at hn |
| have hpos (i : Fin 3) : 0 < Q.basis.coord i p := lt_of_le_of_ne (hnonneg i) (hn i).symm |
| have he : ∀ᶠ n : ℕ in atTop, ∀ i, 0 < Q.basis.coord i (z.iterate n).pos := |
| eventually_all.mpr fun i => (hc i).eventually (lt_mem_nhds (hpos i)) |
| obtain ⟨N, hN⟩ := eventually_atTop.mp he |
| have hzero := (Q.side_coord_zero_iff (z.iterate_on_side N) |
| ((z.iterate N).collision.wall + 2)).mpr rfl |
| have hpositive := hN (N + 1) (Nat.le_succ N) ((z.iterate N).collision.wall + 2) |
| linarith |
| by_contra hn |
| push Not at hn |
| obtain ⟨i, hi⟩ := Q.boundary_open_side hnonneg hz hn |
| have hpos (j : Fin 3) (hj : j ≠ i + 2) : 0 < Q.basis.coord j p := by |
| apply lt_of_le_of_ne (hnonneg j) |
| intro hj0 |
| exact hj ((Q.side_coord_zero_iff hi j).mp hj0.symm) |
| have he : ∀ᶠ n : ℕ in atTop, ∀ j, j ≠ i + 2 → 0 < Q.basis.coord j (z.iterate n).pos := by |
| apply eventually_all.mpr |
| intro j |
| by_cases hj : j = i + 2 |
| · exact Eventually.of_forall fun _ h => False.elim (h hj) |
| · exact ((hc j).eventually (lt_mem_nhds (hpos j hj))).mono fun _ h _ => h |
| obtain ⟨N, hN⟩ := eventually_atTop.mp he |
| have hw (n : ℕ) (hn : N ≤ n + 1) : (z.iterate n).collision.wall = i := by |
| apply add_right_cancel (b := (2 : Fin 3)) |
| by_contra h |
| have hz := (Q.side_coord_zero_iff (z.iterate_on_side n) |
| ((z.iterate n).collision.wall + 2)).mpr rfl |
| have hp := hN (n + 1) hn ((z.iterate n).collision.wall + 2) h |
| linarith |
| exact z.wall_ne_next N ((hw N (by omega)).trans (hw (N + 1) (by omega)).symm) |
|
|
| /-- Absolute angular momentum about a fixed point. -/ |
| def momentum {Q : Triangle} (z : Admissible Q) (p : ℂ) : ℝ := |
| |crossMap z.vel (z.pos - p)| |
|
|
| lemma momentum_next {Q : Triangle} (z : Admissible Q) (p : ℂ) |
| (hp : wallReflection Q z.collision.wall p = p) : z.next.momentum p = z.momentum p := by |
| have hx := wallReflection_fixed_side Q z.collision.on_side |
| have h := crossMap_reflect (Q.tangent_ne_zero z.collision.wall) (z.vel : ℂ) |
| (z.pos + z.collision.delay • (z.vel : ℂ) - p) |
| rw [← wallReflection_sub, hx, hp, crossMap_flight] at h |
| change |crossMap (reflect (Q.tangent z.collision.wall) z.vel) |
| (z.pos + z.collision.delay • (z.vel : ℂ) - p)| = |crossMap (z.vel : ℂ) (z.pos - p)| |
| rw [h, abs_neg] |
|
|
| lemma momentum_tendsto_zero {Q : Triangle} (z : Admissible Q) {p : ℂ} |
| (hp : Tendsto (fun n => (z.iterate n).pos) atTop (𝓝 p)) : |
| Tendsto (fun n => (z.iterate n).momentum p) atTop (𝓝 0) := by |
| have hnorm : Tendsto (fun n => ‖(z.iterate n).pos - p‖) atTop (𝓝 0) := by |
| simpa only [sub_self, norm_zero] using (hp.sub_const p).norm |
| apply squeeze_zero (fun n => abs_nonneg _) (fun n => crossMap_abs_le _ _) hnorm |
|
|
| lemma eventually_wall_fixed_of_vertex_limit {Q : Triangle} (z : Admissible Q) (k : Fin 3) |
| (hp : Tendsto (fun n => (z.iterate n).pos) atTop (𝓝 (Q.vertex k))) : |
| ∀ᶠ n : ℕ in atTop, wallReflection Q (z.iterate n).collision.wall (Q.vertex k) = Q.vertex k := by |
| have hc := (Q.basis.coord k).continuous_of_finiteDimensional.continuousAt.tendsto.comp |
| (hp.comp (tendsto_add_atTop_nat 1)) |
| have hk : Q.basis.coord k (Q.vertex k) = 1 := Q.basis.coord_apply_eq k |
| filter_upwards [hc.eventually (lt_mem_nhds (by rw [hk]; norm_num : 0 < |
| Q.basis.coord k (Q.vertex k)))] with n hn |
| apply wallReflection_fixed_vertex |
| intro he |
| have hz := (Q.side_coord_zero_iff (z.iterate_on_side n) k).mpr he |
| change 0 < Q.basis.coord k (z.iterate (n + 1)).pos at hn |
| linarith |
|
|
| /-- Non-Zeno is proved, not added as an admissibility hypothesis: finite |
| accumulation would approach a vertex, where conservation of absolute |
| angular momentum forces this regular ray to aim through that vertex. -/ |
| lemma time_not_bddAbove {Q : Triangle} (z : Admissible Q) : ¬ BddAbove (range z.time) := by |
| intro hb |
| obtain ⟨p, hp⟩ := z.positions_converge_of_bounded_time hb |
| obtain ⟨k, rfl⟩ := z.limit_is_vertex hp |
| have he := z.eventually_wall_fixed_of_vertex_limit k hp |
| obtain ⟨N, hN⟩ := eventually_atTop.mp he |
| have hconst (n : ℕ) (hn : N ≤ n) : |
| (z.iterate n).momentum (Q.vertex k) = (z.iterate N).momentum (Q.vertex k) := by |
| induction n, hn using Nat.le_induction with |
| | base => rfl |
| | succ n hn ih => |
| exact ((z.iterate n).momentum_next (Q.vertex k) (hN n hn)).trans ih |
| have ht : Tendsto (fun n => (z.iterate n).momentum (Q.vertex k)) atTop |
| (𝓝 ((z.iterate N).momentum (Q.vertex k))) := |
| tendsto_const_nhds.congr' (eventually_atTop.mpr ⟨N, fun n hn => (hconst n hn).symm⟩) |
| have hm := tendsto_nhds_unique ht (z.momentum_tendsto_zero hp) |
| apply (z.iterate N).regular |
| simp only [vertexExceptional, mem_iUnion] |
| refine ⟨[], k, ?_⟩ |
| exact abs_eq_zero.mp hm |
|
|
| lemma time_unbounded_above {Q : Triangle} (z : Admissible Q) (t : ℝ) : |
| ∃ n : ℕ, t < z.time n := by |
| by_contra hn |
| push Not at hn |
| apply z.time_not_bddAbove |
| exact ⟨t, fun _ ⟨n, hn'⟩ => hn' ▸ hn n⟩ |
|
|
| end Admissible |
|
|
| lemma reflect_neg (e v : ℂ) : reflect e (-v) = -reflect e v := by |
| simp [reflect] |
|
|
| lemma vertexExceptional_neg_iff (Q : Triangle) (x : ℂ) (v : Circle) : |
| (x, -v) ∈ vertexExceptional Q ↔ (x, v) ∈ vertexExceptional Q := by |
| simp only [vertexExceptional, mem_iUnion, aimingAt, mem_ofPred_eq, Circle.coe_neg] |
| have he (p : ℂ) : crossMap (-(v : ℂ)) (x - p) = -crossMap v (x - p) := by |
| simp [crossMap] |
| simp only [he, neg_eq_zero] |
|
|
| /-- The two genuine recursively generated rays, joined at an interior state. -/ |
| structure TwoRays (Q : Triangle) (z : Phase) where |
| interior_pos : z.1 ∈ Q.table |
| forward : Admissible Q |
| backward : Admissible Q |
| forward_pos : forward.pos = z.1 |
| backward_pos : backward.pos = z.1 |
| forward_vel : forward.vel = z.2 |
| backward_vel : backward.vel = -z.2 |
|
|
| noncomputable def regularRays (Q : Triangle) (z : Phase) (hx : z.1 ∈ Q.table) |
| (hr : z ∉ vertexExceptional Q) : TwoRays Q z where |
| interior_pos := hx |
| forward := ⟨z.1, z.2, Q.inward_of_table hx, hr⟩ |
| backward := ⟨z.1, -z.2, Q.inward_of_table hx, by rwa [vertexExceptional_neg_iff]⟩ |
| forward_pos := rfl |
| backward_pos := rfl |
| forward_vel := rfl |
| backward_vel := rfl |
|
|
| namespace TwoRays |
|
|
| variable {Q : Triangle} {z : Phase} (r : TwoRays Q z) |
|
|
| def time : ℤ → ℝ |
| | .ofNat 0 => -r.backward.time 1 |
| | .ofNat (n + 1) => r.forward.time (n + 1) |
| | .negSucc n => -r.backward.time (n + 2) |
|
|
| def point : ℤ → ℂ |
| | .ofNat 0 => (r.backward.iterate 1).pos |
| | .ofNat (n + 1) => (r.forward.iterate (n + 1)).pos |
| | .negSucc n => (r.backward.iterate (n + 2)).pos |
|
|
| def direction : ℤ → Circle |
| | .ofNat n => (r.forward.iterate n).vel |
| | .negSucc n => -(r.backward.iterate (n + 1)).vel |
|
|
| def wall : ℤ → Fin 3 |
| | .ofNat 0 => r.backward.collision.wall |
| | .ofNat (n + 1) => (r.forward.iterate n).collision.wall |
| | .negSucc n => (r.backward.iterate (n + 1)).collision.wall |
|
|
| lemma zero_before : r.time 0 < 0 := by |
| change -r.backward.time 1 < 0 |
| have h := r.backward.time_strictMono (Nat.zero_lt_succ 0) |
| rw [r.backward.time_zero] at h |
| exact neg_neg_of_pos h |
|
|
| lemma zero_after : 0 < r.time 1 := by |
| change 0 < r.forward.time 1 |
| have h := r.forward.time_strictMono (Nat.zero_lt_succ 0) |
| rwa [r.forward.time_zero] at h |
|
|
| lemma increasing : StrictMono r.time := by |
| apply strictMono_int_of_lt_succ |
| intro n |
| cases n with |
| | ofNat n => |
| cases n with |
| | zero => exact lt_trans r.zero_before r.zero_after |
| | succ n => exact r.forward.time_strictMono (Nat.lt_succ_self (n + 1)) |
| | negSucc n => |
| cases n with |
| | zero => exact neg_lt_neg (r.backward.time_strictMono (by omega : 1 < 2)) |
| | succ n => exact neg_lt_neg (r.backward.time_strictMono (Nat.lt_succ_self (n + 2))) |
|
|
| lemma unbounded_above (t : ℝ) : ∃ n : ℤ, t < r.time n := by |
| obtain ⟨n, hn⟩ := r.forward.time_unbounded_above t |
| exact ⟨Int.ofNat (n + 1), lt_trans hn (r.forward.time_strictMono (Nat.lt_succ_self n))⟩ |
|
|
| lemma unbounded_below (t : ℝ) : ∃ n : ℤ, r.time n < t := by |
| obtain ⟨n, hn⟩ := r.backward.time_unbounded_above (-t) |
| refine ⟨Int.negSucc n, ?_⟩ |
| change -r.backward.time (n + 2) < t |
| have h := r.backward.time_strictMono (by omega : n < n + 2) |
| linarith |
|
|
| lemma on_side (n : ℤ) : r.point n ∈ Q.side (r.wall n) := by |
| cases n with |
| | ofNat n => |
| cases n with |
| | zero => exact r.backward.iterate_on_side 0 |
| | succ n => exact r.forward.iterate_on_side n |
| | negSucc n => exact r.backward.iterate_on_side (n + 1) |
|
|
| lemma middle_point : |
| r.point 0 = z.1 - r.backward.time 1 • (z.2 : ℂ) := by |
| change (r.backward.iterate 1).pos = _ |
| rw [r.backward.iterate_flight 0, r.backward.time_zero, sub_zero] |
| change r.backward.pos + r.backward.time 1 • (r.backward.vel : ℂ) = _ |
| rw [r.backward_pos, r.backward_vel, Circle.coe_neg, smul_neg, sub_eq_add_neg] |
|
|
| lemma start_point : z.1 = r.point 0 + (-r.time 0) • (r.direction 0 : ℂ) := by |
| rw [r.middle_point] |
| change z.1 = z.1 - r.backward.time 1 • (z.2 : ℂ) + |
| (- -r.backward.time 1) • (r.forward.vel : ℂ) |
| rw [neg_neg, r.forward_vel] |
| abel |
|
|
| lemma flight (n : ℤ) : r.point (n + 1) = r.point n + |
| (r.time (n + 1) - r.time n) • (r.direction n : ℂ) := by |
| cases n with |
| | ofNat n => |
| cases n with |
| | zero => |
| change r.point 1 = r.point 0 + (r.time 1 - r.time 0) • (r.direction 0 : ℂ) |
| rw [r.middle_point] |
| change (r.forward.iterate 1).pos = z.1 - r.backward.time 1 • (z.2 : ℂ) + |
| (r.forward.time 1 - -r.backward.time 1) • (r.forward.vel : ℂ) |
| rw [r.forward.iterate_flight 0, r.forward.time_zero, sub_zero] |
| change r.forward.pos + r.forward.time 1 • (r.forward.vel : ℂ) = _ |
| rw [r.forward_pos, r.forward_vel, sub_neg_eq_add, add_smul] |
| abel |
| | succ n => exact r.forward.iterate_flight (n + 1) |
| | negSucc n => |
| have h := r.backward.iterate_flight (n + 1) |
| cases n with |
| | zero => |
| change (r.backward.iterate 1).pos = (r.backward.iterate 2).pos + |
| (-r.backward.time 1 - -r.backward.time 2) • (-(r.backward.iterate 1).vel : Circle) |
| rw [Circle.coe_neg, smul_neg, h] |
| rw [show -r.backward.time 1 - -r.backward.time 2 = |
| r.backward.time 2 - r.backward.time 1 by ring] |
| abel |
| | succ n => |
| change (r.backward.iterate (n + 2)).pos = (r.backward.iterate (n + 3)).pos + |
| (-r.backward.time (n + 2) - -r.backward.time (n + 3)) • |
| (-(r.backward.iterate (n + 2)).vel : Circle) |
| rw [Circle.coe_neg, smul_neg, h] |
| rw [show -r.backward.time (n + 2) - -r.backward.time (n + 3) = |
| r.backward.time (n + 3) - r.backward.time (n + 2) by ring] |
| abel |
|
|
| lemma middle_flight (t : ℝ) : |
| r.point 0 + (t - r.time 0) • (r.direction 0 : ℂ) = z.1 + t • (z.2 : ℂ) := by |
| rw [r.middle_point] |
| change z.1 - r.backward.time 1 • (z.2 : ℂ) + |
| (t - -r.backward.time 1) • (r.forward.vel : ℂ) = _ |
| rw [r.forward_vel, sub_neg_eq_add, add_smul] |
| abel |
|
|
| lemma inside (n : ℤ) (t : ℝ) (h0 : r.time n < t) (h1 : t < r.time (n + 1)) : |
| r.point n + (t - r.time n) • (r.direction n : ℂ) ∈ Q.table := by |
| cases n with |
| | ofNat n => |
| cases n with |
| | zero => |
| change r.point 0 + (t - r.time 0) • (r.direction 0 : ℂ) ∈ Q.table |
| rw [r.middle_flight] |
| rcases lt_trichotomy t 0 with ht | rfl | ht |
| · have h : -t < r.backward.time 1 := by change -r.backward.time 1 < t at h0; linarith |
| have hp := r.backward.iterate_inside 0 (t := -t) |
| (by rw [r.backward.time_zero]; linarith) h |
| change r.backward.pos + (-t - r.backward.time 0) • (r.backward.vel : ℂ) ∈ Q.table at hp |
| simpa only [r.backward.time_zero, sub_zero, r.backward_pos, r.backward_vel, |
| Circle.coe_neg, smul_neg, neg_smul, neg_neg] using hp |
| · simpa only [zero_smul, add_zero] using r.interior_pos |
| · have hp := r.forward.iterate_inside 0 (t := t) |
| (by rw [r.forward.time_zero]; exact ht) h1 |
| change r.forward.pos + (t - r.forward.time 0) • (r.forward.vel : ℂ) ∈ Q.table at hp |
| simpa only [r.forward.time_zero, sub_zero, r.forward_pos, r.forward_vel] using hp |
| | succ n => exact r.forward.iterate_inside (n + 1) h0 h1 |
| | negSucc n => |
| have ht0 : r.backward.time (n + 1) < -t := by |
| cases n with |
| | zero => change t < -r.backward.time 1 at h1; linarith |
| | succ n => change t < -r.backward.time (n + 2) at h1; linarith |
| have ht1 : -t < r.backward.time (n + 2) := by |
| change -r.backward.time (n + 2) < t at h0 |
| linarith |
| have hp := r.backward.iterate_inside (n + 1) ht0 ht1 |
| change (r.backward.iterate (n + 2)).pos + (t - -r.backward.time (n + 2)) • |
| (-(r.backward.iterate (n + 1)).vel : Circle) ∈ Q.table |
| rw [Circle.coe_neg, smul_neg, r.backward.iterate_flight (n + 1)] |
| convert hp using 1 |
| module |
|
|
| lemma specular (n : ℤ) : |
| (r.direction n : ℂ) = reflect (Q.tangent (r.wall n)) (r.direction (n - 1) : ℂ) := by |
| cases n with |
| | ofNat n => |
| cases n with |
| | zero => |
| change (r.forward.vel : ℂ) = reflect (Q.tangent r.backward.collision.wall) |
| (-(r.backward.iterate 1).vel : Circle) |
| change (r.forward.vel : ℂ) = reflect (Q.tangent r.backward.collision.wall) |
| (-reflectedDirection Q r.backward.collision.wall r.backward.vel : Circle) |
| rw [Circle.coe_neg, reflect_neg] |
| change (r.forward.vel : ℂ) = -reflect (Q.tangent r.backward.collision.wall) |
| (reflect (Q.tangent r.backward.collision.wall) r.backward.vel) |
| rw [reflect_involutive (Q.tangent_ne_zero _), r.forward_vel, r.backward_vel, |
| Circle.coe_neg, neg_neg] |
| | succ n => |
| change ((r.forward.iterate n).next.vel : ℂ) = reflect |
| (Q.tangent (r.forward.iterate n).collision.wall) (r.direction (Int.ofNat (n + 1) - 1) : ℂ) |
| rw [show Int.ofNat (n + 1) - 1 = Int.ofNat n by change (↑(n + 1) : ℤ) - 1 = ↑n; omega] |
| rfl |
| | negSucc n => |
| change (-(r.backward.iterate (n + 1)).vel : Circle) = reflect |
| (Q.tangent (r.backward.iterate (n + 1)).collision.wall) |
| (r.direction (Int.negSucc n - 1) : ℂ) |
| rw [show Int.negSucc n - 1 = Int.negSucc (n + 1) by omega] |
| change (-(r.backward.iterate (n + 1)).vel : Circle) = reflect |
| (Q.tangent (r.backward.iterate (n + 1)).collision.wall) |
| (-reflectedDirection Q (r.backward.iterate (n + 1)).collision.wall |
| (r.backward.iterate (n + 1)).vel : Circle) |
| rw [Circle.coe_neg, Circle.coe_neg, reflect_neg] |
| change -((r.backward.iterate (n + 1)).vel : ℂ) = -reflect |
| (Q.tangent (r.backward.iterate (n + 1)).collision.wall) |
| (reflect (Q.tangent (r.backward.iterate (n + 1)).collision.wall) |
| (r.backward.iterate (n + 1)).vel) |
| rw [reflect_involutive (Q.tangent_ne_zero _)] |
|
|
| /-- The full two-sided, non-Zeno, specular chain, assembled from actual exits. -/ |
| def chain : FlightChain Q z where |
| time := r.time |
| point := r.point |
| direction := r.direction |
| wall := r.wall |
| increasing := r.increasing |
| unbounded_below := r.unbounded_below |
| unbounded_above := r.unbounded_above |
| zero_before := r.zero_before |
| zero_after := r.zero_after |
| on_side := r.on_side |
| flight := r.flight |
| inside := r.inside |
| start_point := r.start_point |
| start_direction := r.forward_vel.symm |
| specular := r.specular |
|
|
| end TwoRays |
|
|
| lemma exists_chain_of_not_exceptional (Q : Triangle) (z : Phase) (hx : z.1 ∈ Q.table) |
| (hr : z ∉ vertexExceptional Q) : Nonempty (FlightChain Q z) := |
| ⟨(regularRays Q z hx hr).chain⟩ |
|
|
| lemma ae_position_in_table (Q : Triangle) : ∀ᵐ z ∂phaseMeasure Q, z.1 ∈ Q.table := by |
| rw [ae_iff] |
| rw [show {a : Phase | a.1 ∉ Q.table} = Q.tableᶜ ×ˢ (univ : Set Circle) by |
| ext a; simp] |
| rw [phaseMeasure, Measure.prod_prod, Measure.smul_apply, |
| Measure.restrict_apply Q.measurableSet_table.compl] |
| simp only [compl_inter_self, measure_empty, smul_zero, zero_mul] |
| |
| /-- Complete regular trajectories exist for almost every initial state under |
| exact normalized area-angular measure; all collisions and both infinite |
| ends have been constructed above, with no completeness hypothesis. -/ |
| lemma ae_exists_chain (Q : Triangle) : |
| ∀ᵐ z ∂phaseMeasure Q, Nonempty (FlightChain Q z) := by |
| have hr : ∀ᵐ z ∂phaseMeasure Q, z ∉ vertexExceptional Q := by |
| rw [ae_iff] |
| convert phaseMeasure_vertexExceptional Q using 2 |
| ext a; simp |
| filter_upwards [ae_position_in_table Q, hr] with z hx hz |
| exact exists_chain_of_not_exceptional Q z hx hz |
| |
| end TriangularBilliards |
| end |
| |
| end OAI |
| |
