ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.toFinset_filter
@[simp]
theorem toFinset_filter (s : List α) (p : α → Bool) :
    (s.filter p).toFinset = s.toFinset.filter (p ·) 
Arguments: {α : Type u_1} [DecidableEq α] (s : List α) (p : α → Bool)
Goal: (List.filter p s).toFinset = Finset.filter (fun x => p x = true) s.toFinset
-- Finset.nodup_toList
theorem nodup_toList (s : Finset α) : s.toList.Nodup 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.toList.Nodup
-- Finset.mem_toList
@[simp]
theorem mem_toList {a : α} {s : Finset α} : a ∈ s.toList ↔ a ∈ s 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: a ∈ s.toList ↔ a ∈ s
-- Finset.toList_eq_nil
@[simp]
theorem toList_eq_nil {s : Finset α} : s.toList = [] ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.toList = [] ↔ s = ∅
-- Finset.empty_toList
@[simp]
theorem empty_toList {s : Finset α} : s.toList.isEmpty ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.toList.isEmpty = true ↔ s = ∅
-- Finset.toList_empty
@[simp]
theorem toList_empty : (∅ : Finset α).toList = [] 
Arguments: {α : Type u_1}
Goal: ∅.toList = []
-- Finset.Nonempty.toList_ne_nil
theorem Nonempty.toList_ne_nil {s : Finset α} (hs : s.Nonempty) : s.toList ≠ [] 
Arguments: {α : Type u_1} {s : Finset α} (hs : s.Nonempty)
Goal: s.toList ≠ []
-- Finset.Nonempty.not_empty_toList
theorem Nonempty.not_empty_toList {s : Finset α} (hs : s.Nonempty) : ¬s.toList.isEmpty 
Arguments: {α : Type u_1} {s : Finset α} (hs : s.Nonempty)
Goal: ¬s.toList.isEmpty = true
-- Finset.coe_toList
@[simp, norm_cast]
theorem coe_toList (s : Finset α) : (s.toList : Multiset α) = s.val 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ↑s.toList = s.val
-- Finset.toList_toFinset
@[simp]
theorem toList_toFinset [DecidableEq α] (s : Finset α) : s.toList.toFinset = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.toList.toFinset = s
-- Finset.toList_eq_singleton_iff
@[simp]
theorem toList_eq_singleton_iff {a : α} {s : Finset α} : s.toList = [a] ↔ s = {a} 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: s.toList = [a] ↔ s = {a}
-- Finset.toList_singleton
@[simp]
theorem toList_singleton : ∀ a, ({a} : Finset α).toList = [a] 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.toList = [a]
-- Finset.exists_list_nodup_eq
theorem exists_list_nodup_eq [DecidableEq α] (s : Finset α) :
    ∃ l : List α, l.Nodup ∧ l.toFinset = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: ∃ l, l.Nodup ∧ l.toFinset = s
-- Finset.toList_cons
theorem toList_cons {a : α} {s : Finset α} (h : a ∉ s) : (cons a s h).toList ~ a :: s.toList 
Arguments: {α : Type u_1} {a : α} {s : Finset α} (h : a ∉ s)
Goal: (Finset.cons a s h).toList.Perm (a :: s.toList)
-- Finset.toList_insert
theorem toList_insert [DecidableEq α] {a : α} {s : Finset α} (h : a ∉ s) :
    (insert a s).toList ~ a :: s.toList 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Finset α} (h : a ∉ s)
