[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s₁ s₂ : Simplex ℝ P n
h : Set.range s₁.points = Set.range s₂.points
⊢ mongePoint s₁ = mongePoint s₂
[PROOFSTEP]
simp_rw [mongePoint_eq_smul_vsub_vadd_circumcenter, centroid_eq_of_range_eq h, circumcenter_eq_of_range_eq h]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
⊢ ∑ i : PointsWithCircumcenterIndex (n + 2), mongePointWeightsWithCircumcenter n i = 1
[PROOFSTEP]
simp_rw [sum_pointsWithCircumcenter, mongePointWeightsWithCircumcenter, sum_const, card_fin, nsmul_eq_mul]
  -- Porting note: replaced
    -- have hn1 : (n + 1 : ℝ) ≠ 0 := by exact_mod_cast Nat.succ_ne_zero _
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
⊢ ↑(n + 2 + 1) * (↑(n + 1))⁻¹ + -2 / ↑(n + 1) = 1
[PROOFSTEP]
field_simp [n.cast_add_one_ne_zero]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
⊢ ↑n + 2 + 1 + -2 = ↑n + 1
[PROOFSTEP]
ring
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
⊢ mongePoint s = ↑(affineCombination ℝ univ (pointsWithCircumcenter s)) (mongePointWeightsWithCircumcenter n)
[PROOFSTEP]
rw [mongePoint_eq_smul_vsub_vadd_circumcenter, centroid_eq_affineCombination_of_pointsWithCircumcenter,
  circumcenter_eq_affineCombination_of_pointsWithCircumcenter, affineCombination_vsub, ← LinearMap.map_smul,
  weightedVSub_vadd_affineCombination]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
⊢ ↑(affineCombination ℝ univ (pointsWithCircumcenter s))
      ((↑(n + 2 + 1) / ↑(n + 2 - 1)) •
          (centroidWeightsWithCircumcenter univ - circumcenterWeightsWithCircumcenter (n + 2)) +
        circumcenterWeightsWithCircumcenter (n + 2)) =
    ↑(affineCombination ℝ univ (pointsWithCircumcenter s)) (mongePointWeightsWithCircumcenter n)
[PROOFSTEP]
congr with i
[GOAL]
case h.e_6.h.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i : PointsWithCircumcenterIndex (n + 2)
⊢ ((↑(n + 2 + 1) / ↑(n + 2 - 1)) •
          (centroidWeightsWithCircumcenter univ - circumcenterWeightsWithCircumcenter (n + 2)) +
        circumcenterWeightsWithCircumcenter (n + 2))
      i =
    mongePointWeightsWithCircumcenter n i
[PROOFSTEP]
rw [Pi.add_apply, Pi.smul_apply, smul_eq_mul, Pi.sub_apply]
  -- Porting note: replaced
    -- have hn1 : (n + 1 : ℝ) ≠ 0 := by exact_mod_cast Nat.succ_ne_zero _
[GOAL]
case h.e_6.h.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i : PointsWithCircumcenterIndex (n + 2)
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) *
        (centroidWeightsWithCircumcenter univ i - circumcenterWeightsWithCircumcenter (n + 2) i) +
      circumcenterWeightsWithCircumcenter (n + 2) i =
    mongePointWeightsWithCircumcenter n i
[PROOFSTEP]
have hn1 : (n + 1 : ℝ) ≠ 0 := n.cast_add_one_ne_zero
[GOAL]
case h.e_6.h.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i : PointsWithCircumcenterIndex (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) *
        (centroidWeightsWithCircumcenter univ i - circumcenterWeightsWithCircumcenter (n + 2) i) +
      circumcenterWeightsWithCircumcenter (n + 2) i =
    mongePointWeightsWithCircumcenter n i
[PROOFSTEP]
cases i
[GOAL]
case h.e_6.h.h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) *
        (centroidWeightsWithCircumcenter univ (point_index a✝) -
          circumcenterWeightsWithCircumcenter (n + 2) (point_index a✝)) +
      circumcenterWeightsWithCircumcenter (n + 2) (point_index a✝) =
    mongePointWeightsWithCircumcenter n (point_index a✝)
[PROOFSTEP]
simp_rw [centroidWeightsWithCircumcenter, circumcenterWeightsWithCircumcenter, mongePointWeightsWithCircumcenter]
[GOAL]
case h.e_6.h.h.circumcenter_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) *
        (centroidWeightsWithCircumcenter univ circumcenter_index -
          circumcenterWeightsWithCircumcenter (n + 2) circumcenter_index) +
      circumcenterWeightsWithCircumcenter (n + 2) circumcenter_index =
    mongePointWeightsWithCircumcenter n circumcenter_index
[PROOFSTEP]
simp_rw [centroidWeightsWithCircumcenter, circumcenterWeightsWithCircumcenter, mongePointWeightsWithCircumcenter]
[GOAL]
case h.e_6.h.h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) * ((if a✝ ∈ univ then (↑(card univ))⁻¹ else 0) - 0) + 0 = (↑(n + 1))⁻¹
[PROOFSTEP]
rw [add_tsub_assoc_of_le (by decide : 1 ≤ 2), (by decide : 2 - 1 = 1)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ 1 ≤ 2
[PROOFSTEP]
decide
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ 2 - 1 = 1
[PROOFSTEP]
decide
[GOAL]
case h.e_6.h.h.circumcenter_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ ↑(n + 2 + 1) / ↑(n + 2 - 1) * (0 - 1) + 1 = -2 / ↑(n + 1)
[PROOFSTEP]
rw [add_tsub_assoc_of_le (by decide : 1 ≤ 2), (by decide : 2 - 1 = 1)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ 1 ≤ 2
[PROOFSTEP]
decide
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ 2 - 1 = 1
[PROOFSTEP]
decide
[GOAL]
case h.e_6.h.h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ ↑(n + 2 + 1) / ↑(n + 1) * ((if a✝ ∈ univ then (↑(card univ))⁻¹ else 0) - 0) + 0 = (↑(n + 1))⁻¹
[PROOFSTEP]
rw [if_pos (mem_univ _), sub_zero, add_zero, card_fin]
  -- Porting note: replaced
      -- have hn3 : (n + 2 + 1 : ℝ) ≠ 0 := by exact_mod_cast Nat.succ_ne_zero _
[GOAL]
case h.e_6.h.h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ ↑(n + 2 + 1) / ↑(n + 1) * (↑(n + 2 + 1))⁻¹ = (↑(n + 1))⁻¹
[PROOFSTEP]
have hn3 : (n + 2 + 1 : ℝ) ≠ 0 := by exact_mod_cast (n + 2).cast_add_one_ne_zero
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
⊢ ↑n + 2 + 1 ≠ 0
[PROOFSTEP]
exact_mod_cast (n + 2).cast_add_one_ne_zero
[GOAL]
case h.e_6.h.h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
a✝ : Fin (n + 2 + 1)
hn3 : ↑n + 2 + 1 ≠ 0
⊢ ↑(n + 2 + 1) / ↑(n + 1) * (↑(n + 2 + 1))⁻¹ = (↑(n + 1))⁻¹
[PROOFSTEP]
field_simp [hn1, hn3, mul_comm]
[GOAL]
case h.e_6.h.h.circumcenter_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ ↑(n + 2 + 1) / ↑(n + 1) * (0 - 1) + 1 = -2 / ↑(n + 1)
[PROOFSTEP]
field_simp [hn1]
[GOAL]
case h.e_6.h.h.circumcenter_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
hn1 : ↑n + 1 ≠ 0
⊢ -1 + (-2 + -↑n) + (↑n + 1) = -2
[PROOFSTEP]
ring
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ =
    mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ
[PROOFSTEP]
ext i
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : PointsWithCircumcenterIndex (n + 2)
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ i =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) i
[PROOFSTEP]
cases' i with i
[GOAL]
case h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ (point_index i) =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) (point_index i)
[PROOFSTEP]
rw [Pi.sub_apply, mongePointWeightsWithCircumcenter, centroidWeightsWithCircumcenter,
  mongePointVSubFaceCentroidWeightsWithCircumcenter]
[GOAL]
case h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
⊢ (match point_index i with
    | point_index i => if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0
    | circumcenter_index => -2 / ↑(n + 1)) =
    (match point_index i with
      | point_index a => (↑(n + 1))⁻¹
      | circumcenter_index => -2 / ↑(n + 1)) -
      match point_index i with
      | point_index i => if i ∈ {i₁, i₂}ᶜ then (↑(card {i₁, i₂}ᶜ))⁻¹ else 0
      | circumcenter_index => 0
[PROOFSTEP]
have hu : card ({ i₁, i₂ }ᶜ : Finset (Fin (n + 3))) = n + 1 := by simp [card_compl, Fintype.card_fin, h]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
⊢ card {i₁, i₂}ᶜ = n + 1
[PROOFSTEP]
simp [card_compl, Fintype.card_fin, h]
[GOAL]
case h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
hu : card {i₁, i₂}ᶜ = n + 1
⊢ (match point_index i with
    | point_index i => if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0
    | circumcenter_index => -2 / ↑(n + 1)) =
    (match point_index i with
      | point_index a => (↑(n + 1))⁻¹
      | circumcenter_index => -2 / ↑(n + 1)) -
      match point_index i with
      | point_index i => if i ∈ {i₁, i₂}ᶜ then (↑(card {i₁, i₂}ᶜ))⁻¹ else 0
      | circumcenter_index => 0
[PROOFSTEP]
rw [hu]
[GOAL]
case h.point_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
hu : card {i₁, i₂}ᶜ = n + 1
⊢ (match point_index i with
    | point_index i => if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0
    | circumcenter_index => -2 / ↑(n + 1)) =
    (match point_index i with
      | point_index a => (↑(n + 1))⁻¹
      | circumcenter_index => -2 / ↑(n + 1)) -
      match point_index i with
      | point_index i => if i ∈ {i₁, i₂}ᶜ then (↑(n + 1))⁻¹ else 0
      | circumcenter_index => 0
[PROOFSTEP]
by_cases hi : i = i₁ ∨ i = i₂
[GOAL]
case pos
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
hu : card {i₁, i₂}ᶜ = n + 1
hi : i = i₁ ∨ i = i₂
⊢ (match point_index i with
    | point_index i => if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0
    | circumcenter_index => -2 / ↑(n + 1)) =
    (match point_index i with
      | point_index a => (↑(n + 1))⁻¹
      | circumcenter_index => -2 / ↑(n + 1)) -
      match point_index i with
      | point_index i => if i ∈ {i₁, i₂}ᶜ then (↑(n + 1))⁻¹ else 0
      | circumcenter_index => 0
[PROOFSTEP]
simp [compl_eq_univ_sdiff, hi]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
i : Fin (n + 2 + 1)
hu : card {i₁, i₂}ᶜ = n + 1
hi : ¬(i = i₁ ∨ i = i₂)
⊢ (match point_index i with
    | point_index i => if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0
    | circumcenter_index => -2 / ↑(n + 1)) =
    (match point_index i with
      | point_index a => (↑(n + 1))⁻¹
      | circumcenter_index => -2 / ↑(n + 1)) -
      match point_index i with
      | point_index i => if i ∈ {i₁, i₂}ᶜ then (↑(n + 1))⁻¹ else 0
      | circumcenter_index => 0
[PROOFSTEP]
simp [compl_eq_univ_sdiff, hi]
[GOAL]
case h.circumcenter_index
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ circumcenter_index =
    (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) circumcenter_index
[PROOFSTEP]
simp [mongePointWeightsWithCircumcenter, centroidWeightsWithCircumcenter,
  mongePointVSubFaceCentroidWeightsWithCircumcenter]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ ∑ i : PointsWithCircumcenterIndex (n + 2), mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ i = 0
[PROOFSTEP]
rw [mongePointVSubFaceCentroidWeightsWithCircumcenter_eq_sub h]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ ∑ i : PointsWithCircumcenterIndex (n + 2),
      (mongePointWeightsWithCircumcenter n - centroidWeightsWithCircumcenter {i₁, i₂}ᶜ) i =
    0
[PROOFSTEP]
simp_rw [Pi.sub_apply, sum_sub_distrib, sum_mongePointWeightsWithCircumcenter]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ 1 - ∑ x : PointsWithCircumcenterIndex (n + 2), centroidWeightsWithCircumcenter {i₁, i₂}ᶜ x = 0
[PROOFSTEP]
rw [sum_centroidWeightsWithCircumcenter, sub_self]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ Finset.Nonempty {i₁, i₂}ᶜ
[PROOFSTEP]
simp [← card_pos, card_compl, h]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : i₁ ≠ i₂
⊢ mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points =
    ↑(weightedVSub univ (pointsWithCircumcenter s)) (mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂)
[PROOFSTEP]
simp_rw [mongePoint_eq_affineCombination_of_pointsWithCircumcenter,
  centroid_eq_affineCombination_of_pointsWithCircumcenter, affineCombination_vsub,
  mongePointVSubFaceCentroidWeightsWithCircumcenter_eq_sub h]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) (points s i₁ -ᵥ points s i₂) = 0
[PROOFSTEP]
by_cases h : i₁ = i₂
[GOAL]
case pos
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : i₁ = i₂
⊢ inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) (points s i₁ -ᵥ points s i₂) = 0
[PROOFSTEP]
simp [h]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
⊢ inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) (points s i₁ -ᵥ points s i₂) = 0
[PROOFSTEP]
simp_rw [mongePoint_vsub_face_centroid_eq_weightedVSub_of_pointsWithCircumcenter s h,
  point_eq_affineCombination_of_pointsWithCircumcenter, affineCombination_vsub]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
⊢ inner (↑(weightedVSub univ (pointsWithCircumcenter s)) (mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂))
      (↑(weightedVSub univ (pointsWithCircumcenter s))
        (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂)) =
    0
[PROOFSTEP]
have hs : ∑ i, (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0 := by simp
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
⊢ ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
[PROOFSTEP]
simp
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
⊢ inner (↑(weightedVSub univ (pointsWithCircumcenter s)) (mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂))
      (↑(weightedVSub univ (pointsWithCircumcenter s))
        (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂)) =
    0
[PROOFSTEP]
rw [inner_weightedVSub _ (sum_mongePointVSubFaceCentroidWeightsWithCircumcenter h) _ hs, sum_pointsWithCircumcenter,
  pointsWithCircumcenter_eq_circumcenter]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
⊢ -(∑ i : Fin (n + 2 + 1),
            ∑ i₂_1 : PointsWithCircumcenterIndex (n + 2),
              mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ (point_index i) *
                  (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i₂_1 *
                (dist (pointsWithCircumcenter s (point_index i)) (pointsWithCircumcenter s i₂_1) *
                  dist (pointsWithCircumcenter s (point_index i)) (pointsWithCircumcenter s i₂_1)) +
          ∑ i₂_1 : PointsWithCircumcenterIndex (n + 2),
            mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂ circumcenter_index *
                (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i₂_1 *
              (dist (circumcenter s) (pointsWithCircumcenter s i₂_1) *
                dist (circumcenter s) (pointsWithCircumcenter s i₂_1))) /
      2 =
    0
[PROOFSTEP]
simp only [mongePointVSubFaceCentroidWeightsWithCircumcenter, pointsWithCircumcenter_point]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
⊢ -(∑ x : Fin (n + 2 + 1),
            ∑ x_1 : PointsWithCircumcenterIndex (n + 2),
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                  (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x_1 *
                (dist (points s x) (pointsWithCircumcenter s x_1) * dist (points s x) (pointsWithCircumcenter s x_1)) +
          ∑ x : PointsWithCircumcenterIndex (n + 2),
            -2 / ↑(n + 1) * (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x *
              (dist (circumcenter s) (pointsWithCircumcenter s x) *
                dist (circumcenter s) (pointsWithCircumcenter s x))) /
      2 =
    0
[PROOFSTEP]
let fs : Finset (Fin (n + 3)) := { i₁, i₂ }
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
⊢ -(∑ x : Fin (n + 2 + 1),
            ∑ x_1 : PointsWithCircumcenterIndex (n + 2),
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                  (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x_1 *
                (dist (points s x) (pointsWithCircumcenter s x_1) * dist (points s x) (pointsWithCircumcenter s x_1)) +
          ∑ x : PointsWithCircumcenterIndex (n + 2),
            -2 / ↑(n + 1) * (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x *
              (dist (circumcenter s) (pointsWithCircumcenter s x) *
                dist (circumcenter s) (pointsWithCircumcenter s x))) /
      2 =
    0
[PROOFSTEP]
have hfs : ∀ i : Fin (n + 3), i ∉ fs → i ≠ i₁ ∧ i ≠ i₂ :=
  by
  intro i hi
  constructor <;> · intro hj; simp [← hj] at hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
⊢ ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
[PROOFSTEP]
intro i hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
i : Fin (n + 3)
hi : ¬i ∈ fs
⊢ i ≠ i₁ ∧ i ≠ i₂
[PROOFSTEP]
constructor
[GOAL]
case left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
i : Fin (n + 3)
hi : ¬i ∈ fs
⊢ i ≠ i₁
[PROOFSTEP]
intro hj
[GOAL]
case left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
i : Fin (n + 3)
hi : ¬i ∈ fs
hj : i = i₁
⊢ False
[PROOFSTEP]
simp [← hj] at hi
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
i : Fin (n + 3)
hi : ¬i ∈ fs
⊢ i ≠ i₂
[PROOFSTEP]
intro hj
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
i : Fin (n + 3)
hi : ¬i ∈ fs
hj : i = i₂
⊢ False
[PROOFSTEP]
simp [← hj] at hi
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x : Fin (n + 2 + 1),
            ∑ x_1 : PointsWithCircumcenterIndex (n + 2),
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                  (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x_1 *
                (dist (points s x) (pointsWithCircumcenter s x_1) * dist (points s x) (pointsWithCircumcenter s x_1)) +
          ∑ x : PointsWithCircumcenterIndex (n + 2),
            -2 / ↑(n + 1) * (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x *
              (dist (circumcenter s) (pointsWithCircumcenter s x) *
                dist (circumcenter s) (pointsWithCircumcenter s x))) /
      2 =
    0
[PROOFSTEP]
rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in fs,
            ∑ x_1 : PointsWithCircumcenterIndex (n + 2),
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                  (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x_1 *
                (dist (points s x) (pointsWithCircumcenter s x_1) * dist (points s x) (pointsWithCircumcenter s x_1)) +
          ∑ x : PointsWithCircumcenterIndex (n + 2),
            -2 / ↑(n + 1) * (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x *
              (dist (circumcenter s) (pointsWithCircumcenter s x) *
                dist (circumcenter s) (pointsWithCircumcenter s x))) /
      2 =
    0
[PROOFSTEP]
simp_rw [sum_pointsWithCircumcenter, pointsWithCircumcenter_eq_circumcenter, pointsWithCircumcenter_point, Pi.sub_apply,
  pointWeightsWithCircumcenter]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in {i₁, i₂},
            (∑ x_1 : Fin (n + 2 + 1),
                (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                    ((if x_1 = i₁ then 1 else 0) - if x_1 = i₂ then 1 else 0) *
                  (dist (points s x) (points s x_1) * dist (points s x) (points s x_1)) +
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s x) (circumcenter s) * dist (points s x) (circumcenter s))) +
          (∑ x : Fin (n + 2 + 1),
              -2 / ↑(n + 1) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s x) * dist (circumcenter s) (points s x)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in {i₁, i₂},
            (∑ x_1 : Fin (n + 2 + 1),
                (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                    ((if x_1 = i₁ then 1 else 0) - if x_1 = i₂ then 1 else 0) *
                  (dist (points s x) (points s x_1) * dist (points s x) (points s x_1)) +
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s x) (circumcenter s) * dist (points s x) (circumcenter s))) +
          (∑ x in fs,
              -2 / ↑(n + 1) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s x) * dist (circumcenter s) (points s x)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
simp_rw [sum_insert (not_mem_singleton.2 h), sum_singleton]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x : Fin (n + 2 + 1),
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            (∑ x : Fin (n + 2 + 1),
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
repeat rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x : Fin (n + 2 + 1),
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            (∑ x : Fin (n + 2 + 1),
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in fs,
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            (∑ x : Fin (n + 2 + 1),
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) =
          0
[PROOFSTEP]
rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in fs,
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            (∑ x in fs,
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) =
          0
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) =
          0
[PROOFSTEP]
rw [← sum_subset fs.subset_univ _]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x in fs,
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            (∑ x in fs,
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
simp_rw [sum_insert (not_mem_singleton.2 h), sum_singleton]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ -((if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                  (dist (points s i₁) (points s i₁) * dist (points s i₁) (points s i₁)) +
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                  (dist (points s i₁) (points s i₂) * dist (points s i₁) (points s i₂)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₁) (circumcenter s) * dist (points s i₁) (circumcenter s)) +
            ((if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                  (dist (points s i₂) (points s i₁) * dist (points s i₂) (points s i₁)) +
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                  (dist (points s i₂) (points s i₂) * dist (points s i₂) (points s i₂)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (points s i₂) (circumcenter s) * dist (points s i₂) (circumcenter s))) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist (circumcenter s) (points s i₁) * dist (circumcenter s) (points s i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist (circumcenter s) (points s i₂) * dist (circumcenter s) (points s i₂)) +
            -2 / ↑(n + 1) * (0 - 0) *
              (dist (circumcenter s) (circumcenter s) * dist (circumcenter s) (circumcenter s)))) /
      2 =
    0
[PROOFSTEP]
simp [h, Ne.symm h, dist_comm (s.points i₁)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) =
          0
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) =
          0
[PROOFSTEP]
all_goals intro i _ hi; simp [hfs i hi]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₂) (points s x) * dist (points s i₂) (points s x)) =
          0
[PROOFSTEP]
intro i _ hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
i : Fin (n + 3)
a✝ : i ∈ univ
hi : ¬i ∈ fs
⊢ (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if i = i₁ then 1 else 0) - if i = i₂ then 1 else 0) *
      (dist (points s i₂) (points s i) * dist (points s i₂) (points s i)) =
    0
[PROOFSTEP]
simp [hfs i hi]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (points s i₁) (points s x) * dist (points s i₁) (points s x)) =
          0
[PROOFSTEP]
intro i _ hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
i : Fin (n + 3)
a✝ : i ∈ univ
hi : ¬i ∈ fs
⊢ (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if i = i₁ then 1 else 0) - if i = i₂ then 1 else 0) *
      (dist (points s i₁) (points s i) * dist (points s i₁) (points s i)) =
    0
[PROOFSTEP]
simp [hfs i hi]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        -2 / ↑(n + 1) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
            (dist (circumcenter s) (points s x) * dist (circumcenter s) (points s x)) =
          0
[PROOFSTEP]
intro i _ hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
i : Fin (n + 3)
a✝ : i ∈ univ
hi : ¬i ∈ fs
⊢ -2 / ↑(n + 1) * ((if i = i₁ then 1 else 0) - if i = i₂ then 1 else 0) *
      (dist (circumcenter s) (points s i) * dist (circumcenter s) (points s i)) =
    0
[PROOFSTEP]
simp [hfs i hi, pointsWithCircumcenter]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
⊢ ∀ (x : Fin (n + 3)),
    x ∈ univ →
      ¬x ∈ fs →
        ∑ x_1 : PointsWithCircumcenterIndex (n + 2),
            (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) *
                (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x_1 *
              (dist (points s x) (pointsWithCircumcenter s x_1) * dist (points s x) (pointsWithCircumcenter s x_1)) =
          0
[PROOFSTEP]
intro i _ hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
h : ¬i₁ = i₂
hs :
  ∑ i : PointsWithCircumcenterIndex (n + 2), (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) i = 0
fs : Finset (Fin (n + 3)) := {i₁, i₂}
hfs : ∀ (i : Fin (n + 3)), ¬i ∈ fs → i ≠ i₁ ∧ i ≠ i₂
i : Fin (n + 3)
a✝ : i ∈ univ
hi : ¬i ∈ fs
⊢ ∑ x : PointsWithCircumcenterIndex (n + 2),
      (if i = i₁ ∨ i = i₂ then (↑(n + 1))⁻¹ else 0) *
          (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂) x *
        (dist (points s i) (pointsWithCircumcenter s x) * dist (points s i) (pointsWithCircumcenter s x)) =
    0
[PROOFSTEP]
simp [hfs i hi]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ mongePlane s i₁ i₂ = mongePlane s i₂ i₁
[PROOFSTEP]
simp_rw [mongePlane_def]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ mk' (centroid ℝ {i₁, i₂}ᶜ s.points) (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓
      affineSpan ℝ (Set.range s.points) =
    mk' (centroid ℝ {i₂, i₁}ᶜ s.points) (Submodule.span ℝ {points s i₂ -ᵥ points s i₁})ᗮ ⊓
      affineSpan ℝ (Set.range s.points)
[PROOFSTEP]
congr 3
[GOAL]
case e_a.e_p.e_s
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ {i₁, i₂}ᶜ = {i₂, i₁}ᶜ
[PROOFSTEP]
congr 1
[GOAL]
case e_a.e_p.e_s.e_a
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ {i₁, i₂} = {i₂, i₁}
[PROOFSTEP]
exact pair_comm _ _
[GOAL]
case e_a.e_direction.e_K
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ Submodule.span ℝ {points s i₁ -ᵥ points s i₂} = Submodule.span ℝ {points s i₂ -ᵥ points s i₁}
[PROOFSTEP]
ext
[GOAL]
case e_a.e_direction.e_K.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ x✝ ∈ Submodule.span ℝ {points s i₁ -ᵥ points s i₂} ↔ x✝ ∈ Submodule.span ℝ {points s i₂ -ᵥ points s i₁}
[PROOFSTEP]
simp_rw [Submodule.mem_span_singleton]
[GOAL]
case e_a.e_direction.e_K.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ (∃ a, a • (points s i₁ -ᵥ points s i₂) = x✝) ↔ ∃ a, a • (points s i₂ -ᵥ points s i₁) = x✝
[PROOFSTEP]
constructor
[GOAL]
case e_a.e_direction.e_K.h.mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ (∃ a, a • (points s i₁ -ᵥ points s i₂) = x✝) → ∃ a, a • (points s i₂ -ᵥ points s i₁) = x✝
case e_a.e_direction.e_K.h.mpr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ (∃ a, a • (points s i₂ -ᵥ points s i₁) = x✝) → ∃ a, a • (points s i₁ -ᵥ points s i₂) = x✝
[PROOFSTEP]
all_goals rintro ⟨r, rfl⟩; use-r; rw [neg_smul, ← smul_neg, neg_vsub_eq_vsub_rev]
[GOAL]
case e_a.e_direction.e_K.h.mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ (∃ a, a • (points s i₁ -ᵥ points s i₂) = x✝) → ∃ a, a • (points s i₂ -ᵥ points s i₁) = x✝
[PROOFSTEP]
rintro ⟨r, rfl⟩
[GOAL]
case e_a.e_direction.e_K.h.mp.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
r : ℝ
⊢ ∃ a, a • (points s i₂ -ᵥ points s i₁) = r • (points s i₁ -ᵥ points s i₂)
[PROOFSTEP]
use-r
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
r : ℝ
⊢ -r • (points s i₂ -ᵥ points s i₁) = r • (points s i₁ -ᵥ points s i₂)
[PROOFSTEP]
rw [neg_smul, ← smul_neg, neg_vsub_eq_vsub_rev]
[GOAL]
case e_a.e_direction.e_K.h.mpr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
x✝ : V
⊢ (∃ a, a • (points s i₂ -ᵥ points s i₁) = x✝) → ∃ a, a • (points s i₁ -ᵥ points s i₂) = x✝
[PROOFSTEP]
rintro ⟨r, rfl⟩
[GOAL]
case e_a.e_direction.e_K.h.mpr.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
r : ℝ
⊢ ∃ a, a • (points s i₁ -ᵥ points s i₂) = r • (points s i₂ -ᵥ points s i₁)
[PROOFSTEP]
use-r
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
r : ℝ
⊢ -r • (points s i₁ -ᵥ points s i₂) = r • (points s i₂ -ᵥ points s i₁)
[PROOFSTEP]
rw [neg_smul, ← smul_neg, neg_vsub_eq_vsub_rev]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ mongePoint s ∈ mongePlane s i₁ i₂
[PROOFSTEP]
rw [mongePlane_def, mem_inf_iff, ← vsub_right_mem_direction_iff_mem (self_mem_mk' _ _), direction_mk',
  Submodule.mem_orthogonal']
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ (∀ (u : V),
      u ∈ Submodule.span ℝ {points s i₁ -ᵥ points s i₂} → inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) u = 0) ∧
    mongePoint s ∈ affineSpan ℝ (Set.range s.points)
[PROOFSTEP]
refine' ⟨_, s.mongePoint_mem_affineSpan⟩
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ ∀ (u : V),
    u ∈ Submodule.span ℝ {points s i₁ -ᵥ points s i₂} → inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) u = 0
[PROOFSTEP]
intro v hv
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
v : V
hv : v ∈ Submodule.span ℝ {points s i₁ -ᵥ points s i₂}
⊢ inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) v = 0
[PROOFSTEP]
rcases Submodule.mem_span_singleton.mp hv with ⟨r, rfl⟩
[GOAL]
case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
r : ℝ
hv : r • (points s i₁ -ᵥ points s i₂) ∈ Submodule.span ℝ {points s i₁ -ᵥ points s i₂}
⊢ inner (mongePoint s -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) (r • (points s i₁ -ᵥ points s i₂)) = 0
[PROOFSTEP]
rw [inner_smul_right, s.inner_mongePoint_vsub_face_centroid_vsub, mul_zero]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ direction (mongePlane s i₁ i₂) = (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
rw [mongePlane_def, direction_inf_of_mem_inf s.mongePoint_mem_mongePlane, direction_mk', direction_affineSpan]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
⊢ p = mongePoint s
[PROOFSTEP]
rw [← @vsub_eq_zero_iff_eq V]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
have h' : ∀ i₂, i₁ ≠ i₂ → p -ᵥ s.mongePoint ∈ (ℝ ∙ s.points i₁ -ᵥ s.points i₂)ᗮ ⊓ vectorSpan ℝ (Set.range s.points) :=
  by
  intro i₂ hne
  rw [← s.direction_mongePlane, vsub_right_mem_direction_iff_mem s.mongePoint_mem_mongePlane]
  exact h i₂ hne
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
⊢ ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
intro i₂ hne
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
i₂ : Fin (n + 3)
hne : i₁ ≠ i₂
⊢ p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
rw [← s.direction_mongePlane, vsub_right_mem_direction_iff_mem s.mongePoint_mem_mongePlane]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
i₂ : Fin (n + 3)
hne : i₁ ≠ i₂
⊢ p ∈ mongePlane s i₁ i₂
[PROOFSTEP]
exact h i₂ hne
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
have hi : p -ᵥ s.mongePoint ∈ ⨅ i₂ : { i // i₁ ≠ i }, (ℝ ∙ s.points i₁ -ᵥ s.points i₂)ᗮ :=
  by
  rw [Submodule.mem_iInf]
  exact fun i => (Submodule.mem_inf.1 (h' i i.property)).1
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
⊢ p -ᵥ mongePoint s ∈ ⨅ (i₂ : { i // i₁ ≠ i }), (Submodule.span ℝ {points s i₁ -ᵥ points s ↑i₂})ᗮ
[PROOFSTEP]
rw [Submodule.mem_iInf]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
⊢ ∀ (i : { i // i₁ ≠ i }), p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s ↑i})ᗮ
[PROOFSTEP]
exact fun i => (Submodule.mem_inf.1 (h' i i.property)).1
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ ⨅ (i₂ : { i // i₁ ≠ i }), (Submodule.span ℝ {points s i₁ -ᵥ points s ↑i₂})ᗮ
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
rw [Submodule.iInf_orthogonal, ← Submodule.span_iUnion] at hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
have hu :
  ⋃ i : { i // i₁ ≠ i }, ({s.points i₁ -ᵥ s.points i} : Set V) =
    (· -ᵥ ·) (s.points i₁) '' (s.points '' (Set.univ \ { i₁ })) :=
  by
  rw [Set.image_image]
  ext x
  simp_rw [Set.mem_iUnion, Set.mem_image, Set.mem_singleton_iff, Set.mem_diff_singleton]
  constructor
  · rintro ⟨i, rfl⟩
    use i, ⟨Set.mem_univ _, i.property.symm⟩
  · rintro
      ⟨i, ⟨-, hi⟩, rfl⟩
          -- Porting note: was `use ⟨i, hi.symm⟩, rfl`
    exact ⟨⟨i, hi.symm⟩, rfl⟩
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
⊢ ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
[PROOFSTEP]
rw [Set.image_image]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
⊢ ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x => (fun x x_1 => x -ᵥ x_1) (points s i₁) (points s x)) '' (Set.univ \ {i₁})
[PROOFSTEP]
ext x
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
x : V
⊢ x ∈ ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} ↔
    x ∈ (fun x => (fun x x_1 => x -ᵥ x_1) (points s i₁) (points s x)) '' (Set.univ \ {i₁})
[PROOFSTEP]
simp_rw [Set.mem_iUnion, Set.mem_image, Set.mem_singleton_iff, Set.mem_diff_singleton]
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
x : V
⊢ (∃ i, x = points s i₁ -ᵥ points s ↑i) ↔ ∃ x_1, (x_1 ∈ Set.univ ∧ x_1 ≠ i₁) ∧ points s i₁ -ᵥ points s x_1 = x
[PROOFSTEP]
constructor
[GOAL]
case h.mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
x : V
⊢ (∃ i, x = points s i₁ -ᵥ points s ↑i) → ∃ x_1, (x_1 ∈ Set.univ ∧ x_1 ≠ i₁) ∧ points s i₁ -ᵥ points s x_1 = x
[PROOFSTEP]
rintro ⟨i, rfl⟩
[GOAL]
case h.mp.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
i : { i // i₁ ≠ i }
⊢ ∃ x, (x ∈ Set.univ ∧ x ≠ i₁) ∧ points s i₁ -ᵥ points s x = points s i₁ -ᵥ points s ↑i
[PROOFSTEP]
use i, ⟨Set.mem_univ _, i.property.symm⟩
[GOAL]
case h.mpr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
x : V
⊢ (∃ x_1, (x_1 ∈ Set.univ ∧ x_1 ≠ i₁) ∧ points s i₁ -ᵥ points s x_1 = x) → ∃ i, x = points s i₁ -ᵥ points s ↑i
[PROOFSTEP]
rintro
  ⟨i, ⟨-, hi⟩, rfl⟩
      -- Porting note: was `use ⟨i, hi.symm⟩, rfl`
[GOAL]
case h.mpr.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi✝ : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
i : Fin (n + 2 + 1)
hi : i ≠ i₁
⊢ ∃ i_1, points s i₁ -ᵥ points s i = points s i₁ -ᵥ points s ↑i_1
[PROOFSTEP]
exact ⟨⟨i, hi.symm⟩, rfl⟩
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (Submodule.span ℝ (⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i}))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
rw [hu, ← vectorSpan_image_eq_span_vsub_set_left_ne ℝ _ (Set.mem_univ _), Set.image_univ] at hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
have hv : p -ᵥ s.mongePoint ∈ vectorSpan ℝ (Set.range s.points) :=
  by
  let s₁ : Finset (Fin (n + 3)) := univ.erase i₁
  obtain ⟨i₂, h₂⟩ := card_pos.1 (show 0 < card s₁ by simp [card_erase_of_mem])
  have h₁₂ : i₁ ≠ i₂ := (ne_of_mem_erase h₂).symm
  exact (Submodule.mem_inf.1 (h' i₂ h₁₂)).2
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
⊢ p -ᵥ mongePoint s ∈ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
let s₁ : Finset (Fin (n + 3)) := univ.erase i₁
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
s₁ : Finset (Fin (n + 3)) := erase univ i₁
⊢ p -ᵥ mongePoint s ∈ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
obtain ⟨i₂, h₂⟩ := card_pos.1 (show 0 < card s₁ by simp [card_erase_of_mem])
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
s₁ : Finset (Fin (n + 3)) := erase univ i₁
⊢ 0 < card s₁
[PROOFSTEP]
simp [card_erase_of_mem]
[GOAL]
case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
s₁ : Finset (Fin (n + 3)) := erase univ i₁
i₂ : Fin (n + 3)
h₂ : i₂ ∈ s₁
⊢ p -ᵥ mongePoint s ∈ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
have h₁₂ : i₁ ≠ i₂ := (ne_of_mem_erase h₂).symm
[GOAL]
case intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
s₁ : Finset (Fin (n + 3)) := erase univ i₁
i₂ : Fin (n + 3)
h₂ : i₂ ∈ s₁
h₁₂ : i₁ ≠ i₂
⊢ p -ᵥ mongePoint s ∈ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
exact (Submodule.mem_inf.1 (h' i₂ h₁₂)).2
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ : Fin (n + 3)
p : P
h : ∀ (i₂ : Fin (n + 3)), i₁ ≠ i₂ → p ∈ mongePlane s i₁ i₂
h' :
  ∀ (i₂ : Fin (n + 3)),
    i₁ ≠ i₂ → p -ᵥ mongePoint s ∈ (Submodule.span ℝ {points s i₁ -ᵥ points s i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
hi : p -ᵥ mongePoint s ∈ (vectorSpan ℝ (Set.range s.points))ᗮ
hu :
  ⋃ (i : { i // i₁ ≠ i }), {points s i₁ -ᵥ points s ↑i} =
    (fun x x_1 => x -ᵥ x_1) (points s i₁) '' (s.points '' (Set.univ \ {i₁}))
hv : p -ᵥ mongePoint s ∈ vectorSpan ℝ (Set.range s.points)
⊢ p -ᵥ mongePoint s = 0
[PROOFSTEP]
exact Submodule.disjoint_def.1 (vectorSpan ℝ (Set.range s.points)).orthogonal_disjoint _ hv hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ direction (altitude s i) = (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
rw [altitude_def, direction_inf_of_mem (self_mem_mk' (s.points i) _) (mem_affineSpan ℝ (Set.mem_range_self _)),
  direction_mk', direction_affineSpan, direction_affineSpan]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ vectorSpan ℝ (s.points '' ↑(erase univ i)) ⟂ direction (altitude s i)
[PROOFSTEP]
rw [direction_altitude]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ vectorSpan ℝ (s.points '' ↑(erase univ i)) ⟂
    (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
[PROOFSTEP]
exact (Submodule.isOrtho_orthogonal_right _).mono_right inf_le_left
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ FiniteDimensional ℝ { x // x ∈ direction (altitude s i) }
[PROOFSTEP]
rw [direction_altitude]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ FiniteDimensional ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) }
[PROOFSTEP]
infer_instance
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ finrank ℝ { x // x ∈ direction (altitude s i) } = 1
[PROOFSTEP]
rw [direction_altitude]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
⊢ finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } = 1
[PROOFSTEP]
have h :=
  Submodule.finrank_add_inf_finrank_orthogonal (vectorSpan_mono ℝ (Set.image_subset_range s.points ↑(univ.erase i)))
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
h :
  finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } +
      finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) }
⊢ finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } = 1
[PROOFSTEP]
have hc : card (univ.erase i) = n + 1 := by rw [card_erase_of_mem (mem_univ _)]; simp
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
h :
  finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } +
      finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) }
⊢ card (erase univ i) = n + 1
[PROOFSTEP]
rw [card_erase_of_mem (mem_univ _)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
h :
  finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } +
      finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) }
⊢ card univ - 1 = n + 1
[PROOFSTEP]
simp
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
h :
  finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } +
      finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) }
hc : card (erase univ i) = n + 1
⊢ finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } = 1
[PROOFSTEP]
refine' add_left_cancel (_root_.trans h _)
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
h :
  finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } +
      finrank ℝ { x // x ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ ⊓ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) }
hc : card (erase univ i) = n + 1
⊢ finrank ℝ { x // x ∈ vectorSpan ℝ (Set.range s.points) } =
    finrank ℝ { x // x ∈ vectorSpan ℝ (s.points '' ↑(erase univ i)) } + 1
[PROOFSTEP]
rw [s.Independent.finrank_vectorSpan (Fintype.card_fin _), ← Finset.coe_image,
  s.Independent.finrank_vectorSpan_image_finset hc]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ affineSpan ℝ {p, points s i} = altitude s i ↔
    p ≠ points s i ∧
      p ∈ affineSpan ℝ (Set.range s.points) ∧
        p -ᵥ points s i ∈ (direction (affineSpan ℝ (s.points '' ↑(erase univ i))))ᗮ
[PROOFSTEP]
rw [eq_iff_direction_eq_of_mem (mem_affineSpan ℝ (Set.mem_insert_of_mem _ (Set.mem_singleton _))) (s.mem_altitude _), ←
  vsub_right_mem_direction_iff_mem (mem_affineSpan ℝ (Set.mem_range_self i)) p, direction_affineSpan,
  direction_affineSpan, direction_affineSpan]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ vectorSpan ℝ {p, points s i} = direction (altitude s i) ↔
    p ≠ points s i ∧
      p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ
[PROOFSTEP]
constructor
[GOAL]
case mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ vectorSpan ℝ {p, points s i} = direction (altitude s i) →
    p ≠ points s i ∧
      p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ
[PROOFSTEP]
intro h
[GOAL]
case mp
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : vectorSpan ℝ {p, points s i} = direction (altitude s i)
⊢ p ≠ points s i ∧
    p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧
      p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ
[PROOFSTEP]
constructor
[GOAL]
case mp.left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : vectorSpan ℝ {p, points s i} = direction (altitude s i)
⊢ p ≠ points s i
[PROOFSTEP]
intro heq
[GOAL]
case mp.left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : vectorSpan ℝ {p, points s i} = direction (altitude s i)
heq : p = points s i
⊢ False
[PROOFSTEP]
rw [heq, Set.pair_eq_singleton, vectorSpan_singleton] at h
[GOAL]
case mp.left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : ⊥ = direction (altitude s i)
heq : p = points s i
⊢ False
[PROOFSTEP]
have hd : finrank ℝ (s.altitude i).direction = 0 := by rw [← h, finrank_bot]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : ⊥ = direction (altitude s i)
heq : p = points s i
⊢ finrank ℝ { x // x ∈ direction (altitude s i) } = 0
[PROOFSTEP]
rw [← h, finrank_bot]
[GOAL]
case mp.left
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : ⊥ = direction (altitude s i)
heq : p = points s i
hd : finrank ℝ { x // x ∈ direction (altitude s i) } = 0
⊢ False
[PROOFSTEP]
simp at hd
[GOAL]
case mp.right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : vectorSpan ℝ {p, points s i} = direction (altitude s i)
⊢ p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧ p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ
[PROOFSTEP]
rw [← Submodule.mem_inf, _root_.inf_comm, ← direction_altitude, ← h]
[GOAL]
case mp.right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
h : vectorSpan ℝ {p, points s i} = direction (altitude s i)
⊢ p -ᵥ points s i ∈ vectorSpan ℝ {p, points s i}
[PROOFSTEP]
exact vsub_mem_vectorSpan ℝ (Set.mem_insert _ _) (Set.mem_insert_of_mem _ (Set.mem_singleton _))
[GOAL]
case mpr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
⊢ p ≠ points s i ∧
      p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧
        p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ →
    vectorSpan ℝ {p, points s i} = direction (altitude s i)
[PROOFSTEP]
rintro ⟨hne, h⟩
[GOAL]
case mpr.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h :
  p -ᵥ points s i ∈ vectorSpan ℝ (Set.range s.points) ∧ p -ᵥ points s i ∈ (vectorSpan ℝ (s.points '' ↑(erase univ i)))ᗮ
⊢ vectorSpan ℝ {p, points s i} = direction (altitude s i)
[PROOFSTEP]
rw [← Submodule.mem_inf, _root_.inf_comm, ← direction_altitude] at h
[GOAL]
case mpr.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ vectorSpan ℝ {p, points s i} = direction (altitude s i)
[PROOFSTEP]
rw [vectorSpan_eq_span_vsub_set_left_ne ℝ (Set.mem_insert _ _), Set.insert_diff_of_mem _ (Set.mem_singleton _),
  Set.diff_singleton_eq_self fun h => hne (Set.mem_singleton_iff.1 h), Set.image_singleton]
[GOAL]
case mpr.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ Submodule.span ℝ {(fun x x_1 => x -ᵥ x_1) p (points s i)} = direction (altitude s i)
[PROOFSTEP]
refine' eq_of_le_of_finrank_eq _ _
[GOAL]
case mpr.intro.refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ Submodule.span ℝ {(fun x x_1 => x -ᵥ x_1) p (points s i)} ≤ direction (altitude s i)
[PROOFSTEP]
rw [Submodule.span_le]
[GOAL]
case mpr.intro.refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ {(fun x x_1 => x -ᵥ x_1) p (points s i)} ⊆ ↑(direction (altitude s i))
[PROOFSTEP]
simpa using h
[GOAL]
case mpr.intro.refine'_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ finrank ℝ { x // x ∈ Submodule.span ℝ {(fun x x_1 => x -ᵥ x_1) p (points s i)} } =
    finrank ℝ { x // x ∈ direction (altitude s i) }
[PROOFSTEP]
rw [finrank_direction_altitude, finrank_span_set_eq_card]
[GOAL]
case mpr.intro.refine'_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ card (Set.toFinset {(fun x x_1 => x -ᵥ x_1) p (points s i)}) = 1
[PROOFSTEP]
simp
[GOAL]
case mpr.intro.refine'_2.hs
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ LinearIndependent ℝ Subtype.val
[PROOFSTEP]
refine' linearIndependent_singleton _
[GOAL]
case mpr.intro.refine'_2.hs
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 1)
i : Fin (n + 2)
p : P
hne : p ≠ points s i
h : p -ᵥ points s i ∈ direction (altitude s i)
⊢ (fun x x_1 => x -ᵥ x_1) p (points s i) ≠ 0
[PROOFSTEP]
simpa using hne
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
⊢ orthocenter t = 3 • (centroid ℝ univ t.points -ᵥ circumcenter t) +ᵥ circumcenter t
[PROOFSTEP]
rw [orthocenter_eq_mongePoint, mongePoint_eq_smul_vsub_vadd_circumcenter]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
⊢ (↑(2 + 1) / ↑(2 - 1)) • (centroid ℝ univ t.points -ᵥ circumcenter t) +ᵥ circumcenter t =
    3 • (centroid ℝ univ t.points -ᵥ circumcenter t) +ᵥ circumcenter t
[PROOFSTEP]
norm_num
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ altitude t i₁ = mongePlane t i₂ i₃
[PROOFSTEP]
have hs : ({ i₂, i₃ }ᶜ : Finset (Fin 3)) = { i₁ } := by
  -- porting note: was `decide!`fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
⊢ {i₂, i₃}ᶜ = {i₁}
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
⊢ {i₂, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
⊢ {i₂, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
⊢ {i₂, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
⊢ altitude t i₁ = mongePlane t i₂ i₃
[PROOFSTEP]
have he : univ.erase i₁ = { i₂, i₃ } := by
  -- porting note: was `decide!`fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
⊢ erase univ i₁ = {i₂, i₃}
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hs : {i₂, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {i₂, i₃}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hs : {i₂, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = {i₂, i₃}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hs : {i₂, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = {i₂, i₃}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 0, isLt := (_ : 0 < 3) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = {{ val := 0, isLt := (_ : 0 < 3) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = {{ val := 0, isLt := (_ : 0 < 3) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₃ : Fin 3
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ = {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 0, isLt := (_ : 0 < 3) }}
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h₁₂ h₁₃ h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
he : erase univ i₁ = {i₂, i₃}
⊢ altitude t i₁ = mongePlane t i₂ i₃
[PROOFSTEP]
rw [mongePlane_def, altitude_def, direction_affineSpan, hs, he, centroid_singleton, coe_insert, coe_singleton,
  vectorSpan_image_eq_span_vsub_set_left_ne ℝ _ (Set.mem_insert i₂ _)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
he : erase univ i₁ = {i₂, i₃}
⊢ mk' (points t i₁) (Submodule.span ℝ ((fun x x_1 => x -ᵥ x_1) (points t i₂) '' (t.points '' ({i₂, i₃} \ {i₂}))))ᗮ ⊓
      affineSpan ℝ (Set.range t.points) =
    mk' (points t i₁) (Submodule.span ℝ {points t i₂ -ᵥ points t i₃})ᗮ ⊓ affineSpan ℝ (Set.range t.points)
[PROOFSTEP]
simp [h₂₃, Submodule.span_insert_eq_span]
  -- porting note: this didn't need the `congr` and the `fin_cases`
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
he : erase univ i₁ = {i₂, i₃}
⊢ mk' (points t i₁) (Submodule.span ℝ ((fun a => points t i₂ -ᵥ a) '' (t.points '' ({i₃} \ {i₂}))))ᗮ ⊓
      affineSpan ℝ (Set.range t.points) =
    mk' (points t i₁) (Submodule.span ℝ {points t i₂ -ᵥ points t i₃})ᗮ ⊓ affineSpan ℝ (Set.range t.points)
[PROOFSTEP]
congr
[GOAL]
case e_a.e_direction.e_K.e_s
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
hs : {i₂, i₃}ᶜ = {i₁}
he : erase univ i₁ = {i₂, i₃}
⊢ (fun a => points t i₂ -ᵥ a) '' (t.points '' ({i₃} \ {i₂})) = {points t i₂ -ᵥ points t i₃}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case e_a.e_direction.e_K.e_s.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₃ : Fin 3
h₁₃ : i₁ ≠ i₃
h₁₂ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hs : {{ val := 0, isLt := (_ : 0 < 3) }, i₃}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 0, isLt := (_ : 0 < 3) }, i₃}
⊢ (fun a => points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ a) ''
      (t.points '' ({i₃} \ {{ val := 0, isLt := (_ : 0 < 3) }})) =
    {points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ points t i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case e_a.e_direction.e_K.e_s.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₃ : Fin 3
h₁₃ : i₁ ≠ i₃
h₁₂ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hs : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₃}
⊢ (fun a => points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ a) ''
      (t.points '' ({i₃} \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }})) =
    {points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ points t i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case e_a.e_direction.e_K.e_s.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₃ : Fin 3
h₁₃ : i₁ ≠ i₃
h₁₂ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hs : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₃}
⊢ (fun a => points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ a) ''
      (t.points '' ({i₃} \ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }})) =
    {points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ points t i₃}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case e_a.e_direction.e_K.e_s.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ h₁₃ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
⊢ (fun a => points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ a) ''
      (t.points '' ({{ val := 0, isLt := (_ : 0 < 3) }} \ {{ val := 0, isLt := (_ : 0 < 3) }})) =
    {points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ points t { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ (fun a => points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ a) ''
      (t.points '' ({{ val := 1, isLt := (_ : (fun a => a < 3) 1) }} \ {{ val := 0, isLt := (_ : 0 < 3) }})) =
    {points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ points t { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ (fun a => points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ a) ''
      (t.points ''
        ({{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} \ {{ val := 0, isLt := (_ : 0 < 3) }})) =
    {points t { val := 0, isLt := (_ : 0 < 3) } -ᵥ points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
⊢ (fun a => points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ a) ''
      (t.points '' ({{ val := 0, isLt := (_ : 0 < 3) }} \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }})) =
    {points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ points t { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ h₁₃ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ (fun a => points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ a) ''
      (t.points ''
        ({{ val := 1, isLt := (_ : (fun a => a < 3) 1) }} \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }})) =
    {points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ points t { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ = {i₁}
he :
  erase univ i₁ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ (fun a => points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ a) ''
      (t.points ''
        ({{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} \
          {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }})) =
    {points t { val := 1, isLt := (_ : (fun a => a < 3) 1) } -ᵥ
        points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : i₁ ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hs : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}ᶜ = {i₁}
he : erase univ i₁ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
⊢ (fun a => points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ a) ''
      (t.points ''
        ({{ val := 0, isLt := (_ : 0 < 3) }} \ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }})) =
    {points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ points t { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : i₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}ᶜ = {i₁}
he :
  erase univ i₁ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
⊢ (fun a => points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ a) ''
      (t.points ''
        ({{ val := 1, isLt := (_ : (fun a => a < 3) 1) }} \
          {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }})) =
    {points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ
        points t { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
case e_a.e_direction.e_K.e_s.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
h₁₂ h₁₃ : i₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hs :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
        { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}ᶜ =
    {i₁}
he :
  erase univ i₁ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
⊢ (fun a => points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ a) ''
      (t.points ''
        ({{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} \
          {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }})) =
    {points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } -ᵥ
        points t { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at h₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
⊢ orthocenter t ∈ altitude t i₁
[PROOFSTEP]
obtain ⟨i₂, i₃, h₁₂, h₂₃, h₁₃⟩ : ∃ i₂ i₃, i₁ ≠ i₂ ∧ i₂ ≠ i₃ ∧ i₁ ≠ i₃ := by
  -- porting note: was `decide!`fin_cases i₁ <;> decide
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ : Fin 3
⊢ ∃ i₂ i₃, i₁ ≠ i₂ ∧ i₂ ≠ i₃ ∧ i₁ ≠ i₃
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
⊢ ∃ i₂ i₃, { val := 0, isLt := (_ : 0 < 3) } ≠ i₂ ∧ i₂ ≠ i₃ ∧ { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
⊢ ∃ i₂ i₃,
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂ ∧ i₂ ≠ i₃ ∧ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
⊢ ∃ i₂ i₃,
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂ ∧
      i₂ ≠ i₃ ∧ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ orthocenter t ∈ altitude t i₁
[PROOFSTEP]
rw [orthocenter_eq_mongePoint, t.altitude_eq_mongePlane h₁₂ h₁₃ h₂₃]
[GOAL]
case intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ mongePoint t ∈ mongePlane t i₂ i₃
[PROOFSTEP]
exact t.mongePoint_mem_mongePlane
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
h₁ : p ∈ altitude t i₁
h₂ : p ∈ altitude t i₂
⊢ p = orthocenter t
[PROOFSTEP]
obtain ⟨i₃, h₂₃, h₁₃⟩ : ∃ i₃, i₂ ≠ i₃ ∧ i₁ ≠ i₃ := by
  clear h₁ h₂
  fin_cases i₁ <;> fin_cases i₂ <;> decide
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
h₁ : p ∈ altitude t i₁
h₂ : p ∈ altitude t i₂
⊢ ∃ i₃, i₂ ≠ i₃ ∧ i₁ ≠ i₃
[PROOFSTEP]
clear h₁ h₂
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
⊢ ∃ i₃, i₂ ≠ i₃ ∧ i₁ ≠ i₃
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
⊢ ∃ i₃, i₂ ≠ i₃ ∧ { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
⊢ ∃ i₃, i₂ ≠ i₃ ∧ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
⊢ ∃ i₃, i₂ ≠ i₃ ∧ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ i₃, { val := 0, isLt := (_ : 0 < 3) } ≠ i₃ ∧ { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ i₃, { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃ ∧ { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ i₃, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃ ∧ { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ i₃, { val := 0, isLt := (_ : 0 < 3) } ≠ i₃ ∧ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ i₃, { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃ ∧ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ i₃,
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃ ∧
      { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ i₃, { val := 0, isLt := (_ : 0 < 3) } ≠ i₃ ∧ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ i₃,
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃ ∧
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ i₃,
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃ ∧
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
[PROOFSTEP]
decide
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
h₁ : p ∈ altitude t i₁
h₂ : p ∈ altitude t i₂
i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ p = orthocenter t
[PROOFSTEP]
rw [t.altitude_eq_mongePlane h₁₃ h₁₂ h₂₃.symm] at h₁
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
h₂ : p ∈ altitude t i₂
i₃ : Fin 3
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ p = orthocenter t
[PROOFSTEP]
rw [t.altitude_eq_mongePlane h₂₃ h₁₂.symm h₁₃.symm] at h₂
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ p = orthocenter t
[PROOFSTEP]
rw [orthocenter_eq_mongePoint]
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ p = mongePoint t
[PROOFSTEP]
have ha : ∀ i, i₃ ≠ i → p ∈ t.mongePlane i₃ i := by
  intro i hi
  have hi₁₂ : i₁ = i ∨ i₂ = i := by
    clear h₁ h₂
    fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> fin_cases i <;> simp at h₁₂ h₁₃ h₂₃ hi ⊢
  cases' hi₁₂ with hi₁₂ hi₁₂
  · exact hi₁₂ ▸ h₂
  · exact hi₁₂ ▸ h₁
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
⊢ ∀ (i : Fin 3), i₃ ≠ i → p ∈ mongePlane t i₃ i
[PROOFSTEP]
intro i hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
⊢ p ∈ mongePlane t i₃ i
[PROOFSTEP]
have hi₁₂ : i₁ = i ∨ i₂ = i := by
  clear h₁ h₂
  fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> fin_cases i <;> simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
⊢ i₁ = i ∨ i₂ = i
[PROOFSTEP]
clear h₁ h₂
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
⊢ i₁ = i ∨ i₂ = i
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ i₂ = i
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ i₂ = i
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
p : P
i₃ : Fin 3
h₂₃ : i₂ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ i₂ = i
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i₃ i : Fin 3
hi : i₃ ≠ i
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i ∨ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 0, isLt := (_ : 0 < 3) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ i
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
i : Fin 3
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i
h₁₃ h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = i
[PROOFSTEP]
fin_cases i
[GOAL]
case head.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 0, isLt := (_ : 0 < 3) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
h₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
h₁₃ h₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
p : P
h₁₂ h₁₃ h₂₃ hi :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h₁₂ h₁₃ h₂₃ hi ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
hi₁₂ : i₁ = i ∨ i₂ = i
⊢ p ∈ mongePlane t i₃ i
[PROOFSTEP]
cases' hi₁₂ with hi₁₂ hi₁₂
[GOAL]
case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
hi₁₂ : i₁ = i
⊢ p ∈ mongePlane t i₃ i
[PROOFSTEP]
exact hi₁₂ ▸ h₂
[GOAL]
case inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
i : Fin 3
hi : i₃ ≠ i
hi₁₂ : i₂ = i
⊢ p ∈ mongePlane t i₃ i
[PROOFSTEP]
exact hi₁₂ ▸ h₁
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
p : P
h₁₂ : i₁ ≠ i₂
i₃ : Fin 3
h₂ : p ∈ mongePlane t i₃ i₁
h₁ : p ∈ mongePlane t i₃ i₂
h₂₃ : i₂ ≠ i₃
h₁₃ : i₁ ≠ i₃
ha : ∀ (i : Fin 3), i₃ ≠ i → p ∈ mongePlane t i₃ i
⊢ p = mongePoint t
[PROOFSTEP]
exact eq_mongePoint_of_forall_mem_mongePlane ha
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ dist (orthocenter t) (↑(EuclideanGeometry.reflection (affineSpan ℝ (t.points '' {i₁, i₂}))) (circumcenter t)) =
    circumradius t
[PROOFSTEP]
rw [← mul_self_inj_of_nonneg dist_nonneg t.circumradius_nonneg,
  t.reflection_circumcenter_eq_affineCombination_of_pointsWithCircumcenter h, t.orthocenter_eq_mongePoint,
  mongePoint_eq_affineCombination_of_pointsWithCircumcenter,
  dist_affineCombination t.pointsWithCircumcenter (sum_mongePointWeightsWithCircumcenter _)
    (sum_reflectionCircumcenterWeightsWithCircumcenter h)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ (-∑ i₁_1 : PointsWithCircumcenterIndex 2,
          ∑ i₂_1 : PointsWithCircumcenterIndex 2,
            ((fun i => mongePointWeightsWithCircumcenter 0 i) - fun i =>
                    reflectionCircumcenterWeightsWithCircumcenter i₁ i₂ i)
                  i₁_1 *
                ((fun i => mongePointWeightsWithCircumcenter 0 i) - fun i =>
                    reflectionCircumcenterWeightsWithCircumcenter i₁ i₂ i)
                  i₂_1 *
              (dist (pointsWithCircumcenter t i₁_1) (pointsWithCircumcenter t i₂_1) *
                dist (pointsWithCircumcenter t i₁_1) (pointsWithCircumcenter t i₂_1))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
simp_rw [sum_pointsWithCircumcenter, Pi.sub_apply, mongePointWeightsWithCircumcenter,
  reflectionCircumcenterWeightsWithCircumcenter]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ -(∑ x : Fin (0 + 2 + 1),
            (∑ x_1 : Fin (0 + 2 + 1),
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
              ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x : Fin (0 + 2 + 1),
              (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                  dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
have hu : ({ i₁, i₂ } : Finset (Fin 3)) ⊆ univ := subset_univ _
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
⊢ -(∑ x : Fin (0 + 2 + 1),
            (∑ x_1 : Fin (0 + 2 + 1),
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
              ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x : Fin (0 + 2 + 1),
              (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                  dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
obtain ⟨i₃, hi₃, hi₃₁, hi₃₂⟩ : ∃ i₃, univ \ ({ i₁, i₂ } : Finset (Fin 3)) = { i₃ } ∧ i₃ ≠ i₁ ∧ i₃ ≠ i₂ := by
  -- porting note: was `decide!`fin_cases i₁ <;> fin_cases i₂ <;> simp at h  <;>
    decide
      -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
⊢ ∃ i₃, univ \ {i₁, i₂} = {i₃} ∧ i₃ ≠ i₁ ∧ i₃ ≠ i₂
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
h : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
hu : {{ val := 0, isLt := (_ : 0 < 3) }, i₂} ⊆ univ
⊢ ∃ i₃, univ \ {{ val := 0, isLt := (_ : 0 < 3) }, i₂} = {i₃} ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ i₂
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
h : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
hu : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₂} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₂} = {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧ i₃ ≠ i₂
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₂ : Fin 3
h : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
hu : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₂} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₂} = {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧ i₃ ≠ i₂
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hu : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }} = {i₃} ∧
      i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hu : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} = {i₃} ∧
      i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hu : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} = {i₃} ∧
      i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hu : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }} = {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hu : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} = {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧ i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hu :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} ⊆ univ
⊢ ∃ i₃,
    univ \
          {{ val := 1, isLt := (_ : (fun a => a < 3) 1) },
            { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} =
        {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
        i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hu : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }} ⊆ univ
⊢ ∃ i₃,
    univ \ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }} = {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hu :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} ⊆ univ
⊢ ∃ i₃,
    univ \
          {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
            { val := 1, isLt := (_ : (fun a => a < 3) 1) }} =
        {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at h
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
h :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hu :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} ⊆
    univ
⊢ ∃ i₃,
    univ \
          {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
            { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} =
        {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at h
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} = {i₃} ∧
      i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu : {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \ {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} = {i₃} ∧
      i₃ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧ i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu : {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \ {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }} = {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu :
  {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \
          {{ val := 1, isLt := (_ : (fun a => a < 3) 1) },
            { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }} =
        {i₃} ∧
      i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
        i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu : {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \ {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }} = {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧ i₃ ≠ { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
hu :
  {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }} ⊆ univ
h : True
⊢ ∃ i₃,
    univ \
          {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
            { val := 1, isLt := (_ : (fun a => a < 3) 1) }} =
        {i₃} ∧
      i₃ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        i₃ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
decide
  -- Porting note: Original proof was `simp_rw [← sum_sdiff hu, hi₃]; simp [hi₃₁, hi₃₂]; norm_num`
[GOAL]
case intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
i₃ : Fin 3
hi₃ : univ \ {i₁, i₂} = {i₃}
hi₃₁ : i₃ ≠ i₁
hi₃₂ : i₃ ≠ i₂
⊢ -(∑ x : Fin (0 + 2 + 1),
            (∑ x_1 : Fin (0 + 2 + 1),
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
              ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x : Fin (0 + 2 + 1),
              (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                  dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                    (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
rw [← sum_sdiff hu, ← sum_sdiff hu, hi₃, sum_singleton, ← sum_sdiff hu, hi₃]
[GOAL]
case intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
i₃ : Fin 3
hi₃ : univ \ {i₁, i₂} = {i₃}
hi₃₁ : i₃ ≠ i₁
hi₃₂ : i₃ ≠ i₂
⊢ -(∑ x in {i₃},
                  ((↑(0 + 1))⁻¹ - if i₃ = i₁ ∨ i₃ = i₂ then 1 else 0) *
                      ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
                ∑ x in {i₁, i₂},
                  ((↑(0 + 1))⁻¹ - if i₃ = i₁ ∨ i₃ = i₂ then 1 else 0) *
                      ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ((↑(0 + 1))⁻¹ - if i₃ = i₁ ∨ i₃ = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)) +
            ∑ x in {i₁, i₂},
              (∑ x_1 : Fin (0 + 2 + 1),
                  ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                      ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x in {i₃},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ∑ x in {i₁, i₂},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h✝ : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
i₃ : Fin 3
hi₃ : univ \ {i₁, i₂} = {i₃}
hi₃₁ : i₃ ≠ i₁
hi₃₂ : i₃ ≠ i₂
h : i₃ = i₁ ∨ i₃ = i₂
⊢ -(∑ x in {i₃},
                  ((↑(0 + 1))⁻¹ - 1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
                ∑ x in {i₁, i₂},
                  ((↑(0 + 1))⁻¹ - 1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ((↑(0 + 1))⁻¹ - 1) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)) +
            ∑ x in {i₁, i₂},
              (∑ x_1 : Fin (0 + 2 + 1),
                  ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                      ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x in {i₃},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ∑ x in {i₁, i₂},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
exact (h.elim hi₃₁ hi₃₂).elim
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h✝ : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
i₃ : Fin 3
hi₃ : univ \ {i₁, i₂} = {i₃}
hi₃₁ : i₃ ≠ i₁
hi₃₂ : i₃ ≠ i₂
h : ¬(i₃ = i₁ ∨ i₃ = i₂)
⊢ -(∑ x in {i₃},
                  ((↑(0 + 1))⁻¹ - 0) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
                ∑ x in {i₁, i₂},
                  ((↑(0 + 1))⁻¹ - 0) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ((↑(0 + 1))⁻¹ - 0) * (-2 / ↑(0 + 1) - -1) *
                (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                  dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index i₃))
                    (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)) +
            ∑ x in {i₁, i₂},
              (∑ x_1 : Fin (0 + 2 + 1),
                  ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                      ((↑(0 + 1))⁻¹ - if x_1 = i₁ ∨ x_1 = i₂ then 1 else 0) *
                    (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1)) *
                      dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                        (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x_1))) +
                ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) * (-2 / ↑(0 + 1) - -1) *
                  (dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                    dist (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))
                      (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index))) +
          (∑ x in {i₃},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
              ∑ x in {i₁, i₂},
                (-2 / ↑(0 + 1) - -1) * ((↑(0 + 1))⁻¹ - if x = i₁ ∨ x = i₂ then 1 else 0) *
                  (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x)) *
                    dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                      (pointsWithCircumcenter t (PointsWithCircumcenterIndex.point_index x))) +
            (-2 / ↑(0 + 1) - -1) * (-2 / ↑(0 + 1) - -1) *
              (dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index) *
                dist (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)
                  (pointsWithCircumcenter t PointsWithCircumcenterIndex.circumcenter_index)))) /
      2 =
    circumradius t * circumradius t
[PROOFSTEP]
simp [h]
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h✝ : i₁ ≠ i₂
hu : {i₁, i₂} ⊆ univ
i₃ : Fin 3
hi₃ : univ \ {i₁, i₂} = {i₃}
hi₃₁ : i₃ ≠ i₁
hi₃₂ : i₃ ≠ i₂
h : ¬(i₃ = i₁ ∨ i₃ = i₂)
⊢ -((-2 + 1) * (circumradius t * circumradius t)) = circumradius t * circumradius t
[PROOFSTEP]
norm_num
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ dist (orthocenter t) (↑(EuclideanGeometry.reflection (affineSpan ℝ (t.points '' ↑{i₁, i₂}))) (circumcenter t)) =
    circumradius t
[PROOFSTEP]
simp only [mem_singleton, coe_insert, coe_singleton, Set.mem_singleton_iff]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i₁ i₂ : Fin 3
h : i₁ ≠ i₂
⊢ dist (orthocenter t) (↑(EuclideanGeometry.reflection (affineSpan ℝ (t.points '' {i₁, i₂}))) (circumcenter t)) =
    circumradius t
[PROOFSTEP]
exact dist_orthocenter_reflection_circumcenter _ h
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ affineSpan ℝ {orthocenter t, points t i} ≤ altitude t i
[PROOFSTEP]
refine' spanPoints_subset_coe_of_subset_coe _
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ {orthocenter t, points t i} ⊆ ↑(altitude t i)
[PROOFSTEP]
rw [Set.insert_subset_iff, Set.singleton_subset_iff]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ orthocenter t ∈ ↑(altitude t i) ∧ points t i ∈ ↑(altitude t i)
[PROOFSTEP]
exact ⟨t.orthocenter_mem_altitude, t.mem_altitude i⟩
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ altitude t₂ j₂ = affineSpan ℝ {points t₁ i₁, points t₁ i₂}
[PROOFSTEP]
symm
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ affineSpan ℝ {points t₁ i₁, points t₁ i₂} = altitude t₂ j₂
[PROOFSTEP]
rw [← h₂, t₂.affineSpan_pair_eq_altitude_iff]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ≠ points t₂ j₂ ∧
    points t₁ i₁ ∈ affineSpan ℝ (Set.range t₂.points) ∧
      points t₁ i₁ -ᵥ points t₂ j₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
rw [h₂]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ≠ points t₁ i₂ ∧
    points t₁ i₁ ∈ affineSpan ℝ (Set.range t₂.points) ∧
      points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
use t₁.Independent.injective.ne hi₁₂
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ∈ affineSpan ℝ (Set.range t₂.points) ∧
    points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
have he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points) :=
  by
  refine' ext_of_direction_eq _ ⟨t₁.points i₃, mem_affineSpan ℝ ⟨j₃, h₃⟩, mem_affineSpan ℝ (Set.mem_range_self _)⟩
  refine' eq_of_le_of_finrank_eq (direction_le (spanPoints_subset_coe_of_subset_coe _)) _
  · have hu : (Finset.univ : Finset (Fin 3)) = { j₁, j₂, j₃ } :=
      by
      clear h₁ h₂ h₃
      fin_cases j₁ <;> fin_cases j₂ <;> fin_cases j₃ <;> simp at hj₁₂ hj₁₃ hj₂₃ ⊢
    rw [← Set.image_univ, ← Finset.coe_univ, hu, Finset.coe_insert, Finset.coe_insert, Finset.coe_singleton,
      Set.image_insert_eq, Set.image_insert_eq, Set.image_singleton, h₁, h₂, h₃, Set.insert_subset_iff,
      Set.insert_subset_iff, Set.singleton_subset_iff]
    exact
      ⟨t₁.orthocenter_mem_affineSpan, mem_affineSpan ℝ (Set.mem_range_self _), mem_affineSpan ℝ (Set.mem_range_self _)⟩
  ·
    rw [direction_affineSpan, direction_affineSpan, t₁.Independent.finrank_vectorSpan (Fintype.card_fin _),
      t₂.Independent.finrank_vectorSpan (Fintype.card_fin _)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
[PROOFSTEP]
refine' ext_of_direction_eq _ ⟨t₁.points i₃, mem_affineSpan ℝ ⟨j₃, h₃⟩, mem_affineSpan ℝ (Set.mem_range_self _)⟩
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ direction (affineSpan ℝ (Set.range t₂.points)) = direction (affineSpan ℝ (Set.range t₁.points))
[PROOFSTEP]
refine' eq_of_le_of_finrank_eq (direction_le (spanPoints_subset_coe_of_subset_coe _)) _
[GOAL]
case refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ Set.range t₂.points ⊆ ↑(affineSpan ℝ (Set.range t₁.points))
[PROOFSTEP]
have hu : (Finset.univ : Finset (Fin 3)) = { j₁, j₂, j₃ } :=
  by
  clear h₁ h₂ h₃
  fin_cases j₁ <;> fin_cases j₂ <;> fin_cases j₃ <;> simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ univ = {j₁, j₂, j₃}
[PROOFSTEP]
clear h₁ h₂ h₃
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
⊢ univ = {j₁, j₂, j₃}
[PROOFSTEP]
fin_cases j₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₂
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
⊢ univ = {{ val := 0, isLt := (_ : 0 < 3) }, j₂, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₂
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
⊢ univ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₂, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₂
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
⊢ univ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₂, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ hj₁₃ hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ univ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
hu : univ = {j₁, j₂, j₃}
⊢ Set.range t₂.points ⊆ ↑(affineSpan ℝ (Set.range t₁.points))
[PROOFSTEP]
rw [← Set.image_univ, ← Finset.coe_univ, hu, Finset.coe_insert, Finset.coe_insert, Finset.coe_singleton,
  Set.image_insert_eq, Set.image_insert_eq, Set.image_singleton, h₁, h₂, h₃, Set.insert_subset_iff,
  Set.insert_subset_iff, Set.singleton_subset_iff]
[GOAL]
case refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
hu : univ = {j₁, j₂, j₃}
⊢ orthocenter t₁ ∈ ↑(affineSpan ℝ (Set.range t₁.points)) ∧
    points t₁ i₂ ∈ ↑(affineSpan ℝ (Set.range t₁.points)) ∧ points t₁ i₃ ∈ ↑(affineSpan ℝ (Set.range t₁.points))
[PROOFSTEP]
exact ⟨t₁.orthocenter_mem_affineSpan, mem_affineSpan ℝ (Set.mem_range_self _), mem_affineSpan ℝ (Set.mem_range_self _)⟩
[GOAL]
case refine'_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ finrank ℝ { x // x ∈ direction (affineSpan ℝ (Set.range t₂.points)) } =
    finrank ℝ { x // x ∈ direction (affineSpan ℝ (Set.range t₁.points)) }
[PROOFSTEP]
rw [direction_affineSpan, direction_affineSpan, t₁.Independent.finrank_vectorSpan (Fintype.card_fin _),
  t₂.Independent.finrank_vectorSpan (Fintype.card_fin _)]
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
⊢ points t₁ i₁ ∈ affineSpan ℝ (Set.range t₂.points) ∧
    points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
rw [he]
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
⊢ points t₁ i₁ ∈ affineSpan ℝ (Set.range t₁.points) ∧
    points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
use mem_affineSpan ℝ (Set.mem_range_self _)
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
have hu : Finset.univ.erase j₂ = { j₁, j₃ } := by
  clear h₁ h₂ h₃
  fin_cases j₁ <;> fin_cases j₂ <;> fin_cases j₃ <;> simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
⊢ erase univ j₂ = {j₁, j₃}
[PROOFSTEP]
clear h₁ h₂ h₃
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
⊢ erase univ j₂ = {j₁, j₃}
[PROOFSTEP]
fin_cases j₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₂
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
⊢ erase univ j₂ = {{ val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₂
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
⊢ erase univ j₂ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₂₃ : j₂ ≠ j₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₂
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
⊢ erase univ j₂ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = {{ val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } = {{ val := 0, isLt := (_ : 0 < 3) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, j₃}
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hj₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hj₁₃ hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hj₁₂ hj₁₃ hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hj₁₂ hj₁₃ hj₂₃ ⊢
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ (t₂.points '' ↑(erase univ j₂))))ᗮ
[PROOFSTEP]
rw [hu, Finset.coe_insert, Finset.coe_singleton, Set.image_insert_eq, Set.image_singleton, h₁, h₃]
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
[PROOFSTEP]
have hle : (t₁.altitude i₃).directionᗮ ≤ line[ℝ, t₁.orthocenter, t₁.points i₃].directionᗮ :=
  Submodule.orthogonal_le (direction_le (affineSpan_orthocenter_point_le_altitude _ _))
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hle : (direction (altitude t₁ i₃))ᗮ ≤ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
[PROOFSTEP]
refine' hle ((t₁.vectorSpan_isOrtho_altitude_direction i₃) _)
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hle : (direction (altitude t₁ i₃))ᗮ ≤ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ vectorSpan ℝ (t₁.points '' ↑(erase univ i₃))
[PROOFSTEP]
have hui : Finset.univ.erase i₃ = { i₁, i₂ } := by
  clear hle h₂ h₃
  fin_cases i₁ <;> fin_cases i₂ <;> fin_cases i₃ <;> simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hle : (direction (altitude t₁ i₃))ᗮ ≤ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
⊢ erase univ i₃ = {i₁, i₂}
[PROOFSTEP]
clear hle h₂ h₃
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
⊢ erase univ i₃ = {i₁, i₂}
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₂
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
⊢ erase univ i₃ = {{ val := 0, isLt := (_ : 0 < 3) }, i₂}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
⊢ erase univ i₃ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, i₂}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂
hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
⊢ erase univ i₃ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, i₂}
[PROOFSTEP]
fin_cases i₂
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ i₃ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ i₃ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ i₃ = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ i₃ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ i₃ = {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ i₃ =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ i₃
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ i₃ = {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ i₃ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₃ j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₃ hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃
hi₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ i₃ =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
fin_cases i₃
[GOAL]
case head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } = {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 0, isLt := (_ : 0 < 3) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 1, isLt := (_ : (fun a => a < 3) 1) }, { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 0, isLt := (_ : 0 < 3) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
hi₁₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }, { val := 1, isLt := (_ : (fun a => a < 3) 1) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ erase univ { val := 0, isLt := (_ : 0 < 3) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
hi₁₃ hi₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ erase univ { val := 1, isLt := (_ : (fun a => a < 3) 1) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
j₁ j₂ j₃ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hi₁₂ hi₁₃ hi₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ erase univ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } =
    {{ val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) },
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }}
[PROOFSTEP]
simp at hi₁₂ hi₁₃ hi₂₃ ⊢
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hle : (direction (altitude t₁ i₃))ᗮ ≤ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
hui : erase univ i₃ = {i₁, i₂}
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ vectorSpan ℝ (t₁.points '' ↑(erase univ i₃))
[PROOFSTEP]
rw [hui, Finset.coe_insert, Finset.coe_singleton, Set.image_insert_eq, Set.image_singleton]
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
he : affineSpan ℝ (Set.range t₂.points) = affineSpan ℝ (Set.range t₁.points)
hu : erase univ j₂ = {j₁, j₃}
hle : (direction (altitude t₁ i₃))ᗮ ≤ (direction (affineSpan ℝ {orthocenter t₁, points t₁ i₃}))ᗮ
hui : erase univ i₃ = {i₁, i₂}
⊢ points t₁ i₁ -ᵥ points t₁ i₂ ∈ vectorSpan ℝ {points t₁ i₁, points t₁ i₂}
[PROOFSTEP]
refine' vsub_mem_vectorSpan ℝ (Set.mem_insert _ _) (Set.mem_insert_of_mem _ (Set.mem_singleton _))
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ orthocenter t₂ = points t₁ i₁
[PROOFSTEP]
refine' (Triangle.eq_orthocenter_of_forall_mem_altitude hj₂₃ _ _).symm
[GOAL]
case refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ∈ altitude t₂ j₂
[PROOFSTEP]
rw [altitude_replace_orthocenter_eq_affineSpan hi₁₂ hi₁₃ hi₂₃ hj₁₂ hj₁₃ hj₂₃ h₁ h₂ h₃]
[GOAL]
case refine'_1
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ∈ affineSpan ℝ {points t₁ i₁, points t₁ i₂}
[PROOFSTEP]
exact mem_affineSpan ℝ (Set.mem_insert _ _)
[GOAL]
case refine'_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ∈ altitude t₂ j₃
[PROOFSTEP]
rw [altitude_replace_orthocenter_eq_affineSpan hi₁₃ hi₁₂ hi₂₃.symm hj₁₃ hj₁₂ hj₂₃.symm h₁ h₃ h₂]
[GOAL]
case refine'_2
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ j₁ j₂ j₃ : Fin 3
hi₁₂ : i₁ ≠ i₂
hi₁₃ : i₁ ≠ i₃
hi₂₃ : i₂ ≠ i₃
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₂₃ : j₂ ≠ j₃
h₁ : points t₂ j₁ = orthocenter t₁
h₂ : points t₂ j₂ = points t₁ i₂
h₃ : points t₂ j₃ = points t₁ i₃
⊢ points t₁ i₁ ∈ affineSpan ℝ {points t₁ i₁, points t₁ i₃}
[PROOFSTEP]
exact mem_affineSpan ℝ (Set.mem_insert _ _)
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
⊢ (∃ i₁ i₂ i₃ j₂ j₃,
      i₁ ≠ i₂ ∧
        i₁ ≠ i₃ ∧
          i₂ ≠ i₃ ∧
            (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
              p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃) ∨
    Set.range p = Set.range t.points
[PROOFSTEP]
by_cases h : t.orthocenter ∈ Set.range p
[GOAL]
case pos
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : Triangle.orthocenter t ∈ Set.range p
⊢ (∃ i₁ i₂ i₃ j₂ j₃,
      i₁ ≠ i₂ ∧
        i₁ ≠ i₃ ∧
          i₂ ≠ i₃ ∧
            (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
              p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃) ∨
    Set.range p = Set.range t.points
[PROOFSTEP]
left
[GOAL]
case pos.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : Triangle.orthocenter t ∈ Set.range p
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
rcases h with ⟨i₁, h₁⟩
[GOAL]
case pos.h.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
obtain ⟨i₂, i₃, h₁₂, h₁₃, h₂₃, h₁₂₃⟩ :
  ∃ i₂ i₃ : Fin 3, i₁ ≠ i₂ ∧ i₁ ≠ i₃ ∧ i₂ ≠ i₃ ∧ ∀ i : Fin 3, i = i₁ ∨ i = i₂ ∨ i = i₃ :=
  by
  clear h₁
  fin_cases i₁ <;> decide
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
⊢ ∃ i₂ i₃, i₁ ≠ i₂ ∧ i₁ ≠ i₃ ∧ i₂ ≠ i₃ ∧ ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
[PROOFSTEP]
clear h₁
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
⊢ ∃ i₂ i₃, i₁ ≠ i₂ ∧ i₁ ≠ i₃ ∧ i₂ ≠ i₃ ∧ ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
[PROOFSTEP]
fin_cases i₁
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
⊢ ∃ i₂ i₃,
    { val := 0, isLt := (_ : 0 < 3) } ≠ i₂ ∧
      { val := 0, isLt := (_ : 0 < 3) } ≠ i₃ ∧
        i₂ ≠ i₃ ∧ ∀ (i : Fin 3), i = { val := 0, isLt := (_ : 0 < 3) } ∨ i = i₂ ∨ i = i₃
[PROOFSTEP]
decide
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
⊢ ∃ i₂ i₃,
    { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₂ ∧
      { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ i₃ ∧
        i₂ ≠ i₃ ∧ ∀ (i : Fin 3), i = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨ i = i₂ ∨ i = i₃
[PROOFSTEP]
decide
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
⊢ ∃ i₂ i₃,
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₂ ∧
      { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ i₃ ∧
        i₂ ≠ i₃ ∧ ∀ (i : Fin 3), i = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨ i = i₂ ∨ i = i₃
[PROOFSTEP]
decide
[GOAL]
case pos.h.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
have h : ∀ i, i₁ ≠ i → ∃ j : Fin 3, t.points j = p i :=
  by
  intro i hi
  replace hps := Set.mem_of_mem_insert_of_ne (Set.mem_of_mem_of_subset (Set.mem_range_self i) hps) (h₁ ▸ hpi.ne hi.symm)
  exact hps
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
⊢ ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
[PROOFSTEP]
intro i hi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
i : Fin 3
hi : i₁ ≠ i
⊢ ∃ j, Simplex.points t j = p i
[PROOFSTEP]
replace hps := Set.mem_of_mem_insert_of_ne (Set.mem_of_mem_of_subset (Set.mem_range_self i) hps) (h₁ ▸ hpi.ne hi.symm)
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
i : Fin 3
hi : i₁ ≠ i
hps : p i ∈ Set.range t.points
⊢ ∃ j, Simplex.points t j = p i
[PROOFSTEP]
exact hps
[GOAL]
case pos.h.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
rcases h i₂ h₁₂ with ⟨j₂, h₂⟩
[GOAL]
case pos.h.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ : Fin 3
h₂ : Simplex.points t j₂ = p i₂
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
rcases h i₃ h₁₃ with ⟨j₃, h₃⟩
[GOAL]
case pos.h.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ : Fin 3
h₂ : Simplex.points t j₂ = p i₂
j₃ : Fin 3
h₃ : Simplex.points t j₃ = p i₃
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
have hj₂₃ : j₂ ≠ j₃ := by
  intro he
  rw [he, h₃] at h₂
  exact h₂₃.symm (hpi h₂)
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ : Fin 3
h₂ : Simplex.points t j₂ = p i₂
j₃ : Fin 3
h₃ : Simplex.points t j₃ = p i₃
⊢ j₂ ≠ j₃
[PROOFSTEP]
intro he
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ : Fin 3
h₂ : Simplex.points t j₂ = p i₂
j₃ : Fin 3
h₃ : Simplex.points t j₃ = p i₃
he : j₂ = j₃
⊢ False
[PROOFSTEP]
rw [he, h₃] at h₂
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ j₃ : Fin 3
h₂ : p i₃ = p i₂
h₃ : Simplex.points t j₃ = p i₃
he : j₂ = j₃
⊢ False
[PROOFSTEP]
exact h₂₃.symm (hpi h₂)
[GOAL]
case pos.h.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ : Fin 3
h₁ : p i₁ = Triangle.orthocenter t
i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h : ∀ (i : Fin 3), i₁ ≠ i → ∃ j, Simplex.points t j = p i
j₂ : Fin 3
h₂ : Simplex.points t j₂ = p i₂
j₃ : Fin 3
h₃ : Simplex.points t j₃ = p i₃
hj₂₃ : j₂ ≠ j₃
⊢ ∃ i₁ i₂ i₃ j₂ j₃,
    i₁ ≠ i₂ ∧
      i₁ ≠ i₃ ∧
        i₂ ≠ i₃ ∧
          (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
            p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃
[PROOFSTEP]
exact ⟨i₁, i₂, i₃, j₂, j₃, h₁₂, h₁₃, h₂₃, h₁₂₃, h₁, hj₂₃, h₂, h₃⟩
[GOAL]
case neg
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : ¬Triangle.orthocenter t ∈ Set.range p
⊢ (∃ i₁ i₂ i₃ j₂ j₃,
      i₁ ≠ i₂ ∧
        i₁ ≠ i₃ ∧
          i₂ ≠ i₃ ∧
            (∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃) ∧
              p i₁ = Triangle.orthocenter t ∧ j₂ ≠ j₃ ∧ Simplex.points t j₂ = p i₂ ∧ Simplex.points t j₃ = p i₃) ∨
    Set.range p = Set.range t.points
[PROOFSTEP]
right
[GOAL]
case neg.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : ¬Triangle.orthocenter t ∈ Set.range p
⊢ Set.range p = Set.range t.points
[PROOFSTEP]
have hs := Set.subset_diff_singleton hps h
[GOAL]
case neg.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : ¬Triangle.orthocenter t ∈ Set.range p
hs : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points) \ {Triangle.orthocenter t}
⊢ Set.range p = Set.range t.points
[PROOFSTEP]
rw [Set.insert_diff_self_of_not_mem ho] at hs
[GOAL]
case neg.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : ¬Triangle.orthocenter t ∈ Set.range p
hs : Set.range p ⊆ Set.range t.points
⊢ Set.range p = Set.range t.points
[PROOFSTEP]
refine' Set.eq_of_subset_of_card_le hs _
[GOAL]
case neg.h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
h : ¬Triangle.orthocenter t ∈ Set.range p
hs : Set.range p ⊆ Set.range t.points
⊢ Fintype.card ↑(Set.range t.points) ≤ Fintype.card ↑(Set.range p)
[PROOFSTEP]
rw [Set.card_range_of_injective hpi, Set.card_range_of_injective t.Independent.injective]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
⊢ ∃ c, c ∈ affineSpan ℝ (Set.range t.points) ∧ ∀ (p₁ : P), p₁ ∈ Set.range p → dist p₁ c = Simplex.circumradius t
[PROOFSTEP]
rcases exists_of_range_subset_orthocentricSystem ho hps hpi with
  (⟨i₁, i₂, i₃, j₂, j₃, _, _, _, h₁₂₃, h₁, hj₂₃, h₂, h₃⟩ | hs)
[GOAL]
case inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ ∃ c, c ∈ affineSpan ℝ (Set.range t.points) ∧ ∀ (p₁ : P), p₁ ∈ Set.range p → dist p₁ c = Simplex.circumradius t
[PROOFSTEP]
use reflection (affineSpan ℝ (t.points '' { j₂, j₃ })) t.circumcenter,
  reflection_mem_of_le_of_mem (affineSpan_mono ℝ (Set.image_subset_range _ _)) t.circumcenter_mem_affineSpan
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ ∀ (p₁ : P),
    p₁ ∈ Set.range p →
      dist p₁ (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
intro p₁ hp₁
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
p₁ : P
hp₁ : p₁ ∈ Set.range p
⊢ dist p₁ (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
rcases hp₁ with ⟨i, rfl⟩
[GOAL]
case right.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
have h₁₂₃ := h₁₂₃ i
[GOAL]
case right.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₁ ∨ i = i₂ ∨ i = i₃
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
repeat' cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₁ ∨ i = i₂ ∨ i = i₃
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₁
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inl.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₁) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₂ ∨ i = i₃
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inr.inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₂
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inr.inl.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₂) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inr.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃✝ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
i : Fin 3
h₁₂₃ : i = i₃
⊢ dist (p i) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inr.inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₃) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
cases' h₁₂₃ with h₁₂₃ h₁₂₃
[GOAL]
case right.intro.inl.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₁) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
convert Triangle.dist_orthocenter_reflection_circumcenter t hj₂₃
[GOAL]
case right.intro.inr.inl.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₂) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
rw [← h₂, dist_reflection_eq_of_mem _ (mem_affineSpan ℝ (Set.mem_image_of_mem _ (Set.mem_insert _ _)))]
[GOAL]
case right.intro.inr.inl.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (Simplex.points t j₂) (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
exact t.dist_circumcenter_eq_circumradius _
[GOAL]
case right.intro.inr.inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (p i₃) (↑(reflection (affineSpan ℝ (t.points '' {j₂, j₃}))) (Simplex.circumcenter t)) = Simplex.circumradius t
[PROOFSTEP]
rw [← h₃,
  dist_reflection_eq_of_mem _
    (mem_affineSpan ℝ (Set.mem_image_of_mem _ (Set.mem_insert_of_mem _ (Set.mem_singleton _))))]
[GOAL]
case right.intro.inr.inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
i₁ i₂ i₃ j₂ j₃ : Fin 3
left✝² : i₁ ≠ i₂
left✝¹ : i₁ ≠ i₃
left✝ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : p i₁ = Triangle.orthocenter t
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t j₂ = p i₂
h₃ : Simplex.points t j₃ = p i₃
⊢ dist (Simplex.points t j₃) (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
exact t.dist_circumcenter_eq_circumradius _
[GOAL]
case inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
hs : Set.range p = Set.range t.points
⊢ ∃ c, c ∈ affineSpan ℝ (Set.range t.points) ∧ ∀ (p₁ : P), p₁ ∈ Set.range p → dist p₁ c = Simplex.circumradius t
[PROOFSTEP]
use t.circumcenter, t.circumcenter_mem_affineSpan
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
hs : Set.range p = Set.range t.points
⊢ ∀ (p₁ : P), p₁ ∈ Set.range p → dist p₁ (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
intro p₁ hp₁
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
hs : Set.range p = Set.range t.points
p₁ : P
hp₁ : p₁ ∈ Set.range p
⊢ dist p₁ (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
rw [hs] at hp₁
[GOAL]
case right
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
hs : Set.range p = Set.range t.points
p₁ : P
hp₁ : p₁ ∈ Set.range t.points
⊢ dist p₁ (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
rcases hp₁ with ⟨i, rfl⟩
[GOAL]
case right.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
ho : ¬Triangle.orthocenter t ∈ Set.range t.points
p : Fin 3 → P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hpi : Function.Injective p
hs : Set.range p = Set.range t.points
i : Fin (2 + 1)
⊢ dist (Simplex.points t i) (Simplex.circumcenter t) = Simplex.circumradius t
[PROOFSTEP]
exact t.dist_circumcenter_eq_circumradius _
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
ho : OrthocentricSystem s
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
⊢ AffineIndependent ℝ p
[PROOFSTEP]
rcases ho with ⟨t, hto, hst⟩
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hst : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ AffineIndependent ℝ p
[PROOFSTEP]
rw [hst] at hps
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hpi : Function.Injective p
t : Triangle ℝ P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hst : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ AffineIndependent ℝ p
[PROOFSTEP]
rcases exists_dist_eq_circumradius_of_subset_insert_orthocenter hto hps hpi with ⟨c, _, hc⟩
[GOAL]
case intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hpi : Function.Injective p
t : Triangle ℝ P
hps : Set.range p ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hst : s = insert (Triangle.orthocenter t) (Set.range t.points)
c : P
left✝ : c ∈ affineSpan ℝ (Set.range t.points)
hc : ∀ (p₁ : P), p₁ ∈ Set.range p → dist p₁ c = Simplex.circumradius t
⊢ AffineIndependent ℝ p
[PROOFSTEP]
exact Cospherical.affineIndependent ⟨c, t.circumradius, hc⟩ Set.Subset.rfl hpi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
ho : OrthocentricSystem s
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
⊢ affineSpan ℝ (Set.range p) = affineSpan ℝ s
[PROOFSTEP]
have ha := ho.affineIndependent hps hpi
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
ho : OrthocentricSystem s
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
⊢ affineSpan ℝ (Set.range p) = affineSpan ℝ s
[PROOFSTEP]
rcases ho with ⟨t, _, hts⟩
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ affineSpan ℝ (Set.range p) = affineSpan ℝ s
[PROOFSTEP]
have hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points) := by
  rw [hts, affineSpan_insert_eq_affineSpan ℝ t.orthocenter_mem_affineSpan]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
[PROOFSTEP]
rw [hts, affineSpan_insert_eq_affineSpan ℝ t.orthocenter_mem_affineSpan]
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
⊢ affineSpan ℝ (Set.range p) = affineSpan ℝ s
[PROOFSTEP]
refine'
  ext_of_direction_eq _ ⟨p 0, mem_affineSpan ℝ (Set.mem_range_self _), mem_affineSpan ℝ (hps (Set.mem_range_self _))⟩
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
⊢ direction (affineSpan ℝ (Set.range p)) = direction (affineSpan ℝ s)
[PROOFSTEP]
have hfd : FiniteDimensional ℝ (affineSpan ℝ s).direction := by rw [hs]; infer_instance
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
⊢ FiniteDimensional ℝ { x // x ∈ direction (affineSpan ℝ s) }
[PROOFSTEP]
rw [hs]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
⊢ FiniteDimensional ℝ { x // x ∈ direction (affineSpan ℝ (Set.range t.points)) }
[PROOFSTEP]
infer_instance
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
hfd : FiniteDimensional ℝ { x // x ∈ direction (affineSpan ℝ s) }
⊢ direction (affineSpan ℝ (Set.range p)) = direction (affineSpan ℝ s)
[PROOFSTEP]
haveI := hfd
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
hfd this : FiniteDimensional ℝ { x // x ∈ direction (affineSpan ℝ s) }
⊢ direction (affineSpan ℝ (Set.range p)) = direction (affineSpan ℝ s)
[PROOFSTEP]
refine' eq_of_le_of_finrank_eq (direction_le (affineSpan_mono ℝ hps)) _
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
p : Fin 3 → P
hps : Set.range p ⊆ s
hpi : Function.Injective p
ha : AffineIndependent ℝ p
t : Triangle ℝ P
left✝ : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
hs : affineSpan ℝ s = affineSpan ℝ (Set.range t.points)
hfd this : FiniteDimensional ℝ { x // x ∈ direction (affineSpan ℝ s) }
⊢ finrank ℝ { x // x ∈ direction (affineSpan ℝ (Set.range p)) } = finrank ℝ { x // x ∈ direction (affineSpan ℝ s) }
[PROOFSTEP]
rw [hs, direction_affineSpan, direction_affineSpan, ha.finrank_vectorSpan (Fintype.card_fin _),
  t.Independent.finrank_vectorSpan (Fintype.card_fin _)]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
ho : OrthocentricSystem s
⊢ ∃ r, ∀ (t : Triangle ℝ P), Set.range t.points ⊆ s → Simplex.circumradius t = r
[PROOFSTEP]
rcases ho with ⟨t, hto, hts⟩
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ ∃ r, ∀ (t : Triangle ℝ P), Set.range t.points ⊆ s → Simplex.circumradius t = r
[PROOFSTEP]
use t.circumradius
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
⊢ ∀ (t_1 : Triangle ℝ P), Set.range t_1.points ⊆ s → Simplex.circumradius t_1 = Simplex.circumradius t
[PROOFSTEP]
intro t₂ ht₂
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ s
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
have ht₂s := ht₂
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ ht₂s : Set.range t₂.points ⊆ s
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
rw [hts] at ht₂
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
rcases exists_dist_eq_circumradius_of_subset_insert_orthocenter hto ht₂ t₂.Independent.injective with ⟨c, hc, h⟩
[GOAL]
case h.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t.points)
h : ∀ (p₁ : P), p₁ ∈ Set.range t₂.points → dist p₁ c = Simplex.circumradius t
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
rw [Set.forall_range_iff] at h
[GOAL]
case h.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t.points)
h : ∀ (i : Fin 3), dist (Simplex.points t₂ i) c = Simplex.circumradius t
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
have hs : Set.range t.points ⊆ s := by
  rw [hts]
  exact Set.subset_insert _ _
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t.points)
h : ∀ (i : Fin 3), dist (Simplex.points t₂ i) c = Simplex.circumradius t
⊢ Set.range t.points ⊆ s
[PROOFSTEP]
rw [hts]
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t.points)
h : ∀ (i : Fin 3), dist (Simplex.points t₂ i) c = Simplex.circumradius t
⊢ Set.range t.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
exact Set.subset_insert _ _
[GOAL]
case h.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t.points)
h : ∀ (i : Fin 3), dist (Simplex.points t₂ i) c = Simplex.circumradius t
hs : Set.range t.points ⊆ s
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
rw [affineSpan_of_orthocentricSystem ⟨t, hto, hts⟩ hs t.Independent.injective, ←
  affineSpan_of_orthocentricSystem ⟨t, hto, hts⟩ ht₂s t₂.Independent.injective] at hc
[GOAL]
case h.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
hto : ¬Triangle.orthocenter t ∈ Set.range t.points
hts : s = insert (Triangle.orthocenter t) (Set.range t.points)
t₂ : Triangle ℝ P
ht₂ : Set.range t₂.points ⊆ insert (Triangle.orthocenter t) (Set.range t.points)
ht₂s : Set.range t₂.points ⊆ s
c : P
hc : c ∈ affineSpan ℝ (Set.range t₂.points)
h : ∀ (i : Fin 3), dist (Simplex.points t₂ i) c = Simplex.circumradius t
hs : Set.range t.points ⊆ s
⊢ Simplex.circumradius t₂ = Simplex.circumradius t
[PROOFSTEP]
exact (t₂.eq_circumradius_of_dist_eq hc h).symm
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
ho : OrthocentricSystem s
t : Triangle ℝ P
ht : Set.range t.points ⊆ s
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
rcases ho with ⟨t₀, ht₀o, ht₀s⟩
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t : Triangle ℝ P
ht : Set.range t.points ⊆ s
t₀ : Triangle ℝ P
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
rw [ht₀s] at ht
[GOAL]
case intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
rcases exists_of_range_subset_orthocentricSystem ht₀o ht t.Independent.injective with
  (⟨i₁, i₂, i₃, j₂, j₃, h₁₂, h₁₃, h₂₃, h₁₂₃, h₁, hj₂₃, h₂, h₃⟩ | hs)
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
obtain ⟨j₁, hj₁₂, hj₁₃, hj₁₂₃⟩ : ∃ j₁ : Fin 3, j₁ ≠ j₂ ∧ j₁ ≠ j₃ ∧ ∀ j : Fin 3, j = j₁ ∨ j = j₂ ∨ j = j₃ :=
  by
  clear h₂ h₃
  fin_cases j₂ <;> fin_cases j₃ <;> simp at hj₂₃ ⊢
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
⊢ ∃ j₁, j₁ ≠ j₂ ∧ j₁ ≠ j₃ ∧ ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
[PROOFSTEP]
clear h₂ h₃
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
⊢ ∃ j₁, j₁ ≠ j₂ ∧ j₁ ≠ j₃ ∧ ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
[PROOFSTEP]
fin_cases j₂
[GOAL]
case head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ j₃
⊢ ∃ j₁,
    j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
      j₁ ≠ j₃ ∧ ∀ (j : Fin 3), j = j₁ ∨ j = { val := 0, isLt := (_ : 0 < 3) } ∨ j = j₃
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ j₃
⊢ ∃ j₁,
    j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
      j₁ ≠ j₃ ∧ ∀ (j : Fin 3), j = j₁ ∨ j = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨ j = j₃
[PROOFSTEP]
fin_cases j₃
[GOAL]
case tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ j₃
⊢ ∃ j₁,
    j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
      j₁ ≠ j₃ ∧ ∀ (j : Fin 3), j = j₁ ∨ j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨ j = j₃
[PROOFSTEP]
fin_cases j₃
[GOAL]
case head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ j₁,
    j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
      j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
        ∀ (j : Fin 3), j = j₁ ∨ j = { val := 0, isLt := (_ : 0 < 3) } ∨ j = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ j₁,
    j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
      j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨ j = { val := 0, isLt := (_ : 0 < 3) } ∨ j = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 0, isLt := (_ : 0 < 3) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ j₁,
    j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
      j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 0, isLt := (_ : 0 < 3) } ∨ j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ j₁,
    j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
      j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨ j = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨ j = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ j₁,
    j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
      j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨ j = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 1, isLt := (_ : (fun a => a < 3) 1) } ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ j₁,
    j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
      j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∨
              j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.tail.head.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 0, isLt := (_ : 0 < 3) }
⊢ ∃ j₁,
    j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
      j₁ ≠ { val := 0, isLt := (_ : 0 < 3) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨ j = { val := 0, isLt := (_ : 0 < 3) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) }
⊢ ∃ j₁,
    j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
      j₁ ≠ { val := 1, isLt := (_ : (fun a => a < 3) 1) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
              j = { val := 1, isLt := (_ : (fun a => a < 3) 1) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case tail.tail.head.tail.tail.head
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ :
  { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ≠
    { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
⊢ ∃ j₁,
    j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
      j₁ ≠ { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∧
        ∀ (j : Fin 3),
          j = j₁ ∨
            j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) } ∨
              j = { val := 2, isLt := (_ : (fun a => (fun a => a < 3) a) 2) }
[PROOFSTEP]
simp at hj₂₃ ⊢
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
suffices h : t₀.points j₁ = t.orthocenter
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
have hui : (Set.univ : Set (Fin 3)) = { i₁, i₂, i₃ } := by ext x; simpa using h₁₂₃ x
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
⊢ Set.univ = {i₁, i₂, i₃}
[PROOFSTEP]
ext x
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
x : Fin 3
⊢ x ∈ Set.univ ↔ x ∈ {i₁, i₂, i₃}
[PROOFSTEP]
simpa using h₁₂₃ x
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
have huj : (Set.univ : Set (Fin 3)) = { j₁, j₂, j₃ } := by ext x; simpa using hj₁₂₃ x
[GOAL]
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
⊢ Set.univ = {j₁, j₂, j₃}
[PROOFSTEP]
ext x
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
x : Fin 3
⊢ x ∈ Set.univ ↔ x ∈ {j₁, j₂, j₃}
[PROOFSTEP]
simpa using hj₁₂₃ x
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
huj : Set.univ = {j₁, j₂, j₃}
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
rw [← h, ht₀s, ← Set.image_univ, huj, ← Set.image_univ, hui]
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
huj : Set.univ = {j₁, j₂, j₃}
⊢ insert (Triangle.orthocenter t₀) (t₀.points '' {j₁, j₂, j₃}) =
    insert (Simplex.points t₀ j₁) (t.points '' {i₁, i₂, i₃})
[PROOFSTEP]
simp_rw [Set.image_insert_eq, Set.image_singleton, h₁, ← h₂, ← h₃]
[GOAL]
case intro.intro.inl.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
h : Simplex.points t₀ j₁ = Triangle.orthocenter t
hui : Set.univ = {i₁, i₂, i₃}
huj : Set.univ = {j₁, j₂, j₃}
⊢ {Triangle.orthocenter t₀, Simplex.points t₀ j₁, Simplex.points t₀ j₂, Simplex.points t₀ j₃} =
    {Simplex.points t₀ j₁, Triangle.orthocenter t₀, Simplex.points t₀ j₂, Simplex.points t₀ j₃}
[PROOFSTEP]
rw [Set.insert_comm]
[GOAL]
case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
i₁ i₂ i₃ j₂ j₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁₂₃ : ∀ (i : Fin 3), i = i₁ ∨ i = i₂ ∨ i = i₃
h₁ : Simplex.points t i₁ = Triangle.orthocenter t₀
hj₂₃ : j₂ ≠ j₃
h₂ : Simplex.points t₀ j₂ = Simplex.points t i₂
h₃ : Simplex.points t₀ j₃ = Simplex.points t i₃
j₁ : Fin 3
hj₁₂ : j₁ ≠ j₂
hj₁₃ : j₁ ≠ j₃
hj₁₂₃ : ∀ (j : Fin 3), j = j₁ ∨ j = j₂ ∨ j = j₃
⊢ Simplex.points t₀ j₁ = Triangle.orthocenter t
[PROOFSTEP]
exact (Triangle.orthocenter_replace_orthocenter_eq_point hj₁₂ hj₁₃ hj₂₃ h₁₂ h₁₃ h₂₃ h₁ h₂.symm h₃.symm).symm
[GOAL]
case intro.intro.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
hs : Set.range t.points = Set.range t₀.points
⊢ s = insert (Triangle.orthocenter t) (Set.range t.points)
[PROOFSTEP]
rw [hs]
[GOAL]
case intro.intro.inr
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
hs : Set.range t.points = Set.range t₀.points
⊢ s = insert (Triangle.orthocenter t) (Set.range t₀.points)
[PROOFSTEP]
convert ht₀s using 2
[GOAL]
case h.e'_3.h.e'_4
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Set P
t t₀ : Triangle ℝ P
ht : Set.range t.points ⊆ insert (Triangle.orthocenter t₀) (Set.range t₀.points)
ht₀o : ¬Triangle.orthocenter t₀ ∈ Set.range t₀.points
ht₀s : s = insert (Triangle.orthocenter t₀) (Set.range t₀.points)
hs : Set.range t.points = Set.range t₀.points
⊢ Triangle.orthocenter t = Triangle.orthocenter t₀
[PROOFSTEP]
exact Triangle.orthocenter_eq_of_range_eq hs