| import OAI.Dynamics.TriangleBilliards.Geometry |
|
|
| namespace OAI |
|
|
| open MeasureTheory Set |
| open scoped ENNReal symmDiff |
| noncomputable section |
| namespace TriangularBilliards |
|
|
| namespace FlightChain |
|
|
| lemma initial_line {Q : Triangle} {z : Phase} (c : FlightChain Q z) (t : ℝ) : |
| c.point 0 + (t - c.time 0) • (c.direction 0 : ℂ) = z.1 + t • (z.2 : ℂ) := by |
| rw [c.start_point, c.start_direction] |
| module |
|
|
| lemma previous_line {Q : Triangle} {z : Phase} (c : FlightChain Q z) (n : ℤ) (t : ℝ) : |
| c.point (n - 1) + (t - c.time (n - 1)) • (c.direction (n - 1) : ℂ) = |
| c.point n + (t - c.time n) • (c.direction (n - 1) : ℂ) := by |
| have h := c.flight (n - 1) |
| simp only [sub_add_cancel] at h |
| rw [h] |
| module |
|
|
| /-- Agreement of the four data fields at a collision; the proof fields |
| are proposition-valued and need no extra equality assumptions. -/ |
| def Agree {Q : Triangle} {z : Phase} (c d : FlightChain Q z) (n : ℤ) : Prop := |
| c.time n = d.time n ∧ c.point n = d.point n ∧ |
| c.direction n = d.direction n ∧ c.wall n = d.wall n |
|
|
| lemma agree_zero {Q : Triangle} {z : Phase} (c d : FlightChain Q z) : c.Agree d 0 := by |
| have hcinside (t : ℝ) (h₁ : c.time 0 < t) (h₂ : t < 0) : |
| z.1 + t • (z.2 : ℂ) ∈ Q.table := by |
| rw [← c.initial_line] |
| exact c.inside 0 t h₁ (by simpa using h₂.trans c.zero_after) |
| have hdinside (t : ℝ) (h₁ : d.time 0 < t) (h₂ : t < 0) : |
| z.1 + t • (z.2 : ℂ) ∈ Q.table := by |
| rw [← d.initial_line] |
| exact d.inside 0 t h₁ (by simpa using h₂.trans d.zero_after) |
| have hcentry : ¬ (z.1 + c.time 0 • (z.2 : ℂ) ∈ Q.table) := by |
| rw [← c.initial_line] |
| simpa only [sub_self, zero_smul, add_zero] using Q.side_not_table (c.on_side 0) |
| have hdentry : ¬ (z.1 + d.time 0 • (z.2 : ℂ) ∈ Q.table) := by |
| rw [← d.initial_line] |
| simpa only [sub_self, zero_smul, add_zero] using Q.side_not_table (d.on_side 0) |
| have ht := entry_time_unique (fun t => z.1 + t • (z.2 : ℂ) ∈ Q.table) |
| c.zero_before d.zero_before hcinside hdinside hcentry hdentry |
| have hp : c.point 0 = d.point 0 := by |
| have hc := c.initial_line (c.time 0) |
| have hd := d.initial_line (d.time 0) |
| simp only [sub_self, zero_smul, add_zero] at hc hd |
| rw [hc, hd, ht] |
| refine ⟨ht, hp, c.start_direction.symm.trans d.start_direction, ?_⟩ |
| exact Q.side_index_unique (hp ▸ c.on_side 0) (d.on_side 0) |
|
|
| lemma agree_succ {Q : Triangle} {z : Phase} (c d : FlightChain Q z) (n : ℤ) |
| (h : c.Agree d n) : c.Agree d (n + 1) := by |
| obtain ⟨ht, hp, hv, _⟩ := h |
| let P : ℝ → Prop := fun t => c.point n + (t - c.time n) • (c.direction n : ℂ) ∈ Q.table |
| have hcinside : ∀ t, c.time n < t → t < c.time (n + 1) → P t := c.inside n |
| have hdinside : ∀ t, c.time n < t → t < d.time (n + 1) → P t := by |
| simpa only [P, ht, hp, hv] using d.inside n |
| have hcexit : ¬ P (c.time (n + 1)) := by |
| change ¬ c.point n + _ • (c.direction n : ℂ) ∈ Q.table |
| rw [← c.flight n] |
| exact Q.side_not_table (c.on_side (n + 1)) |
| have hdexit : ¬ P (d.time (n + 1)) := by |
| change ¬ c.point n + _ • (c.direction n : ℂ) ∈ Q.table |
| rw [ht, hp, hv, ← d.flight n] |
| exact Q.side_not_table (d.on_side (n + 1)) |
| have ht' : c.time (n + 1) = d.time (n + 1) := |
| exit_time_unique P (c.increasing (by omega)) |
| (ht ▸ d.increasing (by omega)) hcinside hdinside hcexit hdexit |
| have hp' : c.point (n + 1) = d.point (n + 1) := by |
| rw [c.flight n, d.flight n, ht', ht, hp, hv] |
| have hw' : c.wall (n + 1) = d.wall (n + 1) := |
| Q.side_index_unique (hp' ▸ c.on_side (n + 1)) (d.on_side (n + 1)) |
| refine ⟨ht', hp', ?_, hw'⟩ |
| apply Subtype.ext |
| rw [c.specular, d.specular, hw'] |
| simp only [add_sub_cancel_right, hv] |
|
|
| lemma agree_pred {Q : Triangle} {z : Phase} (c d : FlightChain Q z) (n : ℤ) |
| (h : c.Agree d n) : c.Agree d (n - 1) := by |
| obtain ⟨ht, hp, hv, hw⟩ := h |
| have hv' : c.direction (n - 1) = d.direction (n - 1) := by |
| apply Subtype.ext |
| calc |
| (c.direction (n - 1) : ℂ) = reflect (Q.tangent (c.wall n)) (c.direction n : ℂ) := by |
| rw [c.specular n] |
| exact (reflect_involutive (Q.tangent_ne_zero _) _).symm |
| _ = reflect (Q.tangent (d.wall n)) (d.direction n : ℂ) := by rw [hw, hv] |
| _ = (d.direction (n - 1) : ℂ) := by |
| rw [d.specular n] |
| exact reflect_involutive (Q.tangent_ne_zero _) _ |
| let P : ℝ → Prop := fun t => |
| c.point n + (t - c.time n) • (c.direction (n - 1) : ℂ) ∈ Q.table |
| have hcinside : ∀ t, c.time (n - 1) < t → t < c.time n → P t := by |
| intro t h₁ h₂ |
| change c.point n + _ • (c.direction (n - 1) : ℂ) ∈ Q.table |
| rw [← c.previous_line n t] |
| exact c.inside (n - 1) t h₁ (by simpa only [sub_add_cancel] using h₂) |
| have hdinside : ∀ t, d.time (n - 1) < t → t < c.time n → P t := by |
| intro t h₁ h₂ |
| change c.point n + _ • (c.direction (n - 1) : ℂ) ∈ Q.table |
| rw [ht, hp, hv', ← d.previous_line n t] |
| exact d.inside (n - 1) t h₁ (by simpa only [sub_add_cancel, ← ht] using h₂) |
| have hcentry : ¬ P (c.time (n - 1)) := by |
| change ¬ c.point n + _ • (c.direction (n - 1) : ℂ) ∈ Q.table |
| rw [← c.previous_line] |
| simpa only [sub_self, zero_smul, add_zero] using Q.side_not_table (c.on_side (n - 1)) |
| have hdentry : ¬ P (d.time (n - 1)) := by |
| change ¬ c.point n + _ • (c.direction (n - 1) : ℂ) ∈ Q.table |
| rw [ht, hp, hv', ← d.previous_line] |
| simpa only [sub_self, zero_smul, add_zero] using Q.side_not_table (d.on_side (n - 1)) |
| have ht' : c.time (n - 1) = d.time (n - 1) := |
| entry_time_unique P (c.increasing (by omega)) |
| (ht ▸ d.increasing (by omega)) hcinside hdinside hcentry hdentry |
| have hp' : c.point (n - 1) = d.point (n - 1) := by |
| have hc := c.previous_line n (c.time (n - 1)) |
| have hd := d.previous_line n (d.time (n - 1)) |
| simp only [sub_self, zero_smul, add_zero] at hc hd |
| rw [hc, hd, ht', ht, hp, hv'] |
| refine ⟨ht', hp', hv', ?_⟩ |
| exact Q.side_index_unique (hp' ▸ c.on_side (n - 1)) (d.on_side (n - 1)) |
|
|
| /-- Determinism of actual complete nonsingular specular trajectories. |
| Both forward and backward schemes use the same geometric reflection and |
| never postulate uniqueness as an assumption. -/ |
| theorem unique {Q : Triangle} {z : Phase} (c d : FlightChain Q z) : c = d := by |
| have h : ∀ n, c.Agree d n := by |
| intro n |
| induction n using Int.induction_on with |
| | zero => exact c.agree_zero d |
| | succ n hn => exact c.agree_succ d n hn |
| | pred n hn => exact c.agree_pred d (-n) hn |
| have ht : c.time = d.time := funext fun n => (h n).1 |
| have hp : c.point = d.point := funext fun n => (h n).2.1 |
| have hv : c.direction = d.direction := funext fun n => (h n).2.2.1 |
| have hw : c.wall = d.wall := funext fun n => (h n).2.2.2 |
| cases c |
| cases d |
| cases ht |
| cases hp |
| cases hv |
| cases hw |
| rfl |
|
|
| /-- Rebase a complete chain at a time strictly between its collisions. |
| The integer relabeling is forced by the designated initial flight. -/ |
| def rebase {Q : Triangle} {z : Phase} (c : FlightChain Q z) |
| (t : ℝ) (n : ℤ) (hn : c.time n < t ∧ t < c.time (n + 1)) : |
| FlightChain Q (c.at t) where |
| time k := c.time (k + n) - t |
| point k := c.point (k + n) |
| direction k := c.direction (k + n) |
| wall k := c.wall (k + n) |
| increasing := by |
| intro a b hab |
| exact sub_lt_sub_right (c.increasing (by omega)) t |
| unbounded_below u := by |
| obtain ⟨k, hk⟩ := c.unbounded_below (u + t) |
| refine ⟨k - n, ?_⟩ |
| simp only [sub_add_cancel] |
| linarith |
| unbounded_above u := by |
| obtain ⟨k, hk⟩ := c.unbounded_above (u + t) |
| refine ⟨k - n, ?_⟩ |
| simp only [sub_add_cancel] |
| linarith |
| zero_before := by simpa only [zero_add, sub_lt_zero] using hn.1 |
| zero_after := by simpa only [add_comm 1 n, sub_pos] using hn.2 |
| on_side k := c.on_side (k + n) |
| flight k := by |
| have hi : k + 1 + n = k + n + 1 := by omega |
| change c.point (k + 1 + n) = c.point (k + n) + |
| ((c.time (k + 1 + n) - t) - (c.time (k + n) - t)) • (c.direction (k + n) : ℂ) |
| rw [hi, sub_sub_sub_cancel_right] |
| exact c.flight (k + n) |
| inside k u h₁ h₂ := by |
| have hk : k + 1 + n = k + n + 1 := by ring |
| have h := c.inside (k + n) (u + t) (by linarith) (by rw [← hk]; linarith) |
| have he : u - (c.time (k + n) - t) = u + t - c.time (k + n) := by ring |
| simpa only [he] using h |
| start_point := by |
| rw [c.at_of_flight ⟨hn.1.le, hn.2⟩] |
| simp only [zero_add, neg_sub] |
| start_direction := by |
| rw [c.at_of_flight ⟨hn.1.le, hn.2⟩] |
| simp only [zero_add] |
| specular k := by |
| rw [show k - 1 + n = k + n - 1 by omega] |
| exact c.specular (k + n) |
|
|
| lemma rebase_at {Q : Triangle} {z : Phase} (c : FlightChain Q z) |
| (t : ℝ) (n : ℤ) (hn : c.time n < t ∧ t < c.time (n + 1)) (s : ℝ) : |
| (c.rebase t n hn).at s = c.at (s + t) := by |
| obtain ⟨k, hk⟩ := c.exists_flight (s + t) |
| have hleft : (c.rebase t n hn).time (k - n) ≤ s ∧ |
| s < (c.rebase t n hn).time (k - n + 1) := by |
| change c.time (k - n + n) - t ≤ s ∧ s < c.time (k - n + 1 + n) - t |
| have hi : k - n + 1 + n = k + 1 := by ring |
| rw [sub_add_cancel, hi] |
| constructor <;> linarith [hk.1, hk.2] |
| rw [at_of_flight _ hleft, c.at_of_flight hk] |
| simp only [rebase, sub_add_cancel] |
| rw [show s - (c.time k - t) = s + t - c.time k by ring] |
| |
| end FlightChain |
| |
| lemma billiardFlow_eq_chain {Q : Triangle} {z : Phase} (c : FlightChain Q z) (t : ℝ) : |
| billiardFlow Q t z = c.at t := by |
| classical |
| have h : Nonempty (FlightChain Q z) := ⟨c⟩ |
| simp only [billiardFlow, dite_eq_left h] |
| rw [FlightChain.unique (Classical.choice h) c] |
|
|
| /-- The exact cocycle identity on every rebased nonsingular trajectory. |
| Only rebasing at a collision is excluded, since Phase itself uses interior |
| initial states; the main theorem still needs the fixed-time exceptional |
| sets to be proved null. -/ |
| lemma billiardFlow_add_of_noncollision {Q : Triangle} {z : Phase} |
| (c : FlightChain Q z) (s t : ℝ) (ht : t ∉ range c.time) : |
| billiardFlow Q (s + t) z = billiardFlow Q s (billiardFlow Q t z) := by |
| obtain ⟨n, hn⟩ := c.exists_flight t |
| have hne : c.time n ≠ t := fun h => ht ⟨n, h⟩ |
| let d := c.rebase t n ⟨lt_of_le_of_ne hn.1 hne, hn.2⟩ |
| rw [billiardFlow_eq_chain c, billiardFlow_eq_chain c, |
| billiardFlow_eq_chain d, FlightChain.rebase_at] |
|
|
| end TriangularBilliards |
| end |
|
|
| end OAI |
|
|