Goal: (insert a s).toList.Perm (a :: s.toList)
-- Finset.choose_spec
theorem choose_spec (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l ∧ p (choose p l hp) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: Finset.choose p l hp ∈ l ∧ p (Finset.choose p l hp)
-- Finset.choose_mem
theorem choose_mem (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: Finset.choose p l hp ∈ l
-- Finset.choose_property
theorem choose_property (hp : ∃! a, a ∈ l ∧ p a) : p (choose p l hp) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: p (Finset.choose p l hp)
-- Finset.pairwise_subtype_iff_pairwise_finset'
theorem pairwise_subtype_iff_pairwise_finset' (r : β → β → Prop) (f : α → β) :
    Pairwise (r on fun x : s => f x) ↔ (s : Set α).Pairwise (r on f) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} (r : β → β → Prop) (f : α → β)
Goal: Pairwise (r on fun x => f ↑x) ↔ (↑s).Pairwise (r on f)
-- Finset.pairwise_subtype_iff_pairwise_finset
theorem pairwise_subtype_iff_pairwise_finset (r : α → α → Prop) :
    Pairwise (r on fun x : s => x) ↔ (s : Set α).Pairwise r 
Arguments: {α : Type u_1} {s : Finset α} (r : α → α → Prop)
Goal: Pairwise (r on fun x => ↑x) ↔ (↑s).Pairwise r
-- Finset.pairwise_cons'
theorem pairwise_cons' {a : α} (ha : a ∉ s) (r : β → β → Prop) (f : α → β) :
    Pairwise (r on fun a : s.cons a ha => f a) ↔
    Pairwise (r on fun a : s => f a) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {a : α} (ha : a ∉ s) (r : β → β → Prop) (f : α → β)
Goal: Pairwise (r on fun a_1 => f ↑a_1) ↔ Pairwise (r on fun a => f ↑a) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a)
-- Finset.pairwise_cons
theorem pairwise_cons {a : α} (ha : a ∉ s) (r : α → α → Prop) :
    Pairwise (r on fun a : s.cons a ha => a) ↔
      Pairwise (r on fun a : s => a) ∧ ∀ b ∈ s, r a b ∧ r b a 
