ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.insert_compl_self
@[simp]
theorem insert_compl_self (x : α) : insert x ({x}ᶜ : Finset α) = univ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (x : α)
Goal: insert x {x}ᶜ = Finset.univ
-- Finset.compl_filter
@[simp]
theorem compl_filter (p : α → Prop) [DecidablePred p] [∀ x, Decidable ¬p x] :
    (univ.filter p)ᶜ = univ.filter fun x => ¬p x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : α → Prop) [DecidablePred p] [(x : α) → Decidable ¬p x]
Goal: (Finset.filter p Finset.univ)ᶜ = Finset.filter (fun x => ¬p x) Finset.univ
-- Finset.compl_ne_univ_iff_nonempty
theorem compl_ne_univ_iff_nonempty (s : Finset α) : sᶜ ≠ univ ↔ s.Nonempty 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: sᶜ ≠ Finset.univ ↔ s.Nonempty
-- Finset.compl_singleton
theorem compl_singleton (a : α) : ({a} : Finset α)ᶜ = univ.erase a 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (a : α)
Goal: {a}ᶜ = Finset.univ.erase a
-- Finset.insert_inj_on'
theorem insert_inj_on' (s : Finset α) : Set.InjOn (fun a => insert a s) (sᶜ : Finset α) 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: Set.InjOn (fun a => insert a s) ↑sᶜ
-- Finset.image_univ_of_surjective
theorem image_univ_of_surjective [Fintype β] {f : β → α} (hf : Surjective f) :
    univ.image f = univ 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq α] [Fintype β] {f : β → α} (hf : Function.Surjective f)
Goal: Finset.image f Finset.univ = Finset.univ
-- Finset.image_univ_equiv
@[simp]
theorem image_univ_equiv [Fintype β] (f : β ≃ α) : univ.image f = univ 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq α] [Fintype β] (f : β ≃ α)
Goal: Finset.image (⇑f) Finset.univ = Finset.univ
-- Finset.univ_inter
@[simp] lemma univ_inter (s : Finset α) : univ ∩ s = s 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: Finset.univ ∩ s = s
-- Finset.inter_univ
@[simp] lemma inter_univ (s : Finset α) : s ∩ univ = s 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: s ∩ Finset.univ = s
-- Finset.inter_eq_univ
@[simp] lemma inter_eq_univ : s ∩ t = univ ↔ s = univ ∧ t = univ 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α} [DecidableEq α]
Goal: s ∩ t = Finset.univ ↔ s = Finset.univ ∧ t = Finset.univ
-- Finset.singleton_eq_univ
lemma singleton_eq_univ [Subsingleton α] (a : α) : ({a} : Finset α) = univ 
Arguments: {α : Type u_1} [Fintype α] [Subsingleton α] (a : α)
Goal: {a} = Finset.univ
-- Finset.map_univ_of_surjective
theorem map_univ_of_surjective [Fintype β] {f : β ↪ α} (hf : Surjective f) : univ.map f = univ 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] {f : β ↪ α} (hf : Function.Surjective ⇑f)
Goal: Finset.map f Finset.univ = Finset.univ
-- Finset.map_univ_equiv
@[simp]
theorem map_univ_equiv [Fintype β] (f : β ≃ α) : univ.map f.toEmbedding = univ 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [Fintype β] (f : β ≃ α)
Goal: Finset.map f.toEmbedding Finset.univ = Finset.univ
-- Finset.univ_map_equiv_to_embedding
theorem univ_map_equiv_to_embedding {α β : Type*} [Fintype α] [Fintype β] (e : α ≃ β) :
    univ.map e.toEmbedding = univ 
