l3lab/ntp-mathlib huggingface dataset:
theorem nat (n : ℕ) (x y : E) : inner_ 𝕜 ((n : 𝕜) • x) y = (n : 𝕜) * inner_ 𝕜 x y := by
  induction' n with n ih
  · simp only [inner_, Nat.zero_eq, zero_sub, Nat.cast_zero, zero_mul,
      eq_self_iff_true, zero_smul, zero_add, mul_zero, sub_self, norm_neg, smul_zero]
  · simp only [Nat.cast_succ, add_smul, one_smul]
    

Proof state:
case succ
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
n : ℕ
ih : inner_ 𝕜 (↑n • x) y = ↑n * inner_ 𝕜 x y
⊢ inner_ 𝕜 (↑n • x + x) y = (↑n + 1) * inner_ 𝕜 x y

Next tactic:
rw [add_left, ih, add_mul, one_mul]
private theorem nat_prop (r : ℕ) : innerProp' E (r : 𝕜) := fun x y => by
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℕ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
simp only [map_natCast]
private theorem nat_prop (r : ℕ) : innerProp' E (r : 𝕜) := fun x y => by
  simp only [map_natCast]; 

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℕ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = ↑r * inner_ 𝕜 x y

Next tactic:
exact nat r x y
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
⊢ InnerProductSpaceable.innerProp' E ↑n

Next tactic:
intro x y
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
⊢ inner_ 𝕜 (↑n • x) y = (starRingEnd 𝕜) ↑n * inner_ 𝕜 x y

Next tactic:
rw [← n.sign_mul_natAbs]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
⊢ inner_ 𝕜 (↑(Int.sign n * ↑(Int.natAbs n)) • x) y = (starRingEnd 𝕜) ↑(Int.sign n * ↑(Int.natAbs n)) * inner_ 𝕜 x y

Next tactic:
simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
⊢ inner_ 𝕜 (↑(Int.sign n) • ↑(Int.natAbs n) • x) y = ↑(Int.sign n) * ↑(Int.natAbs n) * inner_ 𝕜 x y

Next tactic:
obtain hn | rfl | hn := lt_trichotomy n 0
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  obtain hn | rfl | hn := lt_trichotomy n 0
  · 

Proof state:
case inl
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
hn : n < 0
⊢ inner_ 𝕜 (↑(Int.sign n) • ↑(Int.natAbs n) • x) y = ↑(Int.sign n) * ↑(Int.natAbs n) * inner_ 𝕜 x y

Next tactic:
rw [Int.sign_eq_neg_one_of_neg hn, innerProp_neg_one ((n.natAbs : 𝕜) • x), nat]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  obtain hn | rfl | hn := lt_trichotomy n 0
  · rw [Int.sign_eq_neg_one_of_neg hn, innerProp_neg_one ((n.natAbs : 𝕜) • x), nat]
    

Proof state:
case inl
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
hn : n < 0
⊢ (starRingEnd 𝕜) ↑(-1) * (↑(Int.natAbs n) * inner_ 𝕜 x y) = ↑(-1) * ↑(Int.natAbs n) * inner_ 𝕜 x y

Next tactic:
simp only [map_neg, neg_mul, one_mul, mul_eq_mul_left_iff, true_or_iff, Int.natAbs_eq_zero,
      eq_self_iff_true, Int.cast_one, map_one, neg_inj, Nat.cast_eq_zero, Int.cast_neg]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  obtain hn | rfl | hn := lt_trichotomy n 0
  · rw [Int.sign_eq_neg_one_of_neg hn, innerProp_neg_one ((n.natAbs : 𝕜) • x), nat]
    simp only [map_neg, neg_mul, one_mul, mul_eq_mul_left_iff, true_or_iff, Int.natAbs_eq_zero,
      eq_self_iff_true, Int.cast_one, map_one, neg_inj, Nat.cast_eq_zero, Int.cast_neg]
  · 

Proof state:
case inr.inl
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ inner_ 𝕜 (↑(Int.sign 0) • ↑(Int.natAbs 0) • x) y = ↑(Int.sign 0) * ↑(Int.natAbs 0) * inner_ 𝕜 x y