Arguments: {α : Type u_1} {s : Finset α} {a : α} (ha : a ∉ s) (r : α → α → Prop)
Goal: Pairwise (r on fun a_1 => ↑a_1) ↔ Pairwise (r on fun a => ↑a) ∧ ∀ b ∈ s, r a b ∧ r b a
-- Equiv.Finset.union_symm_inl
@[simp]
theorem Finset.union_symm_inl (h : Disjoint s t) (x : s) :
    Equiv.Finset.union s t h (Sum.inl x) = ⟨x, Finset.mem_union.mpr <| Or.inl x.2⟩ 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : Disjoint s t) (x : { x // x ∈ s })
Goal: (Equiv.Finset.union s t h) (Sum.inl x) = ⟨↑x, ⋯⟩
-- Equiv.Finset.union_symm_inr
@[simp]
theorem Finset.union_symm_inr (h : Disjoint s t) (y : t) :
    Equiv.Finset.union s t h (Sum.inr y) = ⟨y, Finset.mem_union.mpr <| Or.inr y.2⟩ 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : Disjoint s t) (y : { x // x ∈ t })
Goal: (Equiv.Finset.union s t h) (Sum.inr y) = ⟨↑y, ⋯⟩
-- Multiset.disjoint_toFinset
theorem disjoint_toFinset {m1 m2 : Multiset α} :
    _root_.Disjoint m1.toFinset m2.toFinset ↔ m1.Disjoint m2 
Arguments: {α : Type u_1} [DecidableEq α] {m1 m2 : Multiset α}
Goal: Disjoint m1.toFinset m2.toFinset ↔ m1.Disjoint m2
-- List.disjoint_toFinset_iff_disjoint
theorem disjoint_toFinset_iff_disjoint : _root_.Disjoint l.toFinset l'.toFinset ↔ l.Disjoint l' 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α}
Goal: Disjoint l.toFinset l'.toFinset ↔ l.Disjoint l'
-- Matrix.invOf_mul_self_assoc
protected theorem invOf_mul_self_assoc (A : Matrix n n α) (B : Matrix n m α) [Invertible A] :
    ⅟ A * (A * B) = B 
Arguments: {m : Type u_1} {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] (A : Matrix n n α) (B : Matrix n m α) [Invertible A]
Goal: ⅟A * (A * B) = B
-- Matrix.mul_invOf_self_assoc
protected theorem mul_invOf_self_assoc (A : Matrix n n α) (B : Matrix n m α) [Invertible A] :
    A * (⅟ A * B) = B 
Arguments: {m : Type u_1} {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] (A : Matrix n n α) (B : Matrix n m α) [Invertible A]
Goal: A * (⅟A * B) = B
-- Matrix.mul_invOf_mul_self_cancel
protected theorem mul_invOf_mul_self_cancel (A : Matrix m n α) (B : Matrix n n α) [Invertible B] :
    A * ⅟ B * B = A 
Arguments: {m : Type u_1} {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] (A : Matrix m n α) (B : Matrix n n α) [Invertible B]
Goal: A * ⅟B * B = A
-- Matrix.mul_mul_invOf_self_cancel
protected theorem mul_mul_invOf_self_cancel (A : Matrix m n α) (B : Matrix n n α) [Invertible B] :
    A * B * ⅟ B = A 
Arguments: {m : Type u_1} {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] (A : Matrix m n α) (B : Matrix n n α) [Invertible B]
Goal: A * B * ⅟B = A
-- Matrix.conjTranspose_invOf
lemma conjTranspose_invOf [Invertible A] [Invertible Aᴴ] : (⅟A)ᴴ = ⅟(Aᴴ) 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] [StarRing α] (A : Matrix n n α) [Invertible A] [Invertible Aᴴ]
Goal: (⅟A)ᴴ = ⅟Aᴴ
-- Matrix.isUnit_conjTranspose
@[simp] lemma isUnit_conjTranspose : IsUnit Aᴴ ↔ IsUnit A 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [Semiring α] [StarRing α] (A : Matrix n n α)
Goal: IsUnit Aᴴ ↔ IsUnit A
-- Matrix.transpose_invOf
lemma transpose_invOf [Invertible A] [Invertible Aᵀ] : (⅟A)ᵀ = ⅟(Aᵀ) 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [CommSemiring α] (A : Matrix n n α) [Invertible A] [Invertible Aᵀ]
Goal: (⅟A)ᵀ = ⅟Aᵀ
-- Matrix.transposeInvertibleEquivInvertible_apply
@[simps]
def transposeInvertibleEquivInvertible : Invertible Aᵀ ≃ Invertible A 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [CommSemiring α] (A : Matrix n n α) [Invertible Aᵀ]
Goal: A.transposeInvertibleEquivInvertible inst✝ = A.invertibleOfInvertibleTranspose
-- Matrix.transposeInvertibleEquivInvertible_symm_apply
@[simps]
def transposeInvertibleEquivInvertible : Invertible Aᵀ ≃ Invertible A 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [CommSemiring α] (A : Matrix n n α) [Invertible A]
Goal: A.transposeInvertibleEquivInvertible.symm inst✝ = A.invertibleTranspose
-- Matrix.isUnit_transpose
@[simp] lemma isUnit_transpose : IsUnit Aᵀ ↔ IsUnit A 
Arguments: {n : Type u_2} {α : Type u_3} [Fintype n] [DecidableEq n] [CommSemiring α] (A : Matrix n n α)
Goal: IsUnit Aᵀ ↔ IsUnit A
-- Matrix.dualNumberEquiv_symm_apply
@[simps]
def Matrix.dualNumberEquiv : Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R) 
Arguments: {R n : Type} [CommSemiring R] [Fintype n] [DecidableEq n] (d : DualNumber (Matrix n n R))
Goal: Matrix.dualNumberEquiv.symm d = Matrix.of fun i j => (TrivSqZeroExt.fst d i j, TrivSqZeroExt.snd d i j)
-- Matrix.dualNumberEquiv_apply
@[simps]
def Matrix.dualNumberEquiv : Matrix n n (DualNumber R) ≃ₐ[R] DualNumber (Matrix n n R) 
Arguments: {R n : Type} [CommSemiring R] [Fintype n] [DecidableEq n] (A : Matrix n n (DualNumber R))
Goal: Matrix.dualNumberEquiv A =
  (Matrix.of fun i j => TrivSqZeroExt.fst (A i j), Matrix.of fun i j => TrivSqZeroExt.snd (A i j))
