-- Mathlib/Geometry/Euclidean/MongePoint.lean
theorem inner_mongePoint_vsub_face_centroid_vsub {n : ℕ} (s : Simplex ℝ P (n + 2))
    {i₁ i₂ : Fin (n + 3)} :
    ⟪s.mongePoint -ᵥ ({i₁, i₂}ᶜ : Finset (Fin (n + 3))).centroid ℝ s.points,
        s.points i₁ -ᵥ s.points i₂⟫ =
      0

Proof state:
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₂

Tactic:
intro hj

Result:
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

Proof state:
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 ∉ 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 (s.points i₁) (s.points i₁) * dist (s.points i₁) (s.points i₁)) +
                (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                  (dist (s.points i₁) (s.points i₂) * dist (s.points i₁) (s.points i₂)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (s.points i₁) s.circumcenter * dist (s.points i₁) s.circumcenter) +
            ((if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                  (dist (s.points i₂) (s.points i₁) * dist (s.points i₂) (s.points i₁)) +
                (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                  (dist (s.points i₂) (s.points i₂) * dist (s.points i₂) (s.points i₂)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (s.points i₂) s.circumcenter * dist (s.points i₂) s.circumcenter)) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist s.circumcenter (s.points i₁) * dist s.circumcenter (s.points i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist s.circumcenter (s.points i₂) * dist s.circumcenter (s.points i₂)) +
            -2 / ↑(n + 1) * (0 - 0) * (dist s.circumcenter s.circumcenter * dist s.circumcenter s.circumcenter))) /
      2 =
    0

Tactic:
simp [h, Ne.symm h, dist_comm (s.points i₁)]

Result:
no goals

Proof state:
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 (s.mongePoint -ᵥ centroid ℝ {i₁, i₂}ᶜ s.points) (s.points i₁ -ᵥ s.points i₂) = 0

Tactic:
simp_rw [mongePoint_vsub_face_centroid_eq_weightedVSub_of_pointsWithCircumcenter s h,
  point_eq_affineCombination_of_pointsWithCircumcenter, affineCombination_vsub]

Result:
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 ((univ.weightedVSub s.pointsWithCircumcenter) (mongePointVSubFaceCentroidWeightsWithCircumcenter i₁ i₂))
      ((univ.weightedVSub s.pointsWithCircumcenter)
        (pointWeightsWithCircumcenter i₁ - pointWeightsWithCircumcenter i₂)) =
    0

Proof state:
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 ∉ fs, i ≠ i₁ ∧ i ≠ i₂
⊢ -(∑ x ∈ fs,
            (∑ 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 (s.points x) (s.points x_1) * dist (s.points x) (s.points x_1)) +
              (if x = i₁ ∨ x = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (s.points x) s.circumcenter * dist (s.points x) s.circumcenter)) +
          (∑ x ∈ fs,
              -2 / ↑(n + 1) * ((if x = i₁ then 1 else 0) - if x = i₂ then 1 else 0) *
                (dist s.circumcenter (s.points x) * dist s.circumcenter (s.points x)) +
            -2 / ↑(n + 1) * (0 - 0) * (dist s.circumcenter s.circumcenter * dist s.circumcenter s.circumcenter))) /
      2 =
    0

Tactic:
simp_rw [fs, sum_insert (not_mem_singleton.2 h), sum_singleton]

Result:
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 ∉ 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 (s.points i₁) (s.points x) * dist (s.points i₁) (s.points x)) +
              (if True ∨ i₁ = i₂ then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (s.points i₁) s.circumcenter * dist (s.points i₁) s.circumcenter) +
            (∑ 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 (s.points i₂) (s.points x) * dist (s.points i₂) (s.points x)) +
              (if i₂ = i₁ ∨ True then (↑(n + 1))⁻¹ else 0) * (0 - 0) *
                (dist (s.points i₂) s.circumcenter * dist (s.points i₂) s.circumcenter)) +
          (-2 / ↑(n + 1) * ((if True then 1 else 0) - if i₁ = i₂ then 1 else 0) *
                (dist s.circumcenter (s.points i₁) * dist s.circumcenter (s.points i₁)) +
              -2 / ↑(n + 1) * ((if i₂ = i₁ then 1 else 0) - if True then 1 else 0) *
                (dist s.circumcenter (s.points i₂) * dist s.circumcenter (s.points i₂)) +
            -2 / ↑(n + 1) * (0 - 0) * (dist s.circumcenter s.circumcenter * dist s.circumcenter s.circumcenter))) /
      2 =
    0