ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.noncommProd_cons
@[to_additive (attr := simp)]
theorem noncommProd_cons (s : Finset α) (a : α) (f : α → β)
    (ha : a ∉ s) (comm) :
    noncommProd (cons a s ha) f comm =
      f a * noncommProd s f (comm.mono fun _ => Finset.mem_cons.2 ∘ .inr) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (a : α) (f : α → β) (ha : a ∉ s) (comm : (↑(Finset.cons a s ha)).Pairwise fun a b => Commute (f a) (f b))
Goal: (Finset.cons a s ha).noncommProd f comm = f a * s.noncommProd f ⋯
-- Finset.noncommSum_cons'
@[to_additive]
theorem noncommProd_cons' (s : Finset α) (a : α) (f : α → β)
    (ha : a ∉ s) (comm) :
    noncommProd (cons a s ha) f comm =
      noncommProd s f (comm.mono fun _ => Finset.mem_cons.2 ∘ .inr) * f a 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (a : α) (f : α → β) (ha : a ∉ s) (comm : (↑(Finset.cons a s ha)).Pairwise fun a b => AddCommute (f a) (f b))
Goal: (Finset.cons a s ha).noncommSum f comm = s.noncommSum f ⋯ + f a
-- Finset.noncommProd_cons'
@[to_additive]
theorem noncommProd_cons' (s : Finset α) (a : α) (f : α → β)
    (ha : a ∉ s) (comm) :
    noncommProd (cons a s ha) f comm =
      noncommProd s f (comm.mono fun _ => Finset.mem_cons.2 ∘ .inr) * f a 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (a : α) (f : α → β) (ha : a ∉ s) (comm : (↑(Finset.cons a s ha)).Pairwise fun a b => Commute (f a) (f b))
Goal: (Finset.cons a s ha).noncommProd f comm = s.noncommProd f ⋯ * f a
-- Finset.noncommProd_insert_of_not_mem
@[to_additive (attr := simp)]
theorem noncommProd_insert_of_not_mem [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm)
    (ha : a ∉ s) :
    noncommProd (insert a s) f comm =
      f a * noncommProd s f (comm.mono fun _ => mem_insert_of_mem) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm : (↑(insert a s)).Pairwise fun a b => Commute (f a) (f b)) (ha : a ∉ s)
Goal: (insert a s).noncommProd f comm = f a * s.noncommProd f ⋯
-- Finset.noncommSum_insert_of_not_mem
@[to_additive (attr := simp)]
theorem noncommProd_insert_of_not_mem [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm)
    (ha : a ∉ s) :
    noncommProd (insert a s) f comm =
      f a * noncommProd s f (comm.mono fun _ => mem_insert_of_mem) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm : (↑(insert a s)).Pairwise fun a b => AddCommute (f a) (f b)) (ha : a ∉ s)
Goal: (insert a s).noncommSum f comm = f a + s.noncommSum f ⋯
-- Finset.noncommSum_insert_of_not_mem'
@[to_additive]
theorem noncommProd_insert_of_not_mem' [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm)
    (ha : a ∉ s) :
    noncommProd (insert a s) f comm =
      noncommProd s f (comm.mono fun _ => mem_insert_of_mem) * f a 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm : (↑(insert a s)).Pairwise fun a b => AddCommute (f a) (f b)) (ha : a ∉ s)
Goal: (insert a s).noncommSum f comm = s.noncommSum f ⋯ + f a
-- Finset.noncommProd_insert_of_not_mem'
@[to_additive]
theorem noncommProd_insert_of_not_mem' [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm)
    (ha : a ∉ s) :
    noncommProd (insert a s) f comm =
      noncommProd s f (comm.mono fun _ => mem_insert_of_mem) * f a 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] (s : Finset α) (a : α) (f : α → β) (comm : (↑(insert a s)).Pairwise fun a b => Commute (f a) (f b)) (ha : a ∉ s)
Goal: (insert a s).noncommProd f comm = s.noncommProd f ⋯ * f a
-- Finset.noncommProd_singleton
@[to_additive (attr := simp)]
theorem noncommProd_singleton (a : α) (f : α → β) :
    noncommProd ({a} : Finset α) f
        (by
          norm_cast
          exact Set.pairwise_singleton _ _) =
      f a 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (a : α) (f : α → β)