-- Matroid.sigma_indep_iff
@[simp] lemma sigma_indep_iff {I} :
    (Matroid.sigma M).Indep I ↔ ∀ i, (M i).Indep (Sigma.mk i ⁻¹' I) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {M : (i : ι) → Matroid (α i)} {I : Set ((i : ι) × α i)}
Goal: (Matroid.sigma M).Indep I ↔ ∀ (i : ι), (M i).Indep (Sigma.mk i ⁻¹' I)
-- Matroid.sigma_base_iff
@[simp] lemma sigma_base_iff {B} :
    (Matroid.sigma M).Base B ↔ ∀ i, (M i).Base (Sigma.mk i ⁻¹' B) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {M : (i : ι) → Matroid (α i)} {B : Set ((i : ι) × α i)}
Goal: (Matroid.sigma M).Base B ↔ ∀ (i : ι), (M i).Base (Sigma.mk i ⁻¹' B)
-- Matroid.sigma_ground_eq
@[simp] lemma sigma_ground_eq : (Matroid.sigma M).E = univ.sigma fun i ↦ (M i).E 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {M : (i : ι) → Matroid (α i)}
Goal: (Matroid.sigma M).E = Set.univ.sigma fun i => (M i).E
-- Matroid.sigma_basis_iff
@[simp] lemma sigma_basis_iff {I X} :
    (Matroid.sigma M).Basis I X ↔ ∀ i, (M i).Basis (Sigma.mk i ⁻¹' I) (Sigma.mk i ⁻¹' X) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {M : (i : ι) → Matroid (α i)} {I X : Set ((i : ι) × α i)}
Goal: (Matroid.sigma M).Basis I X ↔ ∀ (i : ι), (M i).Basis (Sigma.mk i ⁻¹' I) (Sigma.mk i ⁻¹' X)
-- Matroid.Finitary.sigma
lemma Finitary.sigma (h : ∀ i, (M i).Finitary) : (Matroid.sigma M).Finitary 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {M : (i : ι) → Matroid (α i)} (h : ∀ (i : ι), (M i).Finitary)
Goal: (Matroid.sigma M).Finitary
-- Matroid.sum'_indep_iff
@[simp] lemma sum'_indep_iff {I} :
    (Matroid.sum' M).Indep I ↔ ∀ i, (M i).Indep (Prod.mk i ⁻¹' I) 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {I : Set (ι × α)}
Goal: (Matroid.sum' M).Indep I ↔ ∀ (i : ι), (M i).Indep (Prod.mk i ⁻¹' I)
-- Matroid.sum'_ground_eq
@[simp] lemma sum'_ground_eq (M : ι → Matroid α) :
    (Matroid.sum' M).E = ⋃ i, Prod.mk i '' (M i).E 
Arguments: {α : Type u_1} {ι : Type u_2} (M : ι → Matroid α)
Goal: (Matroid.sum' M).E = ⋃ i, Prod.mk i '' (M i).E
-- Matroid.sum'_base_iff
@[simp] lemma sum'_base_iff {B} : (Matroid.sum' M).Base B ↔ ∀ i, (M i).Base (Prod.mk i ⁻¹' B) 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {B : Set (ι × α)}
Goal: (Matroid.sum' M).Base B ↔ ∀ (i : ι), (M i).Base (Prod.mk i ⁻¹' B)
-- Matroid.sum'_basis_iff
@[simp] lemma sum'_basis_iff {I X} :
    (Matroid.sum' M).Basis I X ↔ ∀ i, (M i).Basis (Prod.mk i ⁻¹' I) (Prod.mk i ⁻¹' X) 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {I X : Set (ι × α)}
Goal: (Matroid.sum' M).Basis I X ↔ ∀ (i : ι), (M i).Basis (Prod.mk i ⁻¹' I) (Prod.mk i ⁻¹' X)
-- Matroid.Finitary.sum'
lemma Finitary.sum' (h : ∀ i, (M i).Finitary) : (Matroid.sum' M).Finitary 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} (h : ∀ (i : ι), (M i).Finitary)
Goal: (Matroid.sum' M).Finitary
-- Matroid.disjointSigma_ground_eq
@[simp] lemma disjointSigma_ground_eq {h} : (Matroid.disjointSigma M h).E = ⋃ i : ι, (M i).E 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {h : Pairwise (Disjoint on fun i => (M i).E)}
Goal: (Matroid.disjointSigma M h).E = ⋃ i, (M i).E
-- Matroid.disjointSigma_indep_iff
@[simp] lemma disjointSigma_indep_iff {h I} :
    (Matroid.disjointSigma M h).Indep I ↔
      (∀ i, (M i).Indep (I ∩ (M i).E)) ∧ I ⊆ ⋃ i, (M i).E 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {h : Pairwise (Disjoint on fun i => (M i).E)} {I : Set α}
Goal: (Matroid.disjointSigma M h).Indep I ↔ (∀ (i : ι), (M i).Indep (I ∩ (M i).E)) ∧ I ⊆ ⋃ i, (M i).E
-- Matroid.disjointSigma_base_iff
@[simp] lemma disjointSigma_base_iff {h B} :
    (Matroid.disjointSigma M h).Base B ↔
      (∀ i, (M i).Base (B ∩ (M i).E)) ∧ B ⊆ ⋃ i, (M i).E 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {h : Pairwise (Disjoint on fun i => (M i).E)} {B : Set α}
Goal: (Matroid.disjointSigma M h).Base B ↔ (∀ (i : ι), (M i).Base (B ∩ (M i).E)) ∧ B ⊆ ⋃ i, (M i).E
-- Matroid.disjointSigma_basis_iff
@[simp] lemma disjointSigma_basis_iff {h I X} :
    (Matroid.disjointSigma M h).Basis I X ↔
      (∀ i, (M i).Basis (I ∩ (M i).E) (X ∩ (M i).E)) ∧ I ⊆ X ∧ X ⊆ ⋃ i, (M i).E 
Arguments: {α : Type u_1} {ι : Type u_2} {M : ι → Matroid α} {h : Pairwise (Disjoint on fun i => (M i).E)} {I X : Set α}
Goal: (Matroid.disjointSigma M h).Basis I X ↔ (∀ (i : ι), (M i).Basis (I ∩ (M i).E) (X ∩ (M i).E)) ∧ I ⊆ X ∧ X ⊆ ⋃ i, (M i).E
-- Matroid.sum_ground
@[simp] lemma sum_ground (M : Matroid α) (N : Matroid β) :
    (M.sum N).E = (.inl '' M.E) ∪ (.inr '' N.E) 
Arguments: {α : Type u} {β : Type v} (M : Matroid α) (N : Matroid β)
Goal: (M.sum N).E = Sum.inl '' M.E ∪ Sum.inr '' N.E
-- Matroid.sum_indep_iff
@[simp] lemma sum_indep_iff (M : Matroid α) (N : Matroid β) {I : Set (α ⊕ β)} :
    (M.sum N).Indep I ↔ M.Indep (.inl ⁻¹' I) ∧ N.Indep (.inr ⁻¹' I) 
Arguments: {α : Type u} {β : Type v} (M : Matroid α) (N : Matroid β) {I : Set (α ⊕ β)}
Goal: (M.sum N).Indep I ↔ M.Indep (Sum.inl ⁻¹' I) ∧ N.Indep (Sum.inr ⁻¹' I)
-- Matroid.sum_base_iff
@[simp] lemma sum_base_iff {M : Matroid α} {N : Matroid β} {B : Set (α ⊕ β)} :
    (M.sum N).Base B ↔ M.Base (.inl ⁻¹' B) ∧ N.Base (.inr ⁻¹' B) 
Arguments: {α : Type u} {β : Type v} {M : Matroid α} {N : Matroid β} {B : Set (α ⊕ β)}
Goal: (M.sum N).Base B ↔ M.Base (Sum.inl ⁻¹' B) ∧ N.Base (Sum.inr ⁻¹' B)
-- Matroid.sum_basis_iff
@[simp] lemma sum_basis_iff {M : Matroid α} {N : Matroid β} {I X : Set (α ⊕ β)} :
    (M.sum N).Basis I X ↔
      (M.Basis (Sum.inl ⁻¹' I) (Sum.inl ⁻¹' X) ∧ N.Basis (Sum.inr ⁻¹' I) (Sum.inr ⁻¹' X)) 
Arguments: {α : Type u} {β : Type v} {M : Matroid α} {N : Matroid β} {I X : Set (α ⊕ β)}
Goal: (M.sum N).Basis I X ↔ M.Basis (Sum.inl ⁻¹' I) (Sum.inl ⁻¹' X) ∧ N.Basis (Sum.inr ⁻¹' I) (Sum.inr ⁻¹' X)
-- Matroid.disjointSum_ground_eq
@[simp] lemma disjointSum_ground_eq {h} : (M.disjointSum N h).E = M.E ∪ N.E 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E}
Goal: (M.disjointSum N h).E = M.E ∪ N.E
-- Matroid.disjointSum_indep_iff
@[simp] lemma disjointSum_indep_iff {h I} :
    (M.disjointSum N h).Indep I ↔ M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E} {I : Set α}
Goal: (M.disjointSum N h).Indep I ↔ M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
-- Matroid.disjointSum_base_iff
@[simp] lemma disjointSum_base_iff {h B} :
    (M.disjointSum N h).Base B ↔ M.Base (B ∩ M.E) ∧ N.Base (B ∩ N.E) ∧ B ⊆ M.E ∪ N.E 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E} {B : Set α}
Goal: (M.disjointSum N h).Base B ↔ M.Base (B ∩ M.E) ∧ N.Base (B ∩ N.E) ∧ B ⊆ M.E ∪ N.E
-- Matroid.disjointSum_basis_iff
@[simp] lemma disjointSum_basis_iff {h I X} :
    (M.disjointSum N h).Basis I X ↔ M.Basis (I ∩ M.E) (X ∩ M.E) ∧
      N.Basis (I ∩ N.E) (X ∩ N.E) ∧ I ⊆ X ∧ X ⊆ M.E ∪ N.E 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E} {I X : Set α}
Goal: (M.disjointSum N h).Basis I X ↔ M.Basis (I ∩ M.E) (X ∩ M.E) ∧ N.Basis (I ∩ N.E) (X ∩ N.E) ∧ I ⊆ X ∧ X ⊆ M.E ∪ N.E
-- Matroid.Indep.eq_union_image_of_disjointSum
lemma Indep.eq_union_image_of_disjointSum {h I} (hI : (disjointSum M N h).Indep I) :
    ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E} {I : Set α} (hI : (M.disjointSum N h).Indep I)
Goal: ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN
-- Matroid.Base.eq_union_image_of_disjointSum
lemma Base.eq_union_image_of_disjointSum {h B} (hB : (disjointSum M N h).Base B) :
    ∃ BM BN, M.Base BM ∧ N.Base BN ∧ Disjoint BM BN ∧ B = BM ∪ BN 
Arguments: {α : Type u_1} {M N : Matroid α} {h : Disjoint M.E N.E} {B : Set α} (hB : (M.disjointSum N h).Base B)
Goal: ∃ BM BN, M.Base BM ∧ N.Base BN ∧ Disjoint BM BN ∧ B = BM ∪ BN
-- Matrix.forall_iff
theorem forall_iff : ∀ {m n} (P : Matrix (Fin m) (Fin n) α → Prop), Forall P ↔ ∀ x, P x
  
Arguments: {α : Type u_1} {m n : ℕ} (P : Matrix (Fin m) (Fin n) α → Prop)
Goal: Matrix.Forall P ↔ ∀ (x : Matrix (Fin m) (Fin n) α), P x
-- Matrix.exists_iff
theorem exists_iff : ∀ {m n} (P : Matrix (Fin m) (Fin n) α → Prop), Exists P ↔ ∃ x, P x
  
Arguments: {α : Type u_1} {m n : ℕ} (P : Matrix (Fin m) (Fin n) α → Prop)
Goal: Matrix.Exists P ↔ ∃ x, P x
-- Matrix.transposeᵣ_eq
@[simp]
theorem transposeᵣ_eq : ∀ {m n} (A : Matrix (Fin m) (Fin n) α), transposeᵣ A = transpose A
  
Arguments: {α : Type u_1} {m n : ℕ} (A : Matrix (Fin m) (Fin n) α)
Goal: A.transposeᵣ = Aᵀ
-- Matrix.dotProductᵣ_eq
@[simp]
theorem dotProductᵣ_eq [Mul α] [AddCommMonoid α] {m} (a b : Fin m → α) :
    dotProductᵣ a b = dotProduct a b 
Arguments: {α : Type u_1} [Mul α] [AddCommMonoid α] {m : ℕ} (a b : Fin m → α)
Goal: Matrix.dotProductᵣ a b = a ⬝ᵥ b
-- Matrix.mulᵣ_eq
@[simp]
theorem mulᵣ_eq [Mul α] [AddCommMonoid α] (A : Matrix (Fin l) (Fin m) α)
    (B : Matrix (Fin m) (Fin n) α) : mulᵣ A B = A * B 
Arguments: {l m n : ℕ} {α : Type u_1} [Mul α] [AddCommMonoid α] (A : Matrix (Fin l) (Fin m) α) (B : Matrix (Fin m) (Fin n) α)
Goal: A.mulᵣ B = A * B
-- Matrix.mulVecᵣ_eq
@[simp]
theorem mulVecᵣ_eq [NonUnitalNonAssocSemiring α] (A : Matrix (Fin l) (Fin m) α) (v : Fin m → α) :
    mulVecᵣ A v = A *ᵥ v 
Arguments: {l m : ℕ} {α : Type u_1} [NonUnitalNonAssocSemiring α] (A : Matrix (Fin l) (Fin m) α) (v : Fin m → α)
Goal: A.mulVecᵣ v = A *ᵥ v
-- Matrix.vecMulᵣ_eq
@[simp]
theorem vecMulᵣ_eq [NonUnitalNonAssocSemiring α] (v : Fin l → α) (A : Matrix (Fin l) (Fin m) α) :
    vecMulᵣ v A = v ᵥ* A 
Arguments: {l m : ℕ} {α : Type u_1} [NonUnitalNonAssocSemiring α] (v : Fin l → α) (A : Matrix (Fin l) (Fin m) α)
Goal: Matrix.vecMulᵣ v A = v ᵥ* A
-- Matrix.etaExpand_eq
theorem etaExpand_eq {m n} (A : Matrix (Fin m) (Fin n) α) : etaExpand A = A 
Arguments: {α : Type u_1} {m n : ℕ} (A : Matrix (Fin m) (Fin n) α)
Goal: A.etaExpand = A
-- Matrix.smul_stdBasisMatrix
@[simp]
theorem smul_stdBasisMatrix [SMulZeroClass R α] (r : R) (i : m) (j : n) (a : α) :
    r • stdBasisMatrix i j a = stdBasisMatrix i j (r • a) 
Arguments: {m : Type u_2} {n : Type u_3} {R : Type u_4} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] [SMulZeroClass R α] (r : R) (i : m) (j : n) (a : α)
Goal: r • Matrix.stdBasisMatrix i j a = Matrix.stdBasisMatrix i j (r • a)
-- Matrix.stdBasisMatrix_zero
@[simp]
theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i : m) (j : n)
Goal: Matrix.stdBasisMatrix i j 0 = 0
-- 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 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i : m) (j : n) (a b : α)
Goal: Matrix.stdBasisMatrix i j (a + b) = Matrix.stdBasisMatrix i j a + Matrix.stdBasisMatrix i j b
-- Matrix.mulVec_stdBasisMatrix
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) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] [Fintype m] (i : n) (j : m) (c : α) (x : m → α)
Goal: (Matrix.stdBasisMatrix i j c).mulVec x = Function.update 0 i (c * x j)
-- 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) 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] [Fintype m] [Fintype n] (x : Matrix m n α)
Goal: x = ∑ i : m, ∑ j : n, Matrix.stdBasisMatrix i j (x i j)
-- Matrix.std_basis_eq_basis_mul_basis
theorem std_basis_eq_basis_mul_basis (i : m) (j : n) :
    stdBasisMatrix i j (1 : α) =
      vecMulVec (fun i' => ite (i = i') 1 0) fun j' => ite (j = j') 1 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i : m) (j : n)
Goal: Matrix.stdBasisMatrix i j 1 = Matrix.vecMulVec (fun i' => if i = i' then 1 else 0) fun j' => if j = j' then 1 else 0
-- Matrix.induction_on'
@[elab_as_elim]
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 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] [Finite m] [Finite n] {P : Matrix m n α → Prop} (M : Matrix m n α) (h_zero : P 0) (h_add : ∀ (p q : Matrix m n α), P p → P q → P (p + q)) (h_std_basis : ∀ (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix i j x))
Goal: P M
-- Matrix.induction_on
@[elab_as_elim]
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 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] [Finite m] [Finite n] [Nonempty m] [Nonempty n] {P : Matrix m n α → Prop} (M : Matrix m n α) (h_add : ∀ (p q : Matrix m n α), P p → P q → P (p + q)) (h_std_basis : ∀ (i : m) (j : n) (x : α), P (Matrix.stdBasisMatrix i j x))
Goal: P M
-- Matrix.StdBasisMatrix.apply_same
@[simp]
theorem apply_same : stdBasisMatrix i j c i j = c 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i : m) (j : n) (c : α)
Goal: Matrix.stdBasisMatrix i j c i j = c
-- Matrix.StdBasisMatrix.apply_of_ne
@[simp]
theorem apply_of_ne (h : ¬(i = i' ∧ j = j')) : stdBasisMatrix i j c i' j' = 0 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i : m) (j : n) (c : α) (i' : m) (j' : n) (h : ¬(i = i' ∧ j = j'))
Goal: Matrix.stdBasisMatrix i j c i' j' = 0
-- 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 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] {i i' : m} (hi : i ≠ i') (j j' : n) (a : α)
Goal: Matrix.stdBasisMatrix i j a i' j' = 0
-- 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 
Arguments: {m : Type u_2} {n : Type u_3} {α : Type u_5} [DecidableEq m] [DecidableEq n] [Semiring α] (i i' : m) {j j' : n} (hj : j ≠ j') (a : α)
Goal: Matrix.stdBasisMatrix i j a i' j' = 0