| import OAI.Geometry.CylinderCovering.Caps.FiniteDefinitions |
| import OAI.Geometry.CylinderCovering.Footprints.Shapes |
| import OAI.Geometry.CylinderCovering.Radial.Riemann |
|
|
| namespace OAI |
|
|
| open Set |
| open scoped InnerProductSpace |
| noncomputable section |
| namespace CylinderCovering.HalfheightFinite.Shape |
|
|
| lemma height_pos : 0 < height := by unfold height; positivity |
|
|
| lemma foot_eq_affine (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : |
| foot δ R N i = Footprints.affineFootprint (midpoint N i) (maxCap R N i) |
| (2 * halfwidth N) (δ / 4) (δ / 4) := by |
| ext p |
| simp only [foot, RadialFootprints.halfheightFootprint, |
| Footprints.affineFootprint, mem_ofPred_eq, mem_Icc, collar] |
| have h₁ : -(δ * halfwidth N / 2) = -(δ / 4) * (2 * halfwidth N) := by ring |
| have h₂ : δ * halfwidth N / 2 = δ / 4 * (2 * halfwidth N) := by ring |
| have h₃ : halfwidth N * (p.1 + 2 * (δ * halfwidth N / 2)) = |
| 2 * halfwidth N / 2 * p.1 + δ / 4 * (2 * halfwidth N)^2 := by ring |
| rw [h₃, h₁, h₂] |
| tauto |
|
|
| def firstFootLinear : (ℝ × ℝ) →ₗ[ℝ] Space where |
| toFun := firstFoot |
| map_add' p q := by ext i; fin_cases i <;> simp [firstFoot] <;> ring |
| map_smul' c p := by ext i; fin_cases i <;> simp [firstFoot] <;> ring |
|
|
| def secondFootLinear : (ℝ × ℝ) →ₗ[ℝ] Space where |
| toFun p := !₂[p.2/2,0,-height*p.1] |
| map_add' p q := by ext i; fin_cases i <;> simp <;> ring |
| map_smul' c p := by ext i; fin_cases i <;> simp <;> ring |
|
|
| def secondFootAffine : (ℝ × ℝ) →ᵃ[ℝ] Space where |
| toFun := secondFoot |
| linear := secondFootLinear |
| map_vadd' p q := by |
| ext i |
| fin_cases i <;> simp [secondFoot, secondFootLinear] <;> ring |
|
|
| def projectionLinear (u : Space) : Space →ₗ[ℝ] Space := |
| LinearMap.id - (innerₛₗ ℝ u).smulRight u |
|
|
| lemma projectionLinear_apply (u z : Space) : |
| projectionLinear u z = TriangularCovering.projection u z := rfl |
|
|
| def firstProjectedAffine (δ r : ℝ) : (ℝ × ℝ) →ᵃ[ℝ] Space := |
| (projectionLinear (firstAxis δ r)).toAffineMap.comp firstFootLinear.toAffineMap |
|
|
| def secondProjectedAffine (δ r : ℝ) : (ℝ × ℝ) →ᵃ[ℝ] Space := |
| (projectionLinear (secondAxis δ r)).toAffineMap.comp secondFootAffine |
|
|
| lemma firstRaw_ne_zero (δ r : ℝ) : firstRaw δ r ≠ 0 := by |
| intro h |
| have h₀ := congrArg (fun z : Space => z 0) h |
| norm_num [firstRaw] at h₀ |
|
|
| lemma secondRaw_ne_zero (δ r : ℝ) : secondRaw δ r ≠ 0 := by |
| intro h |
| have h₁ := congrArg (fun z : Space => z 1) h |
| norm_num [secondRaw] at h₁ |
|
|
| lemma firstAxis_zero_ne (δ r : ℝ) : firstAxis δ r 0 ≠ 0 := by |
| simp [firstAxis, firstRaw] |
|
|
| lemma secondAxis_one_ne (δ r : ℝ) : secondAxis δ r 1 ≠ 0 := by |
| simp [secondAxis, secondRaw] |
|
|
| lemma projection_injective_on_coordinate_plane {u p q : Space} {i : Fin 3} |
| (hu : u i ≠ 0) (hp : p i = 0) (hq : q i = 0) |
| (heq : TriangularCovering.projection u p = TriangularCovering.projection u q) : p = q := by |
| have hi := congrArg (fun z : Space => z i) heq |
| simp only [TriangularCovering.projection, PiLp.sub_apply, PiLp.smul_apply, |
| smul_eq_mul, hp, hq, zero_sub] at hi |
| have hin : inner ℝ u p = inner ℝ u q := mul_right_cancel₀ hu (neg_inj.mp hi) |
| simpa only [TriangularCovering.projection, hin, sub_left_inj] using heq |
|
|
| lemma firstProjectedAffine_injective (δ r : ℝ) : |
| Function.Injective (firstProjectedAffine δ r) := by |
| intro p q h |
| have hpq : firstFoot p = firstFoot q := |
| projection_injective_on_coordinate_plane (firstAxis_zero_ne δ r) (by simp [firstFoot]) |
| (by simp [firstFoot]) h |
| have h₁ := congrArg (fun z : Space => z 1) hpq |
| have h₂ := congrArg (fun z : Space => z 2) hpq |
| change p.2 / 2 = q.2 / 2 at h₁ |
| change height * p.1 = height * q.1 at h₂ |
| apply Prod.ext |
| · exact mul_left_cancel₀ (ne_of_gt height_pos) h₂ |
| · linarith |
|
|
| lemma secondProjectedAffine_injective (δ r : ℝ) : |
| Function.Injective (secondProjectedAffine δ r) := by |
| intro p q h |
| have hpq : secondFoot p = secondFoot q := |
| projection_injective_on_coordinate_plane (secondAxis_one_ne δ r) (by simp [secondFoot]) |
| (by simp [secondFoot]) h |
| have h₀ := congrArg (fun z : Space => z 0) hpq |
| have h₂ := congrArg (fun z : Space => z 2) hpq |
| change p.2 / 2 = q.2 / 2 at h₀ |
| change height * (1-p.1) = height * (1-q.1) at h₂ |
| apply Prod.ext |
| · have := mul_left_cancel₀ (ne_of_gt height_pos) h₂ |
| linarith |
| · linarith |
|
|
| lemma firstBase_eq_image (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : |
| firstBase δ R N i = firstProjectedAffine δ (midpoint N i) '' foot δ R N i := by |
| rw [firstBase, image_image] |
| rfl |
|
|
| lemma secondBase_eq_image (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : |
| secondBase δ R N i = secondProjectedAffine δ (midpoint N i) '' foot δ R N i := by |
| rw [secondBase, image_image] |
| rfl |
|
|
| def coordinateVertices (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : Fin 4 → ℝ × ℝ := |
| Footprints.trapezoidVertices (midpoint N i) (maxCap R N i) |
| (2 * halfwidth N) (δ / 4) (δ / 4) |
|
|
| def firstVertices (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : Fin 4 → Space := |
| firstProjectedAffine δ (midpoint N i) ∘ coordinateVertices δ R N i |
|
|
| def secondVertices (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : Fin 4 → Space := |
| secondProjectedAffine δ (midpoint N i) ∘ coordinateVertices δ R N i |
|
|
| lemma halfwidth_pos {N : ℕ} (hN : 0 < N) : 0 < halfwidth N := by |
| unfold halfwidth |
| positivity |
|
|
| lemma radial_length_pos {δ M : ℝ} {N : ℕ} (hδ : 0 < δ) (hM : 0 ≤ M) |
| (hN : 0 < N) : 0 < M + 2 * (δ / 4) * (2 * halfwidth N) := by |
| have := halfwidth_pos hN |
| positivity |
|
|
| lemma coordinate_shape {δ : ℝ} {R : ℝ → ℝ} {N : ℕ} (i : Fin N) |
| (hδ : 0 < δ) (hM : 0 ≤ maxCap R N i) : |
| foot δ R N i = convexHull ℝ (range (coordinateVertices δ R N i)) ∧ |
| Function.Injective (coordinateVertices δ R N i) := by |
| have hN : 0 < N := Nat.zero_lt_of_lt i.isLt |
| have hd : 0 < 2 * halfwidth N := mul_pos (by norm_num) (halfwidth_pos hN) |
| have hpad : δ / 4 / 2 < δ / 4 := by linarith |
| have hlen := radial_length_pos hδ hM hN |
| rw [foot_eq_affine] |
| exact ⟨Footprints.affineFootprint_eq_convexHull_trapezoid hd hpad hlen, |
| Footprints.trapezoidVertices_injective hd hpad hlen⟩ |
|
|
| theorem projected_shape {δ : ℝ} {R : ℝ → ℝ} {N : ℕ} (i : Fin N) |
| (hδ : 0 < δ) (hM : 0 ≤ maxCap R N i) : |
| firstBase δ R N i = convexHull ℝ (range (firstVertices δ R N i)) ∧ |
| secondBase δ R N i = convexHull ℝ (range (secondVertices δ R N i)) ∧ |
| Function.Injective (firstVertices δ R N i) ∧ |
| Function.Injective (secondVertices δ R N i) := by |
| obtain ⟨hfoot, hinj⟩ := coordinate_shape i hδ hM |
| refine ⟨?_, ?_, (firstProjectedAffine_injective δ (midpoint N i)).comp hinj, |
| (secondProjectedAffine_injective δ (midpoint N i)).comp hinj⟩ |
| · rw [firstBase_eq_image, hfoot, (firstProjectedAffine δ (midpoint N i)).image_convexHull, |
| ← range_comp] |
| rfl |
| · rw [secondBase_eq_image, hfoot, (secondProjectedAffine δ (midpoint N i)).image_convexHull, |
| ← range_comp] |
| rfl |
|
|
| lemma vertical_triangle_independent {l r a b c : ℝ} (hlr : l < r) (hab : a < b) : |
| AffineIndependent ℝ ![(l,a),(l,b),(r,c)] := by |
| rw [affineIndependent_iff_of_fintype] |
| intro w hw hv j |
| rw [Finset.weightedVSub_eq_linear_combination _ hw] at hv |
| have hx := congrArg (fun p : ℝ × ℝ => p.1) hv |
| have hy := congrArg (fun p : ℝ × ℝ => p.2) hv |
| simp [Fin.sum_univ_succ] at hw hx hy |
| have hw₂' : (r-l) * w 2 = 0 := by linear_combination hx-l*hw |
| have hw₂ : w 2 = 0 := (mul_eq_zero.mp hw₂').resolve_left (ne_of_gt (sub_pos.mpr hlr)) |
| have hw₁' : (b-a) * w 1 = 0 := by linear_combination hy-a*hw-(c-a)*hw₂ |
| have hw₁ : w 1 = 0 := (mul_eq_zero.mp hw₁').resolve_left (ne_of_gt (sub_pos.mpr hab)) |
| fin_cases j <;> simp_all |
|
|
| lemma coordinate_nondegenerate {δ : ℝ} {R : ℝ → ℝ} {N : ℕ} (i : Fin N) |
| (hδ : 0 < δ) (hM : 0 ≤ maxCap R N i) : |
| AffineIndependent ℝ ![coordinateVertices δ R N i 0, |
| coordinateVertices δ R N i 1, coordinateVertices δ R N i 2] := by |
| have hN : 0 < N := Nat.zero_lt_of_lt i.isLt |
| have hd : 0 < 2 * halfwidth N := mul_pos (by norm_num) (halfwidth_pos hN) |
| have hpad : δ / 4 / 2 < δ / 4 := by linarith |
| have hlen := radial_length_pos hδ hM hN |
| have hwidth := Footprints.affine_width_pos hd hpad (le_refl (-(δ/4)*(2*halfwidth N))) |
| apply vertical_triangle_independent |
| · linarith |
| · linarith |
|
|
| theorem projected_nondegenerate {δ : ℝ} {R : ℝ → ℝ} {N : ℕ} (i : Fin N) |
| (hδ : 0 < δ) (hM : 0 ≤ maxCap R N i) : |
| AffineIndependent ℝ ![firstVertices δ R N i 0, |
| firstVertices δ R N i 1, firstVertices δ R N i 2] ∧ |
| AffineIndependent ℝ ![secondVertices δ R N i 0, |
| secondVertices δ R N i 1, secondVertices δ R N i 2] := by |
| have h := coordinate_nondegenerate i hδ hM |
| constructor |
| · convert h.map' (firstProjectedAffine δ (midpoint N i)) |
| (firstProjectedAffine_injective δ (midpoint N i)) using 1 |
| ext j |
| fin_cases j <;> rfl |
| · convert h.map' (secondProjectedAffine δ (midpoint N i)) |
| (secondProjectedAffine_injective δ (midpoint N i)) using 1 |
| ext j |
| fin_cases j <;> rfl |
|
|
| lemma coordinate_parallel_sides (δ : ℝ) (R : ℝ → ℝ) (N : ℕ) (i : Fin N) : |
| coordinateVertices δ R N i 1 - coordinateVertices δ R N i 0 = |
| (0, 2 * halfwidth N * collar δ N) ∧ |
| coordinateVertices δ R N i 3 - coordinateVertices δ R N i 2 = |
| (0, 2 * halfwidth N * (maxCap R N i + 3 * collar δ N)) := by |
| constructor <;> ext <;> |
| simp [coordinateVertices, Footprints.trapezoidVertices, collar] <;> ring |
|
|
| private lemma affine_side (f : (ℝ × ℝ) →ᵃ[ℝ] Space) {p q : ℝ × ℝ} {a : ℝ} |
| (h : p - q = (0,a)) : f p - f q = a • f.linear (0,1) := by |
| calc |
| f p - f q = f.linear (p-q) := (f.linearMap_vsub p q).symm |
| _ = f.linear (a • (0,1)) := by rw [h]; congr 1; ext <;> simp |
| _ = a • f.linear (0,1) := f.linear.map_smul a (0,1) |
|
|
| private lemma affine_vertical_ne_zero (f : (ℝ × ℝ) →ᵃ[ℝ] Space) |
| (hf : Function.Injective f) : f.linear (0,1) ≠ 0 := by |
| intro h |
| have heq : f.linear (0,1) = f.linear (0,0) := by |
| change f.linear (0,1) = f.linear 0 |
| rw [map_zero] |
| exact h |
| have := (f.linear_injective_iff.mpr hf) heq |
| norm_num at this |
|
|
| theorem projected_parallel_sides {δ : ℝ} {R : ℝ → ℝ} {N : ℕ} (i : Fin N) |
| (hδ : 0 < δ) (hM : 0 ≤ maxCap R N i) : |
| 0 < 2 * halfwidth N * collar δ N ∧ |
| 0 < 2 * halfwidth N * (maxCap R N i + 3 * collar δ N) ∧ |
| ∃ vU vL : Space, vU ≠ 0 ∧ vL ≠ 0 ∧ |
| firstVertices δ R N i 1 - firstVertices δ R N i 0 = |
| (2 * halfwidth N * collar δ N) • vU ∧ |
| firstVertices δ R N i 3 - firstVertices δ R N i 2 = |
| (2 * halfwidth N * (maxCap R N i + 3 * collar δ N)) • vU ∧ |
| secondVertices δ R N i 1 - secondVertices δ R N i 0 = |
| (2 * halfwidth N * collar δ N) • vL ∧ |
| secondVertices δ R N i 3 - secondVertices δ R N i 2 = |
| (2 * halfwidth N * (maxCap R N i + 3 * collar δ N)) • vL := by |
| have hρ := halfwidth_pos (Nat.zero_lt_of_lt i.isLt) |
| have he : 0 < collar δ N := by unfold collar; positivity |
| obtain ⟨hl,hr⟩ := coordinate_parallel_sides δ R N i |
| refine ⟨by positivity, by positivity, |
| (firstProjectedAffine δ (midpoint N i)).linear (0,1), |
| (secondProjectedAffine δ (midpoint N i)).linear (0,1), |
| affine_vertical_ne_zero _ (firstProjectedAffine_injective δ (midpoint N i)), |
| affine_vertical_ne_zero _ (secondProjectedAffine_injective δ (midpoint N i)), |
| affine_side _ hl, affine_side _ hr, affine_side _ hl, affine_side _ hr⟩ |
|
|
| theorem family_shape {δ : ℝ} (hδ : 0 < δ) {R : ℝ → ℝ} |
| (hR : ContinuousOn R (Icc (-1) 1)) (hR0 : ∀ r ∈ Icc (-1:ℝ) 1, 0 ≤ R r) |
| {N : ℕ} (i : Fin N) : |
| firstBase δ R N i = convexHull ℝ (range (firstVertices δ R N i)) ∧ |
| secondBase δ R N i = convexHull ℝ (range (secondVertices δ R N i)) ∧ |
| Function.Injective (firstVertices δ R N i) ∧ |
| Function.Injective (secondVertices δ R N i) := by |
| apply projected_shape i hδ |
| exact RadialRiemann.capMax_nonneg (by norm_num) hR hR0 i |
|
|
| end CylinderCovering.HalfheightFinite.Shape |
|
|
| end |
|
|
| end OAI |
|
|
