ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.mem_ssubsets
@[simp]
theorem mem_ssubsets {s t : Finset α} : t ∈ s.ssubsets ↔ t ⊂ s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α}
Goal: t ∈ s.ssubsets ↔ t ⊂ s
-- Finset.empty_mem_ssubsets
theorem empty_mem_ssubsets {s : Finset α} (h : s.Nonempty) : ∅ ∈ s.ssubsets 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} (h : s.Nonempty)
Goal: ∅ ∈ s.ssubsets
-- Finset.mem_powersetCard
@[simp] lemma mem_powersetCard : s ∈ powersetCard n t ↔ s ⊆ t ∧ card s = n 
Arguments: {α : Type u_1} {n : ℕ} {s t : Finset α}
Goal: s ∈ Finset.powersetCard n t ↔ s ⊆ t ∧ s.card = n
-- Finset.powersetCard_mono
@[simp]
theorem powersetCard_mono {n} {s t : Finset α} (h : s ⊆ t) : powersetCard n s ⊆ powersetCard n t 
Arguments: {α : Type u_1} {n : ℕ} {s t : Finset α} (h : s ⊆ t)
Goal: Finset.powersetCard n s ⊆ Finset.powersetCard n t
-- Finset.card_powersetCard
@[simp]
theorem card_powersetCard (n : ℕ) (s : Finset α) :
    card (powersetCard n s) = Nat.choose (card s) n 
Arguments: {α : Type u_1} (n : ℕ) (s : Finset α)
Goal: (Finset.powersetCard n s).card = s.card.choose n
-- Finset.powersetCard_zero
@[simp]
theorem powersetCard_zero (s : Finset α) : s.powersetCard 0 = {∅} 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Finset.powersetCard 0 s = {∅}
-- Finset.powersetCard_empty_subsingleton
lemma powersetCard_empty_subsingleton (n : ℕ) :
    (powersetCard n (∅ : Finset α) : Set $ Finset α).Subsingleton 
Arguments: {α : Type u_1} (n : ℕ)
Goal: (↑(Finset.powersetCard n ∅)).Subsingleton
-- Finset.map_val_val_powersetCard
@[simp]
theorem map_val_val_powersetCard (s : Finset α) (i : ℕ) :
    (s.powersetCard i).val.map Finset.val = s.1.powersetCard i 
