ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matrix.BlockTriangular.sub
theorem BlockTriangular.sub (hM : BlockTriangular M b) (hN : BlockTriangular N b) :
    BlockTriangular (M - N) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M N : Matrix m m R} {b : m → α} [LT α] (hM : M.BlockTriangular b) (hN : N.BlockTriangular b)
Goal: (M - N).BlockTriangular b
-- Matrix.blockTriangular_diagonal
theorem blockTriangular_diagonal [DecidableEq m] (d : m → R) : BlockTriangular (diagonal d) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m] (d : m → R)
Goal: (Matrix.diagonal d).BlockTriangular b
-- Matrix.blockTriangular_blockDiagonal'
theorem blockTriangular_blockDiagonal' [DecidableEq α] (d : ∀ i : α, Matrix (m' i) (m' i) R) :
    BlockTriangular (blockDiagonal' d) Sigma.fst 
Arguments: {α : Type u_1} {m' : α → Type u_6} {R : Type v} [CommRing R] [Preorder α] [DecidableEq α] (d : (i : α) → Matrix (m' i) (m' i) R)
Goal: (Matrix.blockDiagonal' d).BlockTriangular Sigma.fst
-- Matrix.blockTriangular_blockDiagonal
theorem blockTriangular_blockDiagonal [DecidableEq α] (d : α → Matrix m m R) :
    BlockTriangular (blockDiagonal d) Prod.snd 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] [Preorder α] [DecidableEq α] (d : α → Matrix m m R)
Goal: (Matrix.blockDiagonal d).BlockTriangular Prod.snd
-- Matrix.blockTriangular_one
theorem blockTriangular_one : BlockTriangular (1 : Matrix m m R) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m]
Goal: Matrix.BlockTriangular 1 b
-- Matrix.blockTriangular_stdBasisMatrix
theorem blockTriangular_stdBasisMatrix {i j : m} (hij : b i ≤ b j) (c : R) :
    BlockTriangular (stdBasisMatrix i j c) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m] {i j : m} (hij : b i ≤ b j) (c : R)
Goal: (Matrix.stdBasisMatrix i j c).BlockTriangular b
-- Matrix.blockTriangular_stdBasisMatrix'
theorem blockTriangular_stdBasisMatrix' {i j : m} (hij : b j ≤ b i) (c : R) :
    BlockTriangular (stdBasisMatrix i j c) (toDual ∘ b) 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m] {i j : m} (hij : b j ≤ b i) (c : R)
Goal: (Matrix.stdBasisMatrix i j c).BlockTriangular (⇑OrderDual.toDual ∘ b)
-- Matrix.blockTriangular_transvection
theorem blockTriangular_transvection {i j : m} (hij : b i ≤ b j) (c : R) :
    BlockTriangular (transvection i j c) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m] {i j : m} (hij : b i ≤ b j) (c : R)
Goal: (Matrix.transvection i j c).BlockTriangular b
-- Matrix.blockTriangular_transvection'
theorem blockTriangular_transvection' {i j : m} (hij : b j ≤ b i) (c : R) :
    BlockTriangular (transvection i j c) (OrderDual.toDual ∘ b) 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [Preorder α] [DecidableEq m] {i j : m} (hij : b j ≤ b i) (c : R)
Goal: (Matrix.transvection i j c).BlockTriangular (⇑OrderDual.toDual ∘ b)
-- Matrix.BlockTriangular.mul
theorem BlockTriangular.mul [Fintype m] {M N : Matrix m m R} (hM : BlockTriangular M b)
    (hN : BlockTriangular N b) : BlockTriangular (M * N) b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {b : m → α} [LinearOrder α] [Fintype m] {M N : Matrix m m R} (hM : M.BlockTriangular b) (hN : N.BlockTriangular b)
Goal: (M * N).BlockTriangular b
-- Matrix.upper_two_blockTriangular
theorem upper_two_blockTriangular [Preorder α] (A : Matrix m m R) (B : Matrix m n R)
    (D : Matrix n n R) {a b : α} (hab : a < b) :
    BlockTriangular (fromBlocks A B 0 D) (Sum.elim (fun _ => a) fun _ => b) 
