ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Bool.of_decide_true
theorem of_decide_true {p : Prop} [Decidable p] : decide p → p 
Arguments: {p : Prop} [Decidable p]
Goal: decide p = true → p
-- Bool.bool_iff_false
theorem bool_iff_false {b : Bool} : ¬b ↔ b = false 
Arguments: {b : Bool}
Goal: ¬b = true ↔ b = false
-- Bool.bool_eq_false
theorem bool_eq_false {b : Bool} : ¬b → b = false 
Arguments: {b : Bool}
Goal: ¬b = true → b = false
-- Bool.decide_false_iff
theorem decide_false_iff (p : Prop) {_ : Decidable p} : decide p = false ↔ ¬p 
Arguments: (p : Prop)
Goal: ∀ {x : Decidable p}, decide p = false ↔ ¬p
-- Bool.decide_false
theorem decide_false {p : Prop} [Decidable p] : ¬p → decide p = false 
Arguments: {p : Prop} [Decidable p]
Goal: ¬p → decide p = false
-- Bool.of_decide_false
theorem of_decide_false {p : Prop} [Decidable p] : decide p = false → ¬p 
Arguments: {p : Prop} [Decidable p]
Goal: decide p = false → ¬p
-- Bool.decide_congr
theorem decide_congr {p q : Prop} [Decidable p] [Decidable q] (h : p ↔ q) : decide p = decide q 
Arguments: {p q : Prop} [Decidable p] [Decidable q] (h : p ↔ q)
Goal: decide p = decide q
-- Bool.coe_xor_iff
theorem coe_xor_iff (a b : Bool) : xor a b ↔ Xor' (a = true) (b = true) 
Arguments: (a b : Bool)
Goal: xor a b = true ↔ Xor' (a = true) (b = true)
-- Bool.dichotomy
theorem dichotomy (b : Bool) : b = false ∨ b = true 
Arguments: (b : Bool)
Goal: b = false ∨ b = true
-- Bool.forall_bool'
theorem forall_bool' {p : Bool → Prop} (b : Bool) : (∀ x, p x) ↔ p b ∧ p !b 
Arguments: {p : Bool → Prop} (b : Bool)
Goal: (∀ (x : Bool), p x) ↔ p b ∧ p !b
-- Bool.forall_bool
@[simp]
theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true 
Arguments: {p : Bool → Prop}
Goal: (∀ (b : Bool), p b) ↔ p false ∧ p true
-- Bool.exists_bool'
theorem exists_bool' {p : Bool → Prop} (b : Bool) : (∃ x, p x) ↔ p b ∨ p !b 
Arguments: {p : Bool → Prop} (b : Bool)
Goal: (∃ x, p x) ↔ p b ∨ p !b
-- Bool.exists_bool
@[simp]
theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true 
Arguments: {p : Bool → Prop}
Goal: (∃ b, p b) ↔ p false ∨ p true
-- Bool.not_ne_id
theorem not_ne_id : not ≠ id 
Goal: not ≠ id
-- Bool.or_inl
theorem or_inl {a b : Bool} (H : a) : a || b 
Arguments: {a b : Bool} (H : a = true)
Goal: (a || b) = true
-- Bool.or_inr
theorem or_inr {a b : Bool} (H : b) : a || b 
Arguments: {a b : Bool} (H : b = true)
Goal: (a || b) = true
-- Bool.and_elim_left
theorem and_elim_left : ∀ {a b : Bool}, a && b → a 
Arguments: {a b : Bool}
Goal: (a && b) = true → a = true
-- Bool.and_intro
theorem and_intro : ∀ {a b : Bool}, a → b → a && b 
Arguments: {a b : Bool}
Goal: a = true → b = true → (a && b) = true
-- Bool.and_elim_right
theorem and_elim_right : ∀ {a b : Bool}, a && b → b 
Arguments: {a b : Bool}
Goal: (a && b) = true → b = true
-- Bool.eq_not_iff
lemma eq_not_iff : ∀ {a b : Bool}, a = !b ↔ a ≠ b 
Arguments: {a b : Bool}
Goal: a = !b ↔ a ≠ b
-- Bool.not_eq_iff
lemma not_eq_iff : ∀ {a b : Bool}, !a = b ↔ a ≠ b 
Arguments: {a b : Bool}
Goal: (!decide (a = b)) = true ↔ a ≠ b
-- Bool.ne_not
theorem ne_not {a b : Bool} : a ≠ !b ↔ a = b 
Arguments: {a b : Bool}
Goal: a ≠ !b ↔ a = b
-- Bool.not_ne_self
lemma not_ne_self : ∀ b : Bool, (!b) ≠ b 
Arguments: (b : Bool)
Goal: (!b) ≠ b
-- Bool.self_ne_not
lemma self_ne_not : ∀ b : Bool, b ≠ !b 
Arguments: (b : Bool)
Goal: b ≠ !b
-- Bool.eq_or_eq_not
lemma eq_or_eq_not : ∀ a b, a = b ∨ a = !b 
Arguments: (a b : Bool)
Goal: a = b ∨ a = !b
-- Bool.not_iff_not
theorem not_iff_not : ∀ {b : Bool}, !b ↔ ¬b 
Arguments: {b : Bool}
Goal: (!b) = true ↔ ¬b = true
-- Bool.eq_true_of_not_eq_false'
theorem eq_true_of_not_eq_false' {a : Bool} : !a = false → a = true 
Arguments: {a : Bool}
Goal: (!decide (a = false)) = true → a = true
-- Bool.eq_false_of_not_eq_true'
theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false 
Arguments: {a : Bool}
Goal: (!decide (a = true)) = true → a = false
-- Bool.bne_eq_xor
theorem bne_eq_xor : bne = xor 
Goal: bne = xor
-- Bool.xor_iff_ne
theorem xor_iff_ne : ∀ {x y : Bool}, xor x y = true ↔ x ≠ y 
Arguments: {x y : Bool}
Goal: xor x y = true ↔ x ≠ y
-- Bool.lt_iff
theorem lt_iff : ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true 
Arguments: {x y : Bool}
Goal: x < y ↔ x = false ∧ y = true
-- Bool.false_lt_true
@[simp]
theorem false_lt_true : false < true 
Goal: false < true
-- Bool.le_iff_imp
theorem le_iff_imp : ∀ {x y : Bool}, x ≤ y ↔ x → y 
Arguments: {x y : Bool}
Goal: x ≤ y ↔ x = true → y = true
-- Bool.and_le_left
theorem and_le_left : ∀ x y : Bool, (x && y) ≤ x 
Arguments: (x y : Bool)
Goal: (x && y) ≤ x
-- Bool.and_le_right
theorem and_le_right : ∀ x y : Bool, (x && y) ≤ y 
Arguments: (x y : Bool)
Goal: (x && y) ≤ y
-- Bool.le_and
theorem le_and : ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z) 
Arguments: {x y z : Bool}
Goal: x ≤ y → x ≤ z → x ≤ (y && z)
-- Bool.left_le_or
theorem left_le_or : ∀ x y : Bool, x ≤ (x || y) 
Arguments: (x y : Bool)
Goal: x ≤ (x || y)
-- Bool.right_le_or
theorem right_le_or : ∀ x y : Bool, y ≤ (x || y) 
Arguments: (x y : Bool)
Goal: y ≤ (x || y)
-- Bool.or_le
theorem or_le : ∀ {x y z}, x ≤ z → y ≤ z → (x || y) ≤ z 
Arguments: {x y z : Bool}
Goal: x ≤ z → y ≤ z → (x || y) ≤ z
-- Bool.toNat_beq_zero
@[simp] lemma toNat_beq_zero (b : Bool) : (b.toNat == 0) = !b 
Arguments: (b : Bool)
Goal: (b.toNat == 0) = !b
-- Bool.toNat_bne_zero
@[simp] lemma toNat_bne_zero (b : Bool) : (b.toNat != 0) =  b 
Arguments: (b : Bool)
Goal: (b.toNat != 0) = b
-- Bool.toNat_beq_one
@[simp] lemma toNat_beq_one  (b : Bool) : (b.toNat == 1) =  b 
Arguments: (b : Bool)
Goal: (b.toNat == 1) = b
-- Bool.toNat_bne_one
@[simp] lemma toNat_bne_one  (b : Bool) : (b.toNat != 1) = !b 
Arguments: (b : Bool)
Goal: (b.toNat != 1) = !b
-- Bool.ofNat_le_ofNat
theorem ofNat_le_ofNat {n m : Nat} (h : n ≤ m) : ofNat n ≤ ofNat m 
Arguments: {n m : Nat} (h : n ≤ m)
Goal: Bool.ofNat n ≤ Bool.ofNat m
-- Bool.toNat_le_toNat
theorem toNat_le_toNat {b₀ b₁ : Bool} (h : b₀ ≤ b₁) : toNat b₀ ≤ toNat b₁ 
Arguments: {b₀ b₁ : Bool} (h : b₀ ≤ b₁)
Goal: b₀.toNat ≤ b₁.toNat
-- Bool.ofNat_toNat
theorem ofNat_toNat (b : Bool) : ofNat (toNat b) = b 
Arguments: (b : Bool)
Goal: Bool.ofNat b.toNat = b
-- Bool.injective_iff
@[simp]
theorem injective_iff {α : Sort*} {f : Bool → α} : Function.Injective f ↔ f false ≠ f true 
Arguments: {α : Sort u_1} {f : Bool → α}
Goal: Function.Injective f ↔ f false ≠ f true
-- Bool.apply_apply_apply
theorem apply_apply_apply (f : Bool → Bool) (x : Bool) : f (f (f x)) = f x 
Arguments: (f : Bool → Bool) (x : Bool)
Goal: f (f (f x)) = f x
-- List.all_iff_forall
theorem all_iff_forall {p : α → Bool} : all l p ↔ ∀ a ∈ l, p a 
Arguments: {α : Type u_1} {l : List α} {p : α → Bool}
Goal: l.all p = true ↔ ∀ (a : α), a ∈ l → p a = true
-- List.all_iff_forall_prop
theorem all_iff_forall_prop : (all l fun a => p a) ↔ ∀ a ∈ l, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {l : List α}
Goal: (l.all fun a => decide (p a)) = true ↔ ∀ (a : α), a ∈ l → p a
-- List.any_iff_exists
theorem any_iff_exists {p : α → Bool} : any l p ↔ ∃ a ∈ l, p a 
Arguments: {α : Type u_1} {l : List α} {p : α → Bool}
Goal: l.any p = true ↔ ∃ a, a ∈ l ∧ p a = true
-- List.any_iff_exists_prop
theorem any_iff_exists_prop : (any l fun a => p a) ↔ ∃ a ∈ l, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {l : List α}
Goal: (l.any fun a => decide (p a)) = true ↔ ∃ a, a ∈ l ∧ p a
-- List.any_of_mem
theorem any_of_mem {p : α → Bool} (h₁ : a ∈ l) (h₂ : p a) : any l p 
Arguments: {α : Type u_1} {l : List α} {a : α} {p : α → Bool} (h₁ : a ∈ l) (h₂ : p a = true)
Goal: l.any p = true
-- Nat.Up.next
theorem Up.next {ub i} (h : i < ub) : Up ub (i+1) i 
Arguments: {ub i : Nat} (h : i < ub)
Goal: ub.Up (i + 1) i
-- Nat.Up.WF
theorem Up.WF (ub) : WellFounded (Up ub) 
Arguments: (ub : Nat)
Goal: WellFounded ub.Up
-- Matrix.rank_one
@[simp]
theorem rank_one [StrongRankCondition R] [DecidableEq n] :
    rank (1 : Matrix n n R) = Fintype.card n 
