| import OAI.Geometry.CylinderCovering.Radial.SweepDefinitions |
| import OAI.Geometry.CylinderCovering.Radial.Intercept |
| import OAI.Geometry.CylinderCovering.Radial.Integral |
| import OAI.Geometry.CylinderCovering.Radial.Riemann |
| import OAI.Geometry.CylinderCovering.Radial.AreaConvergence |
| import OAI.Geometry.CylinderCovering.Radial.Projection |
| import OAI.Geometry.CylinderCovering.Radial.Freezing |
|
|
| namespace OAI |
|
|
| open Set MeasureTheory Filter |
| open scoped InnerProductSpace Topology |
|
|
| noncomputable section |
|
|
| namespace CylinderCovering.RadialSweep |
|
|
| theorem velocity_difference_integral (D : Data) {c t : ℝ} |
| (hc : c ∈ Icc D.α D.β) (ht : t ∈ Icc D.α D.β) : |
| D.w t - D.w c = ∫ x in c..t, D.lam x • (D.a + x • D.b) := by |
| have hsub : uIcc c t ⊆ Icc D.α D.β := uIcc_subset_Icc hc ht |
| have hcont : ContinuousOn (fun x => D.lam x • (D.a + x • D.b)) (Icc D.α D.β) := |
| D.scalar_continuous.smul (continuous_const.continuousOn.add |
| (continuous_id.continuousOn.smul continuous_const.continuousOn)) |
| symm |
| apply intervalIntegral.integral_eq_sub_of_hasDeriv_right |
| (D.velocity_continuous.mono hsub) _ ((hcont.mono hsub).intervalIntegrable) |
| intro x hx |
| have hα : D.α < x := lt_of_le_of_lt (le_min hc.1 ht.1) hx.1 |
| have hβ : x < D.β := lt_of_lt_of_le hx.2 (max_le hc.2 ht.2) |
| exact ((D.aligned x ⟨le_of_lt hα, le_of_lt hβ⟩).hasDerivAt |
| (Icc_mem_nhds hα hβ)).hasDerivWithinAt |
|
|
| lemma scalar_le_bound (D : Data) {t : ℝ} (ht : t ∈ Icc D.α D.β) : |
| |D.lam t| ≤ scalarBound D := by |
| exact le_csSup (isCompact_Icc.bddAbove_image D.scalar_continuous.abs) ⟨t, ht, rfl⟩ |
|
|
| lemma cell_midpoint_bound (D : Data) {N : ℕ} {i : Fin N} {t : ℝ} |
| (ht : t ∈ RadialRiemann.cell D.α D.β N i) : |
| |t - midpoint D N i| ≤ RadialRiemann.step D.α D.β N / 2 := by |
| have hstep := RadialRiemann.point_succ D.α D.β N i |
| rw [abs_le] |
| unfold midpoint |
| constructor <;> linarith [ht.1, ht.2] |
|
|
| lemma frozenTriangle_eq (D : Data) (N : ℕ) (i : Fin N) : |
| frozenTriangle D N i = TriangularCovering.triangle |
| (coordinateMap D (leftTip D N, midpoint D N i * leftTip D N)) |
| (coordinateMap D (rightEdge D N i, midpoint D N i * rightEdge D N i - |
| RadialRiemann.step D.α D.β N / 2 * (rightEdge D N i - leftTip D N))) |
| (coordinateMap D (rightEdge D N i, midpoint D N i * rightEdge D N i + |
| RadialRiemann.step D.α D.β N / 2 * (rightEdge D N i - leftTip D N))) := rfl |
|
|
| theorem localSweep_frozen_enclosure (D : Data) {N : ℕ} (i : Fin N) {c : ℝ} |
| (hc : c ∈ RadialRiemann.cell D.α D.β N i) {z : Space} |
| (hz : z ∈ localSweep D N i) : |
| ∃ p ∈ frozenTriangle D N i, ∃ s : ℝ, z = p + s • (D.e + D.w c) := by |
| obtain ⟨t, ht, ρ, hρ, s, hs, rfl⟩ := hz |
| have hci := RadialRiemann.cell_subset D.interval_nonempty i hc |
| have hti := RadialRiemann.cell_subset D.interval_nonempty i ht |
| have hd := RadialRiemann.step_pos D.interval_nonempty (Nat.zero_lt_of_lt i.isLt) |
| have htc : |t - c| ≤ RadialRiemann.step D.α D.β N := by |
| simpa only [Real.dist_eq] using RadialRiemann.cell_dist_le ht hc |
| have hR : ρ ≤ RadialRiemann.capMax D.R D.α D.β N i := |
| hρ.2.trans (RadialRiemann.le_capMax D.interval_nonempty D.cap_continuous ht) |
| obtain ⟨u, v, huv, hu₀, hu₁, hv⟩ := RadialIntegral.aligned_footprint |
| (p0 := D.p₀) D.velocity_continuous D.scalar_continuous D.aligned hci hti |
| (scalarBound_nonneg D) D.length_pos.le hd.le (fun x hx => scalar_le_bound D hx) |
| htc (cell_midpoint_bound D ht) hs hρ.1 hR |
| have htri := RadialFreezing.footprint_subset_triangle |
| (radialError_nonneg D) (div_nonneg (radialError_nonneg D) (by norm_num)) hd.le |
| hu₀ hu₁ hv |
| have hcollar : 2 * (radialError D + radialError D / 2) + 1 = collar D := by |
| unfold collar |
| ring |
| rw [hcollar] at htri |
| refine ⟨coordinateMap D (u, v), ?_, s, ?_⟩ |
| · rw [frozenTriangle_eq] |
| simp only [coordinateMap] |
| rw [← RadialProjection.coordinate_region_image D.p₀ D.a D.b |
| (m := midpoint D N i) (leftTip_lt_rightEdge D (Nat.zero_lt_of_lt i.isLt) i) hd] |
| refine ⟨(u, v), ?_, rfl⟩ |
| change leftTip D N ≤ u ∧ u ≤ rightEdge D N i ∧ |
| |v - midpoint D N i * u| ≤ RadialRiemann.step D.α D.β N / 2 * (u - leftTip D N) |
| simpa only [leftTip, rightEdge, neg_mul, sub_neg_eq_add] using htri |
| · dsimp [coordinateMap] at * |
| calc |
| D.p₀ + ρ • (D.a + t • D.b) + s • (D.e + D.w t) = |
| (D.p₀ + ρ • (D.a + t • D.b) + s • (D.w t - D.w c)) + |
| s • (D.e + D.w c) := by module |
| _ = D.p₀ + u • D.a + v • D.b + s • (D.e + D.w c) := by rw [huv] |
|
|
| lemma direction_ne_zero (D : Data) {t : ℝ} (ht : t ∈ Icc D.α D.β) : |
| D.e + D.w t ≠ 0 := |
| RadialProjection.sideways_ne_zero D.normal_unit (D.velocity_perp t ht) |
|
|
| lemma direction_unit (D : Data) {t : ℝ} (ht : t ∈ Icc D.α D.β) : |
| ‖direction D t‖ = 1 := |
| TriangularCovering.unit_norm (direction_ne_zero D ht) |
|
|
| lemma frozen_nondegenerate (D : Data) {N : ℕ} (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) : |
| inner ℝ (direction D (tag i)) |
| (TriangularCovering.cross3 (frozenVertices D N i 1 - frozenVertices D N i 0) |
| (frozenVertices D N i 2 - frozenVertices D N i 0)) ≠ 0 := by |
| have h := RadialProjection.collar_projection_nondegenerate |
| D.p₀ D.e D.a D.b (D.w (tag i)) |
| (leftTip D N) (rightEdge D N i) (midpoint D N i) (RadialRiemann.step D.α D.β N) |
| D.normal_unit D.a_perp D.b_perp |
| (D.velocity_perp (tag i) (RadialRiemann.cell_subset D.interval_nonempty i (htag i))) |
| (RadialRiemann.step_pos D.interval_nonempty (Nat.zero_lt_of_lt i.isLt)) |
| (leftTip_lt_rightEdge D (Nat.zero_lt_of_lt i.isLt) i) (RadialProjection.gram_sqrt_pos D.independent) |
| simpa [direction, TriangularCovering.unit, frozenVertices, coordinateMap] using h |
|
|
| def frozenCylinder (D : Data) (N : ℕ) (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) : TriangularCovering.TriCylinder := |
| TriangularCovering.projectedCylinder (direction D (tag i)) |
| (direction_unit D (RadialRiemann.cell_subset D.interval_nonempty i (htag i))) |
| (frozenVertices D N i 0) (frozenVertices D N i 1) (frozenVertices D N i 2) |
| (frozen_nondegenerate D tag htag i) |
|
|
| lemma frozenCylinder_axis (D : Data) (N : ℕ) (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) : |
| (frozenCylinder D N tag htag i).axis = direction D (tag i) := rfl |
|
|
| lemma frozenCylinder_base (D : Data) (N : ℕ) (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) : |
| (frozenCylinder D N tag htag i).base = frozenBase D N tag i := rfl |
|
|
| lemma frozenCylinder_area (D : Data) (N : ℕ) (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) : |
| TriangularCovering.area (frozenCylinder D N tag htag i).base = frozenArea D N tag i := by |
| rw [frozenCylinder_base] |
| have h := RadialProjection.collar_projection_area D.p₀ D.e D.a D.b (D.w (tag i)) |
| (leftTip D N) (rightEdge D N i) (midpoint D N i) (RadialRiemann.step D.α D.β N) |
| D.normal_unit D.a_perp D.b_perp |
| (D.velocity_perp (tag i) (RadialRiemann.cell_subset D.interval_nonempty i (htag i))) |
| (RadialRiemann.step_pos D.interval_nonempty (Nat.zero_lt_of_lt i.isLt)).le |
| change TriangularCovering.area (TriangularCovering.projection _ '' frozenTriangle D N i) = _ |
| rw [frozenTriangle_eq] |
| change TriangularCovering.area (TriangularCovering.projection |
| (TriangularCovering.unit (D.e + D.w (tag i))) '' _) = _ |
| simp only [coordinateMap] |
| rw [show TriangularCovering.area |
| (TriangularCovering.projection (TriangularCovering.unit (D.e + D.w (tag i))) '' |
| TriangularCovering.triangle _ _ _) = _ from h] |
| unfold frozenArea kappa leftTip rightEdge |
| ring |
|
|
| lemma localSweep_mem_frozenCylinder (D : Data) {N : ℕ} (tag : Fin N → ℝ) |
| (htag : RadialRiemann.IsTagged D.α D.β N tag) (i : Fin N) {z : Space} |
| (hz : z ∈ localSweep D N i) : z ∈ (frozenCylinder D N tag htag i).carrier := by |
| obtain ⟨p, hp, s, hz⟩ := localSweep_frozen_enclosure D i (htag i) hz |
| exact TriangularCovering.projectedCylinder_mem_direction |
| (D.e + D.w (tag i)) |
| (direction_ne_zero D (RadialRiemann.cell_subset D.interval_nonempty i (htag i))) |
| (frozenVertices D N i 0) (frozenVertices D N i 1) (frozenVertices D N i 2) |
| (frozen_nondegenerate D tag htag i) hp s hz |
|
|
| lemma localSweep_subset_sweep (D : Data) {N : ℕ} (i : Fin N) : |
| localSweep D N i ⊆ sweep D := by |
| rintro z ⟨t, ht, ρ, hρ, s, hs, hz⟩ |
| exact ⟨t, RadialRiemann.cell_subset D.interval_nonempty i ht, ρ, hρ, s, hs, hz⟩ |
|
|
| lemma sweep_eq_iUnion_localSweep (D : Data) {N : ℕ} (hN : 0 < N) : |
| sweep D = ⋃ i : Fin N, localSweep D N i := by |
| apply Set.Subset.antisymm |
| · rintro z ⟨t, ht, ρ, hρ, s, hs, hz⟩ |
| obtain ⟨i, hi⟩ := RadialRiemann.exists_cell hN ht |
| exact Set.mem_iUnion.mpr ⟨i, t, hi, ρ, hρ, s, hs, hz⟩ |
| · intro z hz |
| obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hz |
| exact localSweep_subset_sweep D i hi |
|
|
| theorem aligned_radial_sweep : AlignedStatement := by |
| intro D tag htag |
| refine ⟨fun N => frozenCylinder D N (tag N) (htag N), ?_, ?_⟩ |
| · intro N hN |
| constructor |
| · intro i |
| exact ⟨frozenCylinder_axis D N (tag N) (htag N) i, |
| frozenCylinder_base D N (tag N) (htag N) i, |
| frozenCylinder_area D N (tag N) (htag N) i⟩ |
| · rintro z ⟨t, ht, ρ, hρ, s, hs, hz⟩ |
| obtain ⟨i, hi⟩ := RadialRiemann.exists_cell hN ht |
| exact ⟨i, localSweep_mem_frozenCylinder D (tag N) (htag N) i |
| ⟨t, hi, ρ, hρ, s, hs, hz⟩⟩ |
| · convert frozenArea_tendsto D tag htag using 1 |
| funext N |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact frozenCylinder_area D N (tag N) (htag N) i |
|
|
| end CylinderCovering.RadialSweep |
|
|
| end |
|
|
| end OAI |
|
|