Arguments: {α : Type u_1} {m : Type u_3} {n : Type u_4} {R : Type v} [CommRing R] [Preorder α] (A : Matrix m m R) (B : Matrix m n R) (D : Matrix n n R) {a b : α} (hab : a < b)
Goal: (Matrix.fromBlocks A B 0 D).BlockTriangular (Sum.elim (fun x => a) fun x => b)
-- Matrix.equiv_block_det
theorem equiv_block_det (M : Matrix m m R) {p q : m → Prop} [DecidablePred p] [DecidablePred q]
    (e : ∀ x, q x ↔ p x) : (toSquareBlockProp M p).det = (toSquareBlockProp M q).det 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] (M : Matrix m m R) {p q : m → Prop} [DecidablePred p] [DecidablePred q] (e : ∀ (x : m), q x ↔ p x)
Goal: (M.toSquareBlockProp p).det = (M.toSquareBlockProp q).det
-- Matrix.det_toSquareBlock_id
theorem det_toSquareBlock_id (M : Matrix m m R) (i : m) : (M.toSquareBlock id i).det = M i i 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] (M : Matrix m m R) (i : m)
Goal: (M.toSquareBlock id i).det = M i i
-- Matrix.det_toBlock
theorem det_toBlock (M : Matrix m m R) (p : m → Prop) [DecidablePred p] :
    M.det =
      (fromBlocks (toBlock M p p) (toBlock M p fun j => ¬p j) (toBlock M (fun j => ¬p j) p) <|
          toBlock M (fun j => ¬p j) fun j => ¬p j).det 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] (M : Matrix m m R) (p : m → Prop) [DecidablePred p]
Goal: M.det =
  (Matrix.fromBlocks (M.toBlock p p) (M.toBlock p fun j => ¬p j) (M.toBlock (fun j => ¬p j) p)
      (M.toBlock (fun j => ¬p j) fun j => ¬p j)).det
-- Matrix.twoBlockTriangular_det
theorem twoBlockTriangular_det (M : Matrix m m R) (p : m → Prop) [DecidablePred p]
    (h : ∀ i, ¬p i → ∀ j, p j → M i j = 0) :
    M.det = (toSquareBlockProp M p).det * (toSquareBlockProp M fun i => ¬p i).det 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] (M : Matrix m m R) (p : m → Prop) [DecidablePred p] (h : ∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0)
Goal: M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det
-- Matrix.twoBlockTriangular_det'
theorem twoBlockTriangular_det' (M : Matrix m m R) (p : m → Prop) [DecidablePred p]
    (h : ∀ i, p i → ∀ j, ¬p j → M i j = 0) :
    M.det = (toSquareBlockProp M p).det * (toSquareBlockProp M fun i => ¬p i).det 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] (M : Matrix m m R) (p : m → Prop) [DecidablePred p] (h : ∀ (i : m), p i → ∀ (j : m), ¬p j → M i j = 0)
Goal: M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det
-- Matrix.BlockTriangular.det
protected theorem BlockTriangular.det [DecidableEq α] [LinearOrder α] (hM : BlockTriangular M b) :
    M.det = ∏ a ∈ univ.image b, (M.toSquareBlock b a).det 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [DecidableEq α] [LinearOrder α] (hM : M.BlockTriangular b)
Goal: M.det = ∏ a ∈ Finset.image b Finset.univ, (M.toSquareBlock b a).det
-- Matrix.BlockTriangular.det_fintype
theorem BlockTriangular.det_fintype [DecidableEq α] [Fintype α] [LinearOrder α]
    (h : BlockTriangular M b) : M.det = ∏ k : α, (M.toSquareBlock b k).det 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [DecidableEq α] [Fintype α] [LinearOrder α] (h : M.BlockTriangular b)
Goal: M.det = ∏ k : α, (M.toSquareBlock b k).det
-- Matrix.det_of_upperTriangular
theorem det_of_upperTriangular [LinearOrder m] (h : M.BlockTriangular id) :
    M.det = ∏ i : m, M i i 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} [DecidableEq m] [Fintype m] [LinearOrder m] (h : M.BlockTriangular id)
Goal: M.det = ∏ i : m, M i i
-- Matrix.det_of_lowerTriangular
theorem det_of_lowerTriangular [LinearOrder m] (M : Matrix m m R) (h : M.BlockTriangular toDual) :
    M.det = ∏ i : m, M i i 
Arguments: {m : Type u_3} {R : Type v} [CommRing R] [DecidableEq m] [Fintype m] [LinearOrder m] (M : Matrix m m R) (h : M.BlockTriangular ⇑OrderDual.toDual)
Goal: M.det = ∏ i : m, M i i
-- Matrix.matrixOfPolynomials_blockTriangular
theorem matrixOfPolynomials_blockTriangular {n : ℕ} (p : Fin n → R[X])
    (h_deg : ∀ i, (p i).natDegree ≤ i) :
    Matrix.BlockTriangular (Matrix.of (fun (i j : Fin n) => (p j).coeff i)) id 
Arguments: {R : Type v} [CommRing R] {n : ℕ} (p : Fin n → Polynomial R) (h_deg : ∀ (i : Fin n), (p i).natDegree ≤ ↑i)
Goal: (Matrix.of fun i j => (p j).coeff ↑i).BlockTriangular id
-- Matrix.det_matrixOfPolynomials
theorem det_matrixOfPolynomials {n : ℕ} (p : Fin n → R[X])
    (h_deg : ∀ i, (p i).natDegree = i) (h_monic : ∀ i, Monic <| p i) :
    (Matrix.of (fun (i j : Fin n) => (p j).coeff i)).det = 1 
Arguments: {R : Type v} [CommRing R] {n : ℕ} (p : Fin n → Polynomial R) (h_deg : ∀ (i : Fin n), (p i).natDegree = ↑i) (h_monic : ∀ (i : Fin n), (p i).Monic)
Goal: (Matrix.of fun i j => (p j).coeff ↑i).det = 1
-- Matrix.BlockTriangular.toBlock_inverse_mul_toBlock_eq_one
theorem BlockTriangular.toBlock_inverse_mul_toBlock_eq_one [LinearOrder α] [Invertible M]
    (hM : BlockTriangular M b) (k : α) :
    ((M⁻¹.toBlock (fun i => b i < k) fun i => b i < k) *
        M.toBlock (fun i => b i < k) fun i => b i < k) =
      1 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [LinearOrder α] [Invertible M] (hM : M.BlockTriangular b) (k : α)
Goal: ((M⁻¹.toBlock (fun i => b i < k) fun i => b i < k) * M.toBlock (fun i => b i < k) fun i => b i < k) = 1
-- Matrix.BlockTriangular.inv_toBlock
theorem BlockTriangular.inv_toBlock [LinearOrder α] [Invertible M] (hM : BlockTriangular M b)
    (k : α) :
    (M.toBlock (fun i => b i < k) fun i => b i < k)⁻¹ =
      M⁻¹.toBlock (fun i => b i < k) fun i => b i < k 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [LinearOrder α] [Invertible M] (hM : M.BlockTriangular b) (k : α)
Goal: (M.toBlock (fun i => b i < k) fun i => b i < k)⁻¹ = M⁻¹.toBlock (fun i => b i < k) fun i => b i < k
-- Matrix.toBlock_inverse_eq_zero
theorem toBlock_inverse_eq_zero [LinearOrder α] [Invertible M] (hM : BlockTriangular M b) (k : α) :
    (M⁻¹.toBlock (fun i => k ≤ b i) fun i => b i < k) = 0 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [LinearOrder α] [Invertible M] (hM : M.BlockTriangular b) (k : α)
Goal: (M⁻¹.toBlock (fun i => k ≤ b i) fun i => b i < k) = 0
-- Matrix.blockTriangular_inv_of_blockTriangular
theorem blockTriangular_inv_of_blockTriangular [LinearOrder α] [Invertible M]
    (hM : BlockTriangular M b) : BlockTriangular M⁻¹ b 