Next tactic:
simp only [inner_, Int.cast_zero, zero_sub, Nat.cast_zero, zero_mul,
      eq_self_iff_true, Int.sign_zero, zero_smul, zero_add, mul_zero, smul_zero,
      sub_self, norm_neg, Int.natAbs_zero]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  obtain hn | rfl | hn := lt_trichotomy n 0
  · rw [Int.sign_eq_neg_one_of_neg hn, innerProp_neg_one ((n.natAbs : 𝕜) • x), nat]
    simp only [map_neg, neg_mul, one_mul, mul_eq_mul_left_iff, true_or_iff, Int.natAbs_eq_zero,
      eq_self_iff_true, Int.cast_one, map_one, neg_inj, Nat.cast_eq_zero, Int.cast_neg]
  · simp only [inner_, Int.cast_zero, zero_sub, Nat.cast_zero, zero_mul,
      eq_self_iff_true, Int.sign_zero, zero_smul, zero_add, mul_zero, smul_zero,
      sub_self, norm_neg, Int.natAbs_zero]
  · 

Proof state:
case inr.inr
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
hn : 0 < n
⊢ inner_ 𝕜 (↑(Int.sign n) • ↑(Int.natAbs n) • x) y = ↑(Int.sign n) * ↑(Int.natAbs n) * inner_ 𝕜 x y

Next tactic:
rw [Int.sign_eq_one_of_pos hn]
private theorem int_prop (n : ℤ) : innerProp' E (n : 𝕜) := by
  intro x y
  rw [← n.sign_mul_natAbs]
  simp only [Int.cast_ofNat, map_natCast, map_intCast, Int.cast_mul, map_mul, mul_smul]
  obtain hn | rfl | hn := lt_trichotomy n 0
  · rw [Int.sign_eq_neg_one_of_neg hn, innerProp_neg_one ((n.natAbs : 𝕜) • x), nat]
    simp only [map_neg, neg_mul, one_mul, mul_eq_mul_left_iff, true_or_iff, Int.natAbs_eq_zero,
      eq_self_iff_true, Int.cast_one, map_one, neg_inj, Nat.cast_eq_zero, Int.cast_neg]
  · simp only [inner_, Int.cast_zero, zero_sub, Nat.cast_zero, zero_mul,
      eq_self_iff_true, Int.sign_zero, zero_smul, zero_add, mul_zero, smul_zero,
      sub_self, norm_neg, Int.natAbs_zero]
  · rw [Int.sign_eq_one_of_pos hn]
    

Proof state:
case inr.inr
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
n : ℤ
x y : E
hn : 0 < n
⊢ inner_ 𝕜 (↑1 • ↑(Int.natAbs n) • x) y = ↑1 * ↑(Int.natAbs n) * inner_ 𝕜 x y

Next tactic:
simp only [one_mul, mul_eq_mul_left_iff, true_or_iff, Int.natAbs_eq_zero, eq_self_iff_true,
      Int.cast_one, one_smul, Nat.cast_eq_zero, nat]
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
⊢ InnerProductSpaceable.innerProp' E ↑r

Next tactic:
intro x y
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
have : (r.den : 𝕜) ≠ 0 := by
    haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
    exact mod_cast r.pos.ne'
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  have : (r.den : 𝕜) ≠ 0 := by
    

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
⊢ ↑r.den ≠ 0

Next tactic:
haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  have : (r.den : 𝕜) ≠ 0 := by
    haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
    

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
this : CharZero 𝕜
⊢ ↑r.den ≠ 0