Arguments: {α : Type u_4} {β : Type u_5} [Fintype α] [Fintype β] (e : α ≃ β)
Goal: Finset.map e.toEmbedding Finset.univ = Finset.univ
-- Finset.univ_filter_exists
@[simp]
theorem univ_filter_exists (f : α → β) [Fintype β] [DecidablePred fun y => ∃ x, f x = y]
    [DecidableEq β] : (Finset.univ.filter fun y => ∃ x, f x = y) = Finset.univ.image f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] (f : α → β) [Fintype β] [DecidablePred fun y => ∃ x, f x = y] [DecidableEq β]
Goal: Finset.filter (fun y => ∃ x, f x = y) Finset.univ = Finset.image f Finset.univ
-- Finset.univ_filter_mem_range
theorem univ_filter_mem_range (f : α → β) [Fintype β] [DecidablePred fun y => y ∈ Set.range f]
    [DecidableEq β] : (Finset.univ.filter fun y => y ∈ Set.range f) = Finset.univ.image f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] (f : α → β) [Fintype β] [DecidablePred fun y => y ∈ Set.range f] [DecidableEq β]
Goal: Finset.filter (fun y => y ∈ Set.range f) Finset.univ = Finset.image f Finset.univ
-- Finset.coe_filter_univ
theorem coe_filter_univ (p : α → Prop) [DecidablePred p] :
    (univ.filter p : Set α) = { x | p x } 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p]
Goal: ↑(Finset.filter p Finset.univ) = {x | p x}
-- Finset.subtype_eq_univ
@[simp] lemma subtype_eq_univ {p : α → Prop} [DecidablePred p] [Fintype {a // p a}] :
    s.subtype p = univ ↔ ∀ ⦃a⦄, p a → a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {p : α → Prop} [DecidablePred p] [Fintype { a // p a }]
Goal: Finset.subtype p s = Finset.univ ↔ ∀ ⦃a : α⦄, p a → a ∈ s
-- Finset.subtype_univ
@[simp] lemma subtype_univ [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype {a // p a}] :
    univ.subtype p = univ 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }]
Goal: Finset.subtype p Finset.univ = Finset.univ
-- Finset.univ_map_subtype
lemma univ_map_subtype [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype {a // p a}] :
    univ.map (Function.Embedding.subtype p) = univ.filter p 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }]
Goal: Finset.map (Function.Embedding.subtype p) Finset.univ = Finset.filter p Finset.univ
-- Finset.univ_val_map_subtype_val
lemma univ_val_map_subtype_val [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype {a // p a}] :
    univ.val.map ((↑) : { a // p a } → α) = (univ.filter p).val 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }]
Goal: Multiset.map Subtype.val Finset.univ.val = (Finset.filter p Finset.univ).val
-- Finset.univ_val_map_subtype_restrict
lemma univ_val_map_subtype_restrict [Fintype α] (f : α → β)
    (p : α → Prop) [DecidablePred p] [Fintype {a // p a}] :
    univ.val.map (Subtype.restrict p f) = (univ.filter p).val.map f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] (f : α → β) (p : α → Prop) [DecidablePred p] [Fintype { a // p a }]
Goal: Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val
-- Finset.filter_univ_mem
@[simp]
lemma filter_univ_mem (s : Finset α) : univ.filter (· ∈ s) = s 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun x => x ∈ s) Finset.univ = s
-- Function.Injective.left_inv_of_invOfMemRange
theorem left_inv_of_invOfMemRange (b : Set.range f) : f (hf.invOfMemRange b) = b 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (b : ↑(Set.range f))
Goal: f (hf.invOfMemRange b) = ↑b
-- Function.Injective.right_inv_of_invOfMemRange
@[simp]
theorem right_inv_of_invOfMemRange (a : α) : hf.invOfMemRange ⟨f a, Set.mem_range_self a⟩ = a 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (a : α)
Goal: hf.invOfMemRange ⟨f a, ⋯⟩ = a
-- Function.Injective.invFun_restrict
theorem invFun_restrict [Nonempty α] : (Set.range f).restrict (invFun f) = hf.invOfMemRange 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) [Nonempty α]
Goal: (Set.range f).restrict (Function.invFun f) = hf.invOfMemRange
-- Function.Injective.invOfMemRange_surjective
theorem invOfMemRange_surjective : Function.Surjective hf.invOfMemRange 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (hf : Function.Injective f)
Goal: Function.Surjective hf.invOfMemRange
-- Function.Embedding.left_inv_of_invOfMemRange
@[simp]
theorem left_inv_of_invOfMemRange : f (f.invOfMemRange b) = b 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (f : α ↪ β) (b : ↑(Set.range ⇑f))
Goal: f (f.invOfMemRange b) = ↑b
-- Function.Embedding.right_inv_of_invOfMemRange
@[simp]
theorem right_inv_of_invOfMemRange (a : α) : f.invOfMemRange ⟨f a, Set.mem_range_self a⟩ = a 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (f : α ↪ β) (a : α)
Goal: f.invOfMemRange ⟨f a, ⋯⟩ = a
-- Function.Embedding.invFun_restrict
theorem invFun_restrict [Nonempty α] : (Set.range f).restrict (invFun f) = f.invOfMemRange 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (f : α ↪ β) [Nonempty α]
Goal: (Set.range ⇑f).restrict (Function.invFun ⇑f) = f.invOfMemRange
-- Function.Embedding.invOfMemRange_surjective
theorem invOfMemRange_surjective : Function.Surjective f.invOfMemRange 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (f : α ↪ β)
Goal: Function.Surjective f.invOfMemRange
-- Fintype.univ_ofSubsingleton
theorem univ_ofSubsingleton (a : α) [Subsingleton α] : @univ _ (ofSubsingleton a) = {a} 
Arguments: {α : Type u_1} (a : α) [Subsingleton α]
Goal: Finset.univ = {a}
-- Fintype.univ_ofIsEmpty
theorem univ_ofIsEmpty [IsEmpty α] : @univ α Fintype.ofIsEmpty = ∅ 
Arguments: {α : Type u_1} [IsEmpty α]
Goal: Finset.univ = ∅
-- Set.toFinset_congr
@[congr]
theorem toFinset_congr {s t : Set α} [Fintype s] [Fintype t] (h : s = t) :
    toFinset s = toFinset t 
Arguments: {α : Type u_1} {s t : Set α} [Fintype ↑s] [Fintype ↑t] (h : s = t)
Goal: s.toFinset = t.toFinset
-- Set.mem_toFinset
@[simp]
theorem mem_toFinset {s : Set α} [Fintype s] {a : α} : a ∈ s.toFinset ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Set α} [Fintype ↑s] {a : α}
Goal: a ∈ s.toFinset ↔ a ∈ s
-- Set.toFinset_ofFinset
theorem toFinset_ofFinset {p : Set α} (s : Finset α) (H : ∀ x, x ∈ s ↔ x ∈ p) :
    @Set.toFinset _ p (Fintype.ofFinset s H) = s 
Arguments: {α : Type u_1} {p : Set α} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ x ∈ p)
Goal: p.toFinset = s
-- Set.coe_toFinset
@[simp]
theorem coe_toFinset (s : Set α) [Fintype s] : (↑s.toFinset : Set α) = s 
Arguments: {α : Type u_1} (s : Set α) [Fintype ↑s]
Goal: ↑s.toFinset = s
-- Set.toFinset_nonempty
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem toFinset_nonempty {s : Set α} [Fintype s] : s.toFinset.Nonempty ↔ s.Nonempty 
Arguments: {α : Type u_1} {s : Set α} [Fintype ↑s]
Goal: s.toFinset.Nonempty ↔ s.Nonempty
-- Set.toFinset_inj
@[simp]
theorem toFinset_inj {s t : Set α} [Fintype s] [Fintype t] : s.toFinset = t.toFinset ↔ s = t 
Arguments: {α : Type u_1} {s t : Set α} [Fintype ↑s] [Fintype ↑t]
Goal: s.toFinset = t.toFinset ↔ s = t
-- Set.toFinset_subset_toFinset
@[mono]
theorem toFinset_subset_toFinset [Fintype s] [Fintype t] : s.toFinset ⊆ t.toFinset ↔ s ⊆ t 
Arguments: {α : Type u_1} {s t : Set α} [Fintype ↑s] [Fintype ↑t]
Goal: s.toFinset ⊆ t.toFinset ↔ s ⊆ t
-- Set.toFinset_ssubset
@[simp]
theorem toFinset_ssubset [Fintype s] {t : Finset α} : s.toFinset ⊂ t ↔ s ⊂ t 
Arguments: {α : Type u_1} {s : Set α} [Fintype ↑s] {t : Finset α}
Goal: s.toFinset ⊂ t ↔ s ⊂ ↑t
-- Set.subset_toFinset
@[simp]
theorem subset_toFinset {s : Finset α} [Fintype t] : s ⊆ t.toFinset ↔ ↑s ⊆ t 
Arguments: {α : Type u_1} {t : Set α} {s : Finset α} [Fintype ↑t]
Goal: s ⊆ t.toFinset ↔ ↑s ⊆ t
-- Set.ssubset_toFinset
@[simp]
theorem ssubset_toFinset {s : Finset α} [Fintype t] : s ⊂ t.toFinset ↔ ↑s ⊂ t 
Arguments: {α : Type u_1} {t : Set α} {s : Finset α} [Fintype ↑t]
Goal: s ⊂ t.toFinset ↔ ↑s ⊂ t
-- Set.toFinset_ssubset_toFinset
@[mono]
theorem toFinset_ssubset_toFinset [Fintype s] [Fintype t] : s.toFinset ⊂ t.toFinset ↔ s ⊂ t 
Arguments: {α : Type u_1} {s t : Set α} [Fintype ↑s] [Fintype ↑t]
Goal: s.toFinset ⊂ t.toFinset ↔ s ⊂ t
-- Set.toFinset_subset
@[simp]
theorem toFinset_subset [Fintype s] {t : Finset α} : s.toFinset ⊆ t ↔ s ⊆ t 
Arguments: {α : Type u_1} {s : Set α} [Fintype ↑s] {t : Finset α}
Goal: s.toFinset ⊆ t ↔ s ⊆ ↑t
-- Set.disjoint_toFinset
@[simp]
theorem disjoint_toFinset [Fintype s] [Fintype t] :
    Disjoint s.toFinset t.toFinset ↔ Disjoint s t 
Arguments: {α : Type u_1} {s t : Set α} [Fintype ↑s] [Fintype ↑t]
Goal: Disjoint s.toFinset t.toFinset ↔ Disjoint s t
-- Set.toFinset_inter
@[simp]
theorem toFinset_inter [Fintype (s ∩ t : Set _)] : (s ∩ t).toFinset = s.toFinset ∩ t.toFinset 
Arguments: {α : Type u_1} (s t : Set α) [DecidableEq α] [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s ∩ t)]
Goal: (s ∩ t).toFinset = s.toFinset ∩ t.toFinset
-- Set.toFinset_union
@[simp]
theorem toFinset_union [Fintype (s ∪ t : Set _)] : (s ∪ t).toFinset = s.toFinset ∪ t.toFinset 
Arguments: {α : Type u_1} (s t : Set α) [DecidableEq α] [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s ∪ t)]
Goal: (s ∪ t).toFinset = s.toFinset ∪ t.toFinset
-- Set.toFinset_diff
@[simp]
theorem toFinset_diff [Fintype (s \ t : Set _)] : (s \ t).toFinset = s.toFinset \ t.toFinset 
Arguments: {α : Type u_1} (s t : Set α) [DecidableEq α] [Fintype ↑s] [Fintype ↑t] [Fintype ↑(s \ t)]
Goal: (s \ t).toFinset = s.toFinset \ t.toFinset
-- Set.toFinset_symmDiff
@[simp]
theorem toFinset_symmDiff [Fintype (s ∆ t : Set _)] :
    (s ∆ t).toFinset = s.toFinset ∆ t.toFinset 
Arguments: {α : Type u_1} (s t : Set α) [DecidableEq α] [Fintype ↑s] [Fintype ↑t] [Fintype ↑(symmDiff s t)]
Goal: (symmDiff s t).toFinset = symmDiff s.toFinset t.toFinset
-- Set.toFinset_compl
@[simp]
theorem toFinset_compl [Fintype α] [Fintype (sᶜ : Set _)] : sᶜ.toFinset = s.toFinsetᶜ 
Arguments: {α : Type u_1} (s : Set α) [DecidableEq α] [Fintype ↑s] [Fintype α] [Fintype ↑sᶜ]
Goal: sᶜ.toFinset = s.toFinsetᶜ
-- Set.toFinset_empty
@[simp]
theorem toFinset_empty [Fintype (∅ : Set α)] : (∅ : Set α).toFinset = ∅ 
Arguments: {α : Type u_1} [Fintype ↑∅]
Goal: ∅.toFinset = ∅
-- Set.toFinset_univ
@[simp]
theorem toFinset_univ [Fintype α] [Fintype (Set.univ : Set α)] :
    (Set.univ : Set α).toFinset = Finset.univ 
Arguments: {α : Type u_1} [Fintype α] [Fintype ↑Set.univ]
Goal: Set.univ.toFinset = Finset.univ
-- Set.toFinset_eq_empty
@[simp]
theorem toFinset_eq_empty [Fintype s] : s.toFinset = ∅ ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Set α} [Fintype ↑s]
Goal: s.toFinset = ∅ ↔ s = ∅
-- Set.toFinset_eq_univ
@[simp]
theorem toFinset_eq_univ [Fintype α] [Fintype s] : s.toFinset = Finset.univ ↔ s = univ 
Arguments: {α : Type u_1} {s : Set α} [Fintype α] [Fintype ↑s]
Goal: s.toFinset = Finset.univ ↔ s = Set.univ
-- Set.toFinset_setOf
@[simp]
theorem toFinset_setOf [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { x | p x }] :
    { x | p x }.toFinset = Finset.univ.filter p 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype ↑{x | p x}]
Goal: {x | p x}.toFinset = Finset.filter p Finset.univ
-- Set.toFinset_ssubset_univ
theorem toFinset_ssubset_univ [Fintype α] {s : Set α} [Fintype s] :
    s.toFinset ⊂ Finset.univ ↔ s ⊂ univ 
Arguments: {α : Type u_1} [Fintype α] {s : Set α} [Fintype ↑s]
Goal: s.toFinset ⊂ Finset.univ ↔ s ⊂ Set.univ
-- Set.toFinset_image
@[simp]
theorem toFinset_image [DecidableEq β] (f : α → β) (s : Set α) [Fintype s] [Fintype (f '' s)] :
    (f '' s).toFinset = s.toFinset.image f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (f : α → β) (s : Set α) [Fintype ↑s] [Fintype ↑(f '' s)]
Goal: (f '' s).toFinset = Finset.image f s.toFinset
-- Set.toFinset_range
@[simp]
theorem toFinset_range [DecidableEq α] [Fintype β] (f : β → α) [Fintype (Set.range f)] :
    (Set.range f).toFinset = Finset.univ.image f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [Fintype β] (f : β → α) [Fintype ↑(Set.range f)]
Goal: (Set.range f).toFinset = Finset.image f Finset.univ
-- Set.toFinset_singleton
@[simp] -- Porting note: new attribute
theorem toFinset_singleton (a : α) [Fintype ({a} : Set α)] : ({a} : Set α).toFinset = {a} 
Arguments: {α : Type u_1} (a : α) [Fintype ↑{a}]
Goal: {a}.toFinset = {a}
-- Set.toFinset_insert
@[simp]
theorem toFinset_insert [DecidableEq α] {a : α} {s : Set α} [Fintype (insert a s : Set α)]
    [Fintype s] : (insert a s).toFinset = insert a s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Set α} [Fintype ↑(insert a s)] [Fintype ↑s]
Goal: (insert a s).toFinset = insert a s.toFinset
-- Set.filter_mem_univ_eq_toFinset
theorem filter_mem_univ_eq_toFinset [Fintype α] (s : Set α) [Fintype s] [DecidablePred (· ∈ s)] :
    Finset.univ.filter (· ∈ s) = s.toFinset 
Arguments: {α : Type u_1} [Fintype α] (s : Set α) [Fintype ↑s] [DecidablePred fun x => x ∈ s]
Goal: Finset.filter (fun x => x ∈ s) Finset.univ = s.toFinset
-- Finset.toFinset_coe
@[simp]
theorem Finset.toFinset_coe (s : Finset α) [Fintype (s : Set α)] : (s : Set α).toFinset = s 
Arguments: {α : Type u_1} (s : Finset α) [Fintype ↑↑s]
Goal: (↑s).toFinset = s
-- Fin.univ_def
theorem Fin.univ_def (n : ℕ) : (univ : Finset (Fin n)) = ⟨List.finRange n, List.nodup_finRange n⟩ 
Arguments: (n : ℕ)
Goal: Finset.univ = { val := ↑(List.finRange n), nodup := ⋯ }
-- List.toFinset_finRange
@[simp] theorem List.toFinset_finRange (n : ℕ) : (List.finRange n).toFinset = Finset.univ 
Arguments: (n : ℕ)
Goal: (List.finRange n).toFinset = Finset.univ
-- Fin.univ_val_map
@[simp] theorem Fin.univ_val_map {n : ℕ} (f : Fin n → α) :
    Finset.univ.val.map f = List.ofFn f 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n → α)
Goal: Multiset.map f Finset.univ.val = ↑(List.ofFn f)
-- Fin.univ_image_def
theorem Fin.univ_image_def {n : ℕ} [DecidableEq α] (f : Fin n → α) :
    Finset.univ.image f = (List.ofFn f).toFinset 
Arguments: {α : Type u_1} {n : ℕ} [DecidableEq α] (f : Fin n → α)
Goal: Finset.image f Finset.univ = (List.ofFn f).toFinset
-- Fin.univ_map_def
theorem Fin.univ_map_def {n : ℕ} (f : Fin n ↪ α) :
    Finset.univ.map f = ⟨List.ofFn f, List.nodup_ofFn.mpr f.injective⟩ 
Arguments: {α : Type u_1} {n : ℕ} (f : Fin n ↪ α)
Goal: Finset.map f Finset.univ = { val := ↑(List.ofFn ⇑f), nodup := ⋯ }
-- Fin.image_succAbove_univ
@[simp]
theorem Fin.image_succAbove_univ {n : ℕ} (i : Fin (n + 1)) : univ.image i.succAbove = {i}ᶜ 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: Finset.image i.succAbove Finset.univ = {i}ᶜ
-- Fin.image_succ_univ
@[simp]
theorem Fin.image_succ_univ (n : ℕ) : (univ : Finset (Fin n)).image Fin.succ = {0}ᶜ 
Arguments: (n : ℕ)
Goal: Finset.image Fin.succ Finset.univ = {0}ᶜ
-- Fin.image_castSucc
@[simp]
theorem Fin.image_castSucc (n : ℕ) :
    (univ : Finset (Fin n)).image Fin.castSucc = {Fin.last n}ᶜ 
Arguments: (n : ℕ)
Goal: Finset.image Fin.castSucc Finset.univ = {Fin.last n}ᶜ
-- Fin.univ_succ
theorem Fin.univ_succ (n : ℕ) :
    (univ : Finset (Fin (n + 1))) =
      Finset.cons 0 (univ.map ⟨Fin.succ, Fin.succ_injective _⟩) (by simp [map_eq_image]) 
Arguments: (n : ℕ)
Goal: Finset.univ = Finset.cons 0 (Finset.map { toFun := Fin.succ, inj' := ⋯ } Finset.univ) ⋯
-- Fin.univ_castSuccEmb
theorem Fin.univ_castSuccEmb (n : ℕ) :
    (univ : Finset (Fin (n + 1))) =
      Finset.cons (Fin.last n) (univ.map Fin.castSuccEmb) (by simp [map_eq_image]) 
Arguments: (n : ℕ)
Goal: Finset.univ = Finset.cons (Fin.last n) (Finset.map Fin.castSuccEmb Finset.univ) ⋯
-- Fin.univ_succAbove
theorem Fin.univ_succAbove (n : ℕ) (p : Fin (n + 1)) :
    (univ : Finset (Fin (n + 1))) = Finset.cons p (univ.map <| Fin.succAboveEmb p) (by simp) 
Arguments: (n : ℕ) (p : Fin (n + 1))
Goal: Finset.univ = Finset.cons p (Finset.map p.succAboveEmb Finset.univ) ⋯
-- Fin.univ_image_get
@[simp] theorem Fin.univ_image_get [DecidableEq α] (l : List α) :
    Finset.univ.image l.get = l.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: Finset.image l.get Finset.univ = l.toFinset
-- Fin.univ_image_getElem'
@[simp] theorem Fin.univ_image_getElem' [DecidableEq β] (l : List α) (f : α → β) :
    Finset.univ.image (fun i : Fin l.length => f <| l[(i : Nat)]) = (l.map f).toFinset 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (l : List α) (f : α → β)
Goal: Finset.image (fun i => f l[↑i]) Finset.univ = (List.map f l).toFinset
-- Fin.univ_image_get'
theorem Fin.univ_image_get' [DecidableEq β] (l : List α) (f : α → β) :
    Finset.univ.image (f <| l.get ·) = (l.map f).toFinset 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (l : List α) (f : α → β)
Goal: Finset.image (fun x => f (l.get x)) Finset.univ = (List.map f l).toFinset
-- Fintype.univ_empty
theorem Fintype.univ_empty : @univ Empty _ = ∅ 
Goal: Finset.univ = ∅
-- Fintype.univ_pempty
theorem Fintype.univ_pempty : @univ PEmpty _ = ∅ 
Goal: Finset.univ = ∅
-- Fintype.univ_unit
theorem Fintype.univ_unit : @univ Unit _ = {()} 
Goal: Finset.univ = {()}
-- Fintype.univ_punit
theorem Fintype.univ_punit : @univ PUnit _ = {PUnit.unit} 
Goal: Finset.univ = {PUnit.unit}
-- Fintype.univ_bool
@[simp]
theorem Fintype.univ_bool : @univ Bool _ = {true, false} 
Goal: Finset.univ = {true, false}
-- Finset.univ_eq_attach
@[simp]
theorem Finset.univ_eq_attach {α : Type u} (s : Finset α) : (univ : Finset s) = s.attach 
Arguments: {α : Type u} (s : Finset α)
Goal: Finset.univ = s.attach
-- Fintype.coe_image_univ
theorem Fintype.coe_image_univ [Fintype α] [DecidableEq β] {f : α → β} :
    ↑(Finset.image f Finset.univ) = Set.range f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β}
Goal: ↑(Finset.image f Finset.univ) = Set.range f
-- Finset.attach_eq_univ
theorem Finset.attach_eq_univ {s : Finset α} : s.attach = Finset.univ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.attach = Finset.univ
-- Fintype.univ_Prop
@[simp]
theorem Fintype.univ_Prop : (Finset.univ : Finset Prop) = {True, False} 
Goal: Finset.univ = {True, False}
-- Fintype.coe_finsetEquivSet
@[simp, norm_cast] lemma coe_finsetEquivSet : ⇑finsetEquivSet = ((↑) : Finset α → Set α) 
Arguments: {α : Type u_1} [Fintype α]
Goal: ⇑Fintype.finsetEquivSet = Finset.toSet
-- Fintype.finsetEquivSet_apply
@[simp] lemma finsetEquivSet_apply (s : Finset α) : finsetEquivSet s = s 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α)
Goal: Fintype.finsetEquivSet s = ↑s
-- Fintype.finsetEquivSet_symm_apply
@[simp] lemma finsetEquivSet_symm_apply (s : Set α) [Fintype s] :
    finsetEquivSet.symm s = s.toFinset 
Arguments: {α : Type u_1} [Fintype α] (s : Set α) [Fintype ↑s]
Goal: Fintype.finsetEquivSet.symm s = s.toFinset
-- Fintype.finsetOrderIsoSet_toEquiv
@[simps toEquiv]
noncomputable def finsetOrderIsoSet : Finset α ≃o Set α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Fintype.finsetOrderIsoSet.toEquiv = Fintype.finsetEquivSet
-- Fintype.coe_finsetOrderIsoSet
@[simp, norm_cast]
lemma coe_finsetOrderIsoSet : ⇑finsetOrderIsoSet = ((↑) : Finset α → Set α) 
Arguments: {α : Type u_1} [Fintype α]
Goal: ⇑Fintype.finsetOrderIsoSet = Finset.toSet
-- Fintype.coe_finsetOrderIsoSet_symm
@[simp] lemma coe_finsetOrderIsoSet_symm :
    ⇑(finsetOrderIsoSet : Finset α ≃o Set α).symm = ⇑finsetEquivSet.symm 
Arguments: {α : Type u_1} [Fintype α]
Goal: ⇑Fintype.finsetOrderIsoSet.symm = ⇑Fintype.finsetEquivSet.symm
-- mem_image_univ_iff_mem_range
theorem mem_image_univ_iff_mem_range {α β : Type*} [Fintype α] [DecidableEq β] {f : α → β}
    {b : β} : b ∈ univ.image f ↔ b ∈ Set.range f 
Arguments: {α : Type u_4} {β : Type u_5} [Fintype α] [DecidableEq β] {f : α → β} {b : β}
Goal: b ∈ Finset.image f Finset.univ ↔ b ∈ Set.range f
-- Fintype.choose_spec
theorem choose_spec (hp : ∃! a, p a) : p (choose p hp) 
Arguments: {α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] (hp : ∃! a, p a)
Goal: p (Fintype.choose p hp)
-- Fintype.choose_subtype_eq
theorem choose_subtype_eq {α : Type*} (p : α → Prop) [Fintype { a : α // p a }] [DecidableEq α]
    (x : { a : α // p a })
    (h : ∃! a : { a // p a }, (a : α) = x :=
      ⟨x, rfl, fun y hy => by simpa [Subtype.ext_iff] using hy⟩) :
    Fintype.choose (fun y : { a : α // p a } => (y : α) = x) h = x 
Arguments: {α : Type u_4} (p : α → Prop) [Fintype { a // p a }] [DecidableEq α] (x : { a // p a }) (h : ∃! a, ↑a = ↑x := ⋯)
Goal: Fintype.choose (fun y => ↑y = ↑x) h = x
-- Fintype.leftInverse_bijInv
theorem leftInverse_bijInv (f_bij : Bijective f) : LeftInverse (bijInv f_bij) f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (f_bij : Function.Bijective f)
Goal: Function.LeftInverse (Fintype.bijInv f_bij) f
-- Fintype.rightInverse_bijInv
theorem rightInverse_bijInv (f_bij : Bijective f) : RightInverse (bijInv f_bij) f 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {f : α → β} (f_bij : Function.Bijective f)
Goal: Function.RightInverse (Fintype.bijInv f_bij) f