Goal: {a}.noncommProd f ⋯ = f a
-- Finset.noncommSum_singleton
@[to_additive (attr := simp)]
theorem noncommProd_singleton (a : α) (f : α → β) :
    noncommProd ({a} : Finset α) f
        (by
          norm_cast
          exact Set.pairwise_singleton _ _) =
      f a 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (a : α) (f : α → β)
Goal: {a}.noncommSum f ⋯ = f a
-- Finset.map_noncommProd
@[to_additive]
theorem map_noncommProd [MonoidHomClass F β γ] (s : Finset α) (f : α → β) (comm) (g : F) :
    g (s.noncommProd f comm) =
      s.noncommProd (fun i => g (f i)) fun x hx y hy _ => (comm.of_refl hx hy).map g 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} {γ : Type u_5} [Monoid β] [Monoid γ] [FunLike F β γ] [MonoidHomClass F β γ] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (g : F)
Goal: g (s.noncommProd f comm) = s.noncommProd (fun i => g (f i)) ⋯
-- Finset.map_noncommSum
@[to_additive]
theorem map_noncommProd [MonoidHomClass F β γ] (s : Finset α) (f : α → β) (comm) (g : F) :
    g (s.noncommProd f comm) =
      s.noncommProd (fun i => g (f i)) fun x hx y hy _ => (comm.of_refl hx hy).map g 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} {γ : Type u_5} [AddMonoid β] [AddMonoid γ] [FunLike F β γ] [AddMonoidHomClass F β γ] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => AddCommute (f a) (f b)) (g : F)
Goal: g (s.noncommSum f comm) = s.noncommSum (fun i => g (f i)) ⋯
-- Finset.noncommProd_eq_pow_card
@[to_additive noncommSum_eq_card_nsmul]
theorem noncommProd_eq_pow_card (s : Finset α) (f : α → β) (comm) (m : β) (h : ∀ x ∈ s, f x = m) :
    s.noncommProd f comm = m ^ s.card 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (m : β) (h : ∀ x ∈ s, f x = m)
Goal: s.noncommProd f comm = m ^ s.card
-- Finset.noncommSum_eq_card_nsmul
@[to_additive noncommSum_eq_card_nsmul]
theorem noncommProd_eq_pow_card (s : Finset α) (f : α → β) (comm) (m : β) (h : ∀ x ∈ s, f x = m) :
    s.noncommProd f comm = m ^ s.card 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => AddCommute (f a) (f b)) (m : β) (h : ∀ x ∈ s, f x = m)
Goal: s.noncommSum f comm = s.card • m
-- Finset.noncommProd_commute
@[to_additive]
theorem noncommProd_commute (s : Finset α) (f : α → β) (comm) (y : β)
    (h : ∀ x ∈ s, Commute y (f x)) : Commute y (s.noncommProd f comm) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (y : β) (h : ∀ x ∈ s, Commute y (f x))
Goal: Commute y (s.noncommProd f comm)
-- Finset.noncommSum_addCommute
@[to_additive]
theorem noncommProd_commute (s : Finset α) (f : α → β) (comm) (y : β)
    (h : ∀ x ∈ s, Commute y (f x)) : Commute y (s.noncommProd f comm) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] (s : Finset α) (f : α → β) (comm : (↑s).Pairwise fun a b => AddCommute (f a) (f b)) (y : β) (h : ∀ x ∈ s, AddCommute y (f x))
