ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Option.map_map₂_distrib_left
theorem map_map₂_distrib_left {g : γ → δ} {f' : α' → β → δ} {g' : α → α'}
    (h_distrib : ∀ a b, g (f a b) = f' (g' a) b) :
    (map₂ f a b).map g = map₂ f' (a.map g') b 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {α' : Type u_5} {g : γ → δ} {f' : α' → β → δ} {g' : α → α'} (h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g' a) b)
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g' a) b
-- Option.map_map₂_distrib_right
theorem map_map₂_distrib_right {g : γ → δ} {f' : α → β' → δ} {g' : β → β'}
    (h_distrib : ∀ a b, g (f a b) = f' a (g' b)) : (map₂ f a b).map g = map₂ f' a (b.map g') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {β' : Type u_6} {g : γ → δ} {f' : α → β' → δ} {g' : β → β'} (h_distrib : ∀ (a : α) (b : β), g (f a b) = f' a (g' b))
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' a (Option.map g' b)
-- Option.map₂_map_left_comm
theorem map₂_map_left_comm {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ}
    (h_left_comm : ∀ a b, f (g a) b = g' (f' a b)) : map₂ f (a.map g) b = (map₂ f' a b).map g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {α' : Type u_5} {f : α' → β → γ} {g : α → α'} {f' : α → β → δ} {g' : δ → γ} (h_left_comm : ∀ (a : α) (b : β), f (g a) b = g' (f' a b))
Goal: Option.map₂ f (Option.map g a) b = Option.map g' (Option.map₂ f' a b)
-- Option.map_map₂_right_comm
theorem map_map₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) :
    map₂ f a (b.map g) = (map₂ f' a b).map g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {β' : Type u_6} {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ} (h_right_comm : ∀ (a : α) (b : β), f a (g b) = g' (f' a b))
Goal: Option.map₂ f a (Option.map g b) = Option.map g' (Option.map₂ f' a b)
-- Option.map_map₂_antidistrib
theorem map_map₂_antidistrib {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g₁ b) (g₂ a)) :
    (map₂ f a b).map g = map₂ f' (b.map g₁) (a.map g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {α' : Type u_5} {β' : Type u_6} {g : γ → δ} {f' : β' → α' → δ} {g₁ : β → β'} {g₂ : α → α'} (h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a))
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g₁ b) (Option.map g₂ a)
-- Option.map_map₂_antidistrib_left
theorem map_map₂_antidistrib_left {g : γ → δ} {f' : β' → α → δ} {g' : β → β'}
    (h_antidistrib : ∀ a b, g (f a b) = f' (g' b) a) :
    (map₂ f a b).map g = map₂ f' (b.map g') a 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {β' : Type u_6} {g : γ → δ} {f' : β' → α → δ} {g' : β → β'} (h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a)
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' (Option.map g' b) a
-- Option.map_map₂_antidistrib_right
theorem map_map₂_antidistrib_right {g : γ → δ} {f' : β → α' → δ} {g' : α → α'}
    (h_antidistrib : ∀ a b, g (f a b) = f' b (g' a)) :
    (map₂ f a b).map g = map₂ f' b (a.map g') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → β → γ} {a : Option α} {b : Option β} {α' : Type u_5} {g : γ → δ} {f' : β → α' → δ} {g' : α → α'} (h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a))
Goal: Option.map g (Option.map₂ f a b) = Option.map₂ f' b (Option.map g' a)
-- Option.map₂_map_left_anticomm
theorem map₂_map_left_anticomm {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ}
    (h_left_anticomm : ∀ a b, f (g a) b = g' (f' b a)) :
    map₂ f (a.map g) b = (map₂ f' b a).map g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {α' : Type u_5} {f : α' → β → γ} {g : α → α'} {f' : β → α → δ} {g' : δ → γ} (h_left_anticomm : ∀ (a : α) (b : β), f (g a) b = g' (f' b a))
Goal: Option.map₂ f (Option.map g a) b = Option.map g' (Option.map₂ f' b a)
-- Option.map_map₂_right_anticomm
theorem map_map₂_right_anticomm {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ}
    (h_right_anticomm : ∀ a b, f a (g b) = g' (f' b a)) :
    map₂ f a (b.map g) = (map₂ f' b a).map g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {a : Option α} {b : Option β} {β' : Type u_6} {f : α → β' → γ} {g : β → β'} {f' : β → α → δ} {g' : δ → γ} (h_right_anticomm : ∀ (a : α) (b : β), f a (g b) = g' (f' b a))
Goal: Option.map₂ f a (Option.map g b) = Option.map g' (Option.map₂ f' b a)
-- Option.map₂_left_identity
lemma map₂_left_identity {f : α → β → β} {a : α} (h : ∀ b, f a b = b) (o : Option β) :
    map₂ f (some a) o = o 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β → β} {a : α} (h : ∀ (b : β), f a b = b) (o : Option β)
Goal: Option.map₂ f (some a) o = o
-- Option.map₂_right_identity
lemma map₂_right_identity {f : α → β → α} {b : β} (h : ∀ a, f a b = a) (o : Option α) :
    map₂ f o (some b) = o 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : β} (h : ∀ (a : α), f a b = a) (o : Option α)
Goal: Option.map₂ f o (some b) = o
-- PrimeMultiset.card_ofPrime
theorem card_ofPrime (p : Nat.Primes) : Multiset.card (ofPrime p) = 1 
Arguments: (p : Nat.Primes)
Goal: Multiset.card (PrimeMultiset.ofPrime p) = 1
-- PrimeMultiset.coe_coeNatMonoidHom
@[simp]
theorem coe_coeNatMonoidHom : (coeNatMonoidHom : PrimeMultiset → Multiset ℕ) = Coe.coe 
Goal: ⇑PrimeMultiset.coeNatMonoidHom = Coe.coe
-- PrimeMultiset.coeNat_injective
theorem coeNat_injective : Function.Injective (Coe.coe : PrimeMultiset → Multiset ℕ) 
Goal: Function.Injective Coe.coe
-- PrimeMultiset.coeNat_ofPrime
theorem coeNat_ofPrime (p : Nat.Primes) : (ofPrime p : Multiset ℕ) = {(p : ℕ)} 
Arguments: (p : Nat.Primes)
Goal: (PrimeMultiset.ofPrime p).toNatMultiset = {↑p}
-- PrimeMultiset.coeNat_prime
theorem coeNat_prime (v : PrimeMultiset) (p : ℕ) (h : p ∈ (v : Multiset ℕ)) : p.Prime 
Arguments: (v : PrimeMultiset) (p : ℕ) (h : p ∈ v.toNatMultiset)
Goal: Nat.Prime p
-- PrimeMultiset.coe_coePNatMonoidHom
@[simp]
theorem coe_coePNatMonoidHom : (coePNatMonoidHom : PrimeMultiset → Multiset ℕ+) = Coe.coe 
Goal: ⇑PrimeMultiset.coePNatMonoidHom = Coe.coe
-- PrimeMultiset.coePNat_injective
theorem coePNat_injective : Function.Injective (Coe.coe : PrimeMultiset → Multiset ℕ+) 
Goal: Function.Injective Coe.coe
-- PrimeMultiset.coePNat_ofPrime
theorem coePNat_ofPrime (p : Nat.Primes) : (ofPrime p : Multiset ℕ+) = {(p : ℕ+)} 
Arguments: (p : Nat.Primes)
Goal: (PrimeMultiset.ofPrime p).toPNatMultiset = {↑p}
-- PrimeMultiset.coePNat_prime
theorem coePNat_prime (v : PrimeMultiset) (p : ℕ+) (h : p ∈ (v : Multiset ℕ+)) : p.Prime 
Arguments: (v : PrimeMultiset) (p : ℕ+) (h : p ∈ v.toPNatMultiset)
Goal: p.Prime
-- PrimeMultiset.coePNat_nat
theorem coePNat_nat (v : PrimeMultiset) : ((v : Multiset ℕ+) : Multiset ℕ) = (v : Multiset ℕ) 
Arguments: (v : PrimeMultiset)
Goal: Multiset.map PNat.val v.toPNatMultiset = v.toNatMultiset
-- PrimeMultiset.coe_prod
theorem coe_prod (v : PrimeMultiset) : (v.prod : ℕ) = (v : Multiset ℕ).prod 
Arguments: (v : PrimeMultiset)
Goal: ↑v.prod = v.toNatMultiset.prod
-- PrimeMultiset.prod_ofPrime
theorem prod_ofPrime (p : Nat.Primes) : (ofPrime p).prod = (p : ℕ+) 
Arguments: (p : Nat.Primes)
Goal: (PrimeMultiset.ofPrime p).prod = ↑p
-- PrimeMultiset.to_ofNatMultiset
theorem to_ofNatMultiset (v : Multiset ℕ) (h) : (ofNatMultiset v h : Multiset ℕ) = v 
Arguments: (v : Multiset ℕ) (h : ∀ p ∈ v, Nat.Prime p)
Goal: (PrimeMultiset.ofNatMultiset v h).toNatMultiset = v
-- PrimeMultiset.prod_ofNatMultiset
theorem prod_ofNatMultiset (v : Multiset ℕ) (h) :
    ((ofNatMultiset v h).prod : ℕ) = (v.prod : ℕ) 
Arguments: (v : Multiset ℕ) (h : ∀ p ∈ v, Nat.Prime p)
Goal: ↑(PrimeMultiset.ofNatMultiset v h).prod = v.prod
-- PrimeMultiset.to_ofPNatMultiset
theorem to_ofPNatMultiset (v : Multiset ℕ+) (h) : (ofPNatMultiset v h : Multiset ℕ+) = v 
Arguments: (v : Multiset ℕ+) (h : ∀ p ∈ v, p.Prime)
Goal: (PrimeMultiset.ofPNatMultiset v h).toPNatMultiset = v
-- PrimeMultiset.prod_ofPNatMultiset
theorem prod_ofPNatMultiset (v : Multiset ℕ+) (h) : ((ofPNatMultiset v h).prod : ℕ+) = v.prod 
Arguments: (v : Multiset ℕ+) (h : ∀ p ∈ v, p.Prime)
Goal: (PrimeMultiset.ofPNatMultiset v h).prod = v.prod
-- PrimeMultiset.prod_ofNatList
theorem prod_ofNatList (l : List ℕ) (h) : ((ofNatList l h).prod : ℕ) = l.prod 
Arguments: (l : List ℕ) (h : ∀ p ∈ l, Nat.Prime p)
Goal: ↑(PrimeMultiset.ofNatList l h).prod = l.prod
-- PrimeMultiset.prod_ofPNatList
theorem prod_ofPNatList (l : List ℕ+) (h) : (ofPNatList l h).prod = l.prod 
Arguments: (l : List ℕ+) (h : ∀ p ∈ l, p.Prime)
Goal: (PrimeMultiset.ofPNatList l h).prod = l.prod
-- PrimeMultiset.prod_zero
theorem prod_zero : (0 : PrimeMultiset).prod = 1 
Goal: PrimeMultiset.prod 0 = 1
-- PrimeMultiset.prod_add
theorem prod_add (u v : PrimeMultiset) : (u + v).prod = u.prod * v.prod 
Arguments: (u v : PrimeMultiset)
Goal: (u + v).prod = u.prod * v.prod
-- PrimeMultiset.prod_smul
theorem prod_smul (d : ℕ) (u : PrimeMultiset) : (d • u).prod = u.prod ^ d 
Arguments: (d : ℕ) (u : PrimeMultiset)
Goal: (d • u).prod = u.prod ^ d
-- PNat.prod_factorMultiset
theorem prod_factorMultiset (n : ℕ+) : (factorMultiset n).prod = n 
Arguments: (n : ℕ+)
Goal: n.factorMultiset.prod = n
-- PNat.coeNat_factorMultiset
theorem coeNat_factorMultiset (n : ℕ+) :
    (factorMultiset n : Multiset ℕ) = (Nat.primeFactorsList n : Multiset ℕ) 
Arguments: (n : ℕ+)
Goal: n.factorMultiset.toNatMultiset = ↑(↑n).primeFactorsList
-- PrimeMultiset.factorMultiset_prod
theorem factorMultiset_prod (v : PrimeMultiset) : v.prod.factorMultiset = v 
Arguments: (v : PrimeMultiset)
Goal: v.prod.factorMultiset = v
-- PNat.factorMultiset_one
theorem factorMultiset_one : factorMultiset 1 = 0 
Goal: PNat.factorMultiset 1 = 0
-- PNat.factorMultiset_mul
theorem factorMultiset_mul (n m : ℕ+) :
    factorMultiset (n * m) = factorMultiset n + factorMultiset m 
Arguments: (n m : ℕ+)
Goal: (n * m).factorMultiset = n.factorMultiset + m.factorMultiset
-- PNat.factorMultiset_pow
theorem factorMultiset_pow (n : ℕ+) (m : ℕ) :
    factorMultiset (n ^ m) = m • factorMultiset n 
Arguments: (n : ℕ+) (m : ℕ)
Goal: (n ^ m).factorMultiset = m • n.factorMultiset
-- PNat.factorMultiset_ofPrime
theorem factorMultiset_ofPrime (p : Nat.Primes) :
    (p : ℕ+).factorMultiset = PrimeMultiset.ofPrime p 
Arguments: (p : Nat.Primes)
Goal: (↑p).factorMultiset = PrimeMultiset.ofPrime p
-- PNat.factorMultiset_le_iff
theorem factorMultiset_le_iff {m n : ℕ+} : factorMultiset m ≤ factorMultiset n ↔ m ∣ n 
Arguments: {m n : ℕ+}
Goal: m.factorMultiset ≤ n.factorMultiset ↔ m ∣ n
-- PNat.factorMultiset_le_iff'
theorem factorMultiset_le_iff' {m : ℕ+} {v : PrimeMultiset} :
    factorMultiset m ≤ v ↔ m ∣ v.prod 
Arguments: {m : ℕ+} {v : PrimeMultiset}
Goal: m.factorMultiset ≤ v ↔ m ∣ v.prod
-- PrimeMultiset.prod_dvd_iff
theorem prod_dvd_iff {u v : PrimeMultiset} : u.prod ∣ v.prod ↔ u ≤ v 
Arguments: {u v : PrimeMultiset}
Goal: u.prod ∣ v.prod ↔ u ≤ v
-- PrimeMultiset.prod_dvd_iff'
theorem prod_dvd_iff' {u : PrimeMultiset} {n : ℕ+} : u.prod ∣ n ↔ u ≤ n.factorMultiset 
Arguments: {u : PrimeMultiset} {n : ℕ+}
Goal: u.prod ∣ n ↔ u ≤ n.factorMultiset
-- PNat.factorMultiset_gcd
theorem factorMultiset_gcd (m n : ℕ+) :
    factorMultiset (gcd m n) = factorMultiset m ⊓ factorMultiset n 
Arguments: (m n : ℕ+)
Goal: (m.gcd n).factorMultiset = m.factorMultiset ⊓ n.factorMultiset
-- PNat.factorMultiset_lcm
theorem factorMultiset_lcm (m n : ℕ+) :
    factorMultiset (lcm m n) = factorMultiset m ⊔ factorMultiset n 
Arguments: (m n : ℕ+)
Goal: (m.lcm n).factorMultiset = m.factorMultiset ⊔ n.factorMultiset
-- PNat.count_factorMultiset
theorem count_factorMultiset (m : ℕ+) (p : Nat.Primes) (k : ℕ) :
    (p : ℕ+) ^ k ∣ m ↔ k ≤ m.factorMultiset.count p 
Arguments: (m : ℕ+) (p : Nat.Primes) (k : ℕ)
Goal: ↑p ^ k ∣ m ↔ k ≤ Multiset.count p m.factorMultiset
-- PrimeMultiset.prod_inf
theorem prod_inf (u v : PrimeMultiset) : (u ⊓ v).prod = PNat.gcd u.prod v.prod 
Arguments: (u v : PrimeMultiset)
Goal: (u ⊓ v).prod = u.prod.gcd v.prod
-- PrimeMultiset.prod_sup
theorem prod_sup (u v : PrimeMultiset) : (u ⊔ v).prod = PNat.lcm u.prod v.prod 
Arguments: (u v : PrimeMultiset)
Goal: (u ⊔ v).prod = u.prod.lcm v.prod
-- Tuple.bubble_sort_induction'
theorem bubble_sort_induction' {n : ℕ} {α : Type*} [LinearOrder α] {f : Fin n → α}
    {P : (Fin n → α) → Prop} (hf : P f)
    (h : ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
      i < j → (f ∘ σ) j < (f ∘ σ) i → P (f ∘ σ) → P (f ∘ σ ∘ Equiv.swap i j)) :
    P (f ∘ sort f) 
Arguments: {n : ℕ} {α : Type u_1} [LinearOrder α] {f : Fin n → α} {P : (Fin n → α) → Prop} (hf : P f) (h :
  ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),
    i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j)))
Goal: P (f ∘ ⇑(Tuple.sort f))
-- Tuple.bubble_sort_induction
theorem bubble_sort_induction {n : ℕ} {α : Type*} [LinearOrder α] {f : Fin n → α}
    {P : (Fin n → α) → Prop} (hf : P f)
    (h : ∀ (g : Fin n → α) (i j : Fin n), i < j → g j < g i → P g → P (g ∘ Equiv.swap i j)) :
    P (f ∘ sort f) 
Arguments: {n : ℕ} {α : Type u_1} [LinearOrder α] {f : Fin n → α} {P : (Fin n → α) → Prop} (hf : P f) (h : ∀ (g : Fin n → α) (i j : Fin n), i < j → g j < g i → P g → P (g ∘ ⇑(Equiv.swap i j)))
Goal: P (f ∘ ⇑(Tuple.sort f))
-- Fintype.subtype_card
theorem subtype_card {p : α → Prop} (s : Finset α) (H : ∀ x : α, x ∈ s ↔ p x) :
    @card { x // p x } (Fintype.subtype s H) = s.card 
Arguments: {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x)
Goal: Fintype.card { x // p x } = s.card
-- Fintype.card_of_subtype
theorem card_of_subtype {p : α → Prop} (s : Finset α) (H : ∀ x : α, x ∈ s ↔ p x)
    [Fintype { x // p x }] : card { x // p x } = s.card 
Arguments: {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x) [Fintype { x // p x }]
Goal: Fintype.card { x // p x } = s.card
-- Fintype.card_ofFinset
@[simp]
theorem card_ofFinset {p : Set α} (s : Finset α) (H : ∀ x, x ∈ s ↔ x ∈ p) :
    @Fintype.card p (ofFinset s H) = s.card 
Arguments: {α : Type u_1} {p : Set α} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ x ∈ p)
Goal: Fintype.card ↑p = s.card
-- Fintype.card_of_finset'
theorem card_of_finset' {p : Set α} (s : Finset α) (H : ∀ x, x ∈ s ↔ x ∈ p) [Fintype p] :
    Fintype.card p = s.card 
Arguments: {α : Type u_1} {p : Set α} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ x ∈ p) [Fintype ↑p]
Goal: Fintype.card ↑p = s.card
-- Fintype.ofEquiv_card
theorem ofEquiv_card [Fintype α] (f : α ≃ β) : @card β (ofEquiv α f) = card α 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] (f : α ≃ β)
Goal: Fintype.card β = Fintype.card α
-- Fintype.card_congr
theorem card_congr {α β} [Fintype α] [Fintype β] (f : α ≃ β) : card α = card β 
Arguments: {α : Type u_4} {β : Type u_5} [Fintype α] [Fintype β] (f : α ≃ β)
Goal: Fintype.card α = Fintype.card β
-- Fintype.card_congr'
@[congr]
theorem card_congr' {α β} [Fintype α] [Fintype β] (h : α = β) : card α = card β 
Arguments: {α β : Type u_4} [Fintype α] [Fintype β] (h : α = β)
Goal: Fintype.card α = Fintype.card β
-- Fintype.card_eq
theorem card_eq {α β} [_F : Fintype α] [_G : Fintype β] : card α = card β ↔ Nonempty (α ≃ β) 
Arguments: {α : Type u_4} {β : Type u_5} [_F : Fintype α] [_G : Fintype β]
Goal: Fintype.card α = Fintype.card β ↔ Nonempty (α ≃ β)
-- Fintype.card_ofSubsingleton
@[simp]
theorem card_ofSubsingleton (a : α) [Subsingleton α] : @Fintype.card _ (ofSubsingleton a) = 1 
Arguments: {α : Type u_1} (a : α) [Subsingleton α]
Goal: Fintype.card α = 1
-- Fintype.card_unique
@[simp]
theorem card_unique [Unique α] [h : Fintype α] : Fintype.card α = 1 
Arguments: {α : Type u_1} [Unique α] [h : Fintype α]
Goal: Fintype.card α = 1
-- Fintype.card_ofIsEmpty
@[simp]
theorem card_ofIsEmpty [IsEmpty α] : @Fintype.card α Fintype.ofIsEmpty = 0 
Arguments: {α : Type u_1} [IsEmpty α]
Goal: Fintype.card α = 0
-- Set.toFinset_card
@[simp]
theorem toFinset_card {α : Type*} (s : Set α) [Fintype s] : s.toFinset.card = Fintype.card s 
Arguments: {α : Type u_4} (s : Set α) [Fintype ↑s]
Goal: s.toFinset.card = Fintype.card ↑s
-- Finset.card_univ
@[simp]
theorem Finset.card_univ [Fintype α] : (Finset.univ : Finset α).card = Fintype.card α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Finset.univ.card = Fintype.card α
-- Finset.eq_univ_of_card
theorem Finset.eq_univ_of_card [Fintype α] (s : Finset α) (hs : s.card = Fintype.card α) :
    s = univ 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α) (hs : s.card = Fintype.card α)
Goal: s = Finset.univ
-- Finset.card_eq_iff_eq_univ
theorem Finset.card_eq_iff_eq_univ [Fintype α] (s : Finset α) :
    s.card = Fintype.card α ↔ s = Finset.univ 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α)
Goal: s.card = Fintype.card α ↔ s = Finset.univ
-- Finset.card_le_univ
theorem Finset.card_le_univ [Fintype α] (s : Finset α) : s.card ≤ Fintype.card α 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α)
Goal: s.card ≤ Fintype.card α
-- Finset.card_lt_univ_of_not_mem
theorem Finset.card_lt_univ_of_not_mem [Fintype α] {s : Finset α} {x : α} (hx : x ∉ s) :
    s.card < Fintype.card α 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} {x : α} (hx : x ∉ s)
Goal: s.card < Fintype.card α
-- Finset.card_lt_iff_ne_univ
theorem Finset.card_lt_iff_ne_univ [Fintype α] (s : Finset α) :
    s.card < Fintype.card α ↔ s ≠ Finset.univ 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α)
Goal: s.card < Fintype.card α ↔ s ≠ Finset.univ
-- Finset.card_compl_lt_iff_nonempty
theorem Finset.card_compl_lt_iff_nonempty [Fintype α] [DecidableEq α] (s : Finset α) :
    sᶜ.card < Fintype.card α ↔ s.Nonempty 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: sᶜ.card < Fintype.card α ↔ s.Nonempty
-- Finset.card_univ_diff
theorem Finset.card_univ_diff [DecidableEq α] [Fintype α] (s : Finset α) :
    (Finset.univ \ s).card = Fintype.card α - s.card 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (s : Finset α)
Goal: (Finset.univ \ s).card = Fintype.card α - s.card
-- Finset.card_compl
theorem Finset.card_compl [DecidableEq α] [Fintype α] (s : Finset α) :
    sᶜ.card = Fintype.card α - s.card 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (s : Finset α)
Goal: sᶜ.card = Fintype.card α - s.card
-- Finset.card_add_card_compl
@[simp]
theorem Finset.card_add_card_compl [DecidableEq α] [Fintype α] (s : Finset α) :
    s.card + sᶜ.card = Fintype.card α 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (s : Finset α)
Goal: s.card + sᶜ.card = Fintype.card α
-- Finset.card_compl_add_card
@[simp]
theorem Finset.card_compl_add_card [DecidableEq α] [Fintype α] (s : Finset α) :
    sᶜ.card + s.card = Fintype.card α 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (s : Finset α)
Goal: sᶜ.card + s.card = Fintype.card α
-- Fintype.card_compl_set
theorem Fintype.card_compl_set [Fintype α] (s : Set α) [Fintype s] [Fintype (↥sᶜ : Sort _)] :
    Fintype.card (↥sᶜ : Sort _) = Fintype.card α - Fintype.card s 
Arguments: {α : Type u_1} [Fintype α] (s : Set α) [Fintype ↑s] [Fintype ↑sᶜ]
Goal: Fintype.card ↑sᶜ = Fintype.card α - Fintype.card ↑s
-- Fintype.card_fin
@[simp]
theorem Fintype.card_fin (n : ℕ) : Fintype.card (Fin n) = n 
Arguments: (n : ℕ)
Goal: Fintype.card (Fin n) = n
-- Fintype.card_fin_lt_of_le
theorem Fintype.card_fin_lt_of_le {m n : ℕ} (h : m ≤ n) :
    Fintype.card {i : Fin n // i < m} = m 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: Fintype.card { i // ↑i < m } = m
-- Finset.card_fin
theorem Finset.card_fin (n : ℕ) : Finset.card (Finset.univ : Finset (Fin n)) = n 
Arguments: (n : ℕ)
Goal: Finset.univ.card = n
-- fin_injective
theorem fin_injective : Function.Injective Fin 
Goal: Function.Injective Fin
-- Fin.cast_eq_cast'
theorem Fin.cast_eq_cast' {n m : ℕ} (h : Fin n = Fin m) :
    _root_.cast h = Fin.cast (fin_injective h) 
Arguments: {n m : ℕ} (h : Fin n = Fin m)
Goal: cast h = Fin.cast ⋯
-- card_finset_fin_le
theorem card_finset_fin_le {n : ℕ} (s : Finset (Fin n)) : s.card ≤ n 
Arguments: {n : ℕ} (s : Finset (Fin n))
Goal: s.card ≤ n
-- Fintype.card_subtype_eq
theorem Fintype.card_subtype_eq (y : α) [Fintype { x // x = y }] :
    Fintype.card { x // x = y } = 1 
Arguments: {α : Type u_1} (y : α) [Fintype { x // x = y }]
Goal: Fintype.card { x // x = y } = 1
-- Fintype.card_subtype_eq'
theorem Fintype.card_subtype_eq' (y : α) [Fintype { x // y = x }] :
    Fintype.card { x // y = x } = 1 
Arguments: {α : Type u_1} (y : α) [Fintype { x // y = x }]
Goal: Fintype.card { x // y = x } = 1
-- Fintype.card_empty
theorem Fintype.card_empty : Fintype.card Empty = 0 
Goal: Fintype.card Empty = 0
-- Fintype.card_pempty
theorem Fintype.card_pempty : Fintype.card PEmpty = 0 
Goal: Fintype.card PEmpty.{u_4 + 1} = 0
-- Fintype.card_unit
theorem Fintype.card_unit : Fintype.card Unit = 1 
Goal: Fintype.card Unit = 1
-- Fintype.card_punit
@[simp]
theorem Fintype.card_punit : Fintype.card PUnit = 1 
Goal: Fintype.card PUnit.{u_4 + 1} = 1
-- Fintype.card_bool
@[simp]
theorem Fintype.card_bool : Fintype.card Bool = 2 
Goal: Fintype.card Bool = 2
-- Fintype.card_ulift
@[simp]
theorem Fintype.card_ulift (α : Type*) [Fintype α] : Fintype.card (ULift α) = Fintype.card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card (ULift.{u_5, u_4} α) = Fintype.card α
-- Fintype.card_plift
@[simp]
theorem Fintype.card_plift (α : Type*) [Fintype α] : Fintype.card (PLift α) = Fintype.card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card (PLift α) = Fintype.card α
-- Fintype.card_orderDual
@[simp]
theorem Fintype.card_orderDual (α : Type*) [Fintype α] : Fintype.card αᵒᵈ = Fintype.card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card αᵒᵈ = Fintype.card α
-- Fintype.card_lex
@[simp]
theorem Fintype.card_lex (α : Type*) [Fintype α] : Fintype.card (Lex α) = Fintype.card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card (Lex α) = Fintype.card α
-- Fintype.card_multiplicative
@[simp] lemma Fintype.card_multiplicative (α : Type*) [Fintype α] :
    card (Multiplicative α) = card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card (Multiplicative α) = Fintype.card α
-- Fintype.card_additive
@[simp] lemma Fintype.card_additive (α : Type*) [Fintype α] : card (Additive α) = card α 
Arguments: (α : Type u_4) [Fintype α]
Goal: Fintype.card (Additive α) = Fintype.card α
-- Fintype.finite
protected theorem Fintype.finite {α : Type*} (_inst : Fintype α) : Finite α 
Arguments: {α : Type u_4} (_inst : Fintype α)
Goal: Finite α
-- finite_iff_nonempty_fintype
theorem finite_iff_nonempty_fintype (α : Type*) : Finite α ↔ Nonempty (Fintype α) 
Arguments: (α : Type u_4)
Goal: Finite α ↔ Nonempty (Fintype α)
-- nonempty_fintype
theorem nonempty_fintype (α : Type*) [Finite α] : Nonempty (Fintype α) 
Arguments: (α : Type u_4) [Finite α]
Goal: Nonempty (Fintype α)
-- Finite.of_injective
theorem Finite.of_injective {α β : Sort*} [Finite β] (f : α → β) (H : Injective f) : Finite α 
Arguments: {α : Sort u_4} {β : Sort u_5} [Finite β] (f : α → β) (H : Function.Injective f)
Goal: Finite α
-- Finite.of_surjective
theorem Finite.of_surjective {α β : Sort*} [Finite α] (f : α → β) (H : Surjective f) : Finite β 
Arguments: {α : Sort u_4} {β : Sort u_5} [Finite α] (f : α → β) (H : Function.Surjective f)
Goal: Finite β
-- Finite.exists_univ_list
theorem Finite.exists_univ_list (α) [Finite α] : ∃ l : List α, l.Nodup ∧ ∀ x : α, x ∈ l 
Arguments: (α : Type u_4) [Finite α]
Goal: ∃ l, l.Nodup ∧ ∀ (x : α), x ∈ l
-- List.Nodup.length_le_card
theorem List.Nodup.length_le_card {α : Type*} [Fintype α] {l : List α} (h : l.Nodup) :
    l.length ≤ Fintype.card α 
Arguments: {α : Type u_4} [Fintype α] {l : List α} (h : l.Nodup)
Goal: l.length ≤ Fintype.card α
-- Fintype.card_le_of_injective
theorem card_le_of_injective (f : α → β) (hf : Function.Injective f) : card α ≤ card β 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (f : α → β) (hf : Function.Injective f)
Goal: Fintype.card α ≤ Fintype.card β