Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

320df450

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

d64d67d0

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Jalex Stark. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash
 -/
-import Mathbin.Data.Matrix.Basic
-import Mathbin.LinearAlgebra.Matrix.Trace
+import Data.Matrix.Basic
+import LinearAlgebra.Matrix.Trace
 
 #align_import data.matrix.basis from "leanprover-community/mathlib"@"d64d67d000b974f0d86a2be7918cf800be6271c8"

d64d67d0

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Jalex Stark. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash
-
-! This file was ported from Lean 3 source module data.matrix.basis
-! leanprover-community/mathlib commit d64d67d000b974f0d86a2be7918cf800be6271c8
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Matrix.Basic
 import Mathbin.LinearAlgebra.Matrix.Trace
 
+#align_import data.matrix.basis from "leanprover-community/mathlib"@"d64d67d000b974f0d86a2be7918cf800be6271c8"
+
 /-!
 # Matrices with a single non-zero element.

d64d67d0

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -222,7 +222,7 @@ theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
 theorem mul_same (k : n) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) :=
   by
-  ext (a b)
+  ext a b
   simp only [mul_apply, std_basis_matrix, boole_mul]
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
 #align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
@@ -232,7 +232,7 @@ theorem mul_same (k : n) (d : α) :
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 :=
   by
-  ext (a b)
+  ext a b
   simp only [mul_apply, boole_mul, std_basis_matrix]
   by_cases h₁ : i = a <;> simp [h₁, h, h.symm]
 #align matrix.std_basis_matrix.mul_of_ne Matrix.StdBasisMatrix.mul_of_ne

d64d67d0

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -45,23 +45,30 @@ def stdBasisMatrix (i : m) (j : n) (a : α) : Matrix m n α := fun i' j' =>
 #align matrix.std_basis_matrix Matrix.stdBasisMatrix
 -/
 
+#print Matrix.smul_stdBasisMatrix /-
 @[simp]
 theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
     b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) := by unfold std_basis_matrix; ext; simp
 #align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrix
+-/
 
+#print Matrix.stdBasisMatrix_zero /-
 @[simp]
 theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 := by
   unfold std_basis_matrix; ext; simp
 #align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zero
+-/
 
+#print Matrix.stdBasisMatrix_add /-
 theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
     stdBasisMatrix i j (a + b) = stdBasisMatrix i j a + stdBasisMatrix i j b :=
   by
   unfold std_basis_matrix; ext
   split_ifs with h <;> simp [h]
 #align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_add
+-/
 
+#print Matrix.matrix_eq_sum_std_basis /-
 theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     x = ∑ (i : m) (j : n), stdBasisMatrix i j (x i j) :=
   by
@@ -72,7 +79,9 @@ theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
   · intro j hj
     simp [std_basis_matrix, hj]
 #align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basis
+-/
 
+#print Matrix.std_basis_eq_basis_mul_basis /-
 -- TODO: tie this up with the `basis` machinery of linear algebra
 -- this is not completely trivial because we are indexing by two types, instead of one
 -- TODO: add `std_basis_vec`
@@ -83,7 +92,9 @@ theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :
   norm_num [std_basis_matrix, vec_mul_vec]
   exact ite_and _ _ _ _
 #align matrix.std_basis_eq_basis_mul_basis Matrix.std_basis_eq_basis_mul_basis
+-/
 
+#print Matrix.induction_on' /-
 -- todo: the old proof used fintypes, I don't know `finsupp` but this feels generalizable
 @[elab_as_elim]
 protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → Prop} (M : Matrix m n α)
@@ -94,7 +105,9 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
   apply Finset.sum_induction _ _ h_add h_zero
   · intros; apply h_std_basis
 #align matrix.induction_on' Matrix.induction_on'
+-/
 
+#print Matrix.induction_on /-
 @[elab_as_elim]
 protected theorem induction_on [Fintype m] [Fintype n] [Nonempty m] [Nonempty n]
     {P : Matrix m n α → Prop} (M : Matrix m n α) (h_add : ∀ p q, P p → P q → P (p + q))
@@ -106,6 +119,7 @@ protected theorem induction_on [Fintype m] [Fintype n] [Nonempty m] [Nonempty n]
       simpa using h_std_basis default default 0)
     h_add h_std_basis
 #align matrix.induction_on Matrix.induction_on
+-/
 
 namespace StdBasisMatrix
 
@@ -113,25 +127,33 @@ section
 
 variable (i : m) (j : n) (c : α) (i' : m) (j' : n)
 
+#print Matrix.StdBasisMatrix.apply_same /-
 @[simp]
 theorem apply_same : stdBasisMatrix i j c i j = c :=
   if_pos (And.intro rfl rfl)
 #align matrix.std_basis_matrix.apply_same Matrix.StdBasisMatrix.apply_same
+-/
 
+#print Matrix.StdBasisMatrix.apply_of_ne /-
 @[simp]
 theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 := by
   simp only [std_basis_matrix, and_imp, ite_eq_right_iff]; tauto
 #align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_ne
+-/
 
+#print Matrix.StdBasisMatrix.apply_of_row_ne /-
 @[simp]
 theorem apply_of_row_ne {i i' : m} (hi : i ≠ i') (j j' : n) (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hi]
 #align matrix.std_basis_matrix.apply_of_row_ne Matrix.StdBasisMatrix.apply_of_row_ne
+-/
 
+#print Matrix.StdBasisMatrix.apply_of_col_ne /-
 @[simp]
 theorem apply_of_col_ne (i i' : m) {j j' : n} (hj : j ≠ j') (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hj]
 #align matrix.std_basis_matrix.apply_of_col_ne Matrix.StdBasisMatrix.apply_of_col_ne
+-/
 
 end
 
@@ -139,21 +161,27 @@ section
 
 variable (i j : n) (c : α) (i' j' : n)
 
+#print Matrix.StdBasisMatrix.diag_zero /-
 @[simp]
 theorem diag_zero (h : j ≠ i) : diag (stdBasisMatrix i j c) = 0 :=
   funext fun k => if_neg fun ⟨e₁, e₂⟩ => h (e₂.trans e₁.symm)
 #align matrix.std_basis_matrix.diag_zero Matrix.StdBasisMatrix.diag_zero
+-/
 
+#print Matrix.StdBasisMatrix.diag_same /-
 @[simp]
 theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c := by ext j;
   by_cases hij : i = j <;> try rw [hij] <;> simp [hij]
 #align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_same
+-/
 
 variable [Fintype n]
 
+#print Matrix.StdBasisMatrix.trace_zero /-
 @[simp]
 theorem trace_zero (h : j ≠ i) : trace (stdBasisMatrix i j c) = 0 := by simp [trace, h]
 #align matrix.std_basis_matrix.trace_zero Matrix.StdBasisMatrix.trace_zero
+-/
 
 #print Matrix.StdBasisMatrix.trace_eq /-
 @[simp]
@@ -161,26 +189,35 @@ theorem trace_eq : trace (stdBasisMatrix i i c) = c := by simp [trace]
 #align matrix.std_basis_matrix.trace_eq Matrix.StdBasisMatrix.trace_eq
 -/
 
+#print Matrix.StdBasisMatrix.mul_left_apply_same /-
 @[simp]
 theorem mul_left_apply_same (b : n) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) i b = c * M j b := by simp [mul_apply, std_basis_matrix]
 #align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_same
+-/
 
+#print Matrix.StdBasisMatrix.mul_right_apply_same /-
 @[simp]
 theorem mul_right_apply_same (a : n) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a j = M a i * c := by simp [mul_apply, std_basis_matrix, mul_comm]
 #align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_same
+-/
 
+#print Matrix.StdBasisMatrix.mul_left_apply_of_ne /-
 @[simp]
 theorem mul_left_apply_of_ne (a b : n) (h : a ≠ i) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) a b = 0 := by simp [mul_apply, h.symm]
 #align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_ne
+-/
 
+#print Matrix.StdBasisMatrix.mul_right_apply_of_ne /-
 @[simp]
 theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a b = 0 := by simp [mul_apply, hbj.symm]
 #align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_ne
+-/
 
+#print Matrix.StdBasisMatrix.mul_same /-
 @[simp]
 theorem mul_same (k : n) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) :=
@@ -189,7 +226,9 @@ theorem mul_same (k : n) (d : α) :
   simp only [mul_apply, std_basis_matrix, boole_mul]
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
 #align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
+-/
 
+#print Matrix.StdBasisMatrix.mul_of_ne /-
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 :=
   by
@@ -197,6 +236,7 @@ theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ st
   simp only [mul_apply, boole_mul, std_basis_matrix]
   by_cases h₁ : i = a <;> simp [h₁, h, h.symm]
 #align matrix.std_basis_matrix.mul_of_ne Matrix.StdBasisMatrix.mul_of_ne
+-/
 
 end

d64d67d0

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -92,7 +92,7 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
   by
   rw [matrix_eq_sum_std_basis M, ← Finset.sum_product']
   apply Finset.sum_induction _ _ h_add h_zero
-  · intros ; apply h_std_basis
+  · intros; apply h_std_basis
 #align matrix.induction_on' Matrix.induction_on'
 
 @[elab_as_elim]

d64d67d0

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -28,9 +28,9 @@ variable {R α : Type _}
 
 namespace Matrix
 
-open Matrix
+open scoped Matrix
 
-open BigOperators
+open scoped BigOperators
 
 variable [DecidableEq l] [DecidableEq m] [DecidableEq n]

d64d67d0

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -45,34 +45,16 @@ def stdBasisMatrix (i : m) (j : n) (a : α) : Matrix m n α := fun i' j' =>
 #align matrix.std_basis_matrix Matrix.stdBasisMatrix
 -/
 
-/- warning: matrix.smul_std_basis_matrix -> Matrix.smul_stdBasisMatrix is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (a : α) (b : α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (SMul.smul.{u3, max u1 u2 u3} α (Matrix.{u1, u2, u3} m n α) (Matrix.hasSmul.{u3, u1, u2, u3} m n α α (Mul.toSMul.{u3} α (Distrib.toHasMul.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) b (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a)) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (SMul.smul.{u3, u3} α α (Mul.toSMul.{u3} α (Distrib.toHasMul.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))) b a))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (a : α) (b : α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (HSMul.hSMul.{u1, max (max u1 u2) u3, max (max u3 u2) u1} α (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHSMul.{u1, max (max u3 u2) u1} α (Matrix.{u3, u2, u1} m n α) (Matrix.smul.{u1, u3, u2, u1} m n α α (SMulZeroClass.toSMul.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (SMulWithZero.toSMulZeroClass.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MulZeroClass.toSMulWithZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))))) b (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a)) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HSMul.hSMul.{u1, u1, u1} α α α (instHSMul.{u1, u1} α α (SMulZeroClass.toSMul.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (SMulWithZero.toSMulZeroClass.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MulZeroClass.toSMulWithZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))))))) b a))
-Case conversion may be inaccurate. Consider using '#align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrixₓ'. -/
 @[simp]
 theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
     b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) := by unfold std_basis_matrix; ext; simp
 #align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrix
 
-/- warning: matrix.std_basis_matrix_zero -> Matrix.stdBasisMatrix_zero is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))))) (OfNat.ofNat.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (OfNat.mk.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (Zero.zero.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasZero.{u3, u1, u2} m n α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))) (OfNat.ofNat.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) 0 (Zero.toOfNat0.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.zero.{u1, u3, u2} m n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zeroₓ'. -/
 @[simp]
 theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 := by
   unfold std_basis_matrix; ext; simp
 #align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zero
 
-/- warning: matrix.std_basis_matrix_add -> Matrix.stdBasisMatrix_add is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (a : α) (b : α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HAdd.hAdd.{u3, u3, u3} α α α (instHAdd.{u3} α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))) a b)) (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j b))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (a : α) (b : α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))))) a b)) (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j b))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_addₓ'. -/
 theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
     stdBasisMatrix i j (a + b) = stdBasisMatrix i j a + stdBasisMatrix i j b :=
   by
@@ -80,12 +62,6 @@ theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
   split_ifs with h <;> simp [h]
 #align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_add
 
-/- warning: matrix.matrix_eq_sum_std_basis -> Matrix.matrix_eq_sum_std_basis is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] (x : Matrix.{u1, u2, u3} m n α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) x (Finset.sum.{max u1 u2 u3, u1} (Matrix.{u1, u2, u3} m n α) m (Matrix.addCommMonoid.{u3, u1, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))) (Finset.univ.{u1} m _inst_5) (fun (i : m) => Finset.sum.{max u1 u2 u3, u2} (Matrix.{u1, u2, u3} m n α) n (Matrix.addCommMonoid.{u3, u1, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))) (Finset.univ.{u2} n _inst_6) (fun (j : n) => Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (x i j))))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] (x : Matrix.{u3, u2, u1} m n α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) x (Finset.sum.{max (max u1 u2) u3, u3} (Matrix.{u3, u2, u1} m n α) m (Matrix.addCommMonoid.{u1, u3, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (Finset.univ.{u3} m _inst_5) (fun (i : m) => Finset.sum.{max (max u1 u2) u3, u2} (Matrix.{u3, u2, u1} m n α) n (Matrix.addCommMonoid.{u1, u3, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (Finset.univ.{u2} n _inst_6) (fun (j : n) => Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (x i j))))
-Case conversion may be inaccurate. Consider using '#align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basisₓ'. -/
 theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     x = ∑ (i : m) (j : n), stdBasisMatrix i j (x i j) :=
   by
@@ -97,12 +73,6 @@ theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     simp [std_basis_matrix, hj]
 #align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basis
 
-/- warning: matrix.std_basis_eq_basis_mul_basis -> Matrix.std_basis_eq_basis_mul_basis is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] (i : m) (j : n), Eq.{succ (max u1 u2)} (Matrix.{u1, u2, 0} m n Nat) (Matrix.stdBasisMatrix.{u1, u2, 0} m n Nat (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) Nat.semiring i j (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (Matrix.vecMulVec.{0, u1, u2} m n Nat Nat.hasMul (fun (i' : m) => ite.{1} Nat (Eq.{succ u1} m i i') (_inst_2 i i') (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (fun (j' : n) => ite.{1} Nat (Eq.{succ u2} n j j') (_inst_3 j j') (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))))
-but is expected to have type
-  forall {m : Type.{u2}} {n : Type.{u1}} [_inst_2 : DecidableEq.{succ u2} m] [_inst_3 : DecidableEq.{succ u1} n] (i : m) (j : n), Eq.{max (max (succ u2) (succ u1)) 1} (Matrix.{u2, u1, 0} m n Nat) (Matrix.stdBasisMatrix.{u2, u1, 0} m n Nat (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) Nat.semiring i j (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (Matrix.vecMulVec.{0, u2, u1} m n Nat instMulNat (fun (i' : m) => ite.{1} Nat (Eq.{succ u2} m i i') (_inst_2 i i') (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (fun (j' : n) => ite.{1} Nat (Eq.{succ u1} n j j') (_inst_3 j j') (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_eq_basis_mul_basis Matrix.std_basis_eq_basis_mul_basisₓ'. -/
 -- TODO: tie this up with the `basis` machinery of linear algebra
 -- this is not completely trivial because we are indexing by two types, instead of one
 -- TODO: add `std_basis_vec`
@@ -114,12 +84,6 @@ theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :
   exact ite_and _ _ _ _
 #align matrix.std_basis_eq_basis_mul_basis Matrix.std_basis_eq_basis_mul_basis
 
-/- warning: matrix.induction_on' -> Matrix.induction_on' is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] {P : (Matrix.{u1, u2, u3} m n α) -> Prop} (M : Matrix.{u1, u2, u3} m n α), (P (OfNat.ofNat.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (OfNat.mk.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (Zero.zero.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasZero.{u3, u1, u2} m n α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))) -> (forall (p : Matrix.{u1, u2, u3} m n α) (q : Matrix.{u1, u2, u3} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] {P : (Matrix.{u3, u2, u1} m n α) -> Prop} (M : Matrix.{u3, u2, u1} m n α), (P (OfNat.ofNat.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) 0 (Zero.toOfNat0.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.zero.{u1, u3, u2} m n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))) -> (forall (p : Matrix.{u3, u2, u1} m n α) (q : Matrix.{u3, u2, u1} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
-Case conversion may be inaccurate. Consider using '#align matrix.induction_on' Matrix.induction_on'ₓ'. -/
 -- todo: the old proof used fintypes, I don't know `finsupp` but this feels generalizable
 @[elab_as_elim]
 protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → Prop} (M : Matrix m n α)
@@ -131,12 +95,6 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
   · intros ; apply h_std_basis
 #align matrix.induction_on' Matrix.induction_on'
 
-/- warning: matrix.induction_on -> Matrix.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] [_inst_7 : Nonempty.{succ u1} m] [_inst_8 : Nonempty.{succ u2} n] {P : (Matrix.{u1, u2, u3} m n α) -> Prop} (M : Matrix.{u1, u2, u3} m n α), (forall (p : Matrix.{u1, u2, u3} m n α) (q : Matrix.{u1, u2, u3} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] [_inst_7 : Nonempty.{succ u3} m] [_inst_8 : Nonempty.{succ u2} n] {P : (Matrix.{u3, u2, u1} m n α) -> Prop} (M : Matrix.{u3, u2, u1} m n α), (forall (p : Matrix.{u3, u2, u1} m n α) (q : Matrix.{u3, u2, u1} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
-Case conversion may be inaccurate. Consider using '#align matrix.induction_on Matrix.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on [Fintype m] [Fintype n] [Nonempty m] [Nonempty n]
     {P : Matrix m n α → Prop} (M : Matrix m n α) (h_add : ∀ p q, P p → P q → P (p + q))
@@ -155,45 +113,21 @@ section
 
 variable (i : m) (j : n) (c : α) (i' : m) (j' : n)
 
-/- warning: matrix.std_basis_matrix.apply_same -> Matrix.StdBasisMatrix.apply_same is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i j) c
-but is expected to have type
-  forall {m : Type.{u2}} {n : Type.{u1}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u2} m] [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u2, u1, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i j) c
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_same Matrix.StdBasisMatrix.apply_sameₓ'. -/
 @[simp]
 theorem apply_same : stdBasisMatrix i j c i j = c :=
   if_pos (And.intro rfl rfl)
 #align matrix.std_basis_matrix.apply_same Matrix.StdBasisMatrix.apply_same
 
-/- warning: matrix.std_basis_matrix.apply_of_ne -> Matrix.StdBasisMatrix.apply_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α) (i' : m) (j' : n), (Not (And (Eq.{succ u1} m i i') (Eq.{succ u2} n j j'))) -> (Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (c : α) (i' : m) (j' : n), (Not (And (Eq.{succ u3} m i i') (Eq.{succ u2} n j j'))) -> (Eq.{succ u1} α (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i' j') (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_neₓ'. -/
 @[simp]
 theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 := by
   simp only [std_basis_matrix, and_imp, ite_eq_right_iff]; tauto
 #align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_ne
 
-/- warning: matrix.std_basis_matrix.apply_of_row_ne -> Matrix.StdBasisMatrix.apply_of_row_ne is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] {i : m} {i' : m}, (Ne.{succ u1} m i i') -> (forall (j : n) (j' : n) (a : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
-but is expected to have type
-  forall {m : Type.{u3}} {n : Type.{u1}} {α : Type.{u2}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] {i : m} {i' : m}, (Ne.{succ u3} m i i') -> (forall (j : n) (j' : n) (a : α), Eq.{succ u2} α (Matrix.stdBasisMatrix.{u3, u1, u2} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_row_ne Matrix.StdBasisMatrix.apply_of_row_neₓ'. -/
 @[simp]
 theorem apply_of_row_ne {i i' : m} (hi : i ≠ i') (j j' : n) (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hi]
 #align matrix.std_basis_matrix.apply_of_row_ne Matrix.StdBasisMatrix.apply_of_row_ne
 
-/- warning: matrix.std_basis_matrix.apply_of_col_ne -> Matrix.StdBasisMatrix.apply_of_col_ne is a dubious translation:
-lean 3 declaration is
-  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (i' : m) {j : n} {j' : n}, (Ne.{succ u2} n j j') -> (forall (a : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
-but is expected to have type
-  forall {m : Type.{u1}} {n : Type.{u3}} {α : Type.{u2}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u3} n] [_inst_4 : Semiring.{u2} α] (i : m) (i' : m) {j : n} {j' : n}, (Ne.{succ u3} n j j') -> (forall (a : α), Eq.{succ u2} α (Matrix.stdBasisMatrix.{u1, u3, u2} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_col_ne Matrix.StdBasisMatrix.apply_of_col_neₓ'. -/
 @[simp]
 theorem apply_of_col_ne (i i' : m) {j j' : n} (hj : j ≠ j') (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hj]
@@ -205,23 +139,11 @@ section
 
 variable (i j : n) (c : α) (i' j' : n)
 
-/- warning: matrix.std_basis_matrix.diag_zero -> Matrix.StdBasisMatrix.diag_zero is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α), (Ne.{succ u1} n j i) -> (Eq.{max (succ u1) (succ u2)} (n -> α) (Matrix.diag.{u2, u1} n α (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{max u1 u2} (n -> α) 0 (OfNat.mk.{max u1 u2} (n -> α) 0 (Zero.zero.{max u1 u2} (n -> α) (Pi.instZero.{u1, u2} n (fun (i : n) => α) (fun (i : n) => MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))))))))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α), (Ne.{succ u2} n j i) -> (Eq.{max (succ u2) (succ u1)} (n -> α) (Matrix.diag.{u1, u2} n α (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{max u2 u1} (n -> α) 0 (Zero.toOfNat0.{max u2 u1} (n -> α) (Pi.instZero.{u2, u1} n (fun (i : n) => α) (fun (i : n) => MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.diag_zero Matrix.StdBasisMatrix.diag_zeroₓ'. -/
 @[simp]
 theorem diag_zero (h : j ≠ i) : diag (stdBasisMatrix i j c) = 0 :=
   funext fun k => if_neg fun ⟨e₁, e₂⟩ => h (e₂.trans e₁.symm)
 #align matrix.std_basis_matrix.diag_zero Matrix.StdBasisMatrix.diag_zero
 
-/- warning: matrix.std_basis_matrix.diag_same -> Matrix.StdBasisMatrix.diag_same is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (c : α), Eq.{max (succ u1) (succ u2)} (n -> α) (Matrix.diag.{u2, u1} n α (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i i c)) (Pi.single.{u1, u2} n (fun (i : n) => α) (fun (a : n) (b : n) => _inst_3 a b) (fun (i : n) => MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) i c)
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (c : α), Eq.{max (succ u2) (succ u1)} (n -> α) (Matrix.diag.{u1, u2} n α (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i i c)) (Pi.single.{u2, u1} n (fun (i : n) => α) (fun (a : n) (b : n) => _inst_3 a b) (fun (i : n) => MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) i c)
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_sameₓ'. -/
 @[simp]
 theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c := by ext j;
   by_cases hij : i = j <;> try rw [hij] <;> simp [hij]
@@ -229,12 +151,6 @@ theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c := by ext j;
 
 variable [Fintype n]
 
-/- warning: matrix.std_basis_matrix.trace_zero -> Matrix.StdBasisMatrix.trace_zero is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n], (Ne.{succ u1} n j i) -> (Eq.{succ u2} α (Matrix.trace.{u1, u2} n α _inst_5 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n], (Ne.{succ u2} n j i) -> (Eq.{succ u1} α (Matrix.trace.{u2, u1} n α _inst_5 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.trace_zero Matrix.StdBasisMatrix.trace_zeroₓ'. -/
 @[simp]
 theorem trace_zero (h : j ≠ i) : trace (stdBasisMatrix i j c) = 0 := by simp [trace, h]
 #align matrix.std_basis_matrix.trace_zero Matrix.StdBasisMatrix.trace_zero
@@ -245,56 +161,26 @@ theorem trace_eq : trace (stdBasisMatrix i i c) = c := by simp [trace]
 #align matrix.std_basis_matrix.trace_eq Matrix.StdBasisMatrix.trace_eq
 -/
 
-/- warning: matrix.std_basis_matrix.mul_left_apply_same -> Matrix.StdBasisMatrix.mul_left_apply_same is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (b : n) (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M i b) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) c (M j b))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (b : n) (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M i b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) c (M j b))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_sameₓ'. -/
 @[simp]
 theorem mul_left_apply_same (b : n) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) i b = c * M j b := by simp [mul_apply, std_basis_matrix]
 #align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_same
 
-/- warning: matrix.std_basis_matrix.mul_right_apply_same -> Matrix.StdBasisMatrix.mul_right_apply_same is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) M (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a j) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) (M a i) c)
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) M (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a j) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (M a i) c)
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_sameₓ'. -/
 @[simp]
 theorem mul_right_apply_same (a : n) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a j = M a i * c := by simp [mul_apply, std_basis_matrix, mul_comm]
 #align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_same
 
-/- warning: matrix.std_basis_matrix.mul_left_apply_of_ne -> Matrix.StdBasisMatrix.mul_left_apply_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (b : n), (Ne.{succ u1} n a i) -> (forall (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M a b) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (b : n), (Ne.{succ u2} n a i) -> (forall (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_neₓ'. -/
 @[simp]
 theorem mul_left_apply_of_ne (a b : n) (h : a ≠ i) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) a b = 0 := by simp [mul_apply, h.symm]
 #align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_ne
 
-/- warning: matrix.std_basis_matrix.mul_right_apply_of_ne -> Matrix.StdBasisMatrix.mul_right_apply_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (b : n), (Ne.{succ u1} n b j) -> (forall (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) M (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a b) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (b : n), (Ne.{succ u2} n b j) -> (forall (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) M (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_neₓ'. -/
 @[simp]
 theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a b = 0 := by simp [mul_apply, hbj.symm]
 #align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_ne
 
-/- warning: matrix.std_basis_matrix.mul_same -> Matrix.StdBasisMatrix.mul_same is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (k : n) (d : α), Eq.{succ (max u1 u2)} (Matrix.{u1, u1, u2} n n α) (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 j k d)) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i k (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) c d))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (k : n) (d : α), Eq.{max (succ u2) (succ u1)} (Matrix.{u2, u2, u1} n n α) (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 j k d)) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i k (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) c d))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_sameₓ'. -/
 @[simp]
 theorem mul_same (k : n) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) :=
@@ -304,12 +190,6 @@ theorem mul_same (k : n) (d : α) :
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
 #align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
 
-/- warning: matrix.std_basis_matrix.mul_of_ne -> Matrix.StdBasisMatrix.mul_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] {k : n} {l : n}, (Ne.{succ u1} n j k) -> (forall (d : α), Eq.{succ (max u1 u2)} (Matrix.{u1, u1, u2} n n α) (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 k l d)) (OfNat.ofNat.{max u1 u2} (Matrix.{u1, u1, u2} n n α) 0 (OfNat.mk.{max u1 u2} (Matrix.{u1, u1, u2} n n α) 0 (Zero.zero.{max u1 u2} (Matrix.{u1, u1, u2} n n α) (Matrix.hasZero.{u2, u1, u1} n n α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))))))))
-but is expected to have type
-  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] {k : n} {l : n}, (Ne.{succ u2} n j k) -> (forall (d : α), Eq.{max (succ u2) (succ u1)} (Matrix.{u2, u2, u1} n n α) (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 k l d)) (OfNat.ofNat.{max u2 u1} (Matrix.{u2, u2, u1} n n α) 0 (Zero.toOfNat0.{max u2 u1} (Matrix.{u2, u2, u1} n n α) (Matrix.zero.{u1, u2, u2} n n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))))
-Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_of_ne Matrix.StdBasisMatrix.mul_of_neₓ'. -/
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 :=
   by

d64d67d0

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -53,11 +53,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrixₓ'. -/
 @[simp]
 theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
-    b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) :=
-  by
-  unfold std_basis_matrix
-  ext
-  simp
+    b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) := by unfold std_basis_matrix; ext; simp
 #align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrix
 
 /- warning: matrix.std_basis_matrix_zero -> Matrix.stdBasisMatrix_zero is a dubious translation:
@@ -67,11 +63,8 @@ but is expected to have type
   forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))) (OfNat.ofNat.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) 0 (Zero.toOfNat0.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.zero.{u1, u3, u2} m n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
 Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zeroₓ'. -/
 @[simp]
-theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 :=
-  by
-  unfold std_basis_matrix
-  ext
-  simp
+theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 := by
+  unfold std_basis_matrix; ext; simp
 #align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zero
 
 /- warning: matrix.std_basis_matrix_add -> Matrix.stdBasisMatrix_add is a dubious translation:
@@ -135,8 +128,7 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
   by
   rw [matrix_eq_sum_std_basis M, ← Finset.sum_product']
   apply Finset.sum_induction _ _ h_add h_zero
-  · intros
-    apply h_std_basis
+  · intros ; apply h_std_basis
 #align matrix.induction_on' Matrix.induction_on'
 
 /- warning: matrix.induction_on -> Matrix.induction_on is a dubious translation:
@@ -181,10 +173,8 @@ but is expected to have type
   forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (c : α) (i' : m) (j' : n), (Not (And (Eq.{succ u3} m i i') (Eq.{succ u2} n j j'))) -> (Eq.{succ u1} α (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i' j') (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
 Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_neₓ'. -/
 @[simp]
-theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 :=
-  by
-  simp only [std_basis_matrix, and_imp, ite_eq_right_iff]
-  tauto
+theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 := by
+  simp only [std_basis_matrix, and_imp, ite_eq_right_iff]; tauto
 #align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_ne
 
 /- warning: matrix.std_basis_matrix.apply_of_row_ne -> Matrix.StdBasisMatrix.apply_of_row_ne is a dubious translation:
@@ -233,9 +223,7 @@ but is expected to have type
   forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (c : α), Eq.{max (succ u2) (succ u1)} (n -> α) (Matrix.diag.{u1, u2} n α (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i i c)) (Pi.single.{u2, u1} n (fun (i : n) => α) (fun (a : n) (b : n) => _inst_3 a b) (fun (i : n) => MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) i c)
 Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_sameₓ'. -/
 @[simp]
-theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c :=
-  by
-  ext j
+theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c := by ext j;
   by_cases hij : i = j <;> try rw [hij] <;> simp [hij]
 #align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_same

d64d67d0

bump to nightly-2023-04-06-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/06a655b5fcfbda03502f9158bbf6c0f1400886f9

89485060

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash
 
 ! This file was ported from Lean 3 source module data.matrix.basis
-! leanprover-community/mathlib commit 320df450e9abeb5fc6417971e75acb6ae8bc3794
+! leanprover-community/mathlib commit d64d67d000b974f0d86a2be7918cf800be6271c8
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.LinearAlgebra.Matrix.Trace
 /-!
 # Matrices with a single non-zero element.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file provides `matrix.std_basis_matrix`. The matrix `matrix.std_basis_matrix i j c` has `c`
 at position `(i, j)`, and zeroes elsewhere.
 -/

320df450

bump to nightly-2023-04-04-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/3cacc945118c8c637d89950af01da78307f59325

468d7cfa

Diff

@@ -33,13 +33,21 @@ variable [DecidableEq l] [DecidableEq m] [DecidableEq n]
 
 variable [Semiring α]
 
+#print Matrix.stdBasisMatrix /-
 /-- `std_basis_matrix i j a` is the matrix with `a` in the `i`-th row, `j`-th column,
 and zeroes elsewhere.
 -/
 def stdBasisMatrix (i : m) (j : n) (a : α) : Matrix m n α := fun i' j' =>
   if i = i' ∧ j = j' then a else 0
 #align matrix.std_basis_matrix Matrix.stdBasisMatrix
+-/
 
+/- warning: matrix.smul_std_basis_matrix -> Matrix.smul_stdBasisMatrix is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (a : α) (b : α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (SMul.smul.{u3, max u1 u2 u3} α (Matrix.{u1, u2, u3} m n α) (Matrix.hasSmul.{u3, u1, u2, u3} m n α α (Mul.toSMul.{u3} α (Distrib.toHasMul.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) b (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a)) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (SMul.smul.{u3, u3} α α (Mul.toSMul.{u3} α (Distrib.toHasMul.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))) b a))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (a : α) (b : α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (HSMul.hSMul.{u1, max (max u1 u2) u3, max (max u3 u2) u1} α (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHSMul.{u1, max (max u3 u2) u1} α (Matrix.{u3, u2, u1} m n α) (Matrix.smul.{u1, u3, u2, u1} m n α α (SMulZeroClass.toSMul.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (SMulWithZero.toSMulZeroClass.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MulZeroClass.toSMulWithZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))))) b (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a)) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HSMul.hSMul.{u1, u1, u1} α α α (instHSMul.{u1, u1} α α (SMulZeroClass.toSMul.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (SMulWithZero.toSMulZeroClass.{u1, u1} α α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) (MulZeroClass.toSMulWithZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))))))) b a))
+Case conversion may be inaccurate. Consider using '#align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrixₓ'. -/
 @[simp]
 theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
     b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) :=
@@ -49,6 +57,12 @@ theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
   simp
 #align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrix
 
+/- warning: matrix.std_basis_matrix_zero -> Matrix.stdBasisMatrix_zero is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))))) (OfNat.ofNat.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (OfNat.mk.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (Zero.zero.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasZero.{u3, u1, u2} m n α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))) (OfNat.ofNat.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) 0 (Zero.toOfNat0.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.zero.{u1, u3, u2} m n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zeroₓ'. -/
 @[simp]
 theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 :=
   by
@@ -57,6 +71,12 @@ theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 :=
   simp
 #align matrix.std_basis_matrix_zero Matrix.stdBasisMatrix_zero
 
+/- warning: matrix.std_basis_matrix_add -> Matrix.stdBasisMatrix_add is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (a : α) (b : α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HAdd.hAdd.{u3, u3, u3} α α α (instHAdd.{u3} α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))) a b)) (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a) (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j b))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (a : α) (b : α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))))) a b)) (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a) (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j b))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_addₓ'. -/
 theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
     stdBasisMatrix i j (a + b) = stdBasisMatrix i j a + stdBasisMatrix i j b :=
   by
@@ -64,6 +84,12 @@ theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
   split_ifs with h <;> simp [h]
 #align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_add
 
+/- warning: matrix.matrix_eq_sum_std_basis -> Matrix.matrix_eq_sum_std_basis is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] (x : Matrix.{u1, u2, u3} m n α), Eq.{succ (max u1 u2 u3)} (Matrix.{u1, u2, u3} m n α) x (Finset.sum.{max u1 u2 u3, u1} (Matrix.{u1, u2, u3} m n α) m (Matrix.addCommMonoid.{u3, u1, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))) (Finset.univ.{u1} m _inst_5) (fun (i : m) => Finset.sum.{max u1 u2 u3, u2} (Matrix.{u1, u2, u3} m n α) n (Matrix.addCommMonoid.{u3, u1, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))) (Finset.univ.{u2} n _inst_6) (fun (j : n) => Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (x i j))))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] (x : Matrix.{u3, u2, u1} m n α), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Matrix.{u3, u2, u1} m n α) x (Finset.sum.{max (max u1 u2) u3, u3} (Matrix.{u3, u2, u1} m n α) m (Matrix.addCommMonoid.{u1, u3, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (Finset.univ.{u3} m _inst_5) (fun (i : m) => Finset.sum.{max (max u1 u2) u3, u2} (Matrix.{u3, u2, u1} m n α) n (Matrix.addCommMonoid.{u1, u3, u2} m n α (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (Finset.univ.{u2} n _inst_6) (fun (j : n) => Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j (x i j))))
+Case conversion may be inaccurate. Consider using '#align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basisₓ'. -/
 theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     x = ∑ (i : m) (j : n), stdBasisMatrix i j (x i j) :=
   by
@@ -75,6 +101,12 @@ theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     simp [std_basis_matrix, hj]
 #align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basis
 
+/- warning: matrix.std_basis_eq_basis_mul_basis -> Matrix.std_basis_eq_basis_mul_basis is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] (i : m) (j : n), Eq.{succ (max u1 u2)} (Matrix.{u1, u2, 0} m n Nat) (Matrix.stdBasisMatrix.{u1, u2, 0} m n Nat (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) Nat.semiring i j (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) (Matrix.vecMulVec.{0, u1, u2} m n Nat Nat.hasMul (fun (i' : m) => ite.{1} Nat (Eq.{succ u1} m i i') (_inst_2 i i') (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (fun (j' : n) => ite.{1} Nat (Eq.{succ u2} n j j') (_inst_3 j j') (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))))
+but is expected to have type
+  forall {m : Type.{u2}} {n : Type.{u1}} [_inst_2 : DecidableEq.{succ u2} m] [_inst_3 : DecidableEq.{succ u1} n] (i : m) (j : n), Eq.{max (max (succ u2) (succ u1)) 1} (Matrix.{u2, u1, 0} m n Nat) (Matrix.stdBasisMatrix.{u2, u1, 0} m n Nat (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) Nat.semiring i j (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) (Matrix.vecMulVec.{0, u2, u1} m n Nat instMulNat (fun (i' : m) => ite.{1} Nat (Eq.{succ u2} m i i') (_inst_2 i i') (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (fun (j' : n) => ite.{1} Nat (Eq.{succ u1} n j j') (_inst_3 j j') (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_eq_basis_mul_basis Matrix.std_basis_eq_basis_mul_basisₓ'. -/
 -- TODO: tie this up with the `basis` machinery of linear algebra
 -- this is not completely trivial because we are indexing by two types, instead of one
 -- TODO: add `std_basis_vec`
@@ -86,6 +118,12 @@ theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :
   exact ite_and _ _ _ _
 #align matrix.std_basis_eq_basis_mul_basis Matrix.std_basis_eq_basis_mul_basis
 
+/- warning: matrix.induction_on' -> Matrix.induction_on' is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] {P : (Matrix.{u1, u2, u3} m n α) -> Prop} (M : Matrix.{u1, u2, u3} m n α), (P (OfNat.ofNat.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (OfNat.mk.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) 0 (Zero.zero.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasZero.{u3, u1, u2} m n α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))) -> (forall (p : Matrix.{u1, u2, u3} m n α) (q : Matrix.{u1, u2, u3} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] {P : (Matrix.{u3, u2, u1} m n α) -> Prop} (M : Matrix.{u3, u2, u1} m n α), (P (OfNat.ofNat.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) 0 (Zero.toOfNat0.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.zero.{u1, u3, u2} m n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))) -> (forall (p : Matrix.{u3, u2, u1} m n α) (q : Matrix.{u3, u2, u1} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
+Case conversion may be inaccurate. Consider using '#align matrix.induction_on' Matrix.induction_on'ₓ'. -/
 -- todo: the old proof used fintypes, I don't know `finsupp` but this feels generalizable
 @[elab_as_elim]
 protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → Prop} (M : Matrix m n α)
@@ -98,6 +136,12 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
     apply h_std_basis
 #align matrix.induction_on' Matrix.induction_on'
 
+/- warning: matrix.induction_on -> Matrix.induction_on is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] [_inst_5 : Fintype.{u1} m] [_inst_6 : Fintype.{u2} n] [_inst_7 : Nonempty.{succ u1} m] [_inst_8 : Nonempty.{succ u2} n] {P : (Matrix.{u1, u2, u3} m n α) -> Prop} (M : Matrix.{u1, u2, u3} m n α), (forall (p : Matrix.{u1, u2, u3} m n α) (q : Matrix.{u1, u2, u3} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max u1 u2 u3, max u1 u2 u3, max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (Matrix.{u1, u2, u3} m n α) (instHAdd.{max u1 u2 u3} (Matrix.{u1, u2, u3} m n α) (Matrix.hasAdd.{u3, u1, u2} m n α (Distrib.toHasAdd.{u3} α (NonUnitalNonAssocSemiring.toDistrib.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] [_inst_5 : Fintype.{u3} m] [_inst_6 : Fintype.{u2} n] [_inst_7 : Nonempty.{succ u3} m] [_inst_8 : Nonempty.{succ u2} n] {P : (Matrix.{u3, u2, u1} m n α) -> Prop} (M : Matrix.{u3, u2, u1} m n α), (forall (p : Matrix.{u3, u2, u1} m n α) (q : Matrix.{u3, u2, u1} m n α), (P p) -> (P q) -> (P (HAdd.hAdd.{max (max u3 u2) u1, max (max u3 u2) u1, max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (Matrix.{u3, u2, u1} m n α) (instHAdd.{max (max u3 u2) u1} (Matrix.{u3, u2, u1} m n α) (Matrix.add.{u1, u3, u2} m n α (Distrib.toAdd.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))))) p q))) -> (forall (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j x)) -> (P M)
+Case conversion may be inaccurate. Consider using '#align matrix.induction_on Matrix.induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem induction_on [Fintype m] [Fintype n] [Nonempty m] [Nonempty n]
     {P : Matrix m n α → Prop} (M : Matrix m n α) (h_add : ∀ p q, P p → P q → P (p + q))
@@ -116,27 +160,51 @@ section
 
 variable (i : m) (j : n) (c : α) (i' : m) (j' : n)
 
+/- warning: matrix.std_basis_matrix.apply_same -> Matrix.StdBasisMatrix.apply_same is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i j) c
+but is expected to have type
+  forall {m : Type.{u2}} {n : Type.{u1}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u2} m] [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u2, u1, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i j) c
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_same Matrix.StdBasisMatrix.apply_sameₓ'. -/
 @[simp]
 theorem apply_same : stdBasisMatrix i j c i j = c :=
   if_pos (And.intro rfl rfl)
-#align matrix.std_basis_matrix.apply_same Matrix.stdBasisMatrix.apply_same
-
+#align matrix.std_basis_matrix.apply_same Matrix.StdBasisMatrix.apply_same
+
+/- warning: matrix.std_basis_matrix.apply_of_ne -> Matrix.StdBasisMatrix.apply_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (j : n) (c : α) (i' : m) (j' : n), (Not (And (Eq.{succ u1} m i i') (Eq.{succ u2} n j j'))) -> (Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u2}} {α : Type.{u1}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : m) (j : n) (c : α) (i' : m) (j' : n), (Not (And (Eq.{succ u3} m i i') (Eq.{succ u2} n j j'))) -> (Eq.{succ u1} α (Matrix.stdBasisMatrix.{u3, u2, u1} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c i' j') (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_neₓ'. -/
 @[simp]
 theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 :=
   by
   simp only [std_basis_matrix, and_imp, ite_eq_right_iff]
   tauto
-#align matrix.std_basis_matrix.apply_of_ne Matrix.stdBasisMatrix.apply_of_ne
-
+#align matrix.std_basis_matrix.apply_of_ne Matrix.StdBasisMatrix.apply_of_ne
+
+/- warning: matrix.std_basis_matrix.apply_of_row_ne -> Matrix.StdBasisMatrix.apply_of_row_ne is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] {i : m} {i' : m}, (Ne.{succ u1} m i i') -> (forall (j : n) (j' : n) (a : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
+but is expected to have type
+  forall {m : Type.{u3}} {n : Type.{u1}} {α : Type.{u2}} [_inst_2 : DecidableEq.{succ u3} m] [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] {i : m} {i' : m}, (Ne.{succ u3} m i i') -> (forall (j : n) (j' : n) (a : α), Eq.{succ u2} α (Matrix.stdBasisMatrix.{u3, u1, u2} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_row_ne Matrix.StdBasisMatrix.apply_of_row_neₓ'. -/
 @[simp]
 theorem apply_of_row_ne {i i' : m} (hi : i ≠ i') (j j' : n) (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hi]
-#align matrix.std_basis_matrix.apply_of_row_ne Matrix.stdBasisMatrix.apply_of_row_ne
-
+#align matrix.std_basis_matrix.apply_of_row_ne Matrix.StdBasisMatrix.apply_of_row_ne
+
+/- warning: matrix.std_basis_matrix.apply_of_col_ne -> Matrix.StdBasisMatrix.apply_of_col_ne is a dubious translation:
+lean 3 declaration is
+  forall {m : Type.{u1}} {n : Type.{u2}} {α : Type.{u3}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u3} α] (i : m) (i' : m) {j : n} {j' : n}, (Ne.{succ u2} n j j') -> (forall (a : α), Eq.{succ u3} α (Matrix.stdBasisMatrix.{u1, u2, u3} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u3} α 0 (OfNat.mk.{u3} α 0 (Zero.zero.{u3} α (MulZeroClass.toHasZero.{u3} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u3} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u3} α (Semiring.toNonAssocSemiring.{u3} α _inst_4))))))))
+but is expected to have type
+  forall {m : Type.{u1}} {n : Type.{u3}} {α : Type.{u2}} [_inst_2 : DecidableEq.{succ u1} m] [_inst_3 : DecidableEq.{succ u3} n] [_inst_4 : Semiring.{u2} α] (i : m) (i' : m) {j : n} {j' : n}, (Ne.{succ u3} n j j') -> (forall (a : α), Eq.{succ u2} α (Matrix.stdBasisMatrix.{u1, u3, u2} m n α (fun (a : m) (b : m) => _inst_2 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j a i' j') (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.apply_of_col_ne Matrix.StdBasisMatrix.apply_of_col_neₓ'. -/
 @[simp]
 theorem apply_of_col_ne (i i' : m) {j j' : n} (hj : j ≠ j') (a : α) :
     stdBasisMatrix i j a i' j' = 0 := by simp [hj]
-#align matrix.std_basis_matrix.apply_of_col_ne Matrix.stdBasisMatrix.apply_of_col_ne
+#align matrix.std_basis_matrix.apply_of_col_ne Matrix.StdBasisMatrix.apply_of_col_ne
 
 end
 
@@ -144,48 +212,98 @@ section
 
 variable (i j : n) (c : α) (i' j' : n)
 
+/- warning: matrix.std_basis_matrix.diag_zero -> Matrix.StdBasisMatrix.diag_zero is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α), (Ne.{succ u1} n j i) -> (Eq.{max (succ u1) (succ u2)} (n -> α) (Matrix.diag.{u2, u1} n α (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{max u1 u2} (n -> α) 0 (OfNat.mk.{max u1 u2} (n -> α) 0 (Zero.zero.{max u1 u2} (n -> α) (Pi.instZero.{u1, u2} n (fun (i : n) => α) (fun (i : n) => MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))))))))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α), (Ne.{succ u2} n j i) -> (Eq.{max (succ u2) (succ u1)} (n -> α) (Matrix.diag.{u1, u2} n α (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{max u2 u1} (n -> α) 0 (Zero.toOfNat0.{max u2 u1} (n -> α) (Pi.instZero.{u2, u1} n (fun (i : n) => α) (fun (i : n) => MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.diag_zero Matrix.StdBasisMatrix.diag_zeroₓ'. -/
 @[simp]
 theorem diag_zero (h : j ≠ i) : diag (stdBasisMatrix i j c) = 0 :=
   funext fun k => if_neg fun ⟨e₁, e₂⟩ => h (e₂.trans e₁.symm)
-#align matrix.std_basis_matrix.diag_zero Matrix.stdBasisMatrix.diag_zero
-
+#align matrix.std_basis_matrix.diag_zero Matrix.StdBasisMatrix.diag_zero
+
+/- warning: matrix.std_basis_matrix.diag_same -> Matrix.StdBasisMatrix.diag_same is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (c : α), Eq.{max (succ u1) (succ u2)} (n -> α) (Matrix.diag.{u2, u1} n α (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i i c)) (Pi.single.{u1, u2} n (fun (i : n) => α) (fun (a : n) (b : n) => _inst_3 a b) (fun (i : n) => MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) i c)
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (c : α), Eq.{max (succ u2) (succ u1)} (n -> α) (Matrix.diag.{u1, u2} n α (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i i c)) (Pi.single.{u2, u1} n (fun (i : n) => α) (fun (a : n) (b : n) => _inst_3 a b) (fun (i : n) => MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)) i c)
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_sameₓ'. -/
 @[simp]
 theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c :=
   by
   ext j
   by_cases hij : i = j <;> try rw [hij] <;> simp [hij]
-#align matrix.std_basis_matrix.diag_same Matrix.stdBasisMatrix.diag_same
+#align matrix.std_basis_matrix.diag_same Matrix.StdBasisMatrix.diag_same
 
 variable [Fintype n]
 
+/- warning: matrix.std_basis_matrix.trace_zero -> Matrix.StdBasisMatrix.trace_zero is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n], (Ne.{succ u1} n j i) -> (Eq.{succ u2} α (Matrix.trace.{u1, u2} n α _inst_5 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n], (Ne.{succ u2} n j i) -> (Eq.{succ u1} α (Matrix.trace.{u2, u1} n α _inst_5 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.trace_zero Matrix.StdBasisMatrix.trace_zeroₓ'. -/
 @[simp]
 theorem trace_zero (h : j ≠ i) : trace (stdBasisMatrix i j c) = 0 := by simp [trace, h]
-#align matrix.std_basis_matrix.trace_zero Matrix.stdBasisMatrix.trace_zero
+#align matrix.std_basis_matrix.trace_zero Matrix.StdBasisMatrix.trace_zero
 
+#print Matrix.StdBasisMatrix.trace_eq /-
 @[simp]
 theorem trace_eq : trace (stdBasisMatrix i i c) = c := by simp [trace]
-#align matrix.std_basis_matrix.trace_eq Matrix.stdBasisMatrix.trace_eq
+#align matrix.std_basis_matrix.trace_eq Matrix.StdBasisMatrix.trace_eq
+-/
 
+/- warning: matrix.std_basis_matrix.mul_left_apply_same -> Matrix.StdBasisMatrix.mul_left_apply_same is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (b : n) (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M i b) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) c (M j b))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (b : n) (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M i b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) c (M j b))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_sameₓ'. -/
 @[simp]
 theorem mul_left_apply_same (b : n) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) i b = c * M j b := by simp [mul_apply, std_basis_matrix]
-#align matrix.std_basis_matrix.mul_left_apply_same Matrix.stdBasisMatrix.mul_left_apply_same
-
+#align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_same
+
+/- warning: matrix.std_basis_matrix.mul_right_apply_same -> Matrix.StdBasisMatrix.mul_right_apply_same is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) M (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a j) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) (M a i) c)
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) M (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a j) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) (M a i) c)
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_sameₓ'. -/
 @[simp]
 theorem mul_right_apply_same (a : n) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a j = M a i * c := by simp [mul_apply, std_basis_matrix, mul_comm]
-#align matrix.std_basis_matrix.mul_right_apply_same Matrix.stdBasisMatrix.mul_right_apply_same
-
+#align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_same
+
+/- warning: matrix.std_basis_matrix.mul_left_apply_of_ne -> Matrix.StdBasisMatrix.mul_left_apply_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (b : n), (Ne.{succ u1} n a i) -> (forall (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M a b) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (b : n), (Ne.{succ u2} n a i) -> (forall (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) M a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_neₓ'. -/
 @[simp]
 theorem mul_left_apply_of_ne (a b : n) (h : a ≠ i) (M : Matrix n n α) :
     (stdBasisMatrix i j c ⬝ M) a b = 0 := by simp [mul_apply, h.symm]
-#align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.stdBasisMatrix.mul_left_apply_of_ne
-
+#align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_ne
+
+/- warning: matrix.std_basis_matrix.mul_right_apply_of_ne -> Matrix.StdBasisMatrix.mul_right_apply_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (a : n) (b : n), (Ne.{succ u1} n b j) -> (forall (M : Matrix.{u1, u1, u2} n n α), Eq.{succ u2} α (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) M (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a b) (OfNat.ofNat.{u2} α 0 (OfNat.mk.{u2} α 0 (Zero.zero.{u2} α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))))))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (a : n) (b : n), (Ne.{succ u2} n b j) -> (forall (M : Matrix.{u2, u2, u1} n n α), Eq.{succ u1} α (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) M (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4)))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_neₓ'. -/
 @[simp]
 theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
     (M ⬝ stdBasisMatrix i j c) a b = 0 := by simp [mul_apply, hbj.symm]
-#align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.stdBasisMatrix.mul_right_apply_of_ne
-
+#align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_ne
+
+/- warning: matrix.std_basis_matrix.mul_same -> Matrix.StdBasisMatrix.mul_same is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] (k : n) (d : α), Eq.{succ (max u1 u2)} (Matrix.{u1, u1, u2} n n α) (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 j k d)) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i k (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))))) c d))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] (k : n) (d : α), Eq.{max (succ u2) (succ u1)} (Matrix.{u2, u2, u1} n n α) (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 j k d)) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i k (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4)))) c d))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_sameₓ'. -/
 @[simp]
 theorem mul_same (k : n) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) :=
@@ -193,15 +311,21 @@ theorem mul_same (k : n) (d : α) :
   ext (a b)
   simp only [mul_apply, std_basis_matrix, boole_mul]
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
-#align matrix.std_basis_matrix.mul_same Matrix.stdBasisMatrix.mul_same
-
+#align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
+
+/- warning: matrix.std_basis_matrix.mul_of_ne -> Matrix.StdBasisMatrix.mul_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {n : Type.{u1}} {α : Type.{u2}} [_inst_3 : DecidableEq.{succ u1} n] [_inst_4 : Semiring.{u2} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u1} n] {k : n} {l : n}, (Ne.{succ u1} n j k) -> (forall (d : α), Eq.{succ (max u1 u2)} (Matrix.{u1, u1, u2} n n α) (Matrix.mul.{u2, u1, u1, u1} n n n α _inst_5 (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4))) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u1, u1, u2} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 k l d)) (OfNat.ofNat.{max u1 u2} (Matrix.{u1, u1, u2} n n α) 0 (OfNat.mk.{max u1 u2} (Matrix.{u1, u1, u2} n n α) 0 (Zero.zero.{max u1 u2} (Matrix.{u1, u1, u2} n n α) (Matrix.hasZero.{u2, u1, u1} n n α (MulZeroClass.toHasZero.{u2} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_4)))))))))
+but is expected to have type
+  forall {n : Type.{u2}} {α : Type.{u1}} [_inst_3 : DecidableEq.{succ u2} n] [_inst_4 : Semiring.{u1} α] (i : n) (j : n) (c : α) [_inst_5 : Fintype.{u2} n] {k : n} {l : n}, (Ne.{succ u2} n j k) -> (forall (d : α), Eq.{max (succ u2) (succ u1)} (Matrix.{u2, u2, u1} n n α) (Matrix.mul.{u1, u2, u2, u2} n n n α _inst_5 (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_4))) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 i j c) (Matrix.stdBasisMatrix.{u2, u2, u1} n n α (fun (a : n) (b : n) => _inst_3 a b) (fun (a : n) (b : n) => _inst_3 a b) _inst_4 k l d)) (OfNat.ofNat.{max u2 u1} (Matrix.{u2, u2, u1} n n α) 0 (Zero.toOfNat0.{max u2 u1} (Matrix.{u2, u2, u1} n n α) (Matrix.zero.{u1, u2, u2} n n α (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_4))))))
+Case conversion may be inaccurate. Consider using '#align matrix.std_basis_matrix.mul_of_ne Matrix.StdBasisMatrix.mul_of_neₓ'. -/
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 :=
   by
   ext (a b)
   simp only [mul_apply, boole_mul, std_basis_matrix]
   by_cases h₁ : i = a <;> simp [h₁, h, h.symm]
-#align matrix.std_basis_matrix.mul_of_ne Matrix.stdBasisMatrix.mul_of_ne
+#align matrix.std_basis_matrix.mul_of_ne Matrix.StdBasisMatrix.mul_of_ne
 
 end

320df450

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

320df450

refactor: golf proof using lmarginal (#10857)

Co-authored-by: Heather Macbeth [25316162+hrmacbeth@users.noreply.github.com](mailto:25316162+hrmacbeth@users.noreply.github.com)

1fb63b46

Diff

@@ -56,6 +56,14 @@ theorem stdBasisMatrix_add (i : m) (j : n) (a b : α) :
   split_ifs with h <;> simp [h]
 #align matrix.std_basis_matrix_add Matrix.stdBasisMatrix_add
 
+theorem mulVec_stdBasisMatrix [Fintype m] (i : n) (j : m) (c : α) (x : m → α) :
+    mulVec (stdBasisMatrix i j c) x = Function.update (0 : n → α) i (c * x j) := by
+  ext i'
+  simp [stdBasisMatrix, mulVec, dotProduct]
+  rcases eq_or_ne i i' with rfl|h
+  · simp
+  simp [h, h.symm]
+
 theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     x = ∑ i : m, ∑ j : n, stdBasisMatrix i j (x i j) := by
   ext i j; symm

320df450

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -17,7 +17,6 @@ at position `(i, j)`, and zeroes elsewhere.
 
 
 variable {l m n : Type*}
-
 variable {R α : Type*}
 
 namespace Matrix
@@ -27,7 +26,6 @@ open Matrix
 open BigOperators
 
 variable [DecidableEq l] [DecidableEq m] [DecidableEq n]
-
 variable [Semiring α]
 
 /-- `stdBasisMatrix i j a` is the matrix with `a` in the `i`-th row, `j`-th column,

320df450

chore(*): Fintype -> Finite, drop Decidable (#11423)

Also, in some cases drop unneeded Fintype arguments.

e22cf367

Diff

@@ -91,9 +91,10 @@ theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :
 
 -- todo: the old proof used fintypes, I don't know `Finsupp` but this feels generalizable
 @[elab_as_elim]
-protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → Prop} (M : Matrix m n α)
+protected theorem induction_on' [Finite m] [Finite n] {P : Matrix m n α → Prop} (M : Matrix m n α)
     (h_zero : P 0) (h_add : ∀ p q, P p → P q → P (p + q))
     (h_std_basis : ∀ (i : m) (j : n) (x : α), P (stdBasisMatrix i j x)) : P M := by
+  cases nonempty_fintype m; cases nonempty_fintype n
   rw [matrix_eq_sum_std_basis M, ← Finset.sum_product']
   apply Finset.sum_induction _ _ h_add h_zero
   · intros
@@ -101,7 +102,7 @@ protected theorem induction_on' [Fintype m] [Fintype n] {P : Matrix m n α → P
 #align matrix.induction_on' Matrix.induction_on'
 
 @[elab_as_elim]
-protected theorem induction_on [Fintype m] [Fintype n] [Nonempty m] [Nonempty n]
+protected theorem induction_on [Finite m] [Finite n] [Nonempty m] [Nonempty n]
     {P : Matrix m n α → Prop} (M : Matrix m n α) (h_add : ∀ p q, P p → P q → P (p + q))
     (h_std_basis : ∀ i j x, P (stdBasisMatrix i j x)) : P M :=
   Matrix.induction_on' M

320df450

chore: remove useless tactics (#11333)

The removal of some pointless tactics flagged by #11308.

ee18bf38

Diff

@@ -251,8 +251,7 @@ theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
     obtain rfl | hij := Decidable.eq_or_ne i j
     · rfl
     · exact diag_eq_of_commute_stdBasisMatrix (hM hij)
-  · push_neg at hkl
-    rw [diagonal_apply_ne _ hkl]
+  · rw [diagonal_apply_ne _ hkl]
     obtain rfl | hij := Decidable.eq_or_ne i j
     · rw [col_eq_zero_of_commute_stdBasisMatrix (hM hkl.symm) hkl]
     · rw [row_eq_zero_of_commute_stdBasisMatrix (hM hij) hkl.symm]

320df450

chore: classify was simp porting notes (#10746)

Classifies by adding issue number (#10745) to porting notes claiming was simp.

71e045ac

Diff

@@ -204,7 +204,7 @@ theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
   ext a b
   simp only [mul_apply, boole_mul, stdBasisMatrix]
   by_cases h₁ : i = a
-  -- Porting note: was `simp [h₁, h, h.symm]`
+  -- porting note (#10745): was `simp [h₁, h, h.symm]`
   · simp only [h₁, true_and, mul_ite, ite_mul, zero_mul, mul_zero, ← ite_and, zero_apply]
     refine Finset.sum_eq_zero (fun x _ => ?_)
     apply if_neg

320df450

feat(LinearAlgebra/Matrix): scalar if commutes with every nontrivial transvection (#7815)

M is a scalar matrix if it commutes with every nontrivial transvection (elementary matrix).

Also adds iff versions and corrects the names of the lemmas in #7810

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

Co-authored-by: Wen Yang <yang-wen@139.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

71296caa

Diff

@@ -38,11 +38,11 @@ def stdBasisMatrix (i : m) (j : n) (a : α) : Matrix m n α := fun i' j' =>
 #align matrix.std_basis_matrix Matrix.stdBasisMatrix
 
 @[simp]
-theorem smul_stdBasisMatrix (i : m) (j : n) (a b : α) :
-    b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a) := by
+theorem smul_stdBasisMatrix [SMulZeroClass R α] (r : R) (i : m) (j : n) (a : α) :
+    r • stdBasisMatrix i j a = stdBasisMatrix i j (r • a) := by
   unfold stdBasisMatrix
   ext
-  simp
+  simp [smul_ite]
 #align matrix.smul_std_basis_matrix Matrix.smul_stdBasisMatrix
 
 @[simp]
@@ -216,6 +216,8 @@ theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
 
 end
 
+end StdBasisMatrix
+
 section Commute
 
 variable [Fintype n]
@@ -255,8 +257,20 @@ theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
     · rw [col_eq_zero_of_commute_stdBasisMatrix (hM hkl.symm) hkl]
     · rw [row_eq_zero_of_commute_stdBasisMatrix (hM hij) hkl.symm]
 
-end Commute
+theorem mem_range_scalar_iff_commute_stdBasisMatrix {M : Matrix n n α} :
+    M ∈ Set.range (Matrix.scalar n) ↔ ∀ (i j : n), i ≠ j → Commute (stdBasisMatrix i j 1) M := by
+  refine ⟨fun ⟨r, hr⟩ i j _ => hr ▸ Commute.symm ?_, mem_range_scalar_of_commute_stdBasisMatrix⟩
+  rw [scalar_commute_iff]
+  simp
 
-end StdBasisMatrix
+/-- `M` is a scalar matrix if and only if it commutes with every `stdBasisMatrix`. -/
+theorem mem_range_scalar_iff_commute_stdBasisMatrix' {M : Matrix n n α} :
+    M ∈ Set.range (Matrix.scalar n) ↔ ∀ (i j : n), Commute (stdBasisMatrix i j 1) M := by
+  refine ⟨fun ⟨r, hr⟩ i j => hr ▸ Commute.symm ?_,
+    fun hM => mem_range_scalar_iff_commute_stdBasisMatrix.mpr <| fun i j _ => hM i j⟩
+  rw [scalar_commute_iff]
+  simp
+
+end Commute
 
 end Matrix

320df450

refactor: Use Pairwise wherever possible (#9236)

Performed with a regex search for ∀ (.) (.), \1 ≠ \2 →, and a few variants to catch implicit binders and explicit types.

I have deliberately avoided trying to make the analogous Set.Pairwise transformation (or any Pairwise (foo on bar) transformations) in this PR, to keep the diff small.

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

86393c89

Diff

@@ -237,7 +237,7 @@ theorem diag_eq_of_commute_stdBasisMatrix {i j : n} {M : Matrix n n α}
 
 /-- `M` is a scalar matrix if it commutes with every non-diagonal `stdBasisMatrix`. -/
 theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
-    (hM : ∀ (i j : n), i ≠ j → Commute (stdBasisMatrix i j 1) M) :
+    (hM : Pairwise fun i j => Commute (stdBasisMatrix i j 1) M) :
     M ∈ Set.range (Matrix.scalar n) := by
   cases isEmpty_or_nonempty n
   · exact ⟨0, Subsingleton.elim _ _⟩
@@ -248,12 +248,12 @@ theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
   · rw [diagonal_apply_eq]
     obtain rfl | hij := Decidable.eq_or_ne i j
     · rfl
-    · exact diag_eq_of_commute_stdBasisMatrix (hM _ _ hij)
+    · exact diag_eq_of_commute_stdBasisMatrix (hM hij)
   · push_neg at hkl
     rw [diagonal_apply_ne _ hkl]
     obtain rfl | hij := Decidable.eq_or_ne i j
-    · rw [col_eq_zero_of_commute_stdBasisMatrix (hM k i hkl.symm) hkl]
-    · rw [row_eq_zero_of_commute_stdBasisMatrix (hM i j hij) hkl.symm]
+    · rw [col_eq_zero_of_commute_stdBasisMatrix (hM hkl.symm) hkl]
+    · rw [row_eq_zero_of_commute_stdBasisMatrix (hM hij) hkl.symm]
 
 end Commute

320df450

feat(Data/Matrix): scalar if commutes with every stdBasisMatrix (#7810)

M is a scalar matrix if it commutes with every non-diagonal stdBasisMatrix.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

5b49f9f4

Diff

@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2020 Jalex Stark. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash
+Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash, Wen Yang
 -/
 import Mathlib.Data.Matrix.Basic
 import Mathlib.LinearAlgebra.Matrix.Trace
@@ -216,6 +216,47 @@ theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
 
 end
 
+section Commute
+
+variable [Fintype n]
+
+theorem row_eq_zero_of_commute_stdBasisMatrix {i j k : n} {M : Matrix n n α}
+    (hM : Commute (stdBasisMatrix i j 1) M) (hkj : k ≠ j) : M j k = 0 := by
+  have := ext_iff.mpr hM i k
+  aesop
+
+theorem col_eq_zero_of_commute_stdBasisMatrix {i j k : n} {M : Matrix n n α}
+    (hM : Commute (stdBasisMatrix i j 1) M) (hki : k ≠ i) : M k i = 0 := by
+  have := ext_iff.mpr hM k j
+  aesop
+
+theorem diag_eq_of_commute_stdBasisMatrix {i j : n} {M : Matrix n n α}
+    (hM : Commute (stdBasisMatrix i j 1) M) : M i i = M j j := by
+  have := ext_iff.mpr hM i j
+  aesop
+
+/-- `M` is a scalar matrix if it commutes with every non-diagonal `stdBasisMatrix`. -/
+theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
+    (hM : ∀ (i j : n), i ≠ j → Commute (stdBasisMatrix i j 1) M) :
+    M ∈ Set.range (Matrix.scalar n) := by
+  cases isEmpty_or_nonempty n
+  · exact ⟨0, Subsingleton.elim _ _⟩
+  obtain ⟨i⟩ := ‹Nonempty n›
+  refine ⟨M i i, Matrix.ext fun j k => ?_⟩
+  simp only [scalar_apply]
+  obtain rfl | hkl := Decidable.eq_or_ne j k
+  · rw [diagonal_apply_eq]
+    obtain rfl | hij := Decidable.eq_or_ne i j
+    · rfl
+    · exact diag_eq_of_commute_stdBasisMatrix (hM _ _ hij)
+  · push_neg at hkl
+    rw [diagonal_apply_ne _ hkl]
+    obtain rfl | hij := Decidable.eq_or_ne i j
+    · rw [col_eq_zero_of_commute_stdBasisMatrix (hM k i hkl.symm) hkl]
+    · rw [row_eq_zero_of_commute_stdBasisMatrix (hM i j hij) hkl.symm]
+
+end Commute
+
 end StdBasisMatrix
 
 end Matrix

320df450

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -65,12 +65,12 @@ theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
   -- Porting note: was `convert`
   refine (Fintype.sum_eq_single i ?_).trans ?_; swap
   · -- Porting note: `simp` seems unwilling to apply `Fintype.sum_apply`
-    simp only [stdBasisMatrix]
+    simp (config := { unfoldPartialApp := true }) only [stdBasisMatrix]
     rw [Fintype.sum_apply, Fintype.sum_apply]
     simp
   · intro j' hj'
     -- Porting note: `simp` seems unwilling to apply `Fintype.sum_apply`
-    simp only [stdBasisMatrix]
+    simp (config := { unfoldPartialApp := true }) only [stdBasisMatrix]
     rw [Fintype.sum_apply, Fintype.sum_apply]
     simp [hj']
 #align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basis

320df450

chore: fix some cases in names (#7469)

And fix some names in comments where this revealed issues

be0d066c

Diff

@@ -11,7 +11,7 @@ import Mathlib.LinearAlgebra.Matrix.Trace
 /-!
 # Matrices with a single non-zero element.
 
-This file provides `matrix.stdBasisMatrix`. The matrix `matrix.stdBasisMatrix i j c` has `c`
+This file provides `Matrix.stdBasisMatrix`. The matrix `Matrix.stdBasisMatrix i j c` has `c`
 at position `(i, j)`, and zeroes elsewhere.
 -/

320df450

refactor(Data/Matrix): Eliminate ⬝ notation in favor of HMul (#6487)

The main difficulty here is that * has a slightly difference precedence to ⬝. notably around smul and neg.

The other annoyance is that ↑U ⬝ A ⬝ ↑U⁻¹ : Matrix m m 𝔸 now has to be written U.val * A * (U⁻¹).val in order to typecheck.

A downside of this change to consider: if you have a goal of A * (B * C) = (A * B) * C, mul_assoc now gives the illusion of matching, when in fact Matrix.mul_assoc is needed. Previously the distinct symbol made it easy to avoid this mistake.

On the flipside, there is now no need to rewrite by Matrix.mul_eq_mul all the time (indeed, the lemma is now removed).

38c07226

Diff

@@ -172,27 +172,27 @@ theorem trace_eq : trace (stdBasisMatrix i i c) = c := by
 
 @[simp]
 theorem mul_left_apply_same (b : n) (M : Matrix n n α) :
-    (stdBasisMatrix i j c ⬝ M) i b = c * M j b := by simp [mul_apply, stdBasisMatrix]
+    (stdBasisMatrix i j c * M) i b = c * M j b := by simp [mul_apply, stdBasisMatrix]
 #align matrix.std_basis_matrix.mul_left_apply_same Matrix.StdBasisMatrix.mul_left_apply_same
 
 @[simp]
 theorem mul_right_apply_same (a : n) (M : Matrix n n α) :
-    (M ⬝ stdBasisMatrix i j c) a j = M a i * c := by simp [mul_apply, stdBasisMatrix, mul_comm]
+    (M * stdBasisMatrix i j c) a j = M a i * c := by simp [mul_apply, stdBasisMatrix, mul_comm]
 #align matrix.std_basis_matrix.mul_right_apply_same Matrix.StdBasisMatrix.mul_right_apply_same
 
 @[simp]
 theorem mul_left_apply_of_ne (a b : n) (h : a ≠ i) (M : Matrix n n α) :
-    (stdBasisMatrix i j c ⬝ M) a b = 0 := by simp [mul_apply, h.symm]
+    (stdBasisMatrix i j c * M) a b = 0 := by simp [mul_apply, h.symm]
 #align matrix.std_basis_matrix.mul_left_apply_of_ne Matrix.StdBasisMatrix.mul_left_apply_of_ne
 
 @[simp]
 theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
-    (M ⬝ stdBasisMatrix i j c) a b = 0 := by simp [mul_apply, hbj.symm]
+    (M * stdBasisMatrix i j c) a b = 0 := by simp [mul_apply, hbj.symm]
 #align matrix.std_basis_matrix.mul_right_apply_of_ne Matrix.StdBasisMatrix.mul_right_apply_of_ne
 
 @[simp]
 theorem mul_same (k : n) (d : α) :
-    stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) := by
+    stdBasisMatrix i j c * stdBasisMatrix j k d = stdBasisMatrix i k (c * d) := by
   ext a b
   simp only [mul_apply, stdBasisMatrix, boole_mul]
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
@@ -200,7 +200,7 @@ theorem mul_same (k : n) (d : α) :
 
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
-    stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 := by
+    stdBasisMatrix i j c * stdBasisMatrix k l d = 0 := by
   ext a b
   simp only [mul_apply, boole_mul, stdBasisMatrix]
   by_cases h₁ : i = a

320df450

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -16,9 +16,9 @@ at position `(i, j)`, and zeroes elsewhere.
 -/
 
 
-variable {l m n : Type _}
+variable {l m n : Type*}
 
-variable {R α : Type _}
+variable {R α : Type*}
 
 namespace Matrix

320df450

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Jalex Stark. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jalex Stark, Scott Morrison, Eric Wieser, Oliver Nash
-
-! This file was ported from Lean 3 source module data.matrix.basis
-! leanprover-community/mathlib commit 320df450e9abeb5fc6417971e75acb6ae8bc3794
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Matrix.Basic
 import Mathlib.LinearAlgebra.Matrix.Trace
 
+#align_import data.matrix.basis from "leanprover-community/mathlib"@"320df450e9abeb5fc6417971e75acb6ae8bc3794"
+
 /-!
 # Matrices with a single non-zero element.

320df450

chore: remove superfluous parentheses in calls to ext (#5258)

Co-authored-by: Xavier Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Pol'tta / Miyahara Kō <pol_tta@outlook.jp> Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com> Co-authored-by: Jujian Zhang <jujian.zhang1998@outlook.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

3d6731dc

Diff

@@ -196,7 +196,7 @@ theorem mul_right_apply_of_ne (a b : n) (hbj : b ≠ j) (M : Matrix n n α) :
 @[simp]
 theorem mul_same (k : n) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix j k d = stdBasisMatrix i k (c * d) := by
-  ext (a b)
+  ext a b
   simp only [mul_apply, stdBasisMatrix, boole_mul]
   by_cases h₁ : i = a <;> by_cases h₂ : k = b <;> simp [h₁, h₂]
 #align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
@@ -204,7 +204,7 @@ theorem mul_same (k : n) (d : α) :
 @[simp]
 theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
     stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 := by
-  ext (a b)
+  ext a b
   simp only [mul_apply, boole_mul, stdBasisMatrix]
   by_cases h₁ : i = a
   -- Porting note: was `simp [h₁, h, h.symm]`

320df450

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -78,7 +78,7 @@ theorem matrix_eq_sum_std_basis [Fintype m] [Fintype n] (x : Matrix m n α) :
     simp [hj']
 #align matrix.matrix_eq_sum_std_basis Matrix.matrix_eq_sum_std_basis
 
--- TODO: tie this up with the `basis` machinery of linear algebra
+-- TODO: tie this up with the `Basis` machinery of linear algebra
 -- this is not completely trivial because we are indexing by two types, instead of one
 -- TODO: add `std_basis_vec`
 theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :

320df450

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -202,8 +202,8 @@ theorem mul_same (k : n) (d : α) :
 #align matrix.std_basis_matrix.mul_same Matrix.StdBasisMatrix.mul_same
 
 @[simp]
-theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) : stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 :=
-  by
+theorem mul_of_ne {k l : n} (h : j ≠ k) (d : α) :
+    stdBasisMatrix i j c ⬝ stdBasisMatrix k l d = 0 := by
   ext (a b)
   simp only [mul_apply, boole_mul, stdBasisMatrix]
   by_cases h₁ : i = a

320df450

feat: port Data.Matrix.Basis (#3243)

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

e25fc659

`data.matrix.basis` ⟷ `Mathlib.Data.Matrix.Basis`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 8 + 385

data.matrix.basis ⟷ Mathlib.Data.Matrix.Basis

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 8 + 385

`data.matrix.basis` ⟷ `Mathlib.Data.Matrix.Basis`