ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matrix.StdBasisMatrix.diag_zero
@[simp]
theorem diag_zero (h : j ≠ i) : diag (stdBasisMatrix i j c) = 0 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) (h : j ≠ i)
Goal: (Matrix.stdBasisMatrix i j c).diag = 0
-- Matrix.StdBasisMatrix.diag_same
@[simp]
theorem diag_same : diag (stdBasisMatrix i i c) = Pi.single i c 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i : n) (c : α)
Goal: (Matrix.stdBasisMatrix i i c).diag = Pi.single i c
-- Matrix.StdBasisMatrix.trace_zero
@[simp]
theorem trace_zero (h : j ≠ i) : trace (stdBasisMatrix i j c) = 0 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (h : j ≠ i)
Goal: (Matrix.stdBasisMatrix i j c).trace = 0
-- Matrix.StdBasisMatrix.trace_eq
@[simp]
theorem trace_eq : trace (stdBasisMatrix i i c) = c 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i : n) (c : α) [Fintype n]
Goal: (Matrix.stdBasisMatrix i i c).trace = c
-- 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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (b : n) (M : Matrix n n α)
Goal: (Matrix.stdBasisMatrix i j c * M) i b = c * M j b
-- 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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (a : n) (M : Matrix n n α)
Goal: (M * Matrix.stdBasisMatrix i j c) a j = M a i * c
-- 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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (a b : n) (h : a ≠ i) (M : Matrix n n α)
Goal: (Matrix.stdBasisMatrix i j c * M) a b = 0
-- 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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (a b : n) (hbj : b ≠ j) (M : Matrix n n α)
Goal: (M * Matrix.stdBasisMatrix i j c) a b = 0
-- Matrix.StdBasisMatrix.mul_same
@[simp]
theorem mul_same (k : n) (d : α) :
    stdBasisMatrix i j c * stdBasisMatrix j k d = stdBasisMatrix i k (c * d) 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] (k : n) (d : α)
Goal: Matrix.stdBasisMatrix i j c * Matrix.stdBasisMatrix j k d = Matrix.stdBasisMatrix i k (c * d)
-- 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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] (i j : n) (c : α) [Fintype n] {k l : n} (h : j ≠ k) (d : α)
Goal: Matrix.stdBasisMatrix i j c * Matrix.stdBasisMatrix k l d = 0
-- Matrix.row_eq_zero_of_commute_stdBasisMatrix
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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {i j k : n} {M : Matrix n n α} (hM : Commute (Matrix.stdBasisMatrix i j 1) M) (hkj : k ≠ j)
Goal: M j k = 0
-- Matrix.col_eq_zero_of_commute_stdBasisMatrix
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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {i j k : n} {M : Matrix n n α} (hM : Commute (Matrix.stdBasisMatrix i j 1) M) (hki : k ≠ i)
Goal: M k i = 0
-- Matrix.diag_eq_of_commute_stdBasisMatrix
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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {i j : n} {M : Matrix n n α} (hM : Commute (Matrix.stdBasisMatrix i j 1) M)
Goal: M i i = M j j
-- Matrix.mem_range_scalar_of_commute_stdBasisMatrix
theorem mem_range_scalar_of_commute_stdBasisMatrix {M : Matrix n n α}
    (hM : Pairwise fun i j => Commute (stdBasisMatrix i j 1) M) :
    M ∈ Set.range (Matrix.scalar n) 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {M : Matrix n n α} (hM : Pairwise fun i j => Commute (Matrix.stdBasisMatrix i j 1) M)
Goal: M ∈ Set.range ⇑(Matrix.scalar n)
-- Matrix.mem_range_scalar_iff_commute_stdBasisMatrix
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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {M : Matrix n n α}
Goal: M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), i ≠ j → Commute (Matrix.stdBasisMatrix i j 1) M
-- Matrix.mem_range_scalar_iff_commute_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 
Arguments: {n : Type u_3} {α : Type u_5} [DecidableEq n] [Semiring α] [Fintype n] {M : Matrix n n α}
Goal: M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), Commute (Matrix.stdBasisMatrix i j 1) M
-- MvQPF.Const.mk_get
@[simp]
protected theorem mk_get (x : Const n A α) : Const.mk (Const.get x) = x 
Arguments: {n : ℕ} {A : Type u} {α : TypeVec.{u} n} (x : MvQPF.Const n A α)
Goal: MvQPF.Const.mk x.get = x
-- MvQPF.Const.get_mk
@[simp]
protected theorem get_mk (x : A) : Const.get (Const.mk x : Const n A α) = x 
Arguments: {n : ℕ} {A : Type u} {α : TypeVec.{u} n} (x : A)
Goal: (MvQPF.Const.mk x).get = x
-- MvQPF.Const.map_mk
theorem map_mk (x : A) : f <$$> Const.mk x = Const.mk x 
Arguments: {n : ℕ} {A : Type u} {α β : TypeVec.{u} n} (f : α.Arrow β) (x : A)
Goal: MvFunctor.map f (MvQPF.Const.mk x) = MvQPF.Const.mk x
-- MvQPF.Const.get_map
theorem get_map (x : (Const n A) α) : Const.get (f <$$> x) = Const.get x 
Arguments: {n : ℕ} {A : Type u} {α β : TypeVec.{u} n} (f : α.Arrow β) (x : MvQPF.Const n A α)
Goal: (MvFunctor.map f x).get = x.get
-- Vector3.cons_fz
@[simp]
theorem cons_fz (a : α) (v : Vector3 α n) : (a :: v) fz = a 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Vector3 α n)
Goal: Vector3.cons a v Fin2.fz = a
-- Vector3.cons_fs
@[simp]
theorem cons_fs (a : α) (v : Vector3 α n) (i) : (a :: v) (fs i) = v i 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Vector3 α n) (i : Fin2 n)
Goal: Vector3.cons a v i.fs = v i
-- Vector3.eq_nil
theorem eq_nil (v : Vector3 α 0) : v = [] 
Arguments: {α : Type u_1} (v : Vector3 α 0)
Goal: v = []
-- Vector3.cons_head_tail
theorem cons_head_tail (v : Vector3 α (n + 1)) : (head v :: tail v) = v 
Arguments: {α : Type u_1} {n : ℕ} (v : Vector3 α (n + 1))
Goal: Vector3.cons v.head v.tail = v
-- Vector3.consElim_cons
@[simp]
theorem consElim_cons {C H a t} : @consElim α n C H (a :: t) = H a t 
Arguments: {α : Type u_1} {n : ℕ} {C : Vector3 α (n + 1) → Sort u_2} {H : (a : α) → (t : Vector3 α n) → C (Vector3.cons a t)} {a : α} {t : Vector3 α n}
Goal: Vector3.consElim H (Vector3.cons a t) = H a t
-- Vector3.recOn_nil
@[simp]
theorem recOn_nil {C H0 Hs} : @Vector3.recOn α (@C) 0 [] H0 @Hs = H0 
Arguments: {α : Type u_1} {C : {n : ℕ} → Vector3 α n → Sort u_2} {H0 : C []} {Hs : {n : ℕ} → (a : α) → (w : Vector3 α n) → C w → C (Vector3.cons a w)}
Goal: [].recOn H0 Hs = H0
-- Vector3.recOn_cons
@[simp]
theorem recOn_cons {C H0 Hs n a v} :
    @Vector3.recOn α (@C) (n + 1) (a :: v) H0 @Hs = Hs a v (@Vector3.recOn α (@C) n v H0 @Hs) 
Arguments: {α : Type u_1} {C : {n : ℕ} → Vector3 α n → Sort u_2} {H0 : C []} {Hs : {n : ℕ} → (a : α) → (w : Vector3 α n) → C w → C (Vector3.cons a w)} {n : ℕ} {a : α} {v : Vector3 α n}
Goal: (Vector3.cons a v).recOn H0 Hs = Hs a v (v.recOn H0 Hs)
-- Vector3.append_nil
@[simp]
theorem append_nil (w : Vector3 α n) : [] +-+ w = w 
Arguments: {α : Type u_1} {n : ℕ} (w : Vector3 α n)
Goal: [].append w = w
-- Vector3.append_cons
@[simp]
theorem append_cons (a : α) (v : Vector3 α m) (w : Vector3 α n) : (a :: v) +-+ w = a :: v +-+ w 
Arguments: {α : Type u_1} {m n : ℕ} (a : α) (v : Vector3 α m) (w : Vector3 α n)
Goal: (Vector3.cons a v).append w = Vector3.cons a (v.append w)
-- Vector3.append_left
@[simp]
theorem append_left :
    ∀ {m} (i : Fin2 m) (v : Vector3 α m) {n} (w : Vector3 α n), (v +-+ w) (left n i) = v i
  
Arguments: {α : Type u_1} {m : ℕ} (i : Fin2 m) (v : Vector3 α m) {n : ℕ} (w : Vector3 α n)
Goal: v.append w (Fin2.left n i) = v i
-- Vector3.append_add
@[simp]
theorem append_add :
    ∀ {m} (v : Vector3 α m) {n} (w : Vector3 α n) (i : Fin2 n), (v +-+ w) (add i m) = w i
  
Arguments: {α : Type u_1} {m : ℕ} (v : Vector3 α m) {n : ℕ} (w : Vector3 α n) (i : Fin2 n)
Goal: v.append w (i.add m) = w i
-- Vector3.insert_fz
@[simp]
theorem insert_fz (a : α) (v : Vector3 α n) : insert a v fz = a :: v 
Arguments: {α : Type u_1} {n : ℕ} (a : α) (v : Vector3 α n)
Goal: Vector3.insert a v Fin2.fz = Vector3.cons a v
-- Vector3.insert_fs
@[simp]
theorem insert_fs (a : α) (b : α) (v : Vector3 α n) (i : Fin2 (n + 1)) :
    insert a (b :: v) (fs i) = b :: insert a v i 
Arguments: {α : Type u_1} {n : ℕ} (a b : α) (v : Vector3 α n) (i : Fin2 (n + 1))
Goal: Vector3.insert a (Vector3.cons b v) i.fs = Vector3.cons b (Vector3.insert a v i)
-- Vector3.append_insert
theorem append_insert (a : α) (t : Vector3 α m) (v : Vector3 α n) (i : Fin2 (n + 1))
    (e : (n + 1) + m = (n + m) + 1) :
    insert a (t +-+ v) (Eq.recOn e (i.add m)) = Eq.recOn e (t +-+ insert a v i) 
Arguments: {α : Type u_1} {m n : ℕ} (a : α) (t : Vector3 α m) (v : Vector3 α n) (i : Fin2 (n + 1)) (e : n + 1 + m = n + m + 1)
Goal: Vector3.insert a (t.append v) (Eq.recOn e (i.add m)) = Eq.recOn e (t.append (Vector3.insert a v i))
-- exists_vector_zero
theorem exists_vector_zero (f : Vector3 α 0 → Prop) : Exists f ↔ f [] 
Arguments: {α : Type u_1} (f : Vector3 α 0 → Prop)
Goal: Exists f ↔ f []
-- exists_vector_succ
theorem exists_vector_succ (f : Vector3 α (succ n) → Prop) : Exists f ↔ ∃ x v, f (x :: v) 
Arguments: {α : Type u_1} {n : ℕ} (f : Vector3 α n.succ → Prop)
Goal: Exists f ↔ ∃ x v, f (Vector3.cons x v)
-- vectorEx_iff_exists
theorem vectorEx_iff_exists : ∀ {n} (f : Vector3 α n → Prop), VectorEx n f ↔ Exists f
  
Arguments: {α : Type u_1} {n : ℕ} (f : Vector3 α n → Prop)
Goal: VectorEx n f ↔ Exists f
-- vectorAll_iff_forall
theorem vectorAll_iff_forall : ∀ {n} (f : Vector3 α n → Prop), VectorAll n f ↔ ∀ v, f v
  
Arguments: {α : Type u_1} {n : ℕ} (f : Vector3 α n → Prop)
Goal: VectorAll n f ↔ ∀ (v : Vector3 α n), f v
-- vectorAllP_nil
@[simp]
theorem vectorAllP_nil (p : α → Prop) : VectorAllP p [] = True 
Arguments: {α : Type u_1} (p : α → Prop)
Goal: VectorAllP p [] = True
-- vectorAllP_singleton
@[simp]
theorem vectorAllP_singleton (p : α → Prop) (x : α) : VectorAllP p (cons x []) = p x 
Arguments: {α : Type u_1} (p : α → Prop) (x : α)
Goal: VectorAllP p [x] = p x
-- vectorAllP_cons
@[simp]
theorem vectorAllP_cons (p : α → Prop) (x : α) (v : Vector3 α n) :
    VectorAllP p (x :: v) ↔ p x ∧ VectorAllP p v 
Arguments: {α : Type u_1} {n : ℕ} (p : α → Prop) (x : α) (v : Vector3 α n)
Goal: VectorAllP p (Vector3.cons x v) ↔ p x ∧ VectorAllP p v
-- vectorAllP_iff_forall
theorem vectorAllP_iff_forall (p : α → Prop) (v : Vector3 α n) :
    VectorAllP p v ↔ ∀ i, p (v i) 
Arguments: {α : Type u_1} {n : ℕ} (p : α → Prop) (v : Vector3 α n)
Goal: VectorAllP p v ↔ ∀ (i : Fin2 n), p (v i)
-- VectorAllP.imp
theorem VectorAllP.imp {p q : α → Prop} (h : ∀ x, p x → q x) {v : Vector3 α n}
    (al : VectorAllP p v) : VectorAllP q v 
Arguments: {α : Type u_1} {n : ℕ} {p q : α → Prop} (h : ∀ (x : α), p x → q x) {v : Vector3 α n} (al : VectorAllP p v)
Goal: VectorAllP q v
-- PEquiv.toMatrix_apply
@[simp]
theorem toMatrix_apply [DecidableEq n] [Zero α] [One α] (f : m ≃. n) (i j) :
    toMatrix f i j = if j ∈ f i then (1 : α) else 0 
Arguments: {m : Type u_3} {n : Type u_4} {α : Type v} [DecidableEq n] [Zero α] [One α] (f : m ≃. n) (i : m) (j : n)
Goal: f.toMatrix i j = if j ∈ f i then 1 else 0
-- PEquiv.mul_matrix_apply
theorem mul_matrix_apply [Fintype m] [DecidableEq m] [Semiring α] (f : l ≃. m) (M : Matrix m n α)
    (i j) : (f.toMatrix * M :) i j = Option.casesOn (f i) 0 fun fi => M fi j 
Arguments: {l : Type u_2} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype m] [DecidableEq m] [Semiring α] (f : l ≃. m) (M : Matrix m n α) (i : l) (j : n)
Goal: (f.toMatrix * M) i j = Option.casesOn (f i) 0 fun fi => M fi j
-- PEquiv.toMatrix_symm
theorem toMatrix_symm [DecidableEq m] [DecidableEq n] [Zero α] [One α] (f : m ≃. n) :
    (f.symm.toMatrix : Matrix n m α) = f.toMatrixᵀ 
Arguments: {m : Type u_3} {n : Type u_4} {α : Type v} [DecidableEq m] [DecidableEq n] [Zero α] [One α] (f : m ≃. n)
Goal: f.symm.toMatrix = f.toMatrix.transpose
-- PEquiv.toMatrix_refl
@[simp]
theorem toMatrix_refl [DecidableEq n] [Zero α] [One α] :
    ((PEquiv.refl n).toMatrix : Matrix n n α) = 1 
Arguments: {n : Type u_4} {α : Type v} [DecidableEq n] [Zero α] [One α]
Goal: (PEquiv.refl n).toMatrix = 1
-- PEquiv.matrix_mul_apply
theorem matrix_mul_apply [Fintype m] [Semiring α] [DecidableEq n] (M : Matrix l m α) (f : m ≃. n)
    (i j) : (M * f.toMatrix :) i j = Option.casesOn (f.symm j) 0 fun fj => M i fj 