Arguments: {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [StrongRankCondition R] [DecidableEq n]
Goal: Matrix.rank 1 = Fintype.card n
-- Matrix.rank_zero
@[simp]
theorem rank_zero [Nontrivial R] : rank (0 : Matrix m n R) = 0 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Nontrivial R]
Goal: Matrix.rank 0 = 0
-- Matrix.rank_le_card_width
theorem rank_le_card_width [StrongRankCondition R] (A : Matrix m n R) :
    A.rank ≤ Fintype.card n 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [StrongRankCondition R] (A : Matrix m n R)
Goal: A.rank ≤ Fintype.card n
-- Matrix.rank_le_width
theorem rank_le_width [StrongRankCondition R] {m n : ℕ} (A : Matrix (Fin m) (Fin n) R) :
    A.rank ≤ n 
Arguments: {R : Type u_5} [CommRing R] [StrongRankCondition R] {m n : ℕ} (A : Matrix (Fin m) (Fin n) R)
Goal: A.rank ≤ n
-- Matrix.rank_mul_le_left
theorem rank_mul_le_left [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R) :
    (A * B).rank ≤ A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_5} [Fintype n] [Fintype o] [CommRing R] [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R)
Goal: (A * B).rank ≤ A.rank
-- Matrix.rank_mul_le_right
theorem rank_mul_le_right [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R) :
    (A * B).rank ≤ B.rank 
Arguments: {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_5} [Fintype n] [Fintype o] [CommRing R] [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R)
Goal: (A * B).rank ≤ B.rank
-- Matrix.rank_mul_le
theorem rank_mul_le [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R) :
    (A * B).rank ≤ min A.rank B.rank 
Arguments: {m : Type u_2} {n : Type u_3} {o : Type u_4} {R : Type u_5} [Fintype n] [Fintype o] [CommRing R] [StrongRankCondition R] (A : Matrix m n R) (B : Matrix n o R)
Goal: (A * B).rank ≤ min A.rank B.rank
-- Matrix.rank_unit
theorem rank_unit [StrongRankCondition R] [DecidableEq n] (A : (Matrix n n R)ˣ) :
    (A : Matrix n n R).rank = Fintype.card n 
Arguments: {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [StrongRankCondition R] [DecidableEq n] (A : (Matrix n n R)ˣ)
Goal: (↑A).rank = Fintype.card n
-- Matrix.rank_of_isUnit
theorem rank_of_isUnit [StrongRankCondition R] [DecidableEq n] (A : Matrix n n R) (h : IsUnit A) :
    A.rank = Fintype.card n 
Arguments: {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [StrongRankCondition R] [DecidableEq n] (A : Matrix n n R) (h : IsUnit A)
Goal: A.rank = Fintype.card n
-- Matrix.rank_mul_eq_left_of_isUnit_det
@[simp]
lemma rank_mul_eq_left_of_isUnit_det [DecidableEq n]
    (A : Matrix n n R) (B : Matrix m n R) (hA : IsUnit A.det) :
    (B * A).rank = B.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [DecidableEq n] (A : Matrix n n R) (B : Matrix m n R) (hA : IsUnit A.det)
Goal: (B * A).rank = B.rank
-- Matrix.rank_mul_eq_right_of_isUnit_det
@[simp]
lemma rank_mul_eq_right_of_isUnit_det [Fintype m] [DecidableEq m]
    (A : Matrix m m R) (B : Matrix m n R) (hA : IsUnit A.det) :
    (A * B).rank = B.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Fintype m] [DecidableEq m] (A : Matrix m m R) (B : Matrix m n R) (hA : IsUnit A.det)
Goal: (A * B).rank = B.rank
-- Matrix.rank_submatrix_le
theorem rank_submatrix_le [StrongRankCondition R] [Fintype m] (f : n → m) (e : n ≃ m)
    (A : Matrix m m R) : rank (A.submatrix f e) ≤ rank A 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [StrongRankCondition R] [Fintype m] (f : n → m) (e : n ≃ m) (A : Matrix m m R)
Goal: (A.submatrix f ⇑e).rank ≤ A.rank
-- Matrix.rank_reindex
theorem rank_reindex [Fintype m] (e₁ e₂ : m ≃ n) (A : Matrix m m R) :
    rank (reindex e₁ e₂ A) = rank A 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Fintype m] (e₁ e₂ : m ≃ n) (A : Matrix m m R)
