ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.intersecting_singleton
@[simp]
theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {a : α}
Goal: {a}.Intersecting ↔ a ≠ ⊥
-- Set.Intersecting.insert
protected theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥)
    (h : ∀ b ∈ s, ¬Disjoint a b) : (insert a s).Intersecting 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Set α} {a : α} (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b ∈ s, ¬Disjoint a b)
Goal: (insert a s).Intersecting
-- Set.intersecting_insert
theorem intersecting_insert :
    (insert a s).Intersecting ↔ s.Intersecting ∧ a ≠ ⊥ ∧ ∀ b ∈ s, ¬Disjoint a b 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Set α} {a : α}
Goal: (insert a s).Intersecting ↔ s.Intersecting ∧ a ≠ ⊥ ∧ ∀ b ∈ s, ¬Disjoint a b
-- Set.intersecting_iff_pairwise_not_disjoint
theorem intersecting_iff_pairwise_not_disjoint :
    s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥} 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Set α}
Goal: s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥}
-- Set.Subsingleton.intersecting
protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecting ↔ s ≠ {⊥} 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Set α} (hs : s.Subsingleton)
Goal: s.Intersecting ↔ s ≠ {⊥}
-- Set.intersecting_iff_eq_empty_of_subsingleton
theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
    s.Intersecting ↔ s = ∅ 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] [Subsingleton α] (s : Set α)
Goal: s.Intersecting ↔ s = ∅
-- Set.Intersecting.isUpperSet
protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Set α} (hs : s.Intersecting) (h : ∀ (t : Set α), t.Intersecting → s ⊆ t → s = t)
Goal: IsUpperSet s
-- Set.Intersecting.isUpperSet'
theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
    (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) 
Arguments: {α : Type u_1} [SemilatticeInf α] [OrderBot α] {s : Finset α} (hs : (↑s).Intersecting) (h : ∀ (t : Finset α), (↑t).Intersecting → s ⊆ t → s = t)
Goal: IsUpperSet ↑s
-- Set.Intersecting.exists_mem_set
theorem Intersecting.exists_mem_set {𝒜 : Set (Set α)} (h𝒜 : 𝒜.Intersecting) {s t : Set α}
    (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t 
Arguments: {α : Type u_1} {𝒜 : Set (Set α)} (h𝒜 : 𝒜.Intersecting) {s t : Set α} (hs : s ∈ 𝒜) (ht : t ∈ 𝒜)
Goal: ∃ a ∈ s, a ∈ t
-- Set.Intersecting.exists_mem_finset
theorem Intersecting.exists_mem_finset [DecidableEq α] {𝒜 : Set (Finset α)} (h𝒜 : 𝒜.Intersecting)
    {s t : Finset α} (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Set (Finset α)} (h𝒜 : 𝒜.Intersecting) {s t : Finset α} (hs : s ∈ 𝒜) (ht : t ∈ 𝒜)
Goal: ∃ a ∈ s, a ∈ t
-- Set.Intersecting.not_compl_mem
theorem Intersecting.not_compl_mem {s : Set α} (hs : s.Intersecting) {a : α} (ha : a ∈ s) :
    aᶜ ∉ s 
Arguments: {α : Type u_1} [BooleanAlgebra α] {s : Set α} (hs : s.Intersecting) {a : α} (ha : a ∈ s)
Goal: aᶜ ∉ s
-- Set.Intersecting.not_mem
theorem Intersecting.not_mem {s : Set α} (hs : s.Intersecting) {a : α} (ha : aᶜ ∈ s) : a ∉ s 
Arguments: {α : Type u_1} [BooleanAlgebra α] {s : Set α} (hs : s.Intersecting) {a : α} (ha : aᶜ ∈ s)
Goal: a ∉ s
-- Set.Intersecting.disjoint_map_compl
theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Intersecting) :
    Disjoint s (s.map ⟨compl, compl_injective⟩) 
Arguments: {α : Type u_1} [BooleanAlgebra α] {s : Finset α} (hs : (↑s).Intersecting)
Goal: Disjoint s (Finset.map { toFun := compl, inj' := ⋯ } s)
-- Set.Intersecting.card_le
theorem Intersecting.card_le [Fintype α] {s : Finset α} (hs : (s : Set α).Intersecting) :
    2 * s.card ≤ Fintype.card α 
Arguments: {α : Type u_1} [BooleanAlgebra α] [Fintype α] {s : Finset α} (hs : (↑s).Intersecting)
Goal: 2 * s.card ≤ Fintype.card α
-- Set.Intersecting.is_max_iff_card_eq
theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
    (∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) ↔ 2 * s.card = Fintype.card α 
Arguments: {α : Type u_1} [BooleanAlgebra α] [Nontrivial α] [Fintype α] {s : Finset α} (hs : (↑s).Intersecting)
Goal: (∀ (t : Finset α), (↑t).Intersecting → s ⊆ t → s = t) ↔ 2 * s.card = Fintype.card α
-- Set.Intersecting.exists_card_eq
theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
    ∃ t, s ⊆ t ∧ 2 * t.card = Fintype.card α ∧ (t : Set α).Intersecting 
Arguments: {α : Type u_1} [BooleanAlgebra α] [Nontrivial α] [Fintype α] {s : Finset α} (hs : (↑s).Intersecting)
Goal: ∃ t, s ⊆ t ∧ 2 * t.card = Fintype.card α ∧ (↑t).Intersecting
-- Finset.Shatters.exists_inter_eq_singleton
lemma Shatters.exists_inter_eq_singleton (hs : Shatters 𝒜 s) (ha : a ∈ s) : ∃ t ∈ 𝒜, s ∩ t = {a} 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α} (hs : 𝒜.Shatters s) (ha : a ∈ s)
Goal: ∃ t ∈ 𝒜, s ∩ t = {a}
-- Finset.Shatters.mono_left
lemma Shatters.mono_left (h : 𝒜 ⊆ ℬ) (h𝒜 : 𝒜.Shatters s) : ℬ.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 ℬ : Finset (Finset α)} {s : Finset α} (h : 𝒜 ⊆ ℬ) (h𝒜 : 𝒜.Shatters s)
Goal: ℬ.Shatters s
-- Finset.Shatters.mono_right
lemma Shatters.mono_right (h : t ⊆ s) (hs : 𝒜.Shatters s) : 𝒜.Shatters t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s t : Finset α} (h : t ⊆ s) (hs : 𝒜.Shatters s)
Goal: 𝒜.Shatters t
-- Finset.Shatters.exists_superset
lemma Shatters.exists_superset (h : 𝒜.Shatters s) : ∃ t ∈ 𝒜, s ⊆ t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (h : 𝒜.Shatters s)
Goal: ∃ t ∈ 𝒜, s ⊆ t
-- Finset.shatters_of_forall_subset
lemma shatters_of_forall_subset (h : ∀ t, t ⊆ s → t ∈ 𝒜) : 𝒜.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (h : ∀ t ⊆ s, t ∈ 𝒜)
Goal: 𝒜.Shatters s
-- Finset.Shatters.nonempty
protected lemma Shatters.nonempty (h : 𝒜.Shatters s) : 𝒜.Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (h : 𝒜.Shatters s)
Goal: 𝒜.Nonempty
-- Finset.shatters_empty
@[simp] lemma shatters_empty : 𝒜.Shatters ∅ ↔ 𝒜.Nonempty 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)}
Goal: 𝒜.Shatters ∅ ↔ 𝒜.Nonempty
-- Finset.Shatters.subset_iff
protected lemma Shatters.subset_iff (h : 𝒜.Shatters s) : t ⊆ s ↔ ∃ u ∈ 𝒜, s ∩ u = t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s t : Finset α} (h : 𝒜.Shatters s)
Goal: t ⊆ s ↔ ∃ u ∈ 𝒜, s ∩ u = t
-- Finset.shatters_iff
lemma shatters_iff : 𝒜.Shatters s ↔ 𝒜.image (fun t ↦ s ∩ t) = s.powerset 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α}
Goal: 𝒜.Shatters s ↔ Finset.image (fun t => s ∩ t) 𝒜 = s.powerset
-- Finset.univ_shatters
lemma univ_shatters [Fintype α] : univ.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} [Fintype α]
Goal: Finset.univ.Shatters s
-- Finset.shatters_univ
@[simp] lemma shatters_univ [Fintype α] : 𝒜.Shatters univ ↔ 𝒜 = univ 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} [Fintype α]
Goal: 𝒜.Shatters Finset.univ ↔ 𝒜 = Finset.univ
-- Finset.mem_shatterer
@[simp] lemma mem_shatterer : s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α}
Goal: s ∈ 𝒜.shatterer ↔ 𝒜.Shatters s
-- Finset.shatterer_mono
lemma shatterer_mono (h : 𝒜 ⊆ ℬ) : 𝒜.shatterer ⊆ ℬ.shatterer 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 ℬ : Finset (Finset α)} (h : 𝒜 ⊆ ℬ)
Goal: 𝒜.shatterer ⊆ ℬ.shatterer
-- Finset.subset_shatterer
lemma subset_shatterer (h : IsLowerSet (𝒜 : Set (Finset α))) : 𝒜 ⊆ 𝒜.shatterer 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} (h : IsLowerSet ↑𝒜)
Goal: 𝒜 ⊆ 𝒜.shatterer
-- Finset.isLowerSet_shatterer
@[simp] lemma isLowerSet_shatterer (𝒜 : Finset (Finset α)) :
    IsLowerSet (𝒜.shatterer : Set (Finset α)) 
Arguments: {α : Type u_1} [DecidableEq α] (𝒜 : Finset (Finset α))
Goal: IsLowerSet ↑𝒜.shatterer
-- Finset.shatterer_eq
@[simp] lemma shatterer_eq : 𝒜.shatterer = 𝒜 ↔ IsLowerSet (𝒜 : Set (Finset α)) 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)}
Goal: 𝒜.shatterer = 𝒜 ↔ IsLowerSet ↑𝒜
-- Finset.shatterer_idem
@[simp] lemma shatterer_idem : 𝒜.shatterer.shatterer = 𝒜.shatterer 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)}
Goal: 𝒜.shatterer.shatterer = 𝒜.shatterer
-- Finset.shatters_shatterer
@[simp] lemma shatters_shatterer : 𝒜.shatterer.Shatters s ↔ 𝒜.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α}
Goal: 𝒜.shatterer.Shatters s ↔ 𝒜.Shatters s
-- _private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.aux
private lemma aux (h : ∀ t ∈ 𝒜, a ∉ t) (ht : 𝒜.Shatters t) : a ∉ t 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α} {a : α} (h : ∀ t ∈ 𝒜, a ∉ t) (ht : 𝒜.Shatters t)
Goal: a ∉ t
-- Finset.card_le_card_shatterer
lemma card_le_card_shatterer (𝒜 : Finset (Finset α)) : 𝒜.card ≤ 𝒜.shatterer.card 
Arguments: {α : Type u_1} [DecidableEq α] (𝒜 : Finset (Finset α))
Goal: 𝒜.card ≤ 𝒜.shatterer.card
-- Finset.Shatters.of_compression
lemma Shatters.of_compression (hs : (𝓓 a 𝒜).Shatters s) : 𝒜.Shatters s 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α} (hs : (𝓓 a 𝒜).Shatters s)
Goal: 𝒜.Shatters s
-- Finset.shatterer_compress_subset_shatterer
lemma shatterer_compress_subset_shatterer (a : α) (𝒜 : Finset (Finset α)) :
    (𝓓 a 𝒜).shatterer ⊆ 𝒜.shatterer 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (𝒜 : Finset (Finset α))
Goal: (𝓓 a 𝒜).shatterer ⊆ 𝒜.shatterer
-- Finset.Shatters.card_le_vcDim
lemma Shatters.card_le_vcDim (hs : 𝒜.Shatters s) : s.card ≤ 𝒜.vcDim 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (hs : 𝒜.Shatters s)
Goal: s.card ≤ 𝒜.vcDim
-- Finset.vcDim_compress_le
lemma vcDim_compress_le (a : α) (𝒜 : Finset (Finset α)) : (𝓓 a 𝒜).vcDim ≤ 𝒜.vcDim 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (𝒜 : Finset (Finset α))
Goal: (𝓓 a 𝒜).vcDim ≤ 𝒜.vcDim
-- Finset.card_shatterer_le_sum_vcDim
lemma card_shatterer_le_sum_vcDim [Fintype α] :
    𝒜.shatterer.card ≤ ∑ k ∈ Iic 𝒜.vcDim, (Fintype.card α).choose k 
Arguments: {α : Type u_1} [DecidableEq α] {𝒜 : Finset (Finset α)} [Fintype α]
Goal: 𝒜.shatterer.card ≤ ∑ k ∈ Finset.Iic 𝒜.vcDim, (Fintype.card α).choose k
-- Nat.Partition.parts_sum
@[ext]
structure Partition (n : ℕ) where
    parts : Multiset ℕ
    parts_pos : ∀ {i}, i ∈ parts → 0 < i
    parts_sum : parts.sum = n
Arguments: {n : ℕ} (self : n.Partition)
Goal: self.parts.sum = n
-- Nat.Partition.parts_pos
@[ext]
structure Partition (n : ℕ) where
    parts : Multiset ℕ
    parts_pos : ∀ {i}, i ∈ parts → 0 < i
    parts_sum : parts.sum = n
Arguments: {n : ℕ} (self : n.Partition) {i : ℕ}
Goal: i ∈ self.parts → 0 < i
-- Nat.Partition.ofComposition_parts
@[simps]
def ofComposition (n : ℕ) (c : Composition n) : Partition n 
Arguments: (n : ℕ) (c : Composition n)
Goal: (Nat.Partition.ofComposition n c).parts = ↑c.blocks
-- Nat.Partition.ofComposition_surj
theorem ofComposition_surj {n : ℕ} : Function.Surjective (ofComposition n) 
Arguments: {n : ℕ}
Goal: Function.Surjective (Nat.Partition.ofComposition n)
-- Nat.Partition.ofSums_parts
@[simps]
def ofSums (n : ℕ) (l : Multiset ℕ) (hl : l.sum = n) : Partition n 
Arguments: (n : ℕ) (l : Multiset ℕ) (hl : l.sum = n)
Goal: (Nat.Partition.ofSums n l hl).parts = Multiset.filter (fun x => x ≠ 0) l
-- Nat.Partition.ofMultiset_parts
@[simps!]
def ofMultiset (l : Multiset ℕ) : Partition l.sum 
Arguments: (l : Multiset ℕ)
Goal: (Nat.Partition.ofMultiset l).parts = Multiset.filter (fun x => ¬x = 0) l
-- Nat.Partition.ofSym_map
@[simp] lemma ofSym_map (e : σ ≃ τ) (s : Sym σ n) :
    ofSym (s.map e) = ofSym s 
Arguments: {n : ℕ} {σ : Type u_1} {τ : Type u_2} [DecidableEq σ] [DecidableEq τ] (e : σ ≃ τ) (s : Sym σ n)
Goal: Nat.Partition.ofSym (Sym.map (⇑e) s) = Nat.Partition.ofSym s
-- Nat.Partition.indiscrete_parts
@[simp] lemma indiscrete_parts {n : ℕ} (hn : n ≠ 0) : (indiscrete n).parts = {n} 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: (Nat.Partition.indiscrete n).parts = {n}
-- Nat.Partition.partition_zero_parts
@[simp] lemma partition_zero_parts (p : Partition 0) : p.parts = 0 
Arguments: (p : Nat.Partition 0)
Goal: p.parts = 0
-- Nat.Partition.partition_one_parts
@[simp] lemma partition_one_parts (p : Partition 1) : p.parts = {1} 
Arguments: (p : Nat.Partition 1)
Goal: p.parts = {1}
-- Nat.Partition.ofSym_one
@[simp] lemma ofSym_one (s : Sym σ 1) : ofSym s = indiscrete 1 
Arguments: {σ : Type u_1} [DecidableEq σ] (s : Sym σ 1)
Goal: Nat.Partition.ofSym s = Nat.Partition.indiscrete 1
-- Nat.Partition.count_ofSums_of_ne_zero
theorem count_ofSums_of_ne_zero {n : ℕ} {l : Multiset ℕ} (hl : l.sum = n) {i : ℕ} (hi : i ≠ 0) :
    (ofSums n l hl).parts.count i = l.count i 
Arguments: {n : ℕ} {l : Multiset ℕ} (hl : l.sum = n) {i : ℕ} (hi : i ≠ 0)
Goal: Multiset.count i (Nat.Partition.ofSums n l hl).parts = Multiset.count i l
-- Nat.Partition.count_ofSums_zero
theorem count_ofSums_zero {n : ℕ} {l : Multiset ℕ} (hl : l.sum = n) :
    (ofSums n l hl).parts.count 0 = 0 
Arguments: {n : ℕ} {l : Multiset ℕ} (hl : l.sum = n)
Goal: Multiset.count 0 (Nat.Partition.ofSums n l hl).parts = 0
-- Finset.bipartiteBelow_swap
theorem bipartiteBelow_swap : t.bipartiteBelow (swap r) a = t.bipartiteAbove r a 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Finset β) (a : α) [DecidablePred (r a)]
Goal: Finset.bipartiteBelow (Function.swap r) t a = Finset.bipartiteAbove r t a
-- Finset.bipartiteAbove_swap
theorem bipartiteAbove_swap : s.bipartiteAbove (swap r) b = s.bipartiteBelow r b 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (s : Finset α) (b : β) [(a : α) → Decidable (r a b)]
Goal: Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b
-- Finset.coe_bipartiteBelow
@[simp, norm_cast]
theorem coe_bipartiteBelow : (s.bipartiteBelow r b : Set α) = { a ∈ s | r a b } 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (s : Finset α) (b : β) [(a : α) → Decidable (r a b)]
Goal: ↑(Finset.bipartiteBelow r s b) = {a | a ∈ s ∧ r a b}
-- Finset.coe_bipartiteAbove
@[simp, norm_cast]
theorem coe_bipartiteAbove : (t.bipartiteAbove r a : Set β) = { b ∈ t | r a b } 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Finset β) (a : α) [DecidablePred (r a)]
Goal: ↑(Finset.bipartiteAbove r t a) = {b | b ∈ t ∧ r a b}
-- Finset.mem_bipartiteBelow
@[simp]
theorem mem_bipartiteBelow {a : α} : a ∈ s.bipartiteBelow r b ↔ a ∈ s ∧ r a b 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {b : β} [(a : α) → Decidable (r a b)] {a : α}
Goal: a ∈ Finset.bipartiteBelow r s b ↔ a ∈ s ∧ r a b
-- Finset.mem_bipartiteAbove
@[simp]
theorem mem_bipartiteAbove {b : β} : b ∈ t.bipartiteAbove r a ↔ b ∈ t ∧ r a b 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {t : Finset β} {a : α} [DecidablePred (r a)] {b : β}
Goal: b ∈ Finset.bipartiteAbove r t a ↔ b ∈ t ∧ r a b
-- Finset.sum_card_bipartiteAbove_eq_sum_card_bipartiteBelow
theorem sum_card_bipartiteAbove_eq_sum_card_bipartiteBelow [∀ a b, Decidable (r a b)] :
    (∑ a ∈ s, (t.bipartiteAbove r a).card) = ∑ b ∈ t, (s.bipartiteBelow r b).card 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} [(a : α) → (b : β) → Decidable (r a b)]
Goal: ∑ a ∈ s, (Finset.bipartiteAbove r t a).card = ∑ b ∈ t, (Finset.bipartiteBelow r s b).card
-- Finset.card_mul_le_card_mul
theorem card_mul_le_card_mul [∀ a b, Decidable (r a b)]
    (hm : ∀ a ∈ s, m ≤ (t.bipartiteAbove r a).card)
    (hn : ∀ b ∈ t, (s.bipartiteBelow r b).card ≤ n) : s.card * m ≤ t.card * n 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} {m n : ℕ} [(a : α) → (b : β) → Decidable (r a b)] (hm : ∀ a ∈ s, m ≤ (Finset.bipartiteAbove r t a).card) (hn : ∀ b ∈ t, (Finset.bipartiteBelow r s b).card ≤ n)
Goal: s.card * m ≤ t.card * n
-- Finset.card_mul_le_card_mul'
theorem card_mul_le_card_mul' [∀ a b, Decidable (r a b)]
    (hn : ∀ b ∈ t, n ≤ (s.bipartiteBelow r b).card)
    (hm : ∀ a ∈ s, (t.bipartiteAbove r a).card ≤ m) : t.card * n ≤ s.card * m 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} {m n : ℕ} [(a : α) → (b : β) → Decidable (r a b)] (hn : ∀ b ∈ t, n ≤ (Finset.bipartiteBelow r s b).card) (hm : ∀ a ∈ s, (Finset.bipartiteAbove r t a).card ≤ m)
Goal: t.card * n ≤ s.card * m
-- Finset.card_mul_eq_card_mul
theorem card_mul_eq_card_mul [∀ a b, Decidable (r a b)]
    (hm : ∀ a ∈ s, (t.bipartiteAbove r a).card = m)
    (hn : ∀ b ∈ t, (s.bipartiteBelow r b).card = n) : s.card * m = t.card * n 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} {m n : ℕ} [(a : α) → (b : β) → Decidable (r a b)] (hm : ∀ a ∈ s, (Finset.bipartiteAbove r t a).card = m) (hn : ∀ b ∈ t, (Finset.bipartiteBelow r s b).card = n)
Goal: s.card * m = t.card * n
-- Finset.card_le_card_of_forall_subsingleton
theorem card_le_card_of_forall_subsingleton (hs : ∀ a ∈ s, ∃ b, b ∈ t ∧ r a b)
    (ht : ∀ b ∈ t, ({ a ∈ s | r a b } : Set α).Subsingleton) : s.card ≤ t.card 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} (hs : ∀ a ∈ s, ∃ b ∈ t, r a b) (ht : ∀ b ∈ t, {a | a ∈ s ∧ r a b}.Subsingleton)
Goal: s.card ≤ t.card
-- Finset.card_le_card_of_forall_subsingleton'
theorem card_le_card_of_forall_subsingleton' (ht : ∀ b ∈ t, ∃ a, a ∈ s ∧ r a b)
    (hs : ∀ a ∈ s, ({ b ∈ t | r a b } : Set β).Subsingleton) : t.card ≤ s.card 
Arguments: {α : Type u_1} {β : Type u_2} (r : α → β → Prop) {s : Finset α} {t : Finset β} (ht : ∀ b ∈ t, ∃ a ∈ s, r a b) (hs : ∀ a ∈ s, {b | b ∈ t ∧ r a b}.Subsingleton)
Goal: t.card ≤ s.card
-- Fintype.card_le_card_of_leftTotal_unique
theorem card_le_card_of_leftTotal_unique (h₁ : LeftTotal r) (h₂ : LeftUnique r) :
    Fintype.card α ≤ Fintype.card β 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] {r : α → β → Prop} (h₁ : Relator.LeftTotal r) (h₂ : Relator.LeftUnique r)
Goal: Fintype.card α ≤ Fintype.card β
-- Fintype.card_le_card_of_rightTotal_unique
theorem card_le_card_of_rightTotal_unique (h₁ : RightTotal r) (h₂ : RightUnique r) :
    Fintype.card β ≤ Fintype.card α 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] {r : α → β → Prop} (h₁ : Relator.RightTotal r) (h₂ : Relator.RightUnique r)
Goal: Fintype.card β ≤ Fintype.card α
-- Finset.card_biUnion_le_of_intersecting
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) 
Arguments: {ι : Type u_1} {α : Type u_2} [Fintype α] [DecidableEq α] [Nonempty α] (s : Finset ι) (f : ι → Finset (Finset α)) (hf : ∀ i ∈ s, (↑(f i)).Intersecting)
Goal: (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card)
-- nonempty_embedding_to_cardinal
theorem nonempty_embedding_to_cardinal : Nonempty (σ ↪ Cardinal.{u}) 
Arguments: {σ : Type u}
Goal: Nonempty (σ ↪ Cardinal.{u})
-- WellOrder.wo
structure WellOrder : Type (u + 1) where
    α : Type u
    r : α → α → Prop
    wo : IsWellOrder α r
Arguments: (self : WellOrder)
Goal: IsWellOrder self.α self.r
-- WellOrder.eta
@[simp]
theorem eta (o : WellOrder) : mk o.α o.r o.wo = o 
Arguments: (o : WellOrder)
Goal: { α := o.α, r := o.r, wo := ⋯ } = o
-- Ordinal.type_def'
@[simp]
theorem type_def' (w : WellOrder) : ⟦w⟧ = type w.r 
Arguments: (w : WellOrder)
Goal: ⟦w⟧ = Ordinal.type w.r
-- Ordinal.type_def
@[simp]
theorem type_def (r) [wo : IsWellOrder α r] : (⟦⟨α, r, wo⟩⟧ : Ordinal) = type r 
Arguments: {α : Type u} (r : α → α → Prop) [wo : IsWellOrder α r]
Goal: ⟦{ α := α, r := r, wo := wo }⟧ = Ordinal.type r
-- Ordinal.type_out
@[simp]
theorem type_out (o : Ordinal) : Ordinal.type o.out.r = o 
Arguments: (o : Ordinal.{u_3})
Goal: Ordinal.type (Quotient.out o).r = o
-- Ordinal.type_eq
theorem type_eq {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] :
    type r = type s ↔ Nonempty (r ≃r s) 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type r = Ordinal.type s ↔ Nonempty (r ≃r s)
-- RelIso.ordinal_type_eq
theorem _root_.RelIso.ordinal_type_eq {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] (h : r ≃r s) : type r = type s 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (h : r ≃r s)
Goal: Ordinal.type r = Ordinal.type s
-- Ordinal.type_lt
@[simp]
theorem type_lt (o : Ordinal) : type ((· < ·) : o.out.α → o.out.α → Prop) = o 
Arguments: (o : Ordinal.{u_3})
Goal: (Ordinal.type fun x x_1 => x < x_1) = o
-- Ordinal.type_eq_zero_of_empty
theorem type_eq_zero_of_empty (r) [IsWellOrder α r] [IsEmpty α] : type r = 0 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] [IsEmpty α]
Goal: Ordinal.type r = 0
-- Ordinal.type_eq_zero_iff_isEmpty
@[simp]
theorem type_eq_zero_iff_isEmpty [IsWellOrder α r] : type r = 0 ↔ IsEmpty α 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r]
Goal: Ordinal.type r = 0 ↔ IsEmpty α
-- Ordinal.type_ne_zero_iff_nonempty
theorem type_ne_zero_iff_nonempty [IsWellOrder α r] : type r ≠ 0 ↔ Nonempty α 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r]
Goal: Ordinal.type r ≠ 0 ↔ Nonempty α
-- Ordinal.type_ne_zero_of_nonempty
theorem type_ne_zero_of_nonempty (r) [IsWellOrder α r] [h : Nonempty α] : type r ≠ 0 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] [h : Nonempty α]
Goal: Ordinal.type r ≠ 0
-- Ordinal.type_pEmpty
theorem type_pEmpty : type (@EmptyRelation PEmpty) = 0 
Goal: Ordinal.type EmptyRelation = 0
-- Ordinal.type_empty
theorem type_empty : type (@EmptyRelation Empty) = 0 
Goal: Ordinal.type EmptyRelation = 0
-- Ordinal.type_eq_one_of_unique
theorem type_eq_one_of_unique (r) [IsWellOrder α r] [Unique α] : type r = 1 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] [Unique α]
Goal: Ordinal.type r = 1
-- Ordinal.type_eq_one_iff_unique
@[simp]
theorem type_eq_one_iff_unique [IsWellOrder α r] : type r = 1 ↔ Nonempty (Unique α) 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r]
Goal: Ordinal.type r = 1 ↔ Nonempty (Unique α)
-- Ordinal.type_pUnit
theorem type_pUnit : type (@EmptyRelation PUnit) = 1 
Goal: Ordinal.type EmptyRelation = 1
-- Ordinal.type_unit
theorem type_unit : type (@EmptyRelation Unit) = 1 
Goal: Ordinal.type EmptyRelation = 1
-- Ordinal.out_empty_iff_eq_zero
@[simp]
theorem out_empty_iff_eq_zero {o : Ordinal} : IsEmpty o.out.α ↔ o = 0 
Arguments: {o : Ordinal.{u_3}}
Goal: IsEmpty (Quotient.out o).α ↔ o = 0
-- Ordinal.eq_zero_of_out_empty
theorem eq_zero_of_out_empty (o : Ordinal) [h : IsEmpty o.out.α] : o = 0 
Arguments: (o : Ordinal.{u_3}) [h : IsEmpty (Quotient.out o).α]
Goal: o = 0
-- Ordinal.out_nonempty_iff_ne_zero
@[simp]
theorem out_nonempty_iff_ne_zero {o : Ordinal} : Nonempty o.out.α ↔ o ≠ 0 
Arguments: {o : Ordinal.{u_3}}
Goal: Nonempty (Quotient.out o).α ↔ o ≠ 0
-- Ordinal.ne_zero_of_out_nonempty
theorem ne_zero_of_out_nonempty (o : Ordinal) [h : Nonempty o.out.α] : o ≠ 0 
Arguments: (o : Ordinal.{u_3}) [h : Nonempty (Quotient.out o).α]
Goal: o ≠ 0
-- Ordinal.one_ne_zero
protected theorem one_ne_zero : (1 : Ordinal) ≠ 0 
Goal: 1 ≠ 0
-- Ordinal.type_preimage
theorem type_preimage {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α) :
    type (f ⁻¹'o r) = type r 
Arguments: {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α)
Goal: Ordinal.type (⇑f ⁻¹'o r) = Ordinal.type r
-- Ordinal.type_preimage_aux
@[simp, nolint simpNF] -- `simpNF` incorrectly complains the LHS doesn't simplify.
theorem type_preimage_aux {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α) :
    @type _ (fun x y => r (f x) (f y)) (inferInstanceAs (IsWellOrder β (↑f ⁻¹'o r))) = type r 
Arguments: {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α)
Goal: (Ordinal.type fun x y => r (f x) (f y)) = Ordinal.type r