File: Mathlib/Data/Finset/Functor.lean

full_name: Finset.functor
code: /-- Because `Finset.image` requires a `DecidableEq` instance for the target type, we can only
construct `Functor Finset` when working classically. -/
protected instance functor : Functor Finset 
goal: Functor Finset

full_name: Finset.lawfulFunctor
code: instance lawfulFunctor : LawfulFunctor Finset 
goal: LawfulFunctor Finset

full_name: Finset.fmap_def
code: @[simp]
theorem fmap_def {s : Finset α} (f : α → β) : f <$> s = s.image f 
goal: f <$> s = Finset.image f s

full_name: Finset.pure
code: protected instance pure : Pure Finset 
goal: Pure Finset

full_name: Finset.pure_def
code: @[simp]
theorem pure_def {α} : (pure : α → Finset α) = singleton 
goal: pure = singleton

full_name: Finset.applicative
code: protected instance applicative : Applicative Finset 
goal: Applicative Finset

full_name: Finset.seq_def
code: @[simp]
theorem seq_def (s : Finset α) (t : Finset (α → β)) : t <*> s = t.sup fun f => s.image f 
goal: (Seq.seq t fun x => s) = t.sup fun f => Finset.image f s

full_name: Finset.seqLeft_def
code: @[simp]
theorem seqLeft_def (s : Finset α) (t : Finset β) : s <* t = if t = ∅ then ∅ else s 
goal: (SeqLeft.seqLeft s fun x => t) = if t = ∅ then ∅ else s

full_name: Finset.seqRight_def
code: @[simp]
theorem seqRight_def (s : Finset α) (t : Finset β) : s *> t = if s = ∅ then ∅ else t 
goal: (SeqRight.seqRight s fun x => t) = if s = ∅ then ∅ else t

full_name: Finset.image₂_def
code: /-- `Finset.image₂` in terms of monadic operations. Note that this can't be taken as the definition
because of the lack of universe polymorphism. -/
theorem image₂_def {α β γ : Type u} (f : α → β → γ) (s : Finset α) (t : Finset β) :
    image₂ f s t = f <$> s <*> t 
goal: Finset.image₂ f s t = Seq.seq (f <$> s) fun x => t

full_name: Finset.lawfulApplicative
code: instance lawfulApplicative : LawfulApplicative Finset 
goal: LawfulApplicative Finset

full_name: Finset.commApplicative
code: instance commApplicative : CommApplicative Finset 
goal: CommApplicative Finset

full_name: Finset.instMonad
code: instance : Monad Finset 
goal: Monad Finset

full_name: Finset.bind_def
code: @[simp]
theorem bind_def {α β} : (· >>= ·) = sup (α := Finset α) (β := β) 
goal: (fun x x_1 => x >>= x_1) = Finset.sup

full_name: Finset.instLawfulMonad
code: instance : LawfulMonad Finset 
goal: LawfulMonad Finset

full_name: Finset.instAlternative
code: instance : Alternative Finset 
goal: Alternative Finset

full_name: Finset.traverse
code: /-- Traverse function for `Finset`. -/
def traverse [DecidableEq β] (f : α → F β) (s : Finset α) : F (Finset β) 
goal: F (Finset β)

full_name: Finset.id_traverse
code: @[simp]
theorem id_traverse [DecidableEq α] (s : Finset α) : traverse (pure : α → Id α) s = s 
goal: Finset.traverse pure s = s

full_name: Finset.map_comp_coe
code: @[simp]
theorem map_comp_coe (h : α → β) :
    Functor.map h ∘ Multiset.toFinset = Multiset.toFinset ∘ Functor.map h 
goal: Functor.map h ∘ Multiset.toFinset = Multiset.toFinset ∘ Functor.map h

full_name: Finset.map_traverse
code: theorem map_traverse (g : α → G β) (h : β → γ) (s : Finset α) :
    Functor.map h <$> traverse g s = traverse (Functor.map h ∘ g) s 
goal: Functor.map h <$> Finset.traverse g s = Finset.traverse (Functor.map h ∘ g) s