Arguments: {l : Type u_2} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype m] [Semiring α] [DecidableEq n] (M : Matrix l m α) (f : m ≃. n) (i : l) (j : n)
Goal: (M * f.toMatrix) i j = Option.casesOn (f.symm j) 0 fun fj => M i fj
-- PEquiv.toPEquiv_mul_matrix
theorem toPEquiv_mul_matrix [Fintype m] [DecidableEq m] [Semiring α] (f : m ≃ m)
    (M : Matrix m n α) : f.toPEquiv.toMatrix * M = M.submatrix f id 
Arguments: {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype m] [DecidableEq m] [Semiring α] (f : m ≃ m) (M : Matrix m n α)
Goal: f.toPEquiv.toMatrix * M = M.submatrix (⇑f) id
-- PEquiv.mul_toPEquiv_toMatrix
theorem mul_toPEquiv_toMatrix {m n α : Type*} [Fintype n] [DecidableEq n] [Semiring α] (f : n ≃ n)
    (M : Matrix m n α) : M * f.toPEquiv.toMatrix = M.submatrix id f.symm 
Arguments: {m : Type u_5} {n : Type u_6} {α : Type u_7} [Fintype n] [DecidableEq n] [Semiring α] (f : n ≃ n) (M : Matrix m n α)
Goal: M * f.toPEquiv.toMatrix = M.submatrix id ⇑f.symm
-- PEquiv.toMatrix_trans
theorem toMatrix_trans [Fintype m] [DecidableEq m] [DecidableEq n] [Semiring α] (f : l ≃. m)
    (g : m ≃. n) : ((f.trans g).toMatrix : Matrix l n α) = f.toMatrix * g.toMatrix 
Arguments: {l : Type u_2} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype m] [DecidableEq m] [DecidableEq n] [Semiring α] (f : l ≃. m) (g : m ≃. n)
Goal: (f.trans g).toMatrix = f.toMatrix * g.toMatrix
-- PEquiv.toMatrix_bot
@[simp]
theorem toMatrix_bot [DecidableEq n] [Zero α] [One α] :
    ((⊥ : PEquiv m n).toMatrix : Matrix m n α) = 0 
Arguments: {m : Type u_3} {n : Type u_4} {α : Type v} [DecidableEq n] [Zero α] [One α]
Goal: ⊥.toMatrix = 0
-- PEquiv.toMatrix_injective
theorem toMatrix_injective [DecidableEq n] [MonoidWithZero α] [Nontrivial α] :
    Function.Injective (@toMatrix m n α _ _ _) 
Arguments: {m : Type u_3} {n : Type u_4} {α : Type v} [DecidableEq n] [MonoidWithZero α] [Nontrivial α]
Goal: Function.Injective PEquiv.toMatrix
-- PEquiv.toMatrix_swap
theorem toMatrix_swap [DecidableEq n] [Ring α] (i j : n) :
    (Equiv.swap i j).toPEquiv.toMatrix =
      (1 : Matrix n n α) - (single i i).toMatrix - (single j j).toMatrix + (single i j).toMatrix +
        (single j i).toMatrix 
Arguments: {n : Type u_4} {α : Type v} [DecidableEq n] [Ring α] (i j : n)
Goal: (Equiv.toPEquiv (Equiv.swap i j)).toMatrix =
  1 - (PEquiv.single i i).toMatrix - (PEquiv.single j j).toMatrix + (PEquiv.single i j).toMatrix +
    (PEquiv.single j i).toMatrix
-- PEquiv.single_mul_single
@[simp]
theorem single_mul_single [Fintype n] [DecidableEq k] [DecidableEq m] [DecidableEq n] [Semiring α]
    (a : m) (b : n) (c : k) :
    ((single a b).toMatrix : Matrix _ _ α) * (single b c).toMatrix = (single a c).toMatrix 
Arguments: {k : Type u_1} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype n] [DecidableEq k] [DecidableEq m] [DecidableEq n] [Semiring α] (a : m) (b : n) (c : k)
Goal: (PEquiv.single a b).toMatrix * (PEquiv.single b c).toMatrix = (PEquiv.single a c).toMatrix
-- PEquiv.single_mul_single_of_ne
theorem single_mul_single_of_ne [Fintype n] [DecidableEq n] [DecidableEq k] [DecidableEq m]
    [Semiring α] {b₁ b₂ : n} (hb : b₁ ≠ b₂) (a : m) (c : k) :
    (single a b₁).toMatrix * (single b₂ c).toMatrix = (0 : Matrix _ _ α) 
