l3lab/ntp-mathlib huggingface dataset:
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · 

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
⊢ j ∉ univ → (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j = 0

Next tactic:
intros
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
a✝ : j ∉ univ
⊢ (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j = 0

Next tactic:
have := Finset.mem_univ j
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
a✝ : j ∉ univ
this : j ∈ univ
⊢ (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j = 0

Next tactic:
contradiction
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · 

Proof state:
case h₀
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
⊢ ∀ b ∈ univ,
    b ≠ i →
      ∑ j_1 : n, (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 b * M b j_1 * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j_1 =
        0

Next tactic:
rintro i' - hi'
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    

Proof state:
case h₀
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j i' : n
hi' : i' ≠ i
⊢ ∑ j_1 : n, (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i' * M i' j_1 * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j_1 = 0

Next tactic:
refine' Finset.sum_eq_zero fun j _ => _
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    

Proof state:
case h₀
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j✝ i' : n
hi' : i' ≠ i
j : n
x✝ : j ∈ univ
⊢ (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i' * M i' j * (LinearMap.stdBasis R₂ (fun x => R₂) j✝) 1 j = 0

Next tactic:
apply mul_eq_zero_of_left
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    apply mul_eq_zero_of_left
    

Proof state:
case h₀.h
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j✝ i' : n
hi' : i' ≠ i
j : n
x✝ : j ∈ univ
⊢ (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i' * M i' j = 0

Next tactic:
apply mul_eq_zero_of_left
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    apply mul_eq_zero_of_left
    apply mul_eq_zero_of_left
    

Proof state:
case h₀.h.h
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j✝ i' : n
hi' : i' ≠ i
j : n
x✝ : j ∈ univ
⊢ (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i' = 0

Next tactic:
exact stdBasis_ne R₂ (fun _ => R₂) _ _ hi' 1
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    apply mul_eq_zero_of_left
    apply mul_eq_zero_of_left
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hi' 1
  · 

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
⊢ i ∉ univ →
    ∑ j_1 : n, (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j_1 * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j_1 = 0

Next tactic:
intros
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    apply mul_eq_zero_of_left
    apply mul_eq_zero_of_left
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hi' 1
  · intros
    

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
a✝ : i ∉ univ
⊢ ∑ j_1 : n, (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j_1 * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j_1 = 0

Next tactic:
have := Finset.mem_univ i
theorem Matrix.toBilin'Aux_stdBasis [Fintype n] [DecidableEq n] (M : Matrix n n R₂) (i j : n) :
    M.toBilin'Aux (LinearMap.stdBasis R₂ (fun _ => R₂) i 1)
      (LinearMap.stdBasis R₂ (fun _ => R₂) j 1) = M i j := by
  rw [Matrix.toBilin'Aux]
  dsimp only -- Porting note: had to add `dsimp only` to get rid of the projections
  rw [sum_eq_single i, sum_eq_single j]
  · simp only [stdBasis_same, stdBasis_same, one_mul, mul_one]
  · rintro j' - hj'
    apply mul_eq_zero_of_right
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hj' 1
  · intros
    have := Finset.mem_univ j
    contradiction
  · rintro i' - hi'
    refine' Finset.sum_eq_zero fun j _ => _
    apply mul_eq_zero_of_left
    apply mul_eq_zero_of_left
    exact stdBasis_ne R₂ (fun _ => R₂) _ _ hi' 1
  · intros
    have := Finset.mem_univ i
    

Proof state:
case h₁
R : Type u_1
M✝ : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M✝
inst✝¹⁴ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n R₂
i j : n
a✝ : i ∉ univ
this : i ∈ univ
⊢ ∑ j_1 : n, (LinearMap.stdBasis R₂ (fun x => R₂) i) 1 i * M i j_1 * (LinearMap.stdBasis R₂ (fun x => R₂) j) 1 j_1 = 0

Next tactic:
contradiction
theorem toBilin'Aux_toMatrixAux [DecidableEq n] (B₂ : BilinForm R₂ (n → R₂)) :
    -- porting note: had to hint the base ring even though it should be clear from context...
    Matrix.toBilin'Aux (BilinForm.toMatrixAux (R₂ := R₂)
      (fun j => stdBasis R₂ (fun _ => R₂) j 1) B₂) = B₂ := by
  

Proof state:
R : Type u_1
M : Type u_2
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂✝ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
B₂ : BilinForm R₂ (n → R₂)
⊢ toBilin'Aux ((toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1) B₂) = B₂

Next tactic:
refine' ext_basis (Pi.basisFun R₂ n) fun i j => _
theorem toBilin'Aux_toMatrixAux [DecidableEq n] (B₂ : BilinForm R₂ (n → R₂)) :
    -- porting note: had to hint the base ring even though it should be clear from context...
    Matrix.toBilin'Aux (BilinForm.toMatrixAux (R₂ := R₂)
      (fun j => stdBasis R₂ (fun _ => R₂) j 1) B₂) = B₂ := by
  refine' ext_basis (Pi.basisFun R₂ n) fun i j => _
  

Proof state:
R : Type u_1
M : Type u_2
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂✝ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
B₂ : BilinForm R₂ (n → R₂)
i j : n
⊢ bilin (toBilin'Aux ((toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1) B₂)) ((Pi.basisFun R₂ n) i)
      ((Pi.basisFun R₂ n) j) =
    bilin B₂ ((Pi.basisFun R₂ n) i) ((Pi.basisFun R₂ n) j)

Next tactic:
rw [Pi.basisFun_apply, Pi.basisFun_apply, Matrix.toBilin'Aux_stdBasis,
    BilinForm.toMatrixAux_apply]
/-- The linear equivalence between bilinear forms on `n → R` and `n × n` matrices -/
def BilinForm.toMatrix' : BilinForm R₂ (n → R₂) ≃ₗ[R₂] Matrix n n R₂ :=
  { BilinForm.toMatrixAux fun j =>
      stdBasis R₂ (fun _ => R₂) j
        1 with
    invFun := Matrix.toBilin'Aux
    left_inv := fun B ↦ by 

Proof state:
R : Type u_1
M : Type u_2
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M
inst✝¹⁶ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
src✝ : BilinForm R₂ (n → R₂) →ₗ[R₂] Matrix n n R₂ := toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1
B : BilinForm R₂ (n → R₂)
⊢ toBilin'Aux
      (AddHom.toFun
        { toAddHom := src✝.toAddHom,
            map_smul' :=
              (_ :
                ∀ (r : R₂) (x : BilinForm R₂ (n → R₂)),
                  AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R₂) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
        B) =
    B

Next tactic:
convert toBilin'Aux_toMatrixAux B
/-- The linear equivalence between bilinear forms on `n → R` and `n × n` matrices -/
def BilinForm.toMatrix' : BilinForm R₂ (n → R₂) ≃ₗ[R₂] Matrix n n R₂ :=
  { BilinForm.toMatrixAux fun j =>
      stdBasis R₂ (fun _ => R₂) j
        1 with
    invFun := Matrix.toBilin'Aux
    left_inv := fun B ↦ by convert toBilin'Aux_toMatrixAux B
    right_inv := fun M => by
      

Proof state:
R : Type u_1
M✝ : Type u_2
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
src✝ : BilinForm R₂ (n → R₂) →ₗ[R₂] Matrix n n R₂ := toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1
M : Matrix n n R₂
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R₂) (x : BilinForm R₂ (n → R₂)),
                AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R₂) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      (toBilin'Aux M) =
    M

Next tactic:
ext i j
/-- The linear equivalence between bilinear forms on `n → R` and `n × n` matrices -/
def BilinForm.toMatrix' : BilinForm R₂ (n → R₂) ≃ₗ[R₂] Matrix n n R₂ :=
  { BilinForm.toMatrixAux fun j =>
      stdBasis R₂ (fun _ => R₂) j
        1 with
    invFun := Matrix.toBilin'Aux
    left_inv := fun B ↦ by convert toBilin'Aux_toMatrixAux B
    right_inv := fun M => by
      ext i j
      

Proof state:
case a.h
R : Type u_1
M✝ : Type u_2
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
src✝ : BilinForm R₂ (n → R₂) →ₗ[R₂] Matrix n n R₂ := toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1
M : Matrix n n R₂
i j : n
⊢ AddHom.toFun
      { toAddHom := src✝.toAddHom,
          map_smul' :=
            (_ :
              ∀ (r : R₂) (x : BilinForm R₂ (n → R₂)),
                AddHom.toFun src✝.toAddHom (r • x) = (RingHom.id R₂) r • AddHom.toFun src✝.toAddHom x) }.toAddHom
      (toBilin'Aux M) i j =
    M i j

Next tactic:
simp only [toFun_eq_coe, BilinForm.toMatrixAux_apply, Matrix.toBilin'Aux_stdBasis]
theorem Matrix.toBilin'_apply' (M : Matrix n n R₂) (v w : n → R₂) :
    Matrix.toBilin' M v w = Matrix.dotProduct v (M.mulVec w) := by
  

Proof state:
R : Type u_1
M✝ : Type u_2
inst✝¹⁸ : Semiring R
inst✝¹⁷ : AddCommMonoid M✝
inst✝¹⁶ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁵ : Ring R₁
inst✝¹⁴ : AddCommGroup M₁
inst✝¹³ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹² : CommSemiring R₂
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁹ : CommRing R₃
inst✝⁸ : AddCommGroup M₃
inst✝⁷ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : DecidableEq n
inst✝ : DecidableEq o
M : Matrix n n R₂
v w : n → R₂
⊢ bilin (toBilin' M) v w = v ⬝ᵥ mulVec M w

Next tactic:
simp_rw [Matrix.toBilin'_apply, Matrix.dotProduct, Matrix.mulVec, Matrix.dotProduct]