File: Mathlib/Control/Traversable/Lemmas.lean

full_name: Traversable.PureTransformation
code: /-- The natural applicative transformation from the identity functor
to `F`, defined by `pure : Π {α}, α → F α`. -/
def PureTransformation :
    ApplicativeTransformation Id F 
goal: ApplicativeTransformation Id F

full_name: Traversable.pureTransformation_apply
code: @[simp]
theorem pureTransformation_apply {α} (x : id α) : PureTransformation F x = pure x 
goal: (fun {α} => (Traversable.PureTransformation F).app α) x = pure x

full_name: Traversable.map_eq_traverse_id
code: theorem map_eq_traverse_id : map (f := t) f = traverse (m := Id) (pure ∘ f) 
goal: Functor.map f = traverse (pure ∘ f)

full_name: Traversable.map_traverse
code: theorem map_traverse (x : t α) : map f <$> traverse g x = traverse (map f ∘ g) x 
goal: Functor.map f <$> traverse g x = traverse (Functor.map f ∘ g) x

full_name: Traversable.traverse_map
code: theorem traverse_map (f : β → F γ) (g : α → β) (x : t α) :
    traverse f (g <$> x) = traverse (f ∘ g) x 
goal: traverse f (g <$> x) = traverse (f ∘ g) x

full_name: Traversable.pure_traverse
code: theorem pure_traverse (x : t α) : traverse pure x = (pure x : F (t α)) 
goal: traverse pure x = pure x

full_name: Traversable.id_sequence
code: theorem id_sequence (x : t α) : sequence (f := Id) (pure <$> x) = pure x 
goal: sequence (pure <$> x) = pure x

full_name: Traversable.comp_sequence
code: theorem comp_sequence (x : t (F (G α))) :
    sequence (Comp.mk <$> x) = Comp.mk (sequence <$> sequence x) 
goal: sequence (Functor.Comp.mk <$> x) = Functor.Comp.mk (sequence <$> sequence x)

full_name: Traversable.naturality'
code: theorem naturality' (η : ApplicativeTransformation F G) (x : t (F α)) :
    η (sequence x) = sequence (@η _ <$> x) 
goal: (fun {α} => η.app α) (sequence x) = sequence ((fun {α} => η.app α) <$> x)

full_name: Traversable.traverse_id
code: @[functor_norm]
theorem traverse_id : traverse pure = (pure : t α → Id (t α)) 
goal: traverse pure = pure

full_name: Traversable.traverse_comp
code: @[functor_norm]
theorem traverse_comp (g : α → F β) (h : β → G γ) :
    traverse (Comp.mk ∘ map h ∘ g) =
      (Comp.mk ∘ map (traverse h) ∘ traverse g : t α → Comp F G (t γ)) 
goal: traverse (Functor.Comp.mk ∘ Functor.map h ∘ g) = Functor.Comp.mk ∘ Functor.map (traverse h) ∘ traverse g

full_name: Traversable.traverse_eq_map_id'
code: theorem traverse_eq_map_id' (f : β → γ) :
    traverse (m := Id) (pure ∘ f) = pure ∘ (map f : t β → t γ) 
goal: traverse (pure ∘ f) = pure ∘ Functor.map f

full_name: Traversable.traverse_map'
code: theorem traverse_map' (g : α → β) (h : β → G γ) :
    traverse (h ∘ g) = (traverse h ∘ map g : t α → G (t γ)) 
goal: traverse (h ∘ g) = traverse h ∘ Functor.map g

full_name: Traversable.map_traverse'
code: theorem map_traverse' (g : α → G β) (h : β → γ) :
    traverse (map h ∘ g) = (map (map h) ∘ traverse g : t α → G (t γ)) 
goal: traverse (Functor.map h ∘ g) = Functor.map (Functor.map h) ∘ traverse g

full_name: Traversable.naturality_pf
code: theorem naturality_pf (η : ApplicativeTransformation F G) (f : α → F β) :
    traverse (@η _ ∘ f) = @η _ ∘ (traverse f : t α → F (t β)) 
goal: traverse ((fun {α} => η.app α) ∘ f) = (fun {α} => η.app α) ∘ traverse f