Arguments: {k : Type u_1} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype n] [DecidableEq n] [DecidableEq k] [DecidableEq m] [Semiring α] {b₁ b₂ : n} (hb : b₁ ≠ b₂) (a : m) (c : k)
Goal: (PEquiv.single a b₁).toMatrix * (PEquiv.single b₂ c).toMatrix = 0
-- PEquiv.single_mul_single_right
@[simp]
theorem single_mul_single_right [Fintype n] [Fintype k] [DecidableEq n] [DecidableEq k]
    [DecidableEq m] [Semiring α] (a : m) (b : n) (c : k) (M : Matrix k l α) :
    (single a b).toMatrix * ((single b c).toMatrix * M) = (single a c).toMatrix * M 
Arguments: {k : Type u_1} {l : Type u_2} {m : Type u_3} {n : Type u_4} {α : Type v} [Fintype n] [Fintype k] [DecidableEq n] [DecidableEq k] [DecidableEq m] [Semiring α] (a : m) (b : n) (c : k) (M : Matrix k l α)
Goal: (PEquiv.single a b).toMatrix * ((PEquiv.single b c).toMatrix * M) = (PEquiv.single a c).toMatrix * M
-- PEquiv.equiv_toPEquiv_toMatrix
theorem equiv_toPEquiv_toMatrix [DecidableEq n] [Zero α] [One α] (σ : Equiv n n) (i j : n) :
    σ.toPEquiv.toMatrix i j = (1 : Matrix n n α) (σ i) j 
Arguments: {n : Type u_4} {α : Type v} [DecidableEq n] [Zero α] [One α] (σ : n ≃ n) (i j : n)
Goal: σ.toPEquiv.toMatrix i j = 1 (σ i) j
-- Matroid.restrictIndepMatroid_Indep
@[simps] def restrictIndepMatroid (M : Matroid α) (R : Set α) : IndepMatroid α 
Arguments: {α : Type u_1} (M : Matroid α) (R I : Set α)
Goal: (M.restrictIndepMatroid R).Indep I = (M.Indep I ∧ I ⊆ R)
-- Matroid.restrictIndepMatroid_E
@[simps] def restrictIndepMatroid (M : Matroid α) (R : Set α) : IndepMatroid α 
Arguments: {α : Type u_1} (M : Matroid α) (R : Set α)
Goal: (M.restrictIndepMatroid R).E = R
-- Matroid.restrict_indep_iff
@[simp] theorem restrict_indep_iff : (M ↾ R).Indep I ↔ M.Indep I ∧ I ⊆ R 
Arguments: {α : Type u_1} {M : Matroid α} {R I : Set α}
Goal: (M.restrict R).Indep I ↔ M.Indep I ∧ I ⊆ R
-- Matroid.Indep.indep_restrict_of_subset
theorem Indep.indep_restrict_of_subset (h : M.Indep I) (hIR : I ⊆ R) : (M ↾ R).Indep I 
Arguments: {α : Type u_1} {M : Matroid α} {R I : Set α} (h : M.Indep I) (hIR : I ⊆ R)
Goal: (M.restrict R).Indep I
-- Matroid.Indep.of_restrict
theorem Indep.of_restrict (hI : (M ↾ R).Indep I) : M.Indep I 
Arguments: {α : Type u_1} {M : Matroid α} {R I : Set α} (hI : (M.restrict R).Indep I)
Goal: M.Indep I
-- Matroid.restrict_ground_eq
@[simp] theorem restrict_ground_eq : (M ↾ R).E = R 
Arguments: {α : Type u_1} {M : Matroid α} {R : Set α}
Goal: (M.restrict R).E = R
-- Matroid.restrict_finite
theorem restrict_finite {R : Set α} (hR : R.Finite) : (M ↾ R).Finite 
Arguments: {α : Type u_1} {M : Matroid α} {R : Set α} (hR : R.Finite)
Goal: (M.restrict R).Finite
-- Matroid.restrict_dep_iff
@[simp] theorem restrict_dep_iff : (M ↾ R).Dep X ↔ ¬ M.Indep X ∧ X ⊆ R 
Arguments: {α : Type u_1} {M : Matroid α} {R X : Set α}
Goal: (M.restrict R).Dep X ↔ ¬M.Indep X ∧ X ⊆ R
-- Matroid.restrict_ground_eq_self
@[simp] theorem restrict_ground_eq_self (M : Matroid α) : (M ↾ M.E) = M 
Arguments: {α : Type u_1} (M : Matroid α)
Goal: M.restrict M.E = M
-- Matroid.restrict_restrict_eq
theorem restrict_restrict_eq {R₁ R₂ : Set α} (M : Matroid α) (hR : R₂ ⊆ R₁) :
    (M ↾ R₁) ↾ R₂ = M ↾ R₂ 