Next tactic:
exact mod_cast r.pos.ne'
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  have : (r.den : 𝕜) ≠ 0 := by
    haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
    exact mod_cast r.pos.ne'
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
this : ↑r.den ≠ 0
⊢ inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
rw [← r.num_div_den, ← mul_right_inj' this, ← nat r.den _ y, smul_smul, Rat.cast_div]
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  have : (r.den : 𝕜) ≠ 0 := by
    haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
    exact mod_cast r.pos.ne'
  rw [← r.num_div_den, ← mul_right_inj' this, ← nat r.den _ y, smul_smul, Rat.cast_div]
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
this : ↑r.den ≠ 0
⊢ inner_ 𝕜 ((↑r.den * (↑↑r.num / ↑↑r.den)) • x) y = ↑r.den * ((starRingEnd 𝕜) (↑↑r.num / ↑↑r.den) * inner_ 𝕜 x y)

Next tactic:
simp only [map_natCast, Rat.cast_coe_nat, map_intCast, Rat.cast_coe_int, map_div₀]
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜) := by
  intro x y
  have : (r.den : 𝕜) ≠ 0 := by
    haveI : CharZero 𝕜 := IsROrC.charZero_isROrC
    exact mod_cast r.pos.ne'
  rw [← r.num_div_den, ← mul_right_inj' this, ← nat r.den _ y, smul_smul, Rat.cast_div]
  simp only [map_natCast, Rat.cast_coe_nat, map_intCast, Rat.cast_coe_int, map_div₀]
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℚ
x y : E
this : ↑r.den ≠ 0
⊢ inner_ 𝕜 ((↑r.den * (↑r.num / ↑r.den)) • x) y = ↑r.den * (↑r.num / ↑r.den * inner_ 𝕜 x y)

Next tactic:
rw [← mul_assoc, mul_div_cancel' _ this, int_prop _ x, map_intCast]
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℝ
⊢ InnerProductSpaceable.innerProp' E ↑r

Next tactic:
intro x y
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℝ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
revert r
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  revert r
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ ∀ (r : ℝ), inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
rw [← Function.funext_iff]
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  revert r
  rw [← Function.funext_iff]
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ (fun r => inner_ 𝕜 (↑r • x) y) = fun r => (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
refine' Rat.denseEmbedding_coe_real.dense.equalizer _ _ (funext fun X => _)
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  revert r
  rw [← Function.funext_iff]
  refine' Rat.denseEmbedding_coe_real.dense.equalizer _ _ (funext fun X => _)
  · 

Proof state:
case refine'_1
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ Continuous fun r => inner_ 𝕜 (↑r • x) y

Next tactic:
exact (continuous_ofReal.smul continuous_const).inner_ continuous_const
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  revert r
  rw [← Function.funext_iff]
  refine' Rat.denseEmbedding_coe_real.dense.equalizer _ _ (funext fun X => _)
  · exact (continuous_ofReal.smul continuous_const).inner_ continuous_const
  · 

Proof state:
case refine'_2
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
⊢ Continuous fun r => (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y

Next tactic:
exact (continuous_conj.comp continuous_ofReal).mul continuous_const
private theorem real_prop (r : ℝ) : innerProp' E (r : 𝕜) := by
  intro x y
  revert r
  rw [← Function.funext_iff]
  refine' Rat.denseEmbedding_coe_real.dense.equalizer _ _ (funext fun X => _)
  · exact (continuous_ofReal.smul continuous_const).inner_ continuous_const
  · exact (continuous_conj.comp continuous_ofReal).mul continuous_const
  · 

Proof state:
case refine'_3
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
x y : E
X : ℚ
⊢ ((fun r => inner_ 𝕜 (↑r • x) y) ∘ Rat.cast) X = ((fun r => (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y) ∘ Rat.cast) X

Next tactic:
simp only [Function.comp_apply, IsROrC.ofReal_ratCast, rat_prop _ _]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
⊢ InnerProductSpaceable.innerProp' E I

Next tactic:
by_cases hI : (I : 𝕜) = 0
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · 

Proof state:
case pos
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : I = 0
⊢ InnerProductSpaceable.innerProp' E I

Next tactic:
rw [hI, ← Nat.cast_zero]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; 

Proof state:
case pos
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : I = 0
⊢ InnerProductSpaceable.innerProp' E ↑0

Next tactic:
exact nat_prop _
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  

Proof state:
case neg
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
⊢ InnerProductSpaceable.innerProp' E I

Next tactic:
intro x y
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  

Proof state:
case neg
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
⊢ inner_ 𝕜 (I • x) y = (starRingEnd 𝕜) I * inner_ 𝕜 x y

Next tactic:
have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by 

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
⊢ -I * I = 1

Next tactic:
rw [← inv_I, inv_mul_cancel hI]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  

Proof state:
case neg
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ inner_ 𝕜 (I • x) y = (starRingEnd 𝕜) I * inner_ 𝕜 x y

Next tactic:
rw [conj_I, inner_, inner_, mul_left_comm]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  

Proof state:
case neg
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ 4⁻¹ *
      (𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖I • I • x + y‖ * 𝓚 ‖I • I • x + y‖ -
        I * 𝓚 ‖I • I • x - y‖ * 𝓚 ‖I • I • x - y‖) =
    4⁻¹ *
      (-I *
        (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖ - 𝓚 ‖x - y‖ * 𝓚 ‖x - y‖ + I * 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
          I * 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖))

Next tactic:
congr 1
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  

Proof state:
case neg.e_a
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖I • I • x + y‖ * 𝓚 ‖I • I • x + y‖ -
      I * 𝓚 ‖I • I • x - y‖ * 𝓚 ‖I • I • x - y‖ =
    -I *
      (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖ - 𝓚 ‖x - y‖ * 𝓚 ‖x - y‖ + I * 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
        I * 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖)

Next tactic:
rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  

Proof state:
case neg.e_a
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
      I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖ =
    -I *
      (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖ - 𝓚 ‖x - y‖ * 𝓚 ‖x - y‖ + I * 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
        I * 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖)

Next tactic:
rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
  

Proof state:
case neg.e_a
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
      I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖ =
    -I * (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖) - -I * (𝓚 ‖x - y‖ * 𝓚 ‖x - y‖) + 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
      𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖

Next tactic:
have h₁ : ‖-x - y‖ = ‖x + y‖ := by rw [← neg_add', norm_neg]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
  have h₁ : ‖-x - y‖ = ‖x + y‖ := by 

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
⊢ ‖-x - y‖ = ‖x + y‖

Next tactic:
rw [← neg_add', norm_neg]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
  have h₁ : ‖-x - y‖ = ‖x + y‖ := by rw [← neg_add', norm_neg]
  

Proof state:
case neg.e_a
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
h₁ : ‖-x - y‖ = ‖x + y‖
⊢ 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
      I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖ =
    -I * (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖) - -I * (𝓚 ‖x - y‖ * 𝓚 ‖x - y‖) + 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
      𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖

Next tactic:
have h₂ : ‖-x + y‖ = ‖x - y‖ := by rw [← neg_sub, norm_neg, sub_eq_neg_add]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
  have h₁ : ‖-x - y‖ = ‖x + y‖ := by rw [← neg_add', norm_neg]
  have h₂ : ‖-x + y‖ = ‖x - y‖ := by 

Proof state:
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
h₁ : ‖-x - y‖ = ‖x + y‖
⊢ ‖-x + y‖ = ‖x - y‖

Next tactic:
rw [← neg_sub, norm_neg, sub_eq_neg_add]
private theorem I_prop : innerProp' E (I : 𝕜) := by
  by_cases hI : (I : 𝕜) = 0
  · rw [hI, ← Nat.cast_zero]; exact nat_prop _
  intro x y
  have hI' : (-I : 𝕜) * I = 1 := by rw [← inv_I, inv_mul_cancel hI]
  rw [conj_I, inner_, inner_, mul_left_comm]
  congr 1
  rw [smul_smul, I_mul_I_of_nonzero hI, neg_one_smul]
  rw [mul_sub, mul_add, mul_sub, mul_assoc I (𝓚 ‖I • x - y‖), ← mul_assoc (-I) I, hI', one_mul,
    mul_assoc I (𝓚 ‖I • x + y‖), ← mul_assoc (-I) I, hI', one_mul]
  have h₁ : ‖-x - y‖ = ‖x + y‖ := by rw [← neg_add', norm_neg]
  have h₂ : ‖-x + y‖ = ‖x - y‖ := by rw [← neg_sub, norm_neg, sub_eq_neg_add]
  

Proof state:
case neg.e_a
𝕜 : Type u_1
inst✝³ : IsROrC 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
hI : ¬I = 0
x y : E
hI' : -I * I = 1
h₁ : ‖-x - y‖ = ‖x + y‖
h₂ : ‖-x + y‖ = ‖x - y‖
⊢ 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ - 𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖ + I * 𝓚 ‖-x + y‖ * 𝓚 ‖-x + y‖ -
      I * 𝓚 ‖-x - y‖ * 𝓚 ‖-x - y‖ =
    -I * (𝓚 ‖x + y‖ * 𝓚 ‖x + y‖) - -I * (𝓚 ‖x - y‖ * 𝓚 ‖x - y‖) + 𝓚 ‖I • x + y‖ * 𝓚 ‖I • x + y‖ -
      𝓚 ‖I • x - y‖ * 𝓚 ‖I • x - y‖

Next tactic:
rw [h₁, h₂]