Datasets:

roseking
/

openAI-math-dataset

import OAI.Geometry.CylinderCovering.Angular.GeneralGeometryDefinitions
import OAI.Geometry.CylinderCovering.Angular.Geometry
import OAI.Geometry.CylinderCovering.Angular.Caps

namespace OAI

open Set MeasureTheory
open RuledApproximation
open scoped InnerProductSpace
noncomputable section
namespace CylinderCovering.AngularGeneral

lemma planarSector_eq_image (D : Data) (j : ℕ) :
    planarSector D j = (fun p : ℝ × ℝ => vec2 (p.1 * p.2) p.2) ''
      AngularCaps.radialParameterSet (D.node j) (D.node (j+1)) (D.radius j) := by
  ext p
  constructor
  · rintro ⟨q, hq, s, hs, rfl⟩
    exact ⟨(q, s), ⟨hq, hs⟩, rfl⟩
  · rintro ⟨⟨q, s⟩, ⟨hq, hs⟩, rfl⟩
    exact ⟨q, hq, s, hs, rfl⟩

lemma planarSector_compact {D : Data} {j : ℕ}
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (planarSector D j) := by
  rw [planarSector_eq_image]
  apply (AngularCaps.isCompact_radialParameterSet hc hn).image
  unfold vec2
  fun_prop

lemma lowerAxis_eq_physicalUnit (τ : ℝ) (D : Data) (j : ℕ) :
    lowerAxis τ D j = physicalUnit TriangularCovering.H
      (vec2 (τ * D.alpha j) (τ * D.beta j)) := rfl

lemma lowerAxis_norm (τ : ℝ) (D : Data) (j : ℕ) : ‖lowerAxis τ D j‖ = 1 := by
  rw [lowerAxis_eq_physicalUnit]
  exact physicalUnit_norm _ _

lemma lowerIntercept_eq_image (D : Data) (j : ℕ) :
    lowerIntercept D j = planeEmbedding TriangularCovering.H '' planarSector D j := by
  ext z
  constructor
  · rintro ⟨q, hq, s, hs, rfl⟩
    exact ⟨vec2 (q*s) s, ⟨q, hq, s, hs, rfl⟩, rfl⟩
  · rintro ⟨_, ⟨q, hq, s, hs, rfl⟩, rfl⟩
    exact ⟨q, hq, s, hs, rfl⟩

lemma projection_physicalUnit (h : ℝ) (g p : Plane) :
    TriangularCovering.projection (physicalUnit h g) (planeEmbedding h p) =
      rawProjection h g p := by
  unfold TriangularCovering.projection physicalUnit rawProjection
  simp only [LinearMap.coe_mk, AddHom.coe_mk, inner_smul_left, RCLike.conj_to_real,
    smul_smul]
  congr 1
  congr 1
  ring

lemma lowerBase_eq_rawImage (τ : ℝ) (D : Data) (j : ℕ) :
    lowerBase τ D j = rawProjection TriangularCovering.H
      (vec2 (τ * D.alpha j) (τ * D.beta j)) '' planarSector D j := by
  rw [lowerBase, lowerIntercept_eq_image, image_image]
  apply image_congr
  intro p hp
  rw [lowerAxis_eq_physicalUnit, projection_physicalUnit]

lemma ambient_area_of_intrinsic (C : Cylinder) :
    TriangularCovering.area ((Subtype.val :
      ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ) → Space) '' C.base) = C.area := by
  unfold TriangularCovering.area Cylinder.area
  rw [isometry_subtype_coe.euclideanHausdorffMeasure_image]
  have hm : (Measure.euclideanHausdorffMeasure 2 :
      Measure ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ)) = volume := by
    simpa only [perpendicularPlane_finrank _ C.unit_axis] using
      (InnerProductSpace.euclideanHausdorffMeasure_eq_volume
        (V := ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ)))
  rw [hm]
  rfl

lemma lowerBase_area (τ : ℝ) (D : Data) (j : ℕ) :
    TriangularCovering.area (lowerBase τ D j) =
      AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
        volume.real (planarSector D j) := by
  have hbase : lowerBase τ D j = (Subtype.val :
      ((Submodule.span ℝ ({(AngularGeometry.lowerCylinder TriangularCovering.H τ
        (D.alpha j) (D.beta j) (planarSector D j)).axis} : Set Space))ᗮ) → Space) ''
      (AngularGeometry.lowerCylinder TriangularCovering.H τ
        (D.alpha j) (D.beta j) (planarSector D j)).base := by
    rw [lowerBase_eq_rawImage]
    change _ = Subtype.val '' (perpendicularProjection TriangularCovering.H
      (vec2 (τ * D.alpha j) (τ * D.beta j)) '' planarSector D j)
    rw [image_image]
    rfl
  rw [hbase, ambient_area_of_intrinsic]
  exact AngularGeometry.lowerCylinder_area (Real.sqrt_pos.mpr (by norm_num)) τ
    (D.alpha j) (D.beta j) (planarSector D j)

lemma lowerBase_compact {D : Data} {j : ℕ} (τ : ℝ)
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (lowerBase τ D j) := by
  rw [lowerBase_eq_rawImage]
  exact (planarSector_compact hc hn).image (rawProjection _ _).continuous_of_finiteDimensional

lemma lowerBase_finite {D : Data} {j : ℕ} (τ : ℝ)
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
    Measure.euclideanHausdorffMeasure 2 (lowerBase τ D j) ≠ ⊤ := by
  rw [lowerBase_eq_rawImage]
  have he := (rawProjection TriangularCovering.H
    (vec2 (τ * D.alpha j) (τ * D.beta j))).euclideanHausdorffMeasure_image_eq_normDet_mul_volume
      (planarSector D j)
  rw [show Module.finrank ℝ Plane = 2 by simp] at he
  rw [he]
  exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top (planarSector_compact hc hn).measure_lt_top.ne

lemma projection_add (u x y : Space) :
    TriangularCovering.projection u (x+y) =
      TriangularCovering.projection u x + TriangularCovering.projection u y := by
  unfold TriangularCovering.projection
  rw [inner_add_right, add_smul]
  abel

lemma projection_rotate (R : Space ≃ₗᵢ[ℝ] Space) (u z : Space) :
    TriangularCovering.projection (R u) (R z) = R (TriangularCovering.projection u z) := by
  unfold TriangularCovering.projection
  rw [R.inner_map_map, map_sub, map_smul]

lemma upperDirection_eq_rotate (τ : ℝ) (D : Data) (j : ℕ) :
    upperDirection τ D j = swapReflect (lowerDirection (-τ) D j) := by
  ext i
  fin_cases i <;> simp [upperDirection, lowerDirection, TriangularCovering.point,
    swapReflect, vec3]

lemma upperAxis_eq_rotate (τ : ℝ) (D : Data) (j : ℕ) :
    upperAxis τ D j = swapReflect (lowerAxis (-τ) D j) := by
  unfold upperAxis lowerAxis unitDirection
  rw [upperDirection_eq_rotate, swapReflect.norm_map, map_smul]

lemma upperAxis_norm (τ : ℝ) (D : Data) (j : ℕ) : ‖upperAxis τ D j‖ = 1 := by
  rw [upperAxis_eq_rotate, swapReflect.norm_map, lowerAxis_norm]

lemma upperIntercept_eq_image (D : Data) (j : ℕ) :
    upperIntercept D j = (fun z => vec3 0 0 TriangularCovering.H + swapReflect z) ''
      lowerIntercept D j := by
  ext z
  constructor
  · rintro ⟨q, hq, t, ht, rfl⟩
    refine ⟨TriangularCovering.point 0 (q*t) t, ⟨q, hq, t, ht, rfl⟩, ?_⟩
    ext i
    fin_cases i <;> simp [TriangularCovering.point, swapReflect, vec3]; ring
  · rintro ⟨_, ⟨q, hq, t, ht, rfl⟩, rfl⟩
    refine ⟨q, hq, t, ht, ?_⟩
    ext i
    fin_cases i <;> simp [TriangularCovering.point, swapReflect, vec3]; ring