Arguments: {α : Type u_1} {m : Type u_3} {R : Type v} [CommRing R] {M : Matrix m m R} {b : m → α} [DecidableEq m] [Fintype m] [LinearOrder α] [Invertible M] (hM : M.BlockTriangular b)
Goal: M⁻¹.BlockTriangular b
-- LinearMap.rank_le_range
theorem rank_le_range (f : V →ₗ[K] V') : rank f ≤ Module.rank K V' 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] (f : V →ₗ[K] V')
Goal: f.rank ≤ Module.rank K V'
-- LinearMap.rank_le_domain
theorem rank_le_domain (f : V →ₗ[K] V₁) : rank f ≤ Module.rank K V 
Arguments: {K : Type u} {V V₁ : Type v} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V₁] [Module K V₁] (f : V →ₗ[K] V₁)
Goal: f.rank ≤ Module.rank K V
-- LinearMap.rank_zero
@[simp]
theorem rank_zero [Nontrivial K] : rank (0 : V →ₗ[K] V') = 0 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [Nontrivial K]
Goal: LinearMap.rank 0 = 0
-- LinearMap.rank_comp_le_left
theorem rank_comp_le_left (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') : rank (f.comp g) ≤ rank f 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} {V'' : Type v''} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [AddCommGroup V''] [Module K V''] (g : V →ₗ[K] V') (f : V' →ₗ[K] V'')
Goal: (f ∘ₗ g).rank ≤ f.rank
-- LinearMap.lift_rank_comp_le_right
theorem lift_rank_comp_le_right (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') :
    Cardinal.lift.{v'} (rank (f.comp g)) ≤ Cardinal.lift.{v''} (rank g) 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} {V'' : Type v''} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [AddCommGroup V''] [Module K V''] (g : V →ₗ[K] V') (f : V' →ₗ[K] V'')
Goal: Cardinal.lift.{v', v''} (f ∘ₗ g).rank ≤ Cardinal.lift.{v'', v'} g.rank
-- LinearMap.lift_rank_comp_le
theorem lift_rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'') :
    Cardinal.lift.{v'} (rank (f.comp g)) ≤
      min (Cardinal.lift.{v'} (rank f)) (Cardinal.lift.{v''} (rank g)) 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} {V'' : Type v''} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [AddCommGroup V''] [Module K V''] (g : V →ₗ[K] V') (f : V' →ₗ[K] V'')
Goal: Cardinal.lift.{v', v''} (f ∘ₗ g).rank ≤ min (Cardinal.lift.{v', v''} f.rank) (Cardinal.lift.{v'', v'} g.rank)
-- LinearMap.rank_comp_le_right
theorem rank_comp_le_right (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁) : rank (f.comp g) ≤ rank g 
Arguments: {K : Type u} {V : Type v} {V' V'₁ : Type v'} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [AddCommGroup V'₁] [Module K V'₁] (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁)
Goal: (f ∘ₗ g).rank ≤ g.rank
-- LinearMap.rank_comp_le
theorem rank_comp_le (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁) :
    rank (f.comp g) ≤ min (rank f) (rank g) 
Arguments: {K : Type u} {V : Type v} {V' V'₁ : Type v'} [Ring K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] [AddCommGroup V'₁] [Module K V'₁] (g : V →ₗ[K] V') (f : V' →ₗ[K] V'₁)
Goal: (f ∘ₗ g).rank ≤ min f.rank g.rank
-- LinearMap.rank_add_le
theorem rank_add_le (f g : V →ₗ[K] V') : rank (f + g) ≤ rank f + rank g 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [DivisionRing K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] (f g : V →ₗ[K] V')
Goal: (f + g).rank ≤ f.rank + g.rank
-- LinearMap.rank_finset_sum_le
theorem rank_finset_sum_le {η} (s : Finset η) (f : η → V →ₗ[K] V') :
    rank (∑ d ∈ s, f d) ≤ ∑ d ∈ s, rank (f d) 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [DivisionRing K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] {η : Type u_1} (s : Finset η) (f : η → V →ₗ[K] V')
Goal: (∑ d ∈ s, f d).rank ≤ ∑ d ∈ s, (f d).rank
-- LinearMap.le_rank_iff_exists_linearIndependent
theorem le_rank_iff_exists_linearIndependent {c : Cardinal} {f : V →ₗ[K] V'} :
    c ≤ rank f ↔ ∃ s : Set V,
    Cardinal.lift.{v'} #s = Cardinal.lift.{v} c ∧ LinearIndependent K (fun x : s => f x) 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [DivisionRing K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] {c : Cardinal.{v'}} {f : V →ₗ[K] V'}
Goal: c ≤ f.rank ↔ ∃ s, Cardinal.lift.{v', v} #↑s = Cardinal.lift.{v, v'} c ∧ LinearIndependent K fun (x : ↑s) => f ↑x
-- LinearMap.le_rank_iff_exists_linearIndependent_finset
theorem le_rank_iff_exists_linearIndependent_finset {n : ℕ} {f : V →ₗ[K] V'} :
    ↑n ≤ rank f ↔ ∃ s : Finset V, s.card = n ∧ LinearIndependent K fun x : (s : Set V) => f x 
Arguments: {K : Type u} {V : Type v} {V' : Type v'} [DivisionRing K] [AddCommGroup V] [Module K V] [AddCommGroup V'] [Module K V'] {n : ℕ} {f : V →ₗ[K] V'}
Goal: ↑n ≤ f.rank ↔ ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x
-- FiniteDimensional.finrank_eq_of_rank_eq
theorem finrank_eq_of_rank_eq {n : ℕ} (h : Module.rank R M = ↑n) : finrank R M = n 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] {n : ℕ} (h : Module.rank R M = ↑n)
Goal: FiniteDimensional.finrank R M = n
-- FiniteDimensional.rank_eq_one_iff_finrank_eq_one
lemma rank_eq_one_iff_finrank_eq_one : Module.rank R M = 1 ↔ finrank R M = 1 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M]
Goal: Module.rank R M = 1 ↔ FiniteDimensional.finrank R M = 1
-- FiniteDimensional.rank_eq_ofNat_iff_finrank_eq_ofNat
lemma rank_eq_ofNat_iff_finrank_eq_ofNat (n : ℕ) [Nat.AtLeastTwo n] :
    Module.rank R M = OfNat.ofNat n ↔ finrank R M = OfNat.ofNat n 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] (n : ℕ) [n.AtLeastTwo]
Goal: Module.rank R M = OfNat.ofNat n ↔ FiniteDimensional.finrank R M = OfNat.ofNat n
-- FiniteDimensional.finrank_le_of_rank_le
theorem finrank_le_of_rank_le {n : ℕ} (h : Module.rank R M ≤ ↑n) : finrank R M ≤ n 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] {n : ℕ} (h : Module.rank R M ≤ ↑n)
Goal: FiniteDimensional.finrank R M ≤ n
-- FiniteDimensional.finrank_lt_of_rank_lt
theorem finrank_lt_of_rank_lt {n : ℕ} (h : Module.rank R M < ↑n) : finrank R M < n 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] {n : ℕ} (h : Module.rank R M < ↑n)
Goal: FiniteDimensional.finrank R M < n
-- FiniteDimensional.lt_rank_of_lt_finrank
theorem lt_rank_of_lt_finrank {n : ℕ} (h : n < finrank R M) : ↑n < Module.rank R M 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] {n : ℕ} (h : n < FiniteDimensional.finrank R M)
Goal: ↑n < Module.rank R M
-- FiniteDimensional.one_lt_rank_of_one_lt_finrank
theorem one_lt_rank_of_one_lt_finrank (h : 1 < finrank R M) : 1 < Module.rank R M 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] (h : 1 < FiniteDimensional.finrank R M)
Goal: 1 < Module.rank R M
-- FiniteDimensional.finrank_le_finrank_of_rank_le_rank
theorem finrank_le_finrank_of_rank_le_rank
    (h : lift.{w} (Module.rank R M) ≤ Cardinal.lift.{v} (Module.rank R N))
    (h' : Module.rank R N < ℵ₀) : finrank R M ≤ finrank R N 
Arguments: {R : Type u} {M : Type v} {N : Type w} [Ring R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] (h : Cardinal.lift.{w, v} (Module.rank R M) ≤ Cardinal.lift.{v, w} (Module.rank R N)) (h' : Module.rank R N < ℵ₀)
Goal: FiniteDimensional.finrank R M ≤ FiniteDimensional.finrank R N
-- LinearEquiv.finrank_eq
theorem finrank_eq (f : M ≃ₗ[R] M₂) : finrank R M = finrank R M₂ 
Arguments: {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [Ring R] [AddCommGroup M] [AddCommGroup M₂] [Module R M] [Module R M₂] (f : M ≃ₗ[R] M₂)
Goal: FiniteDimensional.finrank R M = FiniteDimensional.finrank R M₂
-- LinearEquiv.finrank_map_eq
theorem finrank_map_eq (f : M ≃ₗ[R] M₂) (p : Submodule R M) :
    finrank R (p.map (f : M →ₗ[R] M₂)) = finrank R p 
Arguments: {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [Ring R] [AddCommGroup M] [AddCommGroup M₂] [Module R M] [Module R M₂] (f : M ≃ₗ[R] M₂) (p : Submodule R M)
Goal: FiniteDimensional.finrank R ↥(Submodule.map (↑f) p) = FiniteDimensional.finrank R ↥p
-- LinearMap.finrank_range_of_inj
theorem LinearMap.finrank_range_of_inj {f : M →ₗ[R] N} (hf : Function.Injective f) :
    finrank R (LinearMap.range f) = finrank R M 
Arguments: {R : Type u} {M : Type v} {N : Type w} [Ring R] [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N] {f : M →ₗ[R] N} (hf : Function.Injective ⇑f)
Goal: FiniteDimensional.finrank R ↥(LinearMap.range f) = FiniteDimensional.finrank R M
-- Submodule.finrank_map_subtype_eq
@[simp]
theorem Submodule.finrank_map_subtype_eq (p : Submodule R M) (q : Submodule R p) :
    finrank R (q.map p.subtype) = finrank R q 
Arguments: {R : Type u} {M : Type v} [Ring R] [AddCommGroup M] [Module R M] (p : Submodule R M) (q : Submodule R ↥p)
Goal: FiniteDimensional.finrank R ↥(Submodule.map p.subtype q) = FiniteDimensional.finrank R ↥q
-- finrank_top
@[simp]
theorem finrank_top : finrank R (⊤ : Submodule R M) = finrank R M 
Arguments: (R : Type u) (M : Type v) [Ring R] [AddCommGroup M] [Module R M]
Goal: FiniteDimensional.finrank R ↥⊤ = FiniteDimensional.finrank R M
-- Matrix.transvection_zero
@[simp]
theorem transvection_zero : transvection i j (0 : R) = 1 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n)
Goal: Matrix.transvection i j 0 = 1
-- Matrix.updateRow_eq_transvection
theorem updateRow_eq_transvection [Finite n] (c : R) :
    updateRow (1 : Matrix n n R) i ((1 : Matrix n n R) i + c • (1 : Matrix n n R) j) =
      transvection i j c 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Finite n] (c : R)
Goal: Matrix.updateRow 1 i (1 i + c • 1 j) = Matrix.transvection i j c
-- Matrix.transvection_mul_transvection_same
theorem transvection_mul_transvection_same (h : i ≠ j) (c d : R) :
    transvection i j c * transvection i j d = transvection i j (c + d) 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (h : i ≠ j) (c d : R)
Goal: Matrix.transvection i j c * Matrix.transvection i j d = Matrix.transvection i j (c + d)
-- Matrix.transvection_mul_apply_same
@[simp]
theorem transvection_mul_apply_same (b : n) (c : R) (M : Matrix n n R) :
    (transvection i j c * M) i b = M i b + c * M j b 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (b : n) (c : R) (M : Matrix n n R)
Goal: (Matrix.transvection i j c * M) i b = M i b + c * M j b
-- Matrix.mul_transvection_apply_same
@[simp]
theorem mul_transvection_apply_same (a : n) (c : R) (M : Matrix n n R) :
    (M * transvection i j c) a j = M a j + c * M a i 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (a : n) (c : R) (M : Matrix n n R)
Goal: (M * Matrix.transvection i j c) a j = M a j + c * M a i
-- Matrix.transvection_mul_apply_of_ne
@[simp]
theorem transvection_mul_apply_of_ne (a b : n) (ha : a ≠ i) (c : R) (M : Matrix n n R) :
    (transvection i j c * M) a b = M a b 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (a b : n) (ha : a ≠ i) (c : R) (M : Matrix n n R)
Goal: (Matrix.transvection i j c * M) a b = M a b
-- Matrix.mul_transvection_apply_of_ne
@[simp]
theorem mul_transvection_apply_of_ne (a b : n) (hb : b ≠ j) (c : R) (M : Matrix n n R) :
    (M * transvection i j c) a b = M a b 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (a b : n) (hb : b ≠ j) (c : R) (M : Matrix n n R)
Goal: (M * Matrix.transvection i j c) a b = M a b
-- Matrix.det_transvection_of_ne
@[simp]
theorem det_transvection_of_ne (h : i ≠ j) (c : R) : det (transvection i j c) = 1 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) [Fintype n] (h : i ≠ j) (c : R)
Goal: (Matrix.transvection i j c).det = 1
-- Matrix.TransvectionStruct.hij
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure TransvectionStruct where
  (i j : n)
  hij : i ≠ j
  c : R
Arguments: {n : Type u_1} {R : Type u₂} (self : Matrix.TransvectionStruct n R)
Goal: self.i ≠ self.j
-- Matrix.TransvectionStruct.toMatrix_mk
@[simp]
theorem toMatrix_mk (i j : n) (hij : i ≠ j) (c : R) :
    TransvectionStruct.toMatrix ⟨i, j, hij, c⟩ = transvection i j c 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] (i j : n) (hij : i ≠ j) (c : R)
Goal: { i := i, j := j, hij := hij, c := c }.toMatrix = Matrix.transvection i j c
-- Matrix.TransvectionStruct.det
@[simp]
protected theorem det [Fintype n] (t : TransvectionStruct n R) : det t.toMatrix = 1 
Arguments: {n : Type u_1} {R : Type u₂} [DecidableEq n] [CommRing R] [Fintype n] (t : Matrix.TransvectionStruct n R)
Goal: t.toMatrix.det = 1
-- Matrix.TransvectionStruct.det_toMatrix_prod
@[simp]
theorem det_toMatrix_prod [Fintype n] (L : List (TransvectionStruct n 𝕜)) :
    det (L.map toMatrix).prod = 1 
Arguments: {n : Type u_1} {𝕜 : Type u_3} [Field 𝕜] [DecidableEq n] [Fintype n] (L : List (Matrix.TransvectionStruct n 𝕜))
Goal: (List.map Matrix.TransvectionStruct.toMatrix L).prod.det = 1
-- Matrix.TransvectionStruct.inv_j
@[simps]
protected def inv (t : TransvectionStruct n R) : TransvectionStruct n R 
Arguments: {n : Type u_1} {R : Type u₂} [CommRing R] (t : Matrix.TransvectionStruct n R)
Goal: t.inv.j = t.j
-- Matrix.TransvectionStruct.inv_i
@[simps]
protected def inv (t : TransvectionStruct n R) : TransvectionStruct n R 
Arguments: {n : Type u_1} {R : Type u₂} [CommRing R] (t : Matrix.TransvectionStruct n R)
Goal: t.inv.i = t.i
-- Matrix.TransvectionStruct.inv_c
@[simps]
protected def inv (t : TransvectionStruct n R) : TransvectionStruct n R 
Arguments: {n : Type u_1} {R : Type u₂} [CommRing R] (t : Matrix.TransvectionStruct n R)
Goal: t.inv.c = -t.c