File: Mathlib/Control/Applicative.lean

full_name: Applicative.map_seq_map
code: theorem Applicative.map_seq_map (f : α → β → γ) (g : σ → β) (x : F α) (y : F σ) :
    f <$> x <*> g <$> y = ((· ∘ g) ∘ f) <$> x <*> y 
goal: (Seq.seq (f <$> x) fun x => g <$> y) = Seq.seq (((fun x => x ∘ g) ∘ f) <$> x) fun x => y

full_name: Applicative.pure_seq_eq_map'
code: theorem Applicative.pure_seq_eq_map' (f : α → β) : ((pure f : F (α → β)) <*> ·) = (f <$> ·) 
goal: (fun x => Seq.seq (pure f) fun x_1 => x) = fun x => f <$> x

full_name: Applicative.ext
code: theorem Applicative.ext {F} :
    ∀ {A1 : Applicative F} {A2 : Applicative F} [@LawfulApplicative F A1] [@LawfulApplicative F A2],
      (∀ {α : Type u} (x : α), @Pure.pure _ A1.toPure _ x = @Pure.pure _ A2.toPure _ x) →
      (∀ {α β : Type u} (f : F (α → β)) (x : F α),
          @Seq.seq _ A1.toSeq _ _ f (fun _ => x) = @Seq.seq _ A2.toSeq _ _ f (fun _ => x)) →
      A1 = A2
  
goal: (∀ {α : Type u} (x : α), pure x = pure x) →
  (∀ {α β : Type u} (f : F (α → β)) (x : F α), (Seq.seq f fun x_1 => x) = Seq.seq f fun x_1 => x) → A1 = A2

full_name: instCommApplicativeId
code: instance : CommApplicative Id 
goal: CommApplicative Id

full_name: Functor.Comp.map_pure
code: theorem map_pure (f : α → β) (x : α) : (f <$> pure x : Comp F G β) = pure (f x) 
goal: f <$> pure x = pure (f x)

full_name: Functor.Comp.seq_pure
code: theorem seq_pure (f : Comp F G (α → β)) (x : α) : f <*> pure x = (fun g : α → β => g x) <$> f 
goal: (Seq.seq f fun x_1 => pure x) = (fun g => g x) <$> f

full_name: Functor.Comp.seq_assoc
code: theorem seq_assoc (x : Comp F G α) (f : Comp F G (α → β)) (g : Comp F G (β → γ)) :
    g <*> (f <*> x) = @Function.comp α β γ <$> g <*> f <*> x 
goal: (Seq.seq g fun x_1 => Seq.seq f fun x_2 => x) = Seq.seq (Seq.seq (Function.comp <$> g) fun x => f) fun x_1 => x

full_name: Functor.Comp.pure_seq_eq_map
code: theorem pure_seq_eq_map (f : α → β) (x : Comp F G α) : pure f <*> x = f <$> x 
goal: (Seq.seq (pure f) fun x_1 => x) = f <$> x

full_name: Functor.Comp.instLawfulApplicativeComp
code: instance instLawfulApplicativeComp : LawfulApplicative (Comp F G) 
goal: LawfulApplicative (Functor.Comp F G)

full_name: Functor.Comp.applicative_id_comp
code: theorem applicative_id_comp {F} [AF : Applicative F] [LawfulApplicative F] :
    @instApplicativeComp Id F _ _ = AF 
goal: Functor.Comp.instApplicativeComp = AF

full_name: Functor.Comp.applicative_comp_id
code: theorem applicative_comp_id {F} [AF : Applicative F] [LawfulApplicative F] :
    @Comp.instApplicativeComp F Id _ _ = AF 
goal: Functor.Comp.instApplicativeComp = AF

full_name: Functor.Comp.instCommApplicative
code: instance {f : Type u → Type w} {g : Type v → Type u} [Applicative f] [Applicative g]
    [CommApplicative f] [CommApplicative g] : CommApplicative (Comp f g) 
goal: CommApplicative (Functor.Comp f g)

full_name: Comp.seq_mk
code: @[functor_norm]
theorem Comp.seq_mk {α β : Type w} {f : Type u → Type v} {g : Type w → Type u} [Applicative f]
    [Applicative g] (h : f (g (α → β))) (x : f (g α)) :
    Comp.mk h <*> Comp.mk x = Comp.mk ((· <*> ·) <$> h <*> x) 
goal: (Seq.seq (Functor.Comp.mk h) fun x_1 => Functor.Comp.mk x) =
  Functor.Comp.mk (Seq.seq ((fun x x_1 => Seq.seq x fun x => x_1) <$> h) fun x_1 => x)

full_name: instApplicativeConstOfOneOfMul
code: instance {α} [One α] [Mul α] : Applicative (Const α) 
goal: Applicative (Functor.Const α)

full_name: instLawfulApplicativeConst
code: instance {α} [Monoid α] : LawfulApplicative (Const α) 
goal: LawfulApplicative (Functor.Const α)

full_name: instApplicativeAddConstOfZeroOfAdd
code: instance {α} [Zero α] [Add α] : Applicative (AddConst α) 
goal: Applicative (Functor.AddConst α)

full_name: instLawfulApplicativeAddConst
code: instance {α} [AddMonoid α] : LawfulApplicative (AddConst α) 
goal: LawfulApplicative (Functor.AddConst α)