Goal: AddCommute y (s.noncommSum f comm)
-- Finset.mul_noncommProd_erase
theorem mul_noncommProd_erase [DecidableEq α] (s : Finset α) {a : α} (h : a ∈ s) (f : α → β) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    f a * (s.erase a).noncommProd f comm' = s.noncommProd f comm 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] (s : Finset α) {a : α} (h : a ∈ s) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (comm' : ∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y := ⋯)
Goal: f a * (s.erase a).noncommProd f comm' = s.noncommProd f comm
-- Finset.noncommProd_erase_mul
theorem noncommProd_erase_mul [DecidableEq α] (s : Finset α) {a : α} (h : a ∈ s) (f : α → β) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    (s.erase a).noncommProd f comm' * f a = s.noncommProd f comm 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] (s : Finset α) {a : α} (h : a ∈ s) (f : α → β) (comm : (↑s).Pairwise fun a b => Commute (f a) (f b)) (comm' : ∀ x ∈ ↑(s.erase a), ∀ y ∈ ↑(s.erase a), x ≠ y → (fun a b => Commute (f a) (f b)) x y := ⋯)
Goal: (s.erase a).noncommProd f comm' * f a = s.noncommProd f comm
-- Finset.noncommSum_eq_sum
@[to_additive]
theorem noncommProd_eq_prod {β : Type*} [CommMonoid β] (s : Finset α) (f : α → β) :
    (noncommProd s f fun _ _ _ _ _ => Commute.all _ _) = s.prod f 
Arguments: {α : Type u_3} {β : Type u_6} [AddCommMonoid β] (s : Finset α) (f : α → β)
Goal: s.noncommSum f ⋯ = s.sum f
-- Finset.noncommProd_eq_prod
@[to_additive]
theorem noncommProd_eq_prod {β : Type*} [CommMonoid β] (s : Finset α) (f : α → β) :
    (noncommProd s f fun _ _ _ _ _ => Commute.all _ _) = s.prod f 
Arguments: {α : Type u_3} {β : Type u_6} [CommMonoid β] (s : Finset α) (f : α → β)
Goal: s.noncommProd f ⋯ = s.prod f
-- Finset.noncommProd_union_of_disjoint
@[to_additive "The non-commutative version of `Finset.sum_union`"]
theorem noncommProd_union_of_disjoint [DecidableEq α] {s t : Finset α} (h : Disjoint s t)
    (f : α → β) (comm : { x | x ∈ s ∪ t }.Pairwise fun a b => Commute (f a) (f b)) :
    noncommProd (s ∪ t) f comm =
      noncommProd s f (comm.mono <| coe_subset.2 subset_union_left) *
        noncommProd t f (comm.mono <| coe_subset.2 subset_union_right) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] [DecidableEq α] {s t : Finset α} (h : Disjoint s t) (f : α → β) (comm : {x | x ∈ s ∪ t}.Pairwise fun a b => Commute (f a) (f b))
Goal: (s ∪ t).noncommProd f comm = s.noncommProd f ⋯ * t.noncommProd f ⋯
-- Finset.noncommSum_union_of_disjoint
@[to_additive "The non-commutative version of `Finset.sum_union`"]
theorem noncommProd_union_of_disjoint [DecidableEq α] {s t : Finset α} (h : Disjoint s t)
    (f : α → β) (comm : { x | x ∈ s ∪ t }.Pairwise fun a b => Commute (f a) (f b)) :
    noncommProd (s ∪ t) f comm =
      noncommProd s f (comm.mono <| coe_subset.2 subset_union_left) *
        noncommProd t f (comm.mono <| coe_subset.2 subset_union_right) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] [DecidableEq α] {s t : Finset α} (h : Disjoint s t) (f : α → β) (comm : {x | x ∈ s ∪ t}.Pairwise fun a b => AddCommute (f a) (f b))
Goal: (s ∪ t).noncommSum f comm = s.noncommSum f ⋯ + t.noncommSum f ⋯
-- Finset.noncommSum_add_distrib_aux
@[to_additive]
theorem noncommProd_mul_distrib_aux {s : Finset α} {f : α → β} {g : α → β}
    (comm_ff : (s : Set α).Pairwise fun x y => Commute (f x) (f y))
    (comm_gg : (s : Set α).Pairwise fun x y => Commute (g x) (g y))
    (comm_gf : (s : Set α).Pairwise fun x y => Commute (g x) (f y)) :
    (s : Set α).Pairwise fun x y => Commute ((f * g) x) ((f * g) y) 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] {s : Finset α} {f g : α → β} (comm_ff : (↑s).Pairwise fun x y => AddCommute (f x) (f y)) (comm_gg : (↑s).Pairwise fun x y => AddCommute (g x) (g y)) (comm_gf : (↑s).Pairwise fun x y => AddCommute (g x) (f y))