Arguments: {α : Type u_1} {R₁ R₂ : Set α} (M : Matroid α) (hR : R₂ ⊆ R₁)
Goal: (M.restrict R₁).restrict R₂ = M.restrict R₂
-- Matroid.restrict_idem
@[simp] theorem restrict_idem (M : Matroid α) (R : Set α) : M ↾ R ↾ R = M ↾ R 
Arguments: {α : Type u_1} (M : Matroid α) (R : Set α)
Goal: (M.restrict R).restrict R = M.restrict R
-- Matroid.base_restrict_iff
@[simp] theorem base_restrict_iff (hX : X ⊆ M.E := by aesop_mat) :
    (M ↾ X).Base I ↔ M.Basis I X 
Arguments: {α : Type u_1} {M : Matroid α} {I X : Set α} (hX : X ⊆ M.E := by aesop_mat)
Goal: (M.restrict X).Base I ↔ M.Basis I X
-- Matroid.base_restrict_iff'
theorem base_restrict_iff' : (M ↾ X).Base I ↔ M.Basis' I X 
Arguments: {α : Type u_1} {M : Matroid α} {I X : Set α}
Goal: (M.restrict X).Base I ↔ M.Basis' I X
-- Matroid.Basis.restrict_base
theorem Basis.restrict_base (h : M.Basis I X) : (M ↾ X).Base I 
Arguments: {α : Type u_1} {M : Matroid α} {I X : Set α} (h : M.Basis I X)
Goal: (M.restrict X).Base I
-- Matroid.Basis.base_restrict
@[simp] theorem Basis.base_restrict (h : M.Basis I X) : (M ↾ X).Base I 
Arguments: {α : Type u_1} {M : Matroid α} {I X : Set α} (h : M.Basis I X)
Goal: (M.restrict X).Base I
-- Matroid.Basis.basis_restrict_of_subset
theorem Basis.basis_restrict_of_subset (hI : M.Basis I X) (hXY : X ⊆ Y) : (M ↾ Y).Basis I X 
Arguments: {α : Type u_1} {M : Matroid α} {I X Y : Set α} (hI : M.Basis I X) (hXY : X ⊆ Y)
Goal: (M.restrict Y).Basis I X
-- Matroid.basis'_restrict_iff
theorem basis'_restrict_iff : (M ↾ R).Basis' I X ↔ M.Basis' I (X ∩ R) ∧ I ⊆ R 
Arguments: {α : Type u_1} {M : Matroid α} {R I X : Set α}
Goal: (M.restrict R).Basis' I X ↔ M.Basis' I (X ∩ R) ∧ I ⊆ R
-- Matroid.basis_restrict_iff'
theorem basis_restrict_iff' : (M ↾ R).Basis I X ↔ M.Basis I (X ∩ M.E) ∧ X ⊆ R 
Arguments: {α : Type u_1} {M : Matroid α} {R I X : Set α}
Goal: (M.restrict R).Basis I X ↔ M.Basis I (X ∩ M.E) ∧ X ⊆ R
-- Matroid.basis_restrict_iff
theorem basis_restrict_iff (hR : R ⊆ M.E := by aesop_mat) :
    (M ↾ R).Basis I X ↔ M.Basis I X ∧ X ⊆ R 