Goal: ((Matrix.reindex e₁ e₂) A).rank = A.rank
-- Matrix.rank_submatrix
@[simp]
theorem rank_submatrix [Fintype m] (A : Matrix m m R) (e₁ e₂ : n ≃ m) :
    rank (A.submatrix e₁ e₂) = rank A 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Fintype m] (A : Matrix m m R) (e₁ e₂ : n ≃ m)
Goal: (A.submatrix ⇑e₁ ⇑e₂).rank = A.rank
-- Matrix.rank_eq_finrank_range_toLin
theorem rank_eq_finrank_range_toLin [Finite m] [DecidableEq n] {M₁ M₂ : Type*} [AddCommGroup M₁]
    [AddCommGroup M₂] [Module R M₁] [Module R M₂] (A : Matrix m n R) (v₁ : Basis m R M₁)
    (v₂ : Basis n R M₂) : A.rank = finrank R (LinearMap.range (toLin v₂ v₁ A)) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Finite m] [DecidableEq n] {M₁ : Type u_6} {M₂ : Type u_7} [AddCommGroup M₁] [AddCommGroup M₂] [Module R M₁] [Module R M₂] (A : Matrix m n R) (v₁ : Basis m R M₁) (v₂ : Basis n R M₂)
Goal: A.rank = FiniteDimensional.finrank R ↥(LinearMap.range ((Matrix.toLin v₂ v₁) A))
-- Matrix.rank_le_card_height
theorem rank_le_card_height [Fintype m] [StrongRankCondition R] (A : Matrix m n R) :
    A.rank ≤ Fintype.card m 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] [Fintype m] [StrongRankCondition R] (A : Matrix m n R)