lemma upperBase_eq_image (τ : ℝ) (D : Data) (j : ℕ) :
    upperBase τ D j =
      (fun z => TriangularCovering.projection (upperAxis τ D j)
        (vec3 0 0 TriangularCovering.H) + swapReflect z) '' lowerBase (-τ) D j := by
  rw [upperBase, upperIntercept_eq_image, image_image, lowerBase, image_image]
  apply image_congr
  intro z hz
  rw [projection_add, upperAxis_eq_rotate, projection_rotate]

lemma upperBase_area_eq_lower (τ : ℝ) (D : Data) (j : ℕ) :
    TriangularCovering.area (upperBase τ D j) =
      TriangularCovering.area (lowerBase (-τ) D j) := by
  have hi : Isometry (fun z : Space => TriangularCovering.projection (upperAxis τ D j)
      (vec3 0 0 TriangularCovering.H) + swapReflect z) :=
    (isometry_add_left _).comp swapReflect.isometry
  unfold TriangularCovering.area
  rw [upperBase_eq_image, hi.euclideanHausdorffMeasure_image]

lemma upperBase_area (τ : ℝ) (D : Data) (j : ℕ) :
    TriangularCovering.area (upperBase τ D j) =
      AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
        volume.real (planarSector D j) := by
  rw [upperBase_area_eq_lower, lowerBase_area]
  simp [AngularGeometry.areaFactor]

lemma upperBase_compact {D : Data} {j : ℕ} (τ : ℝ)
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (upperBase τ D j) := by
  rw [upperBase_eq_image]
  exact (lowerBase_compact (-τ) hc hn).image (continuous_const.add swapReflect.continuous)

lemma upperBase_finite {D : Data} {j : ℕ} (τ : ℝ)
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
    Measure.euclideanHausdorffMeasure 2 (upperBase τ D j) ≠ ⊤ := by
  have hi : Isometry (fun z : Space => TriangularCovering.projection (upperAxis τ D j)
      (vec3 0 0 TriangularCovering.H) + swapReflect z) :=
    (isometry_add_left _).comp swapReflect.isometry
  rw [upperBase_eq_image, hi.euclideanHausdorffMeasure_image]
  exact lowerBase_finite (-τ) hc hn

lemma projected_base_perpendicular {u : Space} (hu : ‖u‖ = 1) (P : Set Space) :
    ∀ z ∈ TriangularCovering.projection u '' P, inner ℝ u z = 0 := by
  rintro _ ⟨x, hx, rfl⟩
  simp [TriangularCovering.projection, inner_sub_right, inner_smul_right,
    hu]

lemma base_properties {D : Data} {j : ℕ} (τ : ℝ)
    (hc : ContinuousOn (D.radius j) (interval D j))
    (hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
    BaseProperties (lowerAxis τ D j) (lowerBase τ D j) ∧
      BaseProperties (upperAxis τ D j) (upperBase τ D j) := by
  constructor
  · have hcomp := lowerBase_compact τ hc hn
    exact ⟨lowerAxis_norm τ D j, projected_base_perpendicular (lowerAxis_norm τ D j) _,
      hcomp, hcomp.measurableSet, lowerBase_finite τ hc hn⟩
  · have hcomp := upperBase_compact τ hc hn
    exact ⟨upperAxis_norm τ D j, projected_base_perpendicular (upperAxis_norm τ D j) _,
      hcomp, hcomp.measurableSet, upperBase_finite τ hc hn⟩

lemma totalArea_eq_planar_sum (τ : ℝ) (D : Data) :
    totalArea τ D = 2 * ∑ j : Fin D.count,
      AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
        volume.real (planarSector D j) := by
  unfold totalArea
  simp only [lowerBase_area, upperBase_area, ← two_mul, Finset.mul_sum]

lemma cell_cost_of_planar_volume (τ : ℝ) (D : Data) (j : ℕ)
    (hvol : volume.real (planarSector D j) =
      ∫ q in D.node j..D.node (j+1), (D.radius j q)^2 / 2) :
    (TriangularCovering.area (lowerBase τ D j) +
      TriangularCovering.area (upperBase τ D j)) / TriangularCovering.H =
      ∫ q in D.node j..D.node (j+1),
        (D.radius j q)^2 / Real.sqrt (1+τ^2*((D.alpha j)^2+2*(D.beta j)^2)) := by
  rw [lowerBase_area, upperBase_area, hvol]
  unfold TriangularCovering.H
  rw [AngularGeometry.areaFactor_sqrt_two]
  simp only [intervalIntegral.integral_div]
  have hH : Real.sqrt 2 ≠ 0 := (Real.sqrt_pos.mpr (by norm_num)).ne'
  have hden : Real.sqrt (1+τ^2*((D.alpha j)^2+2*(D.beta j)^2)) ≠ 0 :=
    (Real.sqrt_pos.mpr (by positivity)).ne'
  field_simp
  ring

lemma integral_cost_of_planar_volumes (τ : ℝ) (D : Data)
    (hvol : ∀ j < D.count, volume.real (planarSector D j) =
      ∫ q in D.node j..D.node (j+1), (D.radius j q)^2 / 2) :
    totalArea τ D / TriangularCovering.H = integralCost τ D := by
  unfold totalArea integralCost
  rw [Finset.sum_div]
  apply Finset.sum_congr rfl
  intro j hj
  exact cell_cost_of_planar_volume τ D j (hvol j j.isLt)

end CylinderCovering.AngularGeneral

end

end OAI

	import OAI.Geometry.CylinderCovering.Angular.GeneralGeometryDefinitions
	import OAI.Geometry.CylinderCovering.Angular.Geometry
	import OAI.Geometry.CylinderCovering.Angular.Caps

	namespace OAI

	open Set MeasureTheory
	open RuledApproximation
	open scoped InnerProductSpace
	noncomputable section
	namespace CylinderCovering.AngularGeneral

	lemma planarSector_eq_image (D : Data) (j : ℕ) :
	planarSector D j = (fun p : ℝ × ℝ => vec2 (p.1 * p.2) p.2) ''
	AngularCaps.radialParameterSet (D.node j) (D.node (j+1)) (D.radius j) := by
	ext p
	constructor
	· rintro ⟨q, hq, s, hs, rfl⟩
	exact ⟨(q, s), ⟨hq, hs⟩, rfl⟩
	· rintro ⟨⟨q, s⟩, ⟨hq, hs⟩, rfl⟩
	exact ⟨q, hq, s, hs, rfl⟩

	lemma planarSector_compact {D : Data} {j : ℕ}
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (planarSector D j) := by
	rw [planarSector_eq_image]
	apply (AngularCaps.isCompact_radialParameterSet hc hn).image
	unfold vec2
	fun_prop

	lemma lowerAxis_eq_physicalUnit (τ : ℝ) (D : Data) (j : ℕ) :
	lowerAxis τ D j = physicalUnit TriangularCovering.H
	(vec2 (τ * D.alpha j) (τ * D.beta j)) := rfl

	lemma lowerAxis_norm (τ : ℝ) (D : Data) (j : ℕ) : ‖lowerAxis τ D j‖ = 1 := by
	rw [lowerAxis_eq_physicalUnit]
	exact physicalUnit_norm _ _

	lemma lowerIntercept_eq_image (D : Data) (j : ℕ) :
	lowerIntercept D j = planeEmbedding TriangularCovering.H '' planarSector D j := by
	ext z
	constructor
	· rintro ⟨q, hq, s, hs, rfl⟩
	exact ⟨vec2 (q*s) s, ⟨q, hq, s, hs, rfl⟩, rfl⟩
	· rintro ⟨_, ⟨q, hq, s, hs, rfl⟩, rfl⟩
	exact ⟨q, hq, s, hs, rfl⟩

	lemma projection_physicalUnit (h : ℝ) (g p : Plane) :
	TriangularCovering.projection (physicalUnit h g) (planeEmbedding h p) =
	rawProjection h g p := by
	unfold TriangularCovering.projection physicalUnit rawProjection
	simp only [LinearMap.coe_mk, AddHom.coe_mk, inner_smul_left, RCLike.conj_to_real,
	smul_smul]
	congr 1
	congr 1
	ring

	lemma lowerBase_eq_rawImage (τ : ℝ) (D : Data) (j : ℕ) :
	lowerBase τ D j = rawProjection TriangularCovering.H
	(vec2 (τ * D.alpha j) (τ * D.beta j)) '' planarSector D j := by
	rw [lowerBase, lowerIntercept_eq_image, image_image]
	apply image_congr
	intro p hp
	rw [lowerAxis_eq_physicalUnit, projection_physicalUnit]

	lemma ambient_area_of_intrinsic (C : Cylinder) :
	TriangularCovering.area ((Subtype.val :
	((Submodule.span ℝ ({C.axis} : Set Space))ᗮ) → Space) '' C.base) = C.area := by
	unfold TriangularCovering.area Cylinder.area
	rw [isometry_subtype_coe.euclideanHausdorffMeasure_image]
	have hm : (Measure.euclideanHausdorffMeasure 2 :
	Measure ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ)) = volume := by
	simpa only [perpendicularPlane_finrank _ C.unit_axis] using
	(InnerProductSpace.euclideanHausdorffMeasure_eq_volume
	(V := ((Submodule.span ℝ ({C.axis} : Set Space))ᗮ)))
	rw [hm]
	rfl

	lemma lowerBase_area (τ : ℝ) (D : Data) (j : ℕ) :
	TriangularCovering.area (lowerBase τ D j) =
	AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
	volume.real (planarSector D j) := by
	have hbase : lowerBase τ D j = (Subtype.val :
	((Submodule.span ℝ ({(AngularGeometry.lowerCylinder TriangularCovering.H τ
	(D.alpha j) (D.beta j) (planarSector D j)).axis} : Set Space))ᗮ) → Space) ''
	(AngularGeometry.lowerCylinder TriangularCovering.H τ
	(D.alpha j) (D.beta j) (planarSector D j)).base := by
	rw [lowerBase_eq_rawImage]
	change _ = Subtype.val '' (perpendicularProjection TriangularCovering.H
	(vec2 (τ * D.alpha j) (τ * D.beta j)) '' planarSector D j)
	rw [image_image]
	rfl
	rw [hbase, ambient_area_of_intrinsic]
	exact AngularGeometry.lowerCylinder_area (Real.sqrt_pos.mpr (by norm_num)) τ
	(D.alpha j) (D.beta j) (planarSector D j)

	lemma lowerBase_compact {D : Data} {j : ℕ} (τ : ℝ)
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (lowerBase τ D j) := by
	rw [lowerBase_eq_rawImage]
	exact (planarSector_compact hc hn).image (rawProjection _ _).continuous_of_finiteDimensional

	lemma lowerBase_finite {D : Data} {j : ℕ} (τ : ℝ)
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
	Measure.euclideanHausdorffMeasure 2 (lowerBase τ D j) ≠ ⊤ := by
	rw [lowerBase_eq_rawImage]
	have he := (rawProjection TriangularCovering.H
	(vec2 (τ * D.alpha j) (τ * D.beta j))).euclideanHausdorffMeasure_image_eq_normDet_mul_volume
	(planarSector D j)
	rw [show Module.finrank ℝ Plane = 2 by simp] at he
	rw [he]
	exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top (planarSector_compact hc hn).measure_lt_top.ne

	lemma projection_add (u x y : Space) :
	TriangularCovering.projection u (x+y) =
	TriangularCovering.projection u x + TriangularCovering.projection u y := by
	unfold TriangularCovering.projection
	rw [inner_add_right, add_smul]
	abel

	lemma projection_rotate (R : Space ≃ₗᵢ[ℝ] Space) (u z : Space) :
	TriangularCovering.projection (R u) (R z) = R (TriangularCovering.projection u z) := by
	unfold TriangularCovering.projection
	rw [R.inner_map_map, map_sub, map_smul]

	lemma upperDirection_eq_rotate (τ : ℝ) (D : Data) (j : ℕ) :
	upperDirection τ D j = swapReflect (lowerDirection (-τ) D j) := by
	ext i
	fin_cases i <;> simp [upperDirection, lowerDirection, TriangularCovering.point,
	swapReflect, vec3]

	lemma upperAxis_eq_rotate (τ : ℝ) (D : Data) (j : ℕ) :
	upperAxis τ D j = swapReflect (lowerAxis (-τ) D j) := by
	unfold upperAxis lowerAxis unitDirection
	rw [upperDirection_eq_rotate, swapReflect.norm_map, map_smul]

	lemma upperAxis_norm (τ : ℝ) (D : Data) (j : ℕ) : ‖upperAxis τ D j‖ = 1 := by
	rw [upperAxis_eq_rotate, swapReflect.norm_map, lowerAxis_norm]

	lemma upperIntercept_eq_image (D : Data) (j : ℕ) :
	upperIntercept D j = (fun z => vec3 0 0 TriangularCovering.H + swapReflect z) ''
	lowerIntercept D j := by
	ext z
	constructor
	· rintro ⟨q, hq, t, ht, rfl⟩
	refine ⟨TriangularCovering.point 0 (q*t) t, ⟨q, hq, t, ht, rfl⟩, ?_⟩
	ext i
	fin_cases i <;> simp [TriangularCovering.point, swapReflect, vec3]; ring
	· rintro ⟨_, ⟨q, hq, t, ht, rfl⟩, rfl⟩
	refine ⟨q, hq, t, ht, ?_⟩
	ext i
	fin_cases i <;> simp [TriangularCovering.point, swapReflect, vec3]; ring

	lemma upperBase_eq_image (τ : ℝ) (D : Data) (j : ℕ) :
	upperBase τ D j =
	(fun z => TriangularCovering.projection (upperAxis τ D j)
	(vec3 0 0 TriangularCovering.H) + swapReflect z) '' lowerBase (-τ) D j := by
	rw [upperBase, upperIntercept_eq_image, image_image, lowerBase, image_image]
	apply image_congr
	intro z hz
	rw [projection_add, upperAxis_eq_rotate, projection_rotate]

	lemma upperBase_area_eq_lower (τ : ℝ) (D : Data) (j : ℕ) :
	TriangularCovering.area (upperBase τ D j) =
	TriangularCovering.area (lowerBase (-τ) D j) := by
	have hi : Isometry (fun z : Space => TriangularCovering.projection (upperAxis τ D j)
	(vec3 0 0 TriangularCovering.H) + swapReflect z) :=
	(isometry_add_left _).comp swapReflect.isometry
	unfold TriangularCovering.area
	rw [upperBase_eq_image, hi.euclideanHausdorffMeasure_image]

	lemma upperBase_area (τ : ℝ) (D : Data) (j : ℕ) :
	TriangularCovering.area (upperBase τ D j) =
	AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
	volume.real (planarSector D j) := by
	rw [upperBase_area_eq_lower, lowerBase_area]
	simp [AngularGeometry.areaFactor]

	lemma upperBase_compact {D : Data} {j : ℕ} (τ : ℝ)
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) : IsCompact (upperBase τ D j) := by
	rw [upperBase_eq_image]
	exact (lowerBase_compact (-τ) hc hn).image (continuous_const.add swapReflect.continuous)

	lemma upperBase_finite {D : Data} {j : ℕ} (τ : ℝ)
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
	Measure.euclideanHausdorffMeasure 2 (upperBase τ D j) ≠ ⊤ := by
	have hi : Isometry (fun z : Space => TriangularCovering.projection (upperAxis τ D j)
	(vec3 0 0 TriangularCovering.H) + swapReflect z) :=
	(isometry_add_left _).comp swapReflect.isometry
	rw [upperBase_eq_image, hi.euclideanHausdorffMeasure_image]
	exact lowerBase_finite (-τ) hc hn

	lemma projected_base_perpendicular {u : Space} (hu : ‖u‖ = 1) (P : Set Space) :
	∀ z ∈ TriangularCovering.projection u '' P, inner ℝ u z = 0 := by
	rintro _ ⟨x, hx, rfl⟩
	simp [TriangularCovering.projection, inner_sub_right, inner_smul_right,
	hu]

	lemma base_properties {D : Data} {j : ℕ} (τ : ℝ)
	(hc : ContinuousOn (D.radius j) (interval D j))
	(hn : ∀ q ∈ interval D j, 0 ≤ D.radius j q) :
	BaseProperties (lowerAxis τ D j) (lowerBase τ D j) ∧
	BaseProperties (upperAxis τ D j) (upperBase τ D j) := by
	constructor
	· have hcomp := lowerBase_compact τ hc hn
	exact ⟨lowerAxis_norm τ D j, projected_base_perpendicular (lowerAxis_norm τ D j) _,
	hcomp, hcomp.measurableSet, lowerBase_finite τ hc hn⟩
	· have hcomp := upperBase_compact τ hc hn
	exact ⟨upperAxis_norm τ D j, projected_base_perpendicular (upperAxis_norm τ D j) _,
	hcomp, hcomp.measurableSet, upperBase_finite τ hc hn⟩

	lemma totalArea_eq_planar_sum (τ : ℝ) (D : Data) :
	totalArea τ D = 2 * ∑ j : Fin D.count,
	AngularGeometry.areaFactor TriangularCovering.H τ (D.alpha j) (D.beta j) *
	volume.real (planarSector D j) := by
	unfold totalArea
	simp only [lowerBase_area, upperBase_area, ← two_mul, Finset.mul_sum]

	lemma cell_cost_of_planar_volume (τ : ℝ) (D : Data) (j : ℕ)
	(hvol : volume.real (planarSector D j) =
	∫ q in D.node j..D.node (j+1), (D.radius j q)^2 / 2) :
	(TriangularCovering.area (lowerBase τ D j) +
	TriangularCovering.area (upperBase τ D j)) / TriangularCovering.H =
	∫ q in D.node j..D.node (j+1),
	(D.radius j q)^2 / Real.sqrt (1+τ^2((D.alpha j)^2+2(D.beta j)^2)) := by
	rw [lowerBase_area, upperBase_area, hvol]
	unfold TriangularCovering.H
	rw [AngularGeometry.areaFactor_sqrt_two]
	simp only [intervalIntegral.integral_div]
	have hH : Real.sqrt 2 ≠ 0 := (Real.sqrt_pos.mpr (by norm_num)).ne'
	have hden : Real.sqrt (1+τ^2((D.alpha j)^2+2(D.beta j)^2)) ≠ 0 :=
	(Real.sqrt_pos.mpr (by positivity)).ne'
	field_simp
	ring

	lemma integral_cost_of_planar_volumes (τ : ℝ) (D : Data)
	(hvol : ∀ j < D.count, volume.real (planarSector D j) =
	∫ q in D.node j..D.node (j+1), (D.radius j q)^2 / 2) :
	totalArea τ D / TriangularCovering.H = integralCost τ D := by
	unfold totalArea integralCost
	rw [Finset.sum_div]
	apply Finset.sum_congr rfl
	intro j hj
	exact cell_cost_of_planar_volume τ D j (hvol j j.isLt)

	end CylinderCovering.AngularGeneral

	end

	end OAI