Arguments: {α : Type u_1} {M : Matroid α} {R I X : Set α} (hR : R ⊆ M.E := by aesop_mat)
Goal: (M.restrict R).Basis I X ↔ M.Basis I X ∧ X ⊆ R
-- Matroid.restrict_eq_restrict_iff
theorem restrict_eq_restrict_iff (M M' : Matroid α) (X : Set α) :
    M ↾ X = M' ↾ X ↔ ∀ I, I ⊆ X → (M.Indep I ↔ M'.Indep I) 
Arguments: {α : Type u_1} (M M' : Matroid α) (X : Set α)
Goal: M.restrict X = M'.restrict X ↔ ∀ I ⊆ X, M.Indep I ↔ M'.Indep I
-- Matroid.restrict_eq_self_iff
@[simp] theorem restrict_eq_self_iff : M ↾ R = M ↔ R = M.E 
Arguments: {α : Type u_1} {M : Matroid α} {R : Set α}
Goal: M.restrict R = M ↔ R = M.E
-- Matroid.Matroidᵣ.coe_inj
@[simp] theorem Matroidᵣ.coe_inj {M₁ M₂ : Matroidᵣ α} :
    (M₁ : Matroid α) = (M₂ : Matroid α) ↔ M₁ = M₂ 
Arguments: {α : Type u_1} {M₁ M₂ : Matroid.Matroidᵣ α}
Goal: M₁.toMatroid = M₂.toMatroid ↔ M₁ = M₂
-- Matroid.Matroidᵣ.le_iff
@[simp] protected theorem Matroidᵣ.le_iff {M M' : Matroidᵣ α} :
    M ≤ M' ↔ (M : Matroid α) ≤r (M' : Matroid α) 
Arguments: {α : Type u_1} {M M' : Matroid.Matroidᵣ α}
Goal: M ≤ M' ↔ M.toMatroid.Restriction M'.toMatroid
-- Matroid.Matroidᵣ.lt_iff
@[simp] protected theorem Matroidᵣ.lt_iff {M M' : Matroidᵣ α} :
    M < M' ↔ (M : Matroid α) <r (M' : Matroid α) 
Arguments: {α : Type u_1} {M M' : Matroid.Matroidᵣ α}
Goal: M < M' ↔ M.toMatroid.StrictRestriction M'.toMatroid
-- Matroid.ofMatroid_le_iff
theorem ofMatroid_le_iff {M M' : Matroid α} :
    Matroidᵣ.ofMatroid M ≤ Matroidᵣ.ofMatroid M' ↔ M ≤r M' 
Arguments: {α : Type u_1} {M M' : Matroid α}
Goal: { toMatroid := M } ≤ { toMatroid := M' } ↔ M.Restriction M'
-- Matroid.ofMatroid_lt_iff
theorem ofMatroid_lt_iff {M M' : Matroid α} :
    Matroidᵣ.ofMatroid M < Matroidᵣ.ofMatroid M' ↔ M <r M' 
Arguments: {α : Type u_1} {M M' : Matroid α}
Goal: { toMatroid := M } < { toMatroid := M' } ↔ M.StrictRestriction M'
-- Matroid.Restriction.refl
theorem Restriction.refl : M ≤r M 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: M.Restriction M
-- Matroid.Restriction.antisymm
theorem Restriction.antisymm {M' : Matroid α} (h : M ≤r M') (h' : M' ≤r M) : M = M' 
Arguments: {α : Type u_1} {M M' : Matroid α} (h : M.Restriction M') (h' : M'.Restriction M)
Goal: M = M'
-- Matroid.Restriction.trans
theorem Restriction.trans {M₁ M₂ M₃ : Matroid α} (h : M₁ ≤r M₂) (h' : M₂ ≤r M₃) : M₁ ≤r M₃ 
Arguments: {α : Type u_1} {M₁ M₂ M₃ : Matroid α} (h : M₁.Restriction M₂) (h' : M₂.Restriction M₃)
Goal: M₁.Restriction M₃