Goal: (↑s).Pairwise fun x y => AddCommute ((f + g) x) ((f + g) y)
-- Finset.noncommProd_mul_distrib_aux
@[to_additive]
theorem noncommProd_mul_distrib_aux {s : Finset α} {f : α → β} {g : α → β}
    (comm_ff : (s : Set α).Pairwise fun x y => Commute (f x) (f y))
    (comm_gg : (s : Set α).Pairwise fun x y => Commute (g x) (g y))
    (comm_gf : (s : Set α).Pairwise fun x y => Commute (g x) (f y)) :
    (s : Set α).Pairwise fun x y => Commute ((f * g) x) ((f * g) y) 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] {s : Finset α} {f g : α → β} (comm_ff : (↑s).Pairwise fun x y => Commute (f x) (f y)) (comm_gg : (↑s).Pairwise fun x y => Commute (g x) (g y)) (comm_gf : (↑s).Pairwise fun x y => Commute (g x) (f y))
Goal: (↑s).Pairwise fun x y => Commute ((f * g) x) ((f * g) y)
-- Finset.noncommProd_mul_distrib
@[to_additive "The non-commutative version of `Finset.sum_add_distrib`"]
theorem noncommProd_mul_distrib {s : Finset α} (f : α → β) (g : α → β) (comm_ff comm_gg comm_gf) :
    noncommProd s (f * g) (noncommProd_mul_distrib_aux comm_ff comm_gg comm_gf) =
      noncommProd s f comm_ff * noncommProd s g comm_gg 
Arguments: {α : Type u_3} {β : Type u_4} [Monoid β] {s : Finset α} (f g : α → β) (comm_ff : (↑s).Pairwise fun x y => Commute (f x) (f y)) (comm_gg : (↑s).Pairwise fun x y => Commute (g x) (g y)) (comm_gf : (↑s).Pairwise fun x y => Commute (g x) (f y))
Goal: s.noncommProd (f * g) ⋯ = s.noncommProd f comm_ff * s.noncommProd g comm_gg
-- Finset.noncommSum_add_distrib
@[to_additive "The non-commutative version of `Finset.sum_add_distrib`"]
theorem noncommProd_mul_distrib {s : Finset α} (f : α → β) (g : α → β) (comm_ff comm_gg comm_gf) :
    noncommProd s (f * g) (noncommProd_mul_distrib_aux comm_ff comm_gg comm_gf) =
      noncommProd s f comm_ff * noncommProd s g comm_gg 
Arguments: {α : Type u_3} {β : Type u_4} [AddMonoid β] {s : Finset α} (f g : α → β) (comm_ff : (↑s).Pairwise fun x y => AddCommute (f x) (f y)) (comm_gg : (↑s).Pairwise fun x y => AddCommute (g x) (g y)) (comm_gf : (↑s).Pairwise fun x y => AddCommute (g x) (f y))
Goal: s.noncommSum (f + g) ⋯ = s.noncommSum f comm_ff + s.noncommSum g comm_gg
-- Finset.noncommProd_mul_single
@[to_additive]
theorem noncommProd_mul_single [Fintype ι] [DecidableEq ι] (x : ∀ i, M i) :
    (univ.noncommProd (fun i => Pi.mulSingle i (x i)) fun i _ j _ _ =>
        Pi.mulSingle_apply_commute x i j) = x 
Arguments: {ι : Type u_2} {M : ι → Type u_6} [(i : ι) → Monoid (M i)] [Fintype ι] [DecidableEq ι] (x : (i : ι) → M i)
Goal: Finset.univ.noncommProd (fun i => Pi.mulSingle i (x i)) ⋯ = x
-- Finset.noncommSum_single
@[to_additive]
theorem noncommProd_mul_single [Fintype ι] [DecidableEq ι] (x : ∀ i, M i) :
    (univ.noncommProd (fun i => Pi.mulSingle i (x i)) fun i _ j _ _ =>
        Pi.mulSingle_apply_commute x i j) = x 
Arguments: {ι : Type u_2} {M : ι → Type u_6} [(i : ι) → AddMonoid (M i)] [Fintype ι] [DecidableEq ι] (x : (i : ι) → M i)
Goal: Finset.univ.noncommSum (fun i => Pi.single i (x i)) ⋯ = x
-- MonoidHom.pi_ext
@[to_additive]
theorem _root_.MonoidHom.pi_ext [Finite ι] [DecidableEq ι] {f g : (∀ i, M i) →* γ}
    (h : ∀ i x, f (Pi.mulSingle i x) = g (Pi.mulSingle i x)) : f = g 
Arguments: {ι : Type u_2} {γ : Type u_5} [Monoid γ] {M : ι → Type u_6} [(i : ι) → Monoid (M i)] [Finite ι] [DecidableEq ι] {f g : ((i : ι) → M i) →* γ} (h : ∀ (i : ι) (x : M i), f (Pi.mulSingle i x) = g (Pi.mulSingle i x))
Goal: f = g
-- AddMonoidHom.pi_ext
@[to_additive]
theorem _root_.MonoidHom.pi_ext [Finite ι] [DecidableEq ι] {f g : (∀ i, M i) →* γ}
    (h : ∀ i x, f (Pi.mulSingle i x) = g (Pi.mulSingle i x)) : f = g 
Arguments: {ι : Type u_2} {γ : Type u_5} [AddMonoid γ] {M : ι → Type u_6} [(i : ι) → AddMonoid (M i)] [Finite ι] [DecidableEq ι] {f g : ((i : ι) → M i) →+ γ} (h : ∀ (i : ι) (x : M i), f (Pi.single i x) = g (Pi.single i x))
Goal: f = g
-- Matroid.emptyOn_ground
@[simp] theorem emptyOn_ground : (emptyOn α).E = ∅ 
Arguments: {α : Type u_1}
Goal: (Matroid.emptyOn α).E = ∅
-- Matroid.emptyOn_base_iff
@[simp] theorem emptyOn_base_iff : (emptyOn α).Base B ↔ B = ∅ 
Arguments: {α : Type u_1} {B : Set α}
Goal: (Matroid.emptyOn α).Base B ↔ B = ∅
-- Matroid.emptyOn_indep_iff
@[simp] theorem emptyOn_indep_iff : (emptyOn α).Indep I ↔ I = ∅ 
Arguments: {α : Type u_1} {I : Set α}
Goal: (Matroid.emptyOn α).Indep I ↔ I = ∅
-- Matroid.ground_eq_empty_iff
theorem ground_eq_empty_iff : (M.E = ∅) ↔ M = emptyOn α 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: M.E = ∅ ↔ M = Matroid.emptyOn α
-- Matroid.emptyOn_dual_eq
@[simp] theorem emptyOn_dual_eq : (emptyOn α)✶ = emptyOn α 
Arguments: {α : Type u_1}
Goal: (Matroid.emptyOn α)✶ = Matroid.emptyOn α
-- Matroid.restrict_empty
@[simp] theorem restrict_empty (M : Matroid α) : M ↾ (∅ : Set α) = emptyOn α 
Arguments: {α : Type u_1} (M : Matroid α)
Goal: M.restrict ∅ = Matroid.emptyOn α
-- Matroid.eq_emptyOn_or_nonempty
theorem eq_emptyOn_or_nonempty (M : Matroid α) : M = emptyOn α ∨ Matroid.Nonempty M 
Arguments: {α : Type u_1} (M : Matroid α)
Goal: M = Matroid.emptyOn α ∨ M.Nonempty
-- Matroid.eq_emptyOn
theorem eq_emptyOn [IsEmpty α] (M : Matroid α) : M = emptyOn α 
Arguments: {α : Type u_1} [IsEmpty α] (M : Matroid α)
Goal: M = Matroid.emptyOn α
-- Matroid.loopyOn_ground
@[simp] theorem loopyOn_ground (E : Set α) : (loopyOn E).E = E 
Arguments: {α : Type u_1} (E : Set α)
Goal: (Matroid.loopyOn E).E = E
-- Matroid.loopyOn_empty
@[simp] theorem loopyOn_empty (α : Type*) : loopyOn (∅ : Set α) = emptyOn α 
Arguments: (α : Type u_2)
Goal: Matroid.loopyOn ∅ = Matroid.emptyOn α
-- Matroid.loopyOn_indep_iff
@[simp] theorem loopyOn_indep_iff : (loopyOn E).Indep I ↔ I = ∅ 
Arguments: {α : Type u_1} {E I : Set α}
Goal: (Matroid.loopyOn E).Indep I ↔ I = ∅
-- Matroid.eq_loopyOn_iff
theorem eq_loopyOn_iff : M = loopyOn E ↔ M.E = E ∧ ∀ X ⊆ M.E, M.Indep X → X = ∅ 
Arguments: {α : Type u_1} {M : Matroid α} {E : Set α}
Goal: M = Matroid.loopyOn E ↔ M.E = E ∧ ∀ X ⊆ M.E, M.Indep X → X = ∅
-- Matroid.loopyOn_base_iff
@[simp] theorem loopyOn_base_iff : (loopyOn E).Base B ↔ B = ∅ 
Arguments: {α : Type u_1} {E B : Set α}
Goal: (Matroid.loopyOn E).Base B ↔ B = ∅
-- Matroid.loopyOn_basis_iff
@[simp] theorem loopyOn_basis_iff : (loopyOn E).Basis I X ↔ I = ∅ ∧ X ⊆ E 
Arguments: {α : Type u_1} {E I X : Set α}
Goal: (Matroid.loopyOn E).Basis I X ↔ I = ∅ ∧ X ⊆ E
-- Matroid.Finite.loopyOn_finite
theorem Finite.loopyOn_finite (hE : E.Finite) : Matroid.Finite (loopyOn E) 
Arguments: {α : Type u_1} {E : Set α} (hE : E.Finite)
Goal: (Matroid.loopyOn E).Finite
-- Matroid.loopyOn_restrict
@[simp] theorem loopyOn_restrict (E R : Set α) : (loopyOn E) ↾ R = loopyOn R 
Arguments: {α : Type u_1} (E R : Set α)
Goal: (Matroid.loopyOn E).restrict R = Matroid.loopyOn R
-- Matroid.empty_base_iff
theorem empty_base_iff : M.Base ∅ ↔ M = loopyOn M.E 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: M.Base ∅ ↔ M = Matroid.loopyOn M.E
-- Matroid.eq_loopyOn_or_rkPos
theorem eq_loopyOn_or_rkPos (M : Matroid α) : M = loopyOn M.E ∨ RkPos M 
Arguments: {α : Type u_1} (M : Matroid α)
Goal: M = Matroid.loopyOn M.E ∨ M.RkPos
-- Matroid.not_rkPos_iff
theorem not_rkPos_iff : ¬RkPos M ↔ M = loopyOn M.E 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: ¬M.RkPos ↔ M = Matroid.loopyOn M.E
-- Matroid.freeOn_ground
@[simp] theorem freeOn_ground : (freeOn E).E = E 
Arguments: {α : Type u_1} {E : Set α}
Goal: (Matroid.freeOn E).E = E
-- Matroid.freeOn_dual_eq
@[simp] theorem freeOn_dual_eq : (freeOn E)✶ = loopyOn E 
Arguments: {α : Type u_1} {E : Set α}
Goal: (Matroid.freeOn E)✶ = Matroid.loopyOn E
-- Matroid.loopyOn_dual_eq
@[simp] theorem loopyOn_dual_eq : (loopyOn E)✶ = freeOn E 
Arguments: {α : Type u_1} {E : Set α}
Goal: (Matroid.loopyOn E)✶ = Matroid.freeOn E
-- Matroid.freeOn_empty
@[simp] theorem freeOn_empty (α : Type*) : freeOn (∅ : Set α) = emptyOn α 
Arguments: (α : Type u_2)
Goal: Matroid.freeOn ∅ = Matroid.emptyOn α
-- Matroid.freeOn_base_iff
@[simp] theorem freeOn_base_iff : (freeOn E).Base B ↔ B = E 
Arguments: {α : Type u_1} {E B : Set α}
Goal: (Matroid.freeOn E).Base B ↔ B = E
-- Matroid.freeOn_indep_iff
@[simp] theorem freeOn_indep_iff : (freeOn E).Indep I ↔ I ⊆ E 
Arguments: {α : Type u_1} {E I : Set α}
Goal: (Matroid.freeOn E).Indep I ↔ I ⊆ E
-- Matroid.freeOn_indep
theorem freeOn_indep (hIE : I ⊆ E) : (freeOn E).Indep I 
Arguments: {α : Type u_1} {E I : Set α} (hIE : I ⊆ E)
Goal: (Matroid.freeOn E).Indep I
-- Matroid.freeOn_basis_iff
@[simp] theorem freeOn_basis_iff : (freeOn E).Basis I X ↔ I = X ∧ X ⊆ E 
Arguments: {α : Type u_1} {E I X : Set α}
Goal: (Matroid.freeOn E).Basis I X ↔ I = X ∧ X ⊆ E
-- Matroid.freeOn_basis'_iff
@[simp] theorem freeOn_basis'_iff : (freeOn E).Basis' I X ↔ I = X ∩ E 
Arguments: {α : Type u_1} {E I X : Set α}
Goal: (Matroid.freeOn E).Basis' I X ↔ I = X ∩ E
-- Matroid.eq_freeOn_iff
theorem eq_freeOn_iff : M = freeOn E ↔ M.E = E ∧ M.Indep E 
Arguments: {α : Type u_1} {M : Matroid α} {E : Set α}
Goal: M = Matroid.freeOn E ↔ M.E = E ∧ M.Indep E
-- Matroid.ground_indep_iff_eq_freeOn
theorem ground_indep_iff_eq_freeOn : M.Indep M.E ↔ M = freeOn M.E 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: M.Indep M.E ↔ M = Matroid.freeOn M.E
-- Matroid.freeOn_restrict
theorem freeOn_restrict (h : R ⊆ E) : (freeOn E) ↾ R = freeOn R 
Arguments: {α : Type u_1} {E R : Set α} (h : R ⊆ E)
Goal: (Matroid.freeOn E).restrict R = Matroid.freeOn R
-- Matroid.restrict_eq_freeOn_iff
theorem restrict_eq_freeOn_iff : M ↾ I = freeOn I ↔ M.Indep I 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α}
Goal: M.restrict I = Matroid.freeOn I ↔ M.Indep I
-- Matroid.Indep.restrict_eq_freeOn
theorem Indep.restrict_eq_freeOn (hI : M.Indep I) : M ↾ I = freeOn I 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α} (hI : M.Indep I)
Goal: M.restrict I = Matroid.freeOn I
-- Matroid.uniqueBaseOn_ground
@[simp] theorem uniqueBaseOn_ground : (uniqueBaseOn I E).E = E 
Arguments: {α : Type u_1} {E I : Set α}
Goal: (Matroid.uniqueBaseOn I E).E = E
-- Matroid.uniqueBaseOn_base_iff
theorem uniqueBaseOn_base_iff (hIE : I ⊆ E) : (uniqueBaseOn I E).Base B ↔ B = I 
Arguments: {α : Type u_1} {E B I : Set α} (hIE : I ⊆ E)
Goal: (Matroid.uniqueBaseOn I E).Base B ↔ B = I
-- Matroid.uniqueBaseOn_inter_ground_eq
theorem uniqueBaseOn_inter_ground_eq (I E : Set α) :
    uniqueBaseOn (I ∩ E) E = uniqueBaseOn I E 
Arguments: {α : Type u_1} (I E : Set α)
Goal: Matroid.uniqueBaseOn (I ∩ E) E = Matroid.uniqueBaseOn I E
-- Matroid.uniqueBaseOn_indep_iff'
@[simp] theorem uniqueBaseOn_indep_iff' : (uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E 
Arguments: {α : Type u_1} {E I J : Set α}
Goal: (Matroid.uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E
-- Matroid.uniqueBaseOn_indep_iff
theorem uniqueBaseOn_indep_iff (hIE : I ⊆ E) : (uniqueBaseOn I E).Indep J ↔ J ⊆ I 
Arguments: {α : Type u_1} {E I J : Set α} (hIE : I ⊆ E)
Goal: (Matroid.uniqueBaseOn I E).Indep J ↔ J ⊆ I
-- Matroid.uniqueBaseOn_basis_iff
theorem uniqueBaseOn_basis_iff (hI : I ⊆ E) (hX : X ⊆ E) :
    (uniqueBaseOn I E).Basis J X ↔ J = X ∩ I 
Arguments: {α : Type u_1} {E I X J : Set α} (hI : I ⊆ E) (hX : X ⊆ E)
Goal: (Matroid.uniqueBaseOn I E).Basis J X ↔ J = X ∩ I
-- Matroid.uniqueBaseOn_inter_basis
theorem uniqueBaseOn_inter_basis (hI : I ⊆ E) (hX : X ⊆ E) :
    (uniqueBaseOn I E).Basis (X ∩ I) X 
Arguments: {α : Type u_1} {E I X : Set α} (hI : I ⊆ E) (hX : X ⊆ E)
Goal: (Matroid.uniqueBaseOn I E).Basis (X ∩ I) X
-- Matroid.uniqueBaseOn_dual_eq
@[simp] theorem uniqueBaseOn_dual_eq (I E : Set α) :
    (uniqueBaseOn I E)✶ = uniqueBaseOn (E \ I) E 
Arguments: {α : Type u_1} (I E : Set α)
Goal: (Matroid.uniqueBaseOn I E)✶ = Matroid.uniqueBaseOn (E \ I) E
-- Matroid.uniqueBaseOn_self
@[simp] theorem uniqueBaseOn_self (I : Set α) : uniqueBaseOn I I = freeOn I 
Arguments: {α : Type u_1} (I : Set α)
Goal: Matroid.uniqueBaseOn I I = Matroid.freeOn I
-- Matroid.uniqueBaseOn_empty
@[simp] theorem uniqueBaseOn_empty (I : Set α) : uniqueBaseOn ∅ I = loopyOn I 
Arguments: {α : Type u_1} (I : Set α)
Goal: Matroid.uniqueBaseOn ∅ I = Matroid.loopyOn I
-- Matroid.uniqueBaseOn_restrict'
theorem uniqueBaseOn_restrict' (I E R : Set α) :
    (uniqueBaseOn I E) ↾ R = uniqueBaseOn (I ∩ R ∩ E) R 
Arguments: {α : Type u_1} (I E R : Set α)
Goal: (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R ∩ E) R
-- Matroid.uniqueBaseOn_restrict
theorem uniqueBaseOn_restrict (h : I ⊆ E) (R : Set α) :
    (uniqueBaseOn I E) ↾ R = uniqueBaseOn (I ∩ R) R 
Arguments: {α : Type u_1} {E I : Set α} (h : I ⊆ E) (R : Set α)
Goal: (Matroid.uniqueBaseOn I E).restrict R = Matroid.uniqueBaseOn (I ∩ R) R
-- Finset.card_def
theorem card_def (s : Finset α) : s.card = Multiset.card s.1 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.card = Multiset.card s.val
-- Finset.card_val
@[simp] lemma card_val (s : Finset α) : Multiset.card s.1 = s.card 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Multiset.card s.val = s.card
-- Finset.card_mk
@[simp]
theorem card_mk {m nodup} : (⟨m, nodup⟩ : Finset α).card = Multiset.card m 
Arguments: {α : Type u_1} {m : Multiset α} {nodup : m.Nodup}
Goal: { val := m, nodup := nodup }.card = Multiset.card m
-- Finset.card_empty
@[simp]
theorem card_empty : card (∅ : Finset α) = 0 
Arguments: {α : Type u_1}
Goal: ∅.card = 0
-- Finset.card_le_card
@[gcongr]
theorem card_le_card : s ⊆ t → s.card ≤ t.card 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ⊆ t → s.card ≤ t.card
-- Finset.card_mono
@[mono]
theorem card_mono : Monotone (@card α) 
Arguments: {α : Type u_1}
Goal: Monotone Finset.card