Goal: A.rank ≤ Fintype.card m
-- Matrix.rank_le_height
theorem rank_le_height [StrongRankCondition R] {m n : ℕ} (A : Matrix (Fin m) (Fin n) R) :
    A.rank ≤ m 
Arguments: {R : Type u_5} [CommRing R] [StrongRankCondition R] {m n : ℕ} (A : Matrix (Fin m) (Fin n) R)
Goal: A.rank ≤ m
-- Matrix.rank_eq_finrank_span_cols
theorem rank_eq_finrank_span_cols (A : Matrix m n R) :
    A.rank = finrank R (Submodule.span R (Set.range Aᵀ)) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [CommRing R] (A : Matrix m n R)
Goal: A.rank = FiniteDimensional.finrank R ↥(Submodule.span R (Set.range Aᵀ))
-- Matrix.rank_diagonal
theorem rank_diagonal [Fintype m] [DecidableEq m] [DecidableEq R] (w : m → R) :
    (diagonal w).rank = Fintype.card {i // (w i) ≠ 0} 
Arguments: {m : Type u_2} {R : Type u_5} [Field R] [Fintype m] [DecidableEq m] [DecidableEq R] (w : m → R)
Goal: (Matrix.diagonal w).rank = Fintype.card { i // w i ≠ 0 }
-- Matrix.ker_mulVecLin_conjTranspose_mul_self
theorem ker_mulVecLin_conjTranspose_mul_self (A : Matrix m n R) :
    LinearMap.ker (Aᴴ * A).mulVecLin = LinearMap.ker (mulVecLin A) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [Field R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (A : Matrix m n R)
Goal: LinearMap.ker (Aᴴ * A).mulVecLin = LinearMap.ker A.mulVecLin
-- Matrix.rank_conjTranspose_mul_self
theorem rank_conjTranspose_mul_self (A : Matrix m n R) : (Aᴴ * A).rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [Field R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (A : Matrix m n R)
Goal: (Aᴴ * A).rank = A.rank
-- Matrix.rank_conjTranspose
@[simp]
theorem rank_conjTranspose (A : Matrix m n R) : Aᴴ.rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [Field R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (A : Matrix m n R)
Goal: Aᴴ.rank = A.rank
-- Matrix.rank_self_mul_conjTranspose
@[simp]
theorem rank_self_mul_conjTranspose (A : Matrix m n R) : (A * Aᴴ).rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [Field R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (A : Matrix m n R)
Goal: (A * Aᴴ).rank = A.rank
-- Matrix.ker_mulVecLin_transpose_mul_self
theorem ker_mulVecLin_transpose_mul_self (A : Matrix m n R) :
    LinearMap.ker (Aᵀ * A).mulVecLin = LinearMap.ker (mulVecLin A) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [LinearOrderedField R] (A : Matrix m n R)
Goal: LinearMap.ker (Aᵀ * A).mulVecLin = LinearMap.ker A.mulVecLin
-- Matrix.rank_transpose_mul_self
theorem rank_transpose_mul_self (A : Matrix m n R) : (Aᵀ * A).rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [LinearOrderedField R] (A : Matrix m n R)
Goal: (Aᵀ * A).rank = A.rank
-- Matrix.rank_transpose
@[simp]
theorem rank_transpose (A : Matrix m n R) : Aᵀ.rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [LinearOrderedField R] (A : Matrix m n R)
Goal: Aᵀ.rank = A.rank
-- Matrix.rank_self_mul_transpose
@[simp]
theorem rank_self_mul_transpose (A : Matrix m n R) : (A * Aᵀ).rank = A.rank 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [Fintype m] [LinearOrderedField R] (A : Matrix m n R)
Goal: (A * Aᵀ).rank = A.rank
-- Matrix.rank_eq_finrank_span_row
theorem rank_eq_finrank_span_row [LinearOrderedField R] [Finite m] (A : Matrix m n R) :
    A.rank = finrank R (Submodule.span R (Set.range A)) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_5} [Fintype n] [LinearOrderedField R] [Finite m] (A : Matrix m n R)
Goal: A.rank = FiniteDimensional.finrank R ↥(Submodule.span R (Set.range A))
-- Matrix.kroneckerMap_apply
@[simp]
theorem kroneckerMap_apply (f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β) (i j) :
    kroneckerMap f A B i j = f (A i.1 j.1) (B i.2 j.2) 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} (f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β) (i : l × n) (j : m × p)
Goal: Matrix.kroneckerMap f A B i j = f (A i.1 j.1) (B i.2 j.2)
-- Matrix.kroneckerMap_transpose
theorem kroneckerMap_transpose (f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f Aᵀ Bᵀ = (kroneckerMap f A B)ᵀ 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} (f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f A.transpose B.transpose = (Matrix.kroneckerMap f A B).transpose
-- Matrix.kroneckerMap_map_left
theorem kroneckerMap_map_left (f : α' → β → γ) (g : α → α') (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f (A.map g) B = kroneckerMap (fun a b => f (g a) b) A B 
Arguments: {α : Type u_2} {α' : Type u_3} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} (f : α' → β → γ) (g : α → α') (A : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f (A.map g) B = Matrix.kroneckerMap (fun a b => f (g a) b) A B
-- Matrix.kroneckerMap_map_right
theorem kroneckerMap_map_right (f : α → β' → γ) (g : β → β') (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f A (B.map g) = kroneckerMap (fun a b => f a (g b)) A B 
Arguments: {α : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} (f : α → β' → γ) (g : β → β') (A : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f A (B.map g) = Matrix.kroneckerMap (fun a b => f a (g b)) A B
-- Matrix.kroneckerMap_map
theorem kroneckerMap_map (f : α → β → γ) (g : γ → γ') (A : Matrix l m α) (B : Matrix n p β) :
    (kroneckerMap f A B).map g = kroneckerMap (fun a b => g (f a b)) A B 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {γ' : Type u_7} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} (f : α → β → γ) (g : γ → γ') (A : Matrix l m α) (B : Matrix n p β)
Goal: (Matrix.kroneckerMap f A B).map g = Matrix.kroneckerMap (fun a b => g (f a b)) A B
-- Matrix.kroneckerMap_zero_left
@[simp]
theorem kroneckerMap_zero_left [Zero α] [Zero γ] (f : α → β → γ) (hf : ∀ b, f 0 b = 0)
    (B : Matrix n p β) : kroneckerMap f (0 : Matrix l m α) B = 0 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [Zero α] [Zero γ] (f : α → β → γ) (hf : ∀ (b : β), f 0 b = 0) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f 0 B = 0
-- Matrix.kroneckerMap_zero_right
@[simp]
theorem kroneckerMap_zero_right [Zero β] [Zero γ] (f : α → β → γ) (hf : ∀ a, f a 0 = 0)
    (A : Matrix l m α) : kroneckerMap f A (0 : Matrix n p β) = 0 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [Zero β] [Zero γ] (f : α → β → γ) (hf : ∀ (a : α), f a 0 = 0) (A : Matrix l m α)
Goal: Matrix.kroneckerMap f A 0 = 0
-- Matrix.kroneckerMap_add_left
theorem kroneckerMap_add_left [Add α] [Add γ] (f : α → β → γ)
    (hf : ∀ a₁ a₂ b, f (a₁ + a₂) b = f a₁ b + f a₂ b) (A₁ A₂ : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f (A₁ + A₂) B = kroneckerMap f A₁ B + kroneckerMap f A₂ B 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [Add α] [Add γ] (f : α → β → γ) (hf : ∀ (a₁ a₂ : α) (b : β), f (a₁ + a₂) b = f a₁ b + f a₂ b) (A₁ A₂ : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f (A₁ + A₂) B = Matrix.kroneckerMap f A₁ B + Matrix.kroneckerMap f A₂ B
-- Matrix.kroneckerMap_add_right
theorem kroneckerMap_add_right [Add β] [Add γ] (f : α → β → γ)
    (hf : ∀ a b₁ b₂, f a (b₁ + b₂) = f a b₁ + f a b₂) (A : Matrix l m α) (B₁ B₂ : Matrix n p β) :
    kroneckerMap f A (B₁ + B₂) = kroneckerMap f A B₁ + kroneckerMap f A B₂ 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [Add β] [Add γ] (f : α → β → γ) (hf : ∀ (a : α) (b₁ b₂ : β), f a (b₁ + b₂) = f a b₁ + f a b₂) (A : Matrix l m α) (B₁ B₂ : Matrix n p β)
Goal: Matrix.kroneckerMap f A (B₁ + B₂) = Matrix.kroneckerMap f A B₁ + Matrix.kroneckerMap f A B₂
-- Matrix.kroneckerMap_smul_left
theorem kroneckerMap_smul_left [SMul R α] [SMul R γ] (f : α → β → γ) (r : R)
    (hf : ∀ a b, f (r • a) b = r • f a b) (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f (r • A) B = r • kroneckerMap f A B 
Arguments: {R : Type u_1} {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [SMul R α] [SMul R γ] (f : α → β → γ) (r : R) (hf : ∀ (a : α) (b : β), f (r • a) b = r • f a b) (A : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f (r • A) B = r • Matrix.kroneckerMap f A B
-- Matrix.kroneckerMap_smul_right
theorem kroneckerMap_smul_right [SMul R β] [SMul R γ] (f : α → β → γ) (r : R)
    (hf : ∀ a b, f a (r • b) = r • f a b) (A : Matrix l m α) (B : Matrix n p β) :
    kroneckerMap f A (r • B) = r • kroneckerMap f A B 
Arguments: {R : Type u_1} {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} {p : Type u_11} [SMul R β] [SMul R γ] (f : α → β → γ) (r : R) (hf : ∀ (a : α) (b : β), f a (r • b) = r • f a b) (A : Matrix l m α) (B : Matrix n p β)
Goal: Matrix.kroneckerMap f A (r • B) = r • Matrix.kroneckerMap f A B
-- Matrix.kroneckerMap_diagonal_diagonal
theorem kroneckerMap_diagonal_diagonal [Zero α] [Zero β] [Zero γ] [DecidableEq m] [DecidableEq n]
    (f : α → β → γ) (hf₁ : ∀ b, f 0 b = 0) (hf₂ : ∀ a, f a 0 = 0) (a : m → α) (b : n → β) :
    kroneckerMap f (diagonal a) (diagonal b) = diagonal fun mn => f (a mn.1) (b mn.2) 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {m : Type u_9} {n : Type u_10} [Zero α] [Zero β] [Zero γ] [DecidableEq m] [DecidableEq n] (f : α → β → γ) (hf₁ : ∀ (b : β), f 0 b = 0) (hf₂ : ∀ (a : α), f a 0 = 0) (a : m → α) (b : n → β)
Goal: Matrix.kroneckerMap f (Matrix.diagonal a) (Matrix.diagonal b) = Matrix.diagonal fun mn => f (a mn.1) (b mn.2)
-- Matrix.kroneckerMap_diagonal_right
theorem kroneckerMap_diagonal_right [Zero β] [Zero γ] [DecidableEq n] (f : α → β → γ)
    (hf : ∀ a, f a 0 = 0) (A : Matrix l m α) (b : n → β) :
    kroneckerMap f A (diagonal b) = blockDiagonal fun i => A.map fun a => f a (b i) 
Arguments: {α : Type u_2} {β : Type u_4} {γ : Type u_6} {l : Type u_8} {m : Type u_9} {n : Type u_10} [Zero β] [Zero γ] [DecidableEq n] (f : α → β → γ) (hf : ∀ (a : α), f a 0 = 0) (A : Matrix l m α) (b : n → β)
Goal: Matrix.kroneckerMap f A (Matrix.diagonal b) = Matrix.blockDiagonal fun i => A.map fun a => f a (b i)