File size: 6,372 Bytes
785c727
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import OAI.Geometry.CylinderCovering.Simplex.ProjectionDefinitions
import OAI.Geometry.CylinderCovering.Simplex.Diameter

namespace OAI

open Set Metric MeasureTheory

namespace CylinderCovering

lemma longestChord_eq_maxChord {d : ℕ} (S : Set (Euclidean d)) (u : Euclidean d) :
    longestChord S u = SimplexDiameter.maxChord S u := rfl

lemma simplexMinimumShadowArea_of_product {d : ℕ} (hd : 2 ≤ d)
    (v : Fin (d + 1) → Euclidean d) (hv : AffineIndependent ℝ v)
    (hprod : ∀ u, ‖u‖ = 1 → simplexShadowArea v u * longestChord (simplexCarrier v) u =
      (d : ℝ) * volume.real (simplexCarrier v)) :
    simplexMinimumShadowArea v =
      (d : ℝ) * volume.real (simplexCarrier v) / diam (simplexCarrier v) := by
  have : Nontrivial (Fin (d + 1)) := Fin.nontrivial_iff_two_le.mpr (by omega)
  have hleast := SimplexDiameter.projection_minimum_of_chord_identity
    ((finite_range v).isCompact_convexHull ℝ)
    ((range_nonempty v).mono (subset_convexHull ℝ _))
    (SimplexDiameter.affineIndependent_diameter_pos hv)
    (simplexShadowArea v) ((d : ℝ) * volume.real (simplexCarrier v))
    (fun _ _ => ENNReal.toReal_nonneg) hprod
  unfold simplexMinimumShadowArea
  convert hleast.csInf_eq using 1 <;> congr 1
  ext a
  simp only [eq_comm]

lemma tetrahedronEdgeMinimizer_of_simplexChordProjection
    (h : SimplexChordProjectionStatement) : TetrahedronEdgeMinimizerStatement := by
  intro v hv
  obtain ⟨hdir, _, hmin⟩ := h 3 (by omega) v hv
  have hprod := fun u hu => (hdir u hu).2.2
  obtain ⟨i, j, hij, hu, hval, _⟩ := SimplexDiameter.finite_edge_projection_minimizer v
    (SimplexDiameter.affineIndependent_diameter_pos hv)
    (simplexShadowArea v) ((3 : ℝ) * volume.real (simplexCarrier v))
    (fun _ _ => ENNReal.toReal_nonneg) hprod
  refine ⟨i, j, hij, ?_⟩
  change simplexShadowArea v (NormedSpace.normalize (v j - v i)) =
    simplexMinimumShadowArea v
  exact hval.trans hmin.symm

lemma simplexCarrier_isCompact {d : ℕ} (v : Fin (d + 1) → Euclidean d) :
    IsCompact (simplexCarrier v) := (finite_range v).isCompact_convexHull ℝ

lemma simplexCarrier_interior_nonempty {d : ℕ}
    (v : Fin (d + 1) → Euclidean d) (hv : AffineIndependent ℝ v) :
    (interior (simplexCarrier v)).Nonempty := by
  apply (convex_convexHull ℝ (range v)).interior_nonempty_iff_affineSpan_eq_top.mpr
  rw [affineSpan_convexHull]
  apply hv.affineSpan_eq_top_iff_card_eq_finrank_add_one.mpr
  simp

lemma simplexCarrier_volume_pos {d : ℕ}
    (v : Fin (d + 1) → Euclidean d) (hv : AffineIndependent ℝ v) :
    0 < volume.real (simplexCarrier v) := by
  apply ENNReal.toReal_pos
  · exact (Measure.measure_pos_of_nonempty_interior volume
      (simplexCarrier_interior_nonempty v hv)).ne'
  · exact (simplexCarrier_isCompact v).measure_ne_top

lemma simplex_longestChord_pos {d : ℕ}
    (v : Fin (d + 1) → Euclidean d) (hv : AffineIndependent ℝ v)
    {u : Euclidean d} (hu : ‖u‖ = 1) :
    0 < longestChord (simplexCarrier v) u :=
  SimplexDiameter.maxChord_pos_of_interior (simplexCarrier_isCompact v)
    (simplexCarrier_interior_nonempty v hv) hu

lemma simplexMinimumShadowArea_attained_of_product {d : ℕ} (hd : 2 ≤ d)
    (v : Fin (d + 1) → Euclidean d) (hv : AffineIndependent ℝ v)
    (hprod : ∀ u, ‖u‖ = 1 → simplexShadowArea v u * longestChord (simplexCarrier v) u =
      (d : ℝ) * volume.real (simplexCarrier v)) :
    ∃ u, ‖u‖ = 1 ∧ simplexShadowArea v u = simplexMinimumShadowArea v := by
  have : Nontrivial (Fin (d + 1)) := Fin.nontrivial_iff_two_le.mpr (by omega)
  obtain ⟨u, hu, hmax⟩ := SimplexDiameter.exists_maxChord_eq_diam
    (simplexCarrier_isCompact v) ((range_nonempty v).mono (subset_convexHull ℝ _))
    (SimplexDiameter.affineIndependent_diameter_pos hv)
  simp only [simplexCarrier] at hmax
  refine ⟨u, hu, ?_⟩
  rw [simplexMinimumShadowArea_of_product hd v hv hprod]
  apply (eq_div_iff (SimplexDiameter.affineIndependent_diameter_pos hv).ne').mpr
  simpa only [longestChord_eq_maxChord, simplexCarrier, hmax] using hprod u hu

lemma simplexChordProjection_of_products
    (hprod : ∀ d : ℕ, 2 ≤ d → ∀ v : Fin (d + 1) → Euclidean d,
      AffineIndependent ℝ v → ∀ u, ‖u‖ = 1 →
      simplexShadowArea v u * longestChord (simplexCarrier v) u =
        (d : ℝ) * volume.real (simplexCarrier v)) :
    SimplexChordProjectionStatement := by
  intro d hd v hv
  refine ⟨?_, simplexMinimumShadowArea_attained_of_product hd v hv (hprod d hd v hv),
    simplexMinimumShadowArea_of_product hd v hv (hprod d hd v hv)⟩
  intro u hu
  exact ⟨simplex_longestChord_pos v hv hu,
    (SimplexDiameter.maxChord_attained (simplexCarrier_isCompact v)
      ((range_nonempty v).mono (subset_convexHull ℝ _)) hu).2,
    hprod d hd v hv u hu⟩

lemma regular_edge_shadow_eq_minimum_of_simplexChordProjection
    (h : SimplexChordProjectionStatement)
    (v : Fin 4 → Space) (hv : AffineIndependent ℝ v)
    {edge : ℝ} (he : 0 < edge)
    (hvEdge : ∀ i j : Fin 4, i ≠ j → dist (v i) (v j) = edge)
    {i j : Fin 4} (hij : i ≠ j) :
    shadowArea (convexHull ℝ (range v)) (‖v j - v i‖⁻¹ • (v j - v i)) =
      minimumShadowArea (convexHull ℝ (range v)) := by
  obtain ⟨hu, hchord⟩ := SimplexDiameter.regular_edge_maxChord v he hvEdge hij
  obtain ⟨hdir, _, hmin⟩ := h 3 (by omega) v hv
  change simplexShadowArea v (NormedSpace.normalize (v j - v i)) =
    simplexMinimumShadowArea v
  have hprod := (hdir _ hu).2.2
  have hd : diam (simplexCarrier v) = edge :=
    SimplexDiameter.regular_convexHull_diameter v he.le hvEdge
  rw [hmin, hd]
  apply (eq_div_iff he.ne').mpr
  simpa only [longestChord_eq_maxChord, simplexCarrier, hchord] using hprod

lemma regularProjectionNormalization_of_minimum
    (h : SimplexChordProjectionStatement)
    (hmin : ∀ v : Fin 4 → Space, AffineIndependent ℝ v →
      ∀ edge : ℝ, 0 < edge →
      (∀ i j : Fin 4, i ≠ j → dist (v i) (v j) = edge) →
      minimumShadowArea (convexHull ℝ (range v)) = edge ^ 2 / (2 * Real.sqrt 2)) :
    RegularProjectionNormalizationStatement := by
  intro v hv edge he hvEdge
  refine ⟨hmin v hv edge he hvEdge, ?_⟩
  intro i j hij
  exact (regular_edge_shadow_eq_minimum_of_simplexChordProjection h v hv he hvEdge hij).trans
    (hmin v hv edge he hvEdge)

end CylinderCovering

end OAI