Arguments: {α : Type u_1} (s : Finset α) (i : ℕ)
Goal: Multiset.map Finset.val (Finset.powersetCard i s).val = Multiset.powersetCard i s.val
-- Finset.powersetCard_one
theorem powersetCard_one (s : Finset α) :
    s.powersetCard 1 = s.map ⟨_, Finset.singleton_injective⟩ 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Finset.powersetCard 1 s = Finset.map { toFun := singleton, inj' := ⋯ } s
-- Finset.powersetCard_eq_empty
@[simp]
lemma powersetCard_eq_empty : powersetCard n s = ∅ ↔ s.card < n 
Arguments: {α : Type u_1} {n : ℕ} {s : Finset α}
Goal: Finset.powersetCard n s = ∅ ↔ s.card < n
-- Finset.powersetCard_card_add
@[simp] lemma powersetCard_card_add (s : Finset α) (hn : 0 < n) :
    s.powersetCard (s.card + n) = ∅ 
Arguments: {α : Type u_1} {n : ℕ} (s : Finset α) (hn : 0 < n)
Goal: Finset.powersetCard (s.card + n) s = ∅
-- Finset.powersetCard_eq_filter
theorem powersetCard_eq_filter {n} {s : Finset α} :
    powersetCard n s = (powerset s).filter fun x => x.card = n 
Arguments: {α : Type u_1} {n : ℕ} {s : Finset α}
Goal: Finset.powersetCard n s = Finset.filter (fun x => x.card = n) s.powerset
-- Finset.powersetCard_succ_insert
theorem powersetCard_succ_insert [DecidableEq α] {x : α} {s : Finset α} (h : x ∉ s) (n : ℕ) :
    powersetCard n.succ (insert x s) =
    powersetCard n.succ s ∪ (powersetCard n s).image (insert x) 
Arguments: {α : Type u_1} [DecidableEq α] {x : α} {s : Finset α} (h : x ∉ s) (n : ℕ)
Goal: Finset.powersetCard n.succ (insert x s) =
  Finset.powersetCard n.succ s ∪ Finset.image (insert x) (Finset.powersetCard n s)
-- Finset.powersetCard_nonempty
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma powersetCard_nonempty : (powersetCard n s).Nonempty ↔ n ≤ s.card 
Arguments: {α : Type u_1} {n : ℕ} {s : Finset α}
Goal: (Finset.powersetCard n s).Nonempty ↔ n ≤ s.card
-- Finset.powersetCard_self
@[simp]
theorem powersetCard_self (s : Finset α) : powersetCard s.card s = {s} 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Finset.powersetCard s.card s = {s}
-- Finset.pairwise_disjoint_powersetCard
theorem pairwise_disjoint_powersetCard (s : Finset α) :
    Pairwise fun i j => Disjoint (s.powersetCard i) (s.powersetCard j) 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Pairwise fun i j => Disjoint (Finset.powersetCard i s) (Finset.powersetCard j s)
-- Finset.powerset_card_disjiUnion
theorem powerset_card_disjiUnion (s : Finset α) :
    Finset.powerset s =
      (range (s.card + 1)).disjiUnion (fun i => powersetCard i s)
        (s.pairwise_disjoint_powersetCard.set_pairwise _) 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s.powerset = (Finset.range (s.card + 1)).disjiUnion (fun i => Finset.powersetCard i s) ⋯
-- Finset.powerset_card_biUnion
theorem powerset_card_biUnion [DecidableEq (Finset α)] (s : Finset α) :
    Finset.powerset s = (range (s.card + 1)).biUnion fun i => powersetCard i s 
Arguments: {α : Type u_1} [DecidableEq (Finset α)] (s : Finset α)
Goal: s.powerset = (Finset.range (s.card + 1)).biUnion fun i => Finset.powersetCard i s
-- Finset.powersetCard_sup
theorem powersetCard_sup [DecidableEq α] (u : Finset α) (n : ℕ) (hn : n < u.card) :
    (powersetCard n.succ u).sup id = u 
Arguments: {α : Type u_1} [DecidableEq α] (u : Finset α) (n : ℕ) (hn : n < u.card)
Goal: (Finset.powersetCard n.succ u).sup id = u
-- Finset.powersetCard_map
theorem powersetCard_map {β : Type*} (f : α ↪ β) (n : ℕ) (s : Finset α) :
    powersetCard n (s.map f) = (powersetCard n s).map (mapEmbedding f).toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (n : ℕ) (s : Finset α)
Goal: Finset.powersetCard n (Finset.map f s) = Finset.map (Finset.mapEmbedding f).toEmbedding (Finset.powersetCard n s)
-- Finset.Nat.antidiagonal_eq_map
lemma antidiagonal_eq_map (n : ℕ) :
    antidiagonal n = (range (n + 1)).map ⟨fun i ↦ (i, n - i), fun _ _ h ↦ (Prod.ext_iff.1 h).1⟩ 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal n = Finset.map { toFun := fun i => (i, n - i), inj' := ⋯ } (Finset.range (n + 1))
-- Finset.Nat.antidiagonal_eq_map'
lemma antidiagonal_eq_map' (n : ℕ) :
    antidiagonal n =
      (range (n + 1)).map ⟨fun i ↦ (n - i, i), fun _ _ h ↦ (Prod.ext_iff.1 h).2⟩ 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal n = Finset.map { toFun := fun i => (n - i, i), inj' := ⋯ } (Finset.range (n + 1))
-- Finset.Nat.antidiagonal_eq_image
lemma antidiagonal_eq_image (n : ℕ) :
    antidiagonal n = (range (n + 1)).image fun i ↦ (i, n - i) 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal n = Finset.image (fun i => (i, n - i)) (Finset.range (n + 1))
-- Finset.Nat.antidiagonal_eq_image'
lemma antidiagonal_eq_image' (n : ℕ) :
    antidiagonal n = (range (n + 1)).image fun i ↦ (n - i, i) 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal n = Finset.image (fun i => (n - i, i)) (Finset.range (n + 1))
-- Finset.Nat.card_antidiagonal
@[simp]
theorem card_antidiagonal (n : ℕ) : (antidiagonal n).card = n + 1 
Arguments: (n : ℕ)
Goal: (Finset.antidiagonal n).card = n + 1
-- Finset.Nat.antidiagonal_zero
@[simp]
theorem antidiagonal_zero : antidiagonal 0 = {(0, 0)} 
Goal: Finset.antidiagonal 0 = {(0, 0)}
-- Finset.Nat.antidiagonal_succ
theorem antidiagonal_succ (n : ℕ) :
    antidiagonal (n + 1) =
      cons (0, n + 1)
        ((antidiagonal n).map
          (Embedding.prodMap ⟨Nat.succ, Nat.succ_injective⟩ (Embedding.refl _)))
        (by simp) 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal (n + 1) =
  Finset.cons (0, n + 1)
    (Finset.map ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap (Function.Embedding.refl ℕ))
      (Finset.antidiagonal n))
    ⋯
-- Finset.Nat.antidiagonal_succ'
theorem antidiagonal_succ' (n : ℕ) :
    antidiagonal (n + 1) =
      cons (n + 1, 0)
        ((antidiagonal n).map
          (Embedding.prodMap (Embedding.refl _) ⟨Nat.succ, Nat.succ_injective⟩))
        (by simp) 
Arguments: (n : ℕ)
Goal: Finset.antidiagonal (n + 1) =
  Finset.cons (n + 1, 0)
    (Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
      (Finset.antidiagonal n))
    ⋯
-- Finset.Nat.antidiagonal_succ_succ'
theorem antidiagonal_succ_succ' {n : ℕ} :
    antidiagonal (n + 2) =
      cons (0, n + 2)
        (cons (n + 2, 0)
            ((antidiagonal n).map
              (Embedding.prodMap ⟨Nat.succ, Nat.succ_injective⟩
                ⟨Nat.succ, Nat.succ_injective⟩)) <|
          by simp)
        (by simp) 
Arguments: {n : ℕ}
Goal: Finset.antidiagonal (n + 2) =
  Finset.cons (0, n + 2)
    (Finset.cons (n + 2, 0)
      (Finset.map
        ({ toFun := Nat.succ, inj' := Nat.succ_injective }.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective })
        (Finset.antidiagonal n))
      ⋯)
    ⋯
-- Finset.Nat.antidiagonal.fst_lt
theorem antidiagonal.fst_lt {n : ℕ} {kl : ℕ × ℕ} (hlk : kl ∈ antidiagonal n) : kl.1 < n + 1 
Arguments: {n : ℕ} {kl : ℕ × ℕ} (hlk : kl ∈ Finset.antidiagonal n)
Goal: kl.1 < n + 1
-- Finset.Nat.antidiagonal.snd_lt
theorem antidiagonal.snd_lt {n : ℕ} {kl : ℕ × ℕ} (hlk : kl ∈ antidiagonal n) : kl.2 < n + 1 
Arguments: {n : ℕ} {kl : ℕ × ℕ} (hlk : kl ∈ Finset.antidiagonal n)
Goal: kl.2 < n + 1
-- Finset.Nat.antidiagonal_filter_snd_le_of_le
@[simp] lemma antidiagonal_filter_snd_le_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ a.snd ≤ k) = (antidiagonal k).map
      (Embedding.prodMap ⟨_, add_left_injective (n - k)⟩ (Embedding.refl ℕ)) 
Arguments: {n k : ℕ} (h : k ≤ n)
Goal: Finset.filter (fun a => a.2 ≤ k) (Finset.antidiagonal n) =
  Finset.map ({ toFun := fun x => x + (n - k), inj' := ⋯ }.prodMap (Function.Embedding.refl ℕ)) (Finset.antidiagonal k)
-- Finset.Nat.antidiagonal_filter_fst_le_of_le
@[simp] lemma antidiagonal_filter_fst_le_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ a.fst ≤ k) = (antidiagonal k).map
      (Embedding.prodMap (Embedding.refl ℕ) ⟨_, add_left_injective (n - k)⟩) 
Arguments: {n k : ℕ} (h : k ≤ n)
Goal: Finset.filter (fun a => a.1 ≤ k) (Finset.antidiagonal n) =
  Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := fun x => x + (n - k), inj' := ⋯ }) (Finset.antidiagonal k)
-- Finset.Nat.antidiagonal_filter_le_fst_of_le
@[simp] lemma antidiagonal_filter_le_fst_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ k ≤ a.fst) = (antidiagonal (n - k)).map
      (Embedding.prodMap ⟨_, add_left_injective k⟩ (Embedding.refl ℕ)) 
Arguments: {n k : ℕ} (h : k ≤ n)
Goal: Finset.filter (fun a => k ≤ a.1) (Finset.antidiagonal n) =
  Finset.map ({ toFun := fun x => x + k, inj' := ⋯ }.prodMap (Function.Embedding.refl ℕ)) (Finset.antidiagonal (n - k))
-- Finset.Nat.antidiagonal_filter_le_snd_of_le
@[simp] lemma antidiagonal_filter_le_snd_of_le {n k : ℕ} (h : k ≤ n) :
    (antidiagonal n).filter (fun a ↦ k ≤ a.snd) = (antidiagonal (n - k)).map
      (Embedding.prodMap (Embedding.refl ℕ) ⟨_, add_left_injective k⟩) 
Arguments: {n k : ℕ} (h : k ≤ n)
Goal: Finset.filter (fun a => k ≤ a.2) (Finset.antidiagonal n) =
  Finset.map ((Function.Embedding.refl ℕ).prodMap { toFun := fun x => x + k, inj' := ⋯ }) (Finset.antidiagonal (n - k))
-- Finset.Nat.antidiagonalEquivFin_apply_val
@[simps]
def antidiagonalEquivFin (n : ℕ) : antidiagonal n ≃ Fin (n + 1) 
Arguments: (n : ℕ)
Goal: ∀ (x : { x // x ∈ Finset.antidiagonal n }), ↑((Finset.Nat.antidiagonalEquivFin n) x) = x.1.1
-- Finset.Nat.antidiagonalEquivFin_symm_apply_coe
@[simps]
def antidiagonalEquivFin (n : ℕ) : antidiagonal n ≃ Fin (n + 1) 
Arguments: (n : ℕ)
Goal: ∀ (x : Fin (n + 1)), ↑((Finset.Nat.antidiagonalEquivFin n).symm x) = (↑x, n - ↑x)
-- Finset.fmap_def
@[simp]
theorem fmap_def {s : Finset α} (f : α → β) : f <$> s = s.image f 
Arguments: {α β : Type u} [(P : Prop) → Decidable P] {s : Finset α} (f : α → β)
Goal: f <$> s = Finset.image f s
-- Finset.pure_def
@[simp]
theorem pure_def {α} : (pure : α → Finset α) = singleton 
Arguments: {α : Type u_1}
Goal: pure = singleton
-- Finset.seq_def
@[simp]
theorem seq_def (s : Finset α) (t : Finset (α → β)) : t <*> s = t.sup fun f => s.image f 
Arguments: {α β : Type u} [(P : Prop) → Decidable P] (s : Finset α) (t : Finset (α → β))
Goal: (Seq.seq t fun x => s) = t.sup fun f => Finset.image f s
-- Finset.seqLeft_def
@[simp]
theorem seqLeft_def (s : Finset α) (t : Finset β) : s <* t = if t = ∅ then ∅ else s 
Arguments: {α β : Type u} [(P : Prop) → Decidable P] (s : Finset α) (t : Finset β)
Goal: (SeqLeft.seqLeft s fun x => t) = if t = ∅ then ∅ else s
-- Finset.seqRight_def
@[simp]
theorem seqRight_def (s : Finset α) (t : Finset β) : s *> t = if s = ∅ then ∅ else t 
Arguments: {α β : Type u} [(P : Prop) → Decidable P] (s : Finset α) (t : Finset β)
Goal: (SeqRight.seqRight s fun x => t) = if s = ∅ then ∅ else t
-- Finset.image₂_def
theorem image₂_def {α β γ : Type u} (f : α → β → γ) (s : Finset α) (t : Finset β) :
    image₂ f s t = f <$> s <*> t 
Arguments: [(P : Prop) → Decidable P] {α β γ : Type u} (f : α → β → γ) (s : Finset α) (t : Finset β)
Goal: Finset.image₂ f s t = Seq.seq (f <$> s) fun x => t
-- Finset.bind_def
@[simp]
theorem bind_def {α β} : (· >>= ·) = sup (α := Finset α) (β := β) 
Arguments: [(P : Prop) → Decidable P] {α β : Type u_1}
Goal: (fun x x_1 => x >>= x_1) = Finset.sup
-- Finset.id_traverse
@[simp]
theorem id_traverse [DecidableEq α] (s : Finset α) : traverse (pure : α → Id α) s = s 
Arguments: {α : Type u} [DecidableEq α] (s : Finset α)
Goal: Finset.traverse pure s = s
-- Finset.map_comp_coe
@[simp]
theorem map_comp_coe (h : α → β) :
    Functor.map h ∘ Multiset.toFinset = Multiset.toFinset ∘ Functor.map h 
Arguments: {α β : Type u} (h : α → β)
Goal: Functor.map h ∘ Multiset.toFinset = Multiset.toFinset ∘ Functor.map h
-- Finset.map_traverse
theorem map_traverse (g : α → G β) (h : β → γ) (s : Finset α) :
    Functor.map h <$> traverse g s = traverse (Functor.map h ∘ g) s 
Arguments: {α β γ : Type u} {G : Type u → Type u} [Applicative G] [CommApplicative G] (g : α → G β) (h : β → γ) (s : Finset α)
Goal: Functor.map h <$> Finset.traverse g s = Finset.traverse (Functor.map h ∘ g) s
-- Option.toFinset_none
@[simp]
theorem toFinset_none : none.toFinset = (∅ : Finset α) 
Arguments: {α : Type u_1}
Goal: none.toFinset = ∅
-- Option.toFinset_some
@[simp]
theorem toFinset_some {a : α} : (some a).toFinset = {a} 
Arguments: {α : Type u_1} {a : α}
Goal: (some a).toFinset = {a}
-- Option.mem_toFinset
@[simp]
theorem mem_toFinset {a : α} {o : Option α} : a ∈ o.toFinset ↔ a ∈ o 
Arguments: {α : Type u_1} {a : α} {o : Option α}
Goal: a ∈ o.toFinset ↔ a ∈ o
-- Option.card_toFinset
theorem card_toFinset (o : Option α) : o.toFinset.card = o.elim 0 1 
Arguments: {α : Type u_1} (o : Option α)
Goal: o.toFinset.card = o.elim 0 1
-- Finset.mem_insertNone
@[simp]
theorem mem_insertNone {s : Finset α} : ∀ {o : Option α}, o ∈ insertNone s ↔ ∀ a ∈ o, a ∈ s
  
Arguments: {α : Type u_1} {s : Finset α} {o : Option α}
Goal: o ∈ Finset.insertNone s ↔ ∀ a ∈ o, a ∈ s
-- Finset.forall_mem_insertNone
lemma forall_mem_insertNone {s : Finset α} {p : Option α → Prop} :
    (∀ a ∈ insertNone s, p a) ↔ p none ∧ ∀ a ∈ s, p a 
Arguments: {α : Type u_1} {s : Finset α} {p : Option α → Prop}
Goal: (∀ a ∈ Finset.insertNone s, p a) ↔ p none ∧ ∀ a ∈ s, p (some a)
-- Finset.some_mem_insertNone
theorem some_mem_insertNone {s : Finset α} {a : α} : some a ∈ insertNone s ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: some a ∈ Finset.insertNone s ↔ a ∈ s
-- Finset.none_mem_insertNone
lemma none_mem_insertNone {s : Finset α} : none ∈ insertNone s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: none ∈ Finset.insertNone s
-- Finset.insertNone_nonempty
@[aesop safe apply (rule_sets := [finsetNonempty])]
lemma insertNone_nonempty {s : Finset α} : insertNone s |>.Nonempty 
Arguments: {α : Type u_1} {s : Finset α}
Goal: (Finset.insertNone s).Nonempty
-- Finset.card_insertNone
@[simp]
theorem card_insertNone (s : Finset α) : s.insertNone.card = s.card + 1 
Arguments: {α : Type u_1} (s : Finset α)
Goal: (Finset.insertNone s).card = s.card + 1
-- Finset.mem_eraseNone
@[simp]
theorem mem_eraseNone {s : Finset (Option α)} {x : α} : x ∈ eraseNone s ↔ some x ∈ s 
Arguments: {α : Type u_1} {s : Finset (Option α)} {x : α}
Goal: x ∈ Finset.eraseNone s ↔ some x ∈ s
-- Finset.forall_mem_eraseNone
lemma forall_mem_eraseNone {s : Finset (Option α)} {p : Option α → Prop} :
    (∀ a ∈ eraseNone s, p a) ↔ ∀ a : α, (a : Option α) ∈ s → p a 
Arguments: {α : Type u_1} {s : Finset (Option α)} {p : Option α → Prop}
Goal: (∀ a ∈ Finset.eraseNone s, p (some a)) ↔ ∀ (a : α), some a ∈ s → p (some a)
-- Finset.eraseNone_eq_biUnion
theorem eraseNone_eq_biUnion [DecidableEq α] (s : Finset (Option α)) :
    eraseNone s = s.biUnion Option.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset (Option α))
Goal: Finset.eraseNone s = s.biUnion Option.toFinset
-- Finset.eraseNone_map_some
@[simp]
theorem eraseNone_map_some (s : Finset α) : eraseNone (s.map Embedding.some) = s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Finset.eraseNone (Finset.map Function.Embedding.some s) = s
-- Finset.eraseNone_image_some
@[simp]
theorem eraseNone_image_some [DecidableEq (Option α)] (s : Finset α) :
    eraseNone (s.image some) = s 
Arguments: {α : Type u_1} [DecidableEq (Option α)] (s : Finset α)
Goal: Finset.eraseNone (Finset.image some s) = s
-- Finset.coe_eraseNone
@[simp]
theorem coe_eraseNone (s : Finset (Option α)) : (eraseNone s : Set α) = some ⁻¹' s 
Arguments: {α : Type u_1} (s : Finset (Option α))
Goal: ↑(Finset.eraseNone s) = some ⁻¹' ↑s
-- Finset.eraseNone_union
@[simp]
theorem eraseNone_union [DecidableEq (Option α)] [DecidableEq α] (s t : Finset (Option α)) :
    eraseNone (s ∪ t) = eraseNone s ∪ eraseNone t 
Arguments: {α : Type u_1} [DecidableEq (Option α)] [DecidableEq α] (s t : Finset (Option α))
Goal: Finset.eraseNone (s ∪ t) = Finset.eraseNone s ∪ Finset.eraseNone t
-- Finset.eraseNone_inter
@[simp]
theorem eraseNone_inter [DecidableEq (Option α)] [DecidableEq α] (s t : Finset (Option α)) :
    eraseNone (s ∩ t) = eraseNone s ∩ eraseNone t 
Arguments: {α : Type u_1} [DecidableEq (Option α)] [DecidableEq α] (s t : Finset (Option α))
Goal: Finset.eraseNone (s ∩ t) = Finset.eraseNone s ∩ Finset.eraseNone t
-- Finset.eraseNone_empty
@[simp]
theorem eraseNone_empty : eraseNone (∅ : Finset (Option α)) = ∅ 
Arguments: {α : Type u_1}
Goal: Finset.eraseNone ∅ = ∅
-- Finset.eraseNone_none
@[simp]
theorem eraseNone_none : eraseNone ({none} : Finset (Option α)) = ∅ 
Arguments: {α : Type u_1}
Goal: Finset.eraseNone {none} = ∅
-- Finset.image_some_eraseNone
@[simp]
theorem image_some_eraseNone [DecidableEq (Option α)] (s : Finset (Option α)) :
    (eraseNone s).image some = s.erase none 
Arguments: {α : Type u_1} [DecidableEq (Option α)] (s : Finset (Option α))
Goal: Finset.image some (Finset.eraseNone s) = s.erase none
-- Finset.map_some_eraseNone
@[simp]
theorem map_some_eraseNone [DecidableEq (Option α)] (s : Finset (Option α)) :
    (eraseNone s).map Embedding.some = s.erase none 
Arguments: {α : Type u_1} [DecidableEq (Option α)] (s : Finset (Option α))
Goal: Finset.map Function.Embedding.some (Finset.eraseNone s) = s.erase none
-- Finset.insertNone_eraseNone
@[simp]
theorem insertNone_eraseNone [DecidableEq (Option α)] (s : Finset (Option α)) :
    insertNone (eraseNone s) = insert none s 
Arguments: {α : Type u_1} [DecidableEq (Option α)] (s : Finset (Option α))
Goal: Finset.insertNone (Finset.eraseNone s) = insert none s
-- Finset.eraseNone_insertNone
@[simp]
theorem eraseNone_insertNone (s : Finset α) : eraseNone (insertNone s) = s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: Finset.eraseNone (Finset.insertNone s) = s
-- Finset.Icc_eq_filter_powerset
theorem Icc_eq_filter_powerset : Icc s t = t.powerset.filter (s ⊆ ·) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: Finset.Icc s t = Finset.filter (fun x => s ⊆ x) t.powerset
-- Finset.Ico_eq_filter_ssubsets
theorem Ico_eq_filter_ssubsets : Ico s t = t.ssubsets.filter (s ⊆ ·) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: Finset.Ico s t = Finset.filter (fun x => s ⊆ x) t.ssubsets
-- Finset.Ioc_eq_filter_powerset
theorem Ioc_eq_filter_powerset : Ioc s t = t.powerset.filter (s ⊂ ·) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: Finset.Ioc s t = Finset.filter (fun x => s ⊂ x) t.powerset
-- Finset.Ioo_eq_filter_ssubsets
theorem Ioo_eq_filter_ssubsets : Ioo s t = t.ssubsets.filter (s ⊂ ·) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Finset α)
Goal: Finset.Ioo s t = Finset.filter (fun x => s ⊂ x) t.ssubsets
-- Finset.Iic_eq_powerset
theorem Iic_eq_powerset : Iic s = s.powerset 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.Iic s = s.powerset
-- Finset.Iio_eq_ssubsets
theorem Iio_eq_ssubsets : Iio s = s.ssubsets 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: Finset.Iio s = s.ssubsets
-- Finset.Icc_eq_image_powerset
theorem Icc_eq_image_powerset (h : s ⊆ t) : Icc s t = (t \ s).powerset.image (s ∪ ·) 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: Finset.Icc s t = Finset.image (fun x => s ∪ x) (t \ s).powerset
-- Finset.Ico_eq_image_ssubsets
theorem Ico_eq_image_ssubsets (h : s ⊆ t) : Ico s t = (t \ s).ssubsets.image (s ∪ ·) 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: Finset.Ico s t = Finset.image (fun x => s ∪ x) (t \ s).ssubsets
-- Finset.card_Icc_finset
theorem card_Icc_finset (h : s ⊆ t) : (Icc s t).card = 2 ^ (t.card - s.card) 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: (Finset.Icc s t).card = 2 ^ (t.card - s.card)
-- Finset.card_Ico_finset
theorem card_Ico_finset (h : s ⊆ t) : (Ico s t).card = 2 ^ (t.card - s.card) - 1 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: (Finset.Ico s t).card = 2 ^ (t.card - s.card) - 1
-- Finset.card_Ioc_finset
theorem card_Ioc_finset (h : s ⊆ t) : (Ioc s t).card = 2 ^ (t.card - s.card) - 1 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: (Finset.Ioc s t).card = 2 ^ (t.card - s.card) - 1
-- Finset.card_Ioo_finset
theorem card_Ioo_finset (h : s ⊆ t) : (Ioo s t).card = 2 ^ (t.card - s.card) - 2 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} (h : s ⊆ t)
Goal: (Finset.Ioo s t).card = 2 ^ (t.card - s.card) - 2
-- Finset.card_Iic_finset
theorem card_Iic_finset : (Iic s).card = 2 ^ s.card 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α}
Goal: (Finset.Iic s).card = 2 ^ s.card
-- Finset.card_Iio_finset
theorem card_Iio_finset : (Iio s).card = 2 ^ s.card - 1 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α}
Goal: (Finset.Iio s).card = 2 ^ s.card - 1
-- Finset.monotone_iff_forall_le_cons
lemma monotone_iff_forall_le_cons : Monotone f ↔ ∀ s, ∀ ⦃a⦄ (ha), f s ≤ f (cons a s ha) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β}
Goal: Monotone f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f s ≤ f (Finset.cons a s ha)
-- Finset.antitone_iff_forall_cons_le
lemma antitone_iff_forall_cons_le : Antitone f ↔ ∀ s ⦃a⦄ ha, f (cons a s ha) ≤ f s 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β}
Goal: Antitone f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f (Finset.cons a s ha) ≤ f s
-- Finset.strictMono_iff_forall_lt_cons
lemma strictMono_iff_forall_lt_cons : StrictMono f ↔ ∀ s ⦃a⦄ ha, f s < f (cons a s ha) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β}
Goal: StrictMono f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f s < f (Finset.cons a s ha)
-- Finset.strictAnti_iff_forall_cons_lt
lemma strictAnti_iff_forall_cons_lt : StrictAnti f ↔ ∀ s ⦃a⦄ ha, f (cons a s ha) < f s 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β}
Goal: StrictAnti f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f (Finset.cons a s ha) < f s
-- Finset.monotone_iff_forall_le_insert
lemma monotone_iff_forall_le_insert : Monotone f ↔ ∀ s ⦃a⦄, a ∉ s → f s ≤ f (insert a s) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β} [DecidableEq α]
Goal: Monotone f ↔ ∀ (s : Finset α) ⦃a : α⦄, a ∉ s → f s ≤ f (insert a s)
-- Finset.antitone_iff_forall_insert_le
lemma antitone_iff_forall_insert_le : Antitone f ↔ ∀ s ⦃a⦄, a ∉ s → f (insert a s) ≤ f s 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β} [DecidableEq α]
Goal: Antitone f ↔ ∀ (s : Finset α) ⦃a : α⦄, a ∉ s → f (insert a s) ≤ f s
-- Finset.strictMono_iff_forall_lt_insert
lemma strictMono_iff_forall_lt_insert : StrictMono f ↔ ∀ s ⦃a⦄, a ∉ s → f s < f (insert a s) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder β] {f : Finset α → β} [DecidableEq α]
Goal: StrictMono f ↔ ∀ (s : Finset α) ⦃a : α⦄, a ∉ s → f s < f (insert a s)