zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_38 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} (hA : ¬A = 0)
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) :
  let normA := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖;
  (∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖) →
    0 < normA →
      ∀ (y : EuclideanSpace ℝ (Fin ↑n)),
        ‖x - y‖ ≤ ε / normA ^ 2 →
          ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x) →
            (∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)) →
              normA * ‖x - y‖ * normA * ‖x - y‖ ≤ ε * ‖x - y‖ → 0 ≤ ‖x - y‖ := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
hA : ¬A = 0
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
normA : ℝ := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖
norm_mul : ∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖
normApos : 0 < normA
y : EuclideanSpace ℝ (Fin ↑n)
ydist : ‖x - y‖ ≤ ε / normA ^ 2
aux1 : ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x)
aux2 : ∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)
⊢ normA * ‖x - y‖ * normA * ‖x - y‖ ≤ ε * ‖x - y‖

Tactic:
apply mul_le_mul_of_nonneg_right

Tactic state after:
[case h
 n m : ℕ+
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 hA : ¬A = 0
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 normA : ℝ := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖
 norm_mul : ∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖
 normApos : 0 < normA
 y : EuclideanSpace ℝ (Fin ↑n)
 ydist : ‖x - y‖ ≤ ε / normA ^ 2
 aux1 : ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x)
 aux2 : ∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)
 ⊢ normA * ‖x - y‖ * normA ≤ ε,
 case a0
 n m : ℕ+
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 hA : ¬A = 0
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 normA : ℝ := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖
 norm_mul : ∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖
 normApos : 0 < normA
 y : EuclideanSpace ℝ (Fin ↑n)
 ydist : ‖x - y‖ ≤ ε / normA ^ 2
 aux1 : ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x)
 aux2 : ∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)
 ⊢ 0 ≤ ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_39 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} (hA : ¬A = 0)
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) :
  let normA := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖;
  (∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖) →
    0 < normA →
      ∀ (y : EuclideanSpace ℝ (Fin ↑n)),
        ‖x - y‖ ≤ ε / normA ^ 2 →
          ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x) →
            (∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)) → 0 ≤ ‖x - y‖ := sorry

Tactic state before:
case a0
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
hA : ¬A = 0
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
normA : ℝ := ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) A‖
norm_mul : ∀ (x : EuclideanSpace ℝ (Fin ↑n)), ‖A *ᵥ x‖ ≤ normA * ‖x‖
normApos : 0 < normA
y : EuclideanSpace ℝ (Fin ↑n)
ydist : ‖x - y‖ ≤ ε / normA ^ 2
aux1 : ((fun x_1 => y x_1 - x x_1) ⬝ᵥ fun x_1 => ((Aᵀ * A) *ᵥ x) x_1) = (Aᵀ * A) *ᵥ x ⬝ᵥ (y - x)
aux2 : ∀ (u v : Fin ↑m → ℝ), u ⬝ᵥ u + (v ⬝ᵥ v - v ⬝ᵥ u * 2) = (u - v) ⬝ᵥ (u - v)
⊢ 0 ≤ ‖x - y‖

Tactic:
apply norm_nonneg

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_40 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (h_original_goal : HasGradientAt (fun x => b ⬝ᵥ A *ᵥ x) (Aᵀ *ᵥ b) x) (ε : ℝ) :
  ε > 0 →
    ∃ δ > 0,
      ∀ (x' : EuclideanSpace ℝ (Fin ↑n)),
        ‖x - x'‖ ≤ δ → ‖b ⬝ᵥ A *ᵥ x' - b ⬝ᵥ A *ᵥ x - inner (Aᵀ *ᵥ b) (x' - x)‖ ≤ ε * ‖x - x'‖ := sorry

Tactic state before:
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
⊢ HasGradientAt (fun x => b ⬝ᵥ A *ᵥ x) (Aᵀ *ᵥ b) x

Tactic:
rw [HasGradient_iff_Convergence_Point]

Tactic state after:
[n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ⊢ ∀ ε > 0,
     ∃ δ > 0,
       ∀ (x' : EuclideanSpace ℝ (Fin ↑n)),
         ‖x - x'‖ ≤ δ → ‖b ⬝ᵥ A *ᵥ x' - b ⬝ᵥ A *ᵥ x - inner (Aᵀ *ᵥ b) (x' - x)‖ ≤ ε * ‖x - x'‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_41 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal : ‖b ⬝ᵥ A *ᵥ y - b ⬝ᵥ A *ᵥ x - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖) :
  ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ ‖b ⬝ᵥ A *ᵥ y - b ⬝ᵥ A *ᵥ x - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖

Tactic:
rw [dot_mul_eq_transpose_mul_dot, dot_mul_eq_transpose_mul_dot, ← dotProduct_sub]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_42 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal : ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖) :
  ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - (WithLp.equiv 2 (Fin ↑n → ℝ)) (y - x) ⬝ᵥ star ((WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))‖ ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - inner (Aᵀ *ᵥ b) (y - x)‖ ≤ ε * ‖x - y‖

Tactic:
rw [EuclideanSpace.inner_eq_star_dotProduct]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - (WithLp.equiv 2 (Fin ↑n → ℝ)) (y - x) ⬝ᵥ star ((WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))‖ ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_43 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - (WithLp.equiv 2 (Fin ↑n → ℝ)) (y - x) ⬝ᵥ star ((WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))‖ ≤
      ε * ‖x - y‖) :
  |Aᵀ *ᵥ b ⬝ᵥ y - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ ‖Aᵀ *ᵥ b ⬝ᵥ (y - x) - (WithLp.equiv 2 (Fin ↑n → ℝ)) (y - x) ⬝ᵥ star ((WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))‖ ≤
    ε * ‖x - y‖

Tactic:
simp

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |Aᵀ *ᵥ b ⬝ᵥ y - Aᵀ *ᵥ b ⬝ᵥ x -
         ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_44 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |Aᵀ *ᵥ b ⬝ᵥ y - Aᵀ *ᵥ b ⬝ᵥ x -
          ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |∑ i, (Aᵀ *ᵥ b) i * y i - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |Aᵀ *ᵥ b ⬝ᵥ y - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
rw [dotProduct]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ i, (Aᵀ *ᵥ b) i * y i - Aᵀ *ᵥ b ⬝ᵥ x -
         ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_45 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ x, y x * (Aᵀ *ᵥ b) x - Aᵀ *ᵥ b ⬝ᵥ x -
          ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ i, (Aᵀ *ᵥ b) i * x i -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
rw [dotProduct]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ i, (Aᵀ *ᵥ b) i * x i -
         ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_46 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
          ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
        (∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) y i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
rw [dotProduct]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
         (∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) y i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_47 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |(WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
      ε * ‖x - y‖) :
  |∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) x i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |(WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
    ε * ‖x - y‖

Tactic:
rw [dotProduct]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) x i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_48 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ i, (Aᵀ *ᵥ b) i * y i - Aᵀ *ᵥ b ⬝ᵥ x -
          ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |∑ x, y x * (Aᵀ *ᵥ b) x - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ i, (Aᵀ *ᵥ b) i * y i - Aᵀ *ᵥ b ⬝ᵥ x -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
simp [mul_comm]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - Aᵀ *ᵥ b ⬝ᵥ x -
         ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_49 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ i, (Aᵀ *ᵥ b) i * x i -
          ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ i, (Aᵀ *ᵥ b) i * x i -
        ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
simp [mul_comm]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
         ((WithLp.equiv 2 (Fin ↑n → ℝ)) y ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) -
           (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_50 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
          (∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) y i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i -
            (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
      ε * ‖x - y‖) :
  |(WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
    ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ x, y x * (Aᵀ *ᵥ b) x - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1 -
        (∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) y i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i -
          (WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b))| ≤
    ε * ‖x - y‖

Tactic:
simp [mul_comm]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ |(WithLp.equiv 2 (Fin ↑n → ℝ)) x ⬝ᵥ (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
     ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_51 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal :
    |∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) x i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i -
          ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
      ε * ‖x - y‖) :
  0 ≤ ε * ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ |∑ i, (WithLp.equiv 2 (Fin ↑n → ℝ)) x i * (WithLp.equiv 2 (Fin ↑n → ℝ)) (Aᵀ *ᵥ b) i - ∑ x_1, x x_1 * (Aᵀ *ᵥ b) x_1| ≤
    ε * ‖x - y‖

Tactic:
simp [mul_comm]

Tactic state after:
[case right
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ 0 ≤ ε * ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_52 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal : 0 ≤ ε * ‖x - y‖) : 0 ≤ ε := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ 0 ≤ ε * ‖x - y‖

Tactic:
apply mul_nonneg

Tactic state after:
[case right.ha
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ 0 ≤ ε,
 case right.hb
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ 0 ≤ ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_53 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε)
  (h_original_goal : 0 ≤ ε * ‖x - y‖) : 0 ≤ ‖x - y‖ := sorry

Tactic state before:
case right
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ 0 ≤ ε * ‖x - y‖

Tactic:
apply mul_nonneg

Tactic state after:
[case right.ha
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ 0 ≤ ε,
 case right.hb
 n m : ℕ+
 b : Fin ↑m → ℝ
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 x : EuclideanSpace ℝ (Fin ↑n)
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 a✝ : ‖x - y‖ ≤ ε
 ⊢ 0 ≤ ‖x - y‖]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_54 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (a : ‖x - y‖ ≤ ε) :
  0 ≤ ‖x - y‖ := sorry

Tactic state before:
case right.hb
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x : EuclideanSpace ℝ (Fin ↑n)
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
a✝ : ‖x - y‖ ≤ ε
⊢ 0 ≤ ‖x - y‖

Tactic:
apply norm_nonneg

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_55 {n m : ℕ+} {b : Fin ↑m → ℝ} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ}
  (x : EuclideanSpace ℝ (Fin ↑n)) : Aᵀ *ᵥ A *ᵥ x = (1 / 2) • 2 • Aᵀ *ᵥ A *ᵥ x := sorry

Tactic state before:
n m : ℕ+
b : Fin ↑m → ℝ
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
x✝ : EuclideanSpace ℝ (Fin ↑n)
f : EuclideanSpace ℝ (Fin ↑n) → ℝ := fun x => 1 / 2 * A *ᵥ x ⬝ᵥ A *ᵥ x
f' : EuclideanSpace ℝ (Fin ↑n) → Fin ↑n → ℝ := fun x => Aᵀ *ᵥ A *ᵥ x
g : EuclideanSpace ℝ (Fin ↑n) → Fin ↑n → ℝ := fun x => (1 / 2) • 2 • Aᵀ *ᵥ A *ᵥ x
x : EuclideanSpace ℝ (Fin ↑n)
⊢ Aᵀ *ᵥ A *ᵥ x = (1 / 2) • 2 • Aᵀ *ᵥ A *ᵥ x

Tactic:
simp

Tactic state after: