File: Mathlib/Topology/Algebra/ContinuousMonoidHom.lean

full_name: ContinuousAddMonoidHom.continuous_toFun
code: /-- The type of continuous additive monoid homomorphisms from `A` to `B`.

When possible, instead of parametrizing results over `(f : ContinuousAddMonoidHom A B)`,
you should parametrize over `(F : Type*) [ContinuousAddMonoidHomClass F A B] (f : F)`.

When you extend this structure, make sure to extend `ContinuousAddMonoidHomClass`. -/
structure ContinuousAddMonoidHom (A B : Type*) [AddMonoid A] [AddMonoid B] [TopologicalSpace A]
  [TopologicalSpace B] extends A →+ B where
  /-- Proof of continuity of the Hom. -/
  continuous_toFun : @Continuous A B _ _ toFun
goal: Continuous (↑self.toAddMonoidHom).toFun

full_name: ContinuousAddMonoidHom
code: /-- The type of continuous additive monoid homomorphisms from `A` to `B`.

When possible, instead of parametrizing results over `(f : ContinuousAddMonoidHom A B)`,
you should parametrize over `(F : Type*) [ContinuousAddMonoidHomClass F A B] (f : F)`.

When you extend this structure, make sure to extend `ContinuousAddMonoidHomClass`. -/
structure ContinuousAddMonoidHom (A B : Type*) [AddMonoid A] [AddMonoid B] [TopologicalSpace A]
  [TopologicalSpace B] extends A →+ B where
  /-- Proof of continuity of the Hom. -/
  continuous_toFun : @Continuous A B _ _ toFun
goal: Type (max u_7 u_8)

full_name: ContinuousMonoidHom.continuous_toFun
code: /-- The type of continuous monoid homomorphisms from `A` to `B`.

When possible, instead of parametrizing results over `(f : ContinuousMonoidHom A B)`,
you should parametrize over `(F : Type*) [ContinuousMonoidHomClass F A B] (f : F)`.

When you extend this structure, make sure to extend `ContinuousAddMonoidHomClass`. -/
@[to_additive "The type of continuous additive monoid homomorphisms from `A` to `B`."]
structure ContinuousMonoidHom extends A →* B where
  /-- Proof of continuity of the Hom. -/
  continuous_toFun : @Continuous A B _ _ toFun
goal: Continuous (↑self.toMonoidHom).toFun

full_name: ContinuousMonoidHom
code: /-- The type of continuous monoid homomorphisms from `A` to `B`.

When possible, instead of parametrizing results over `(f : ContinuousMonoidHom A B)`,
you should parametrize over `(F : Type*) [ContinuousMonoidHomClass F A B] (f : F)`.

When you extend this structure, make sure to extend `ContinuousAddMonoidHomClass`. -/
@[to_additive "The type of continuous additive monoid homomorphisms from `A` to `B`."]
structure ContinuousMonoidHom extends A →* B where
  /-- Proof of continuity of the Hom. -/
  continuous_toFun : @Continuous A B _ _ toFun
goal: Type (max u_2 u_3)

full_name: ContinuousAddMonoidHomClass.map_continuous
code: /-- `ContinuousAddMonoidHomClass F A B` states that `F` is a type of continuous additive monoid
homomorphisms.

You should also extend this typeclass when you extend `ContinuousAddMonoidHom`. -/
-- Porting note: Changed A B to outParam to help synthesizing order
class ContinuousAddMonoidHomClass (A B : outParam Type*) [AddMonoid A] [AddMonoid B]
    [TopologicalSpace A] [TopologicalSpace B] [FunLike F A B]
    extends AddMonoidHomClass F A B : Prop where
  /-- Proof of the continuity of the map. -/
  map_continuous (f : F) : Continuous f
goal: Continuous ⇑f

full_name: ContinuousAddMonoidHomClass
code: /-- `ContinuousAddMonoidHomClass F A B` states that `F` is a type of continuous additive monoid
homomorphisms.

You should also extend this typeclass when you extend `ContinuousAddMonoidHom`. -/
-- Porting note: Changed A B to outParam to help synthesizing order
class ContinuousAddMonoidHomClass (A B : outParam Type*) [AddMonoid A] [AddMonoid B]
    [TopologicalSpace A] [TopologicalSpace B] [FunLike F A B]
    extends AddMonoidHomClass F A B : Prop where
  /-- Proof of the continuity of the map. -/
  map_continuous (f : F) : Continuous f
goal: Prop

full_name: ContinuousMonoidHomClass.map_continuous
code: /-- `ContinuousMonoidHomClass F A B` states that `F` is a type of continuous monoid
homomorphisms.

You should also extend this typeclass when you extend `ContinuousMonoidHom`. -/
-- Porting note: Changed A B to outParam to help synthesizing order
@[to_additive]
class ContinuousMonoidHomClass (A B : outParam Type*) [Monoid A] [Monoid B]
    [TopologicalSpace A] [TopologicalSpace B] [FunLike F A B]
    extends MonoidHomClass F A B : Prop where
  /-- Proof of the continuity of the map. -/
  map_continuous (f : F) : Continuous f
goal: Continuous ⇑f

full_name: ContinuousMonoidHomClass
code: /-- `ContinuousMonoidHomClass F A B` states that `F` is a type of continuous monoid
homomorphisms.

You should also extend this typeclass when you extend `ContinuousMonoidHom`. -/
-- Porting note: Changed A B to outParam to help synthesizing order
@[to_additive]
class ContinuousMonoidHomClass (A B : outParam Type*) [Monoid A] [Monoid B]
    [TopologicalSpace A] [TopologicalSpace B] [FunLike F A B]
    extends MonoidHomClass F A B : Prop where
  /-- Proof of the continuity of the map. -/
  map_continuous (f : F) : Continuous f
goal: Prop

full_name: ContinuousMonoidHomClass.toContinuousMapClass
code: @[to_additive]
instance (priority := 100) ContinuousMonoidHomClass.toContinuousMapClass
    [FunLike F A B] [ContinuousMonoidHomClass F A B] : ContinuousMapClass F A B 
goal: ContinuousMapClass F A B

full_name: ContinuousAddMonoidHomClass.toContinuousMapClass
code: @[to_additive]
instance (priority := 100) ContinuousMonoidHomClass.toContinuousMapClass
    [FunLike F A B] [ContinuousMonoidHomClass F A B] : ContinuousMapClass F A B 
goal: ContinuousMapClass F A B

full_name: ContinuousMonoidHom.funLike
code: @[to_additive]
instance funLike : FunLike (ContinuousMonoidHom A B) A B 
goal: FunLike (ContinuousMonoidHom A B) A B

full_name: ContinuousAddMonoidHom.funLike
code: @[to_additive]
instance funLike : FunLike (ContinuousMonoidHom A B) A B 
goal: FunLike (ContinuousAddMonoidHom A B) A B

full_name: ContinuousAddMonoidHom.ContinuousAddMonoidHomClass
code: @[to_additive]
instance ContinuousMonoidHomClass : ContinuousMonoidHomClass (ContinuousMonoidHom A B) A B 
goal: ContinuousAddMonoidHomClass (ContinuousAddMonoidHom A B) A B

full_name: ContinuousMonoidHom.ContinuousMonoidHomClass
code: @[to_additive]
instance ContinuousMonoidHomClass : ContinuousMonoidHomClass (ContinuousMonoidHom A B) A B 
goal: ContinuousMonoidHomClass (ContinuousMonoidHom A B) A B

full_name: ContinuousAddMonoidHom.ext
code: @[to_additive (attr := ext)]
theorem ext {f g : ContinuousMonoidHom A B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousMonoidHom.ext
code: @[to_additive (attr := ext)]
theorem ext {f g : ContinuousMonoidHom A B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousMonoidHom.toContinuousMap
code: /-- Reinterpret a `ContinuousMonoidHom` as a `ContinuousMap`. -/
@[to_additive "Reinterpret a `ContinuousAddMonoidHom` as a `ContinuousMap`."]
def toContinuousMap (f : ContinuousMonoidHom A B) : C(A, B) 
goal: C(A, B)

full_name: ContinuousAddMonoidHom.toContinuousMap
code: /-- Reinterpret a `ContinuousMonoidHom` as a `ContinuousMap`. -/
@[to_additive "Reinterpret a `ContinuousAddMonoidHom` as a `ContinuousMap`."]
def toContinuousMap (f : ContinuousMonoidHom A B) : C(A, B) 
goal: C(A, B)

full_name: ContinuousAddMonoidHom.toContinuousMap_injective
code: @[to_additive]
theorem toContinuousMap_injective : Injective (toContinuousMap : _ → C(A, B)) 
goal: Function.Injective ContinuousAddMonoidHom.toContinuousMap

full_name: ContinuousMonoidHom.toContinuousMap_injective
code: @[to_additive]
theorem toContinuousMap_injective : Injective (toContinuousMap : _ → C(A, B)) 
goal: Function.Injective ContinuousMonoidHom.toContinuousMap

full_name: ContinuousMonoidHom.mk'
code: /-- Construct a `ContinuousMonoidHom` from a `Continuous` `MonoidHom`. -/
@[to_additive "Construct a `ContinuousAddMonoidHom` from a `Continuous` `AddMonoidHom`."]
def mk' (f : A →* B) (hf : Continuous f) : ContinuousMonoidHom A B 
goal: ContinuousMonoidHom A B

full_name: ContinuousAddMonoidHom.mk'
code: /-- Construct a `ContinuousMonoidHom` from a `Continuous` `MonoidHom`. -/
@[to_additive "Construct a `ContinuousAddMonoidHom` from a `Continuous` `AddMonoidHom`."]
def mk' (f : A →* B) (hf : Continuous f) : ContinuousMonoidHom A B 
goal: ContinuousAddMonoidHom A B

full_name: ContinuousAddMonoidHom.comp_toFun
code: /-- Composition of two continuous homomorphisms. -/
@[to_additive (attr := simps!) "Composition of two continuous homomorphisms."]
def comp (g : ContinuousMonoidHom B C) (f : ContinuousMonoidHom A B) : ContinuousMonoidHom A C 
goal: ∀ (a : A), (g.comp f) a = g.toAddMonoidHom (f.toAddMonoidHom a)

full_name: ContinuousMonoidHom.comp_toFun
code: /-- Composition of two continuous homomorphisms. -/
@[to_additive (attr := simps!) "Composition of two continuous homomorphisms."]
def comp (g : ContinuousMonoidHom B C) (f : ContinuousMonoidHom A B) : ContinuousMonoidHom A C 
goal: ∀ (a : A), (g.comp f) a = g.toMonoidHom (f.toMonoidHom a)

full_name: ContinuousAddMonoidHom.comp
code: /-- Composition of two continuous homomorphisms. -/
@[to_additive (attr := simps!) "Composition of two continuous homomorphisms."]
def comp (g : ContinuousMonoidHom B C) (f : ContinuousMonoidHom A B) : ContinuousMonoidHom A C 
goal: ContinuousAddMonoidHom A C

full_name: ContinuousMonoidHom.comp
code: /-- Composition of two continuous homomorphisms. -/
@[to_additive (attr := simps!) "Composition of two continuous homomorphisms."]
def comp (g : ContinuousMonoidHom B C) (f : ContinuousMonoidHom A B) : ContinuousMonoidHom A C 
goal: ContinuousMonoidHom A C

full_name: ContinuousMonoidHom.prod_toFun
code: /-- Product of two continuous homomorphisms on the same space. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on the same space."]
def prod (f : ContinuousMonoidHom A B) (g : ContinuousMonoidHom A C) :
    ContinuousMonoidHom A (B × C) 
goal: (f.prod g) i = (f.toMonoidHom i, g.toMonoidHom i)

full_name: ContinuousAddMonoidHom.sum_toFun
code: /-- Product of two continuous homomorphisms on the same space. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on the same space."]
def prod (f : ContinuousMonoidHom A B) (g : ContinuousMonoidHom A C) :
    ContinuousMonoidHom A (B × C) 
goal: (f.sum g) i = (f.toAddMonoidHom i, g.toAddMonoidHom i)

full_name: ContinuousAddMonoidHom.sum
code: /-- Product of two continuous homomorphisms on the same space. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on the same space."]
def prod (f : ContinuousMonoidHom A B) (g : ContinuousMonoidHom A C) :
    ContinuousMonoidHom A (B × C) 
goal: ContinuousAddMonoidHom A (B × C)

full_name: ContinuousMonoidHom.prod
code: /-- Product of two continuous homomorphisms on the same space. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on the same space."]
def prod (f : ContinuousMonoidHom A B) (g : ContinuousMonoidHom A C) :
    ContinuousMonoidHom A (B × C) 
goal: ContinuousMonoidHom A (B × C)

full_name: ContinuousAddMonoidHom.sum_map_toFun
code: /-- Product of two continuous homomorphisms on different spaces. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on different spaces."]
def prod_map (f : ContinuousMonoidHom A C) (g : ContinuousMonoidHom B D) :
    ContinuousMonoidHom (A × B) (C × D) 
goal: (f.sum_map g) i = (f.toAddMonoidHom i.1, g.toAddMonoidHom i.2)

full_name: ContinuousAddMonoidHom.sum_map
code: /-- Product of two continuous homomorphisms on different spaces. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on different spaces."]
def prod_map (f : ContinuousMonoidHom A C) (g : ContinuousMonoidHom B D) :
    ContinuousMonoidHom (A × B) (C × D) 
goal: ContinuousAddMonoidHom (A × B) (C × D)

full_name: ContinuousMonoidHom.prod_map_toFun
code: /-- Product of two continuous homomorphisms on different spaces. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on different spaces."]
def prod_map (f : ContinuousMonoidHom A C) (g : ContinuousMonoidHom B D) :
    ContinuousMonoidHom (A × B) (C × D) 
goal: (f.prod_map g) i = (f.toMonoidHom i.1, g.toMonoidHom i.2)

full_name: ContinuousMonoidHom.prod_map
code: /-- Product of two continuous homomorphisms on different spaces. -/
@[to_additive (attr := simps!) "Product of two continuous homomorphisms on different spaces."]
def prod_map (f : ContinuousMonoidHom A C) (g : ContinuousMonoidHom B D) :
    ContinuousMonoidHom (A × B) (C × D) 
goal: ContinuousMonoidHom (A × B) (C × D)

full_name: ContinuousAddMonoidHom.zero_toFun
code: /-- The trivial continuous homomorphism. -/
@[to_additive (attr := simps!) "The trivial continuous homomorphism."]
def one : ContinuousMonoidHom A B 
goal: ∀ (x : A), (ContinuousAddMonoidHom.zero A B) x = 0

full_name: ContinuousAddMonoidHom.zero
code: /-- The trivial continuous homomorphism. -/
@[to_additive (attr := simps!) "The trivial continuous homomorphism."]
def one : ContinuousMonoidHom A B 
goal: ContinuousAddMonoidHom A B

full_name: ContinuousMonoidHom.one_toFun
code: /-- The trivial continuous homomorphism. -/
@[to_additive (attr := simps!) "The trivial continuous homomorphism."]
def one : ContinuousMonoidHom A B 
goal: ∀ (x : A), (ContinuousMonoidHom.one A B) x = 1

full_name: ContinuousMonoidHom.one
code: /-- The trivial continuous homomorphism. -/
@[to_additive (attr := simps!) "The trivial continuous homomorphism."]
def one : ContinuousMonoidHom A B 
goal: ContinuousMonoidHom A B

full_name: ContinuousAddMonoidHom.instInhabited
code: @[to_additive]
instance : Inhabited (ContinuousMonoidHom A B) 
goal: Inhabited (ContinuousAddMonoidHom A B)

full_name: ContinuousMonoidHom.instInhabited
code: @[to_additive]
instance : Inhabited (ContinuousMonoidHom A B) 
goal: Inhabited (ContinuousMonoidHom A B)

full_name: ContinuousMonoidHom.id_toFun
code: /-- The identity continuous homomorphism. -/
@[to_additive (attr := simps!) "The identity continuous homomorphism."]
def id : ContinuousMonoidHom A A 
goal: (ContinuousMonoidHom.id A) x = x

full_name: ContinuousMonoidHom.id
code: /-- The identity continuous homomorphism. -/
@[to_additive (attr := simps!) "The identity continuous homomorphism."]
def id : ContinuousMonoidHom A A 
goal: ContinuousMonoidHom A A

full_name: ContinuousAddMonoidHom.id_toFun
code: /-- The identity continuous homomorphism. -/
@[to_additive (attr := simps!) "The identity continuous homomorphism."]
def id : ContinuousMonoidHom A A 
goal: (ContinuousAddMonoidHom.id A) x = x

full_name: ContinuousAddMonoidHom.id
code: /-- The identity continuous homomorphism. -/
@[to_additive (attr := simps!) "The identity continuous homomorphism."]
def id : ContinuousMonoidHom A A 
goal: ContinuousAddMonoidHom A A

full_name: ContinuousMonoidHom.fst
code: /-- The continuous homomorphism given by projection onto the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the first factor."]
def fst : ContinuousMonoidHom (A × B) A 
goal: ContinuousMonoidHom (A × B) A

full_name: ContinuousAddMonoidHom.fst_toFun
code: /-- The continuous homomorphism given by projection onto the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the first factor."]
def fst : ContinuousMonoidHom (A × B) A 
goal: (ContinuousAddMonoidHom.fst A B) self = self.1

full_name: ContinuousAddMonoidHom.fst
code: /-- The continuous homomorphism given by projection onto the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the first factor."]
def fst : ContinuousMonoidHom (A × B) A 
goal: ContinuousAddMonoidHom (A × B) A

full_name: ContinuousMonoidHom.fst_toFun
code: /-- The continuous homomorphism given by projection onto the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the first factor."]
def fst : ContinuousMonoidHom (A × B) A 
goal: (ContinuousMonoidHom.fst A B) self = self.1

full_name: ContinuousAddMonoidHom.snd_toFun
code: /-- The continuous homomorphism given by projection onto the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the second factor."]
def snd : ContinuousMonoidHom (A × B) B 
goal: (ContinuousAddMonoidHom.snd A B) self = self.2

full_name: ContinuousMonoidHom.snd
code: /-- The continuous homomorphism given by projection onto the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the second factor."]
def snd : ContinuousMonoidHom (A × B) B 
goal: ContinuousMonoidHom (A × B) B

full_name: ContinuousMonoidHom.snd_toFun
code: /-- The continuous homomorphism given by projection onto the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the second factor."]
def snd : ContinuousMonoidHom (A × B) B 
goal: (ContinuousMonoidHom.snd A B) self = self.2

full_name: ContinuousAddMonoidHom.snd
code: /-- The continuous homomorphism given by projection onto the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by projection onto the second factor."]
def snd : ContinuousMonoidHom (A × B) B 
goal: ContinuousAddMonoidHom (A × B) B

full_name: ContinuousMonoidHom.inl_toFun
code: /-- The continuous homomorphism given by inclusion of the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the first factor."]
def inl : ContinuousMonoidHom A (A × B) 
goal: (ContinuousMonoidHom.inl A B) i =
  ((ContinuousMonoidHom.id A).toMonoidHom i, (ContinuousMonoidHom.one A B).toMonoidHom i)

full_name: ContinuousAddMonoidHom.inl
code: /-- The continuous homomorphism given by inclusion of the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the first factor."]
def inl : ContinuousMonoidHom A (A × B) 
goal: ContinuousAddMonoidHom A (A × B)

full_name: ContinuousAddMonoidHom.inl_toFun
code: /-- The continuous homomorphism given by inclusion of the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the first factor."]
def inl : ContinuousMonoidHom A (A × B) 
goal: (ContinuousAddMonoidHom.inl A B) i =
  ((ContinuousAddMonoidHom.id A).toAddMonoidHom i, (ContinuousAddMonoidHom.zero A B).toAddMonoidHom i)

full_name: ContinuousMonoidHom.inl
code: /-- The continuous homomorphism given by inclusion of the first factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the first factor."]
def inl : ContinuousMonoidHom A (A × B) 
goal: ContinuousMonoidHom A (A × B)

full_name: ContinuousAddMonoidHom.inr
code: /-- The continuous homomorphism given by inclusion of the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the second factor."]
def inr : ContinuousMonoidHom B (A × B) 
goal: ContinuousAddMonoidHom B (A × B)

full_name: ContinuousMonoidHom.inr_toFun
code: /-- The continuous homomorphism given by inclusion of the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the second factor."]
def inr : ContinuousMonoidHom B (A × B) 
goal: (ContinuousMonoidHom.inr A B) i =
  ((ContinuousMonoidHom.one B A).toMonoidHom i, (ContinuousMonoidHom.id B).toMonoidHom i)

full_name: ContinuousMonoidHom.inr
code: /-- The continuous homomorphism given by inclusion of the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the second factor."]
def inr : ContinuousMonoidHom B (A × B) 
goal: ContinuousMonoidHom B (A × B)

full_name: ContinuousAddMonoidHom.inr_toFun
code: /-- The continuous homomorphism given by inclusion of the second factor. -/
@[to_additive (attr := simps!)
  "The continuous homomorphism given by inclusion of the second factor."]
def inr : ContinuousMonoidHom B (A × B) 
goal: (ContinuousAddMonoidHom.inr A B) i =
  ((ContinuousAddMonoidHom.zero B A).toAddMonoidHom i, (ContinuousAddMonoidHom.id B).toAddMonoidHom i)

full_name: ContinuousMonoidHom.diag
code: /-- The continuous homomorphism given by the diagonal embedding. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by the diagonal embedding."]
def diag : ContinuousMonoidHom A (A × A) 
goal: ContinuousMonoidHom A (A × A)

full_name: ContinuousMonoidHom.diag_toFun
code: /-- The continuous homomorphism given by the diagonal embedding. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by the diagonal embedding."]
def diag : ContinuousMonoidHom A (A × A) 
goal: (ContinuousMonoidHom.diag A) i = ((ContinuousMonoidHom.id A).toMonoidHom i, (ContinuousMonoidHom.id A).toMonoidHom i)

full_name: ContinuousAddMonoidHom.diag_toFun
code: /-- The continuous homomorphism given by the diagonal embedding. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by the diagonal embedding."]
def diag : ContinuousMonoidHom A (A × A) 
goal: (ContinuousAddMonoidHom.diag A) i =
  ((ContinuousAddMonoidHom.id A).toAddMonoidHom i, (ContinuousAddMonoidHom.id A).toAddMonoidHom i)

full_name: ContinuousAddMonoidHom.diag
code: /-- The continuous homomorphism given by the diagonal embedding. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by the diagonal embedding."]
def diag : ContinuousMonoidHom A (A × A) 
goal: ContinuousAddMonoidHom A (A × A)

full_name: ContinuousAddMonoidHom.swap_toFun
code: /-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A) 
goal: (ContinuousAddMonoidHom.swap A B) i =
  ((ContinuousAddMonoidHom.snd A B).toAddMonoidHom i, (ContinuousAddMonoidHom.fst A B).toAddMonoidHom i)

full_name: ContinuousMonoidHom.swap_toFun
code: /-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A) 
goal: (ContinuousMonoidHom.swap A B) i =
  ((ContinuousMonoidHom.snd A B).toMonoidHom i, (ContinuousMonoidHom.fst A B).toMonoidHom i)

full_name: ContinuousAddMonoidHom.swap
code: /-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A) 
goal: ContinuousAddMonoidHom (A × B) (B × A)

full_name: ContinuousMonoidHom.swap
code: /-- The continuous homomorphism given by swapping components. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by swapping components."]
def swap : ContinuousMonoidHom (A × B) (B × A) 
goal: ContinuousMonoidHom (A × B) (B × A)

full_name: ContinuousMonoidHom.mul
code: /-- The continuous homomorphism given by multiplication. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by addition."]
def mul : ContinuousMonoidHom (E × E) E 
goal: ContinuousMonoidHom (E × E) E

full_name: ContinuousMonoidHom.mul_toFun
code: /-- The continuous homomorphism given by multiplication. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by addition."]
def mul : ContinuousMonoidHom (E × E) E 
goal: ∀ (a : E × E), (ContinuousMonoidHom.mul E) a = a.1 * a.2

full_name: ContinuousAddMonoidHom.add_toFun
code: /-- The continuous homomorphism given by multiplication. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by addition."]
def mul : ContinuousMonoidHom (E × E) E 
goal: ∀ (a : E × E), (ContinuousAddMonoidHom.add E) a = a.1 + a.2

full_name: ContinuousAddMonoidHom.add
code: /-- The continuous homomorphism given by multiplication. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by addition."]
def mul : ContinuousMonoidHom (E × E) E 
goal: ContinuousAddMonoidHom (E × E) E

full_name: ContinuousAddMonoidHom.neg_toFun
code: /-- The continuous homomorphism given by inversion. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by negation."]
def inv : ContinuousMonoidHom E E 
goal: ∀ (a : E), (ContinuousAddMonoidHom.neg E) a = -a

full_name: ContinuousMonoidHom.inv
code: /-- The continuous homomorphism given by inversion. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by negation."]
def inv : ContinuousMonoidHom E E 
goal: ContinuousMonoidHom E E

full_name: ContinuousMonoidHom.inv_toFun
code: /-- The continuous homomorphism given by inversion. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by negation."]
def inv : ContinuousMonoidHom E E 
goal: ∀ (a : E), (ContinuousMonoidHom.inv E) a = a⁻¹

full_name: ContinuousAddMonoidHom.neg
code: /-- The continuous homomorphism given by inversion. -/
@[to_additive (attr := simps!) "The continuous homomorphism given by negation."]
def inv : ContinuousMonoidHom E E 
goal: ContinuousAddMonoidHom E E

full_name: ContinuousMonoidHom.coprod
code: /-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E 
goal: ContinuousMonoidHom (A × B) E

full_name: ContinuousAddMonoidHom.coprod_toFun
code: /-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E 
goal: ∀ (a : A × B), (f.coprod g) a = (ContinuousAddMonoidHom.add E).toAddMonoidHom ((f.sum_map g).toAddMonoidHom a)

full_name: ContinuousMonoidHom.coprod_toFun
code: /-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E 
goal: ∀ (a : A × B), (f.coprod g) a = (ContinuousMonoidHom.mul E).toMonoidHom ((f.prod_map g).toMonoidHom a)

full_name: ContinuousAddMonoidHom.coprod
code: /-- Coproduct of two continuous homomorphisms to the same space. -/
@[to_additive (attr := simps!) "Coproduct of two continuous homomorphisms to the same space."]
def coprod (f : ContinuousMonoidHom A E) (g : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (A × B) E 
goal: ContinuousAddMonoidHom (A × B) E

full_name: ContinuousAddMonoidHom.instAddCommGroup
code: @[to_additive]
instance : CommGroup (ContinuousMonoidHom A E) 
goal: AddCommGroup (ContinuousAddMonoidHom A E)

full_name: ContinuousMonoidHom.instCommGroup
code: @[to_additive]
instance : CommGroup (ContinuousMonoidHom A E) 
goal: CommGroup (ContinuousMonoidHom A E)

full_name: ContinuousMonoidHom.instTopologicalSpace
code: @[to_additive]
instance : TopologicalSpace (ContinuousMonoidHom A B) 
goal: TopologicalSpace (ContinuousMonoidHom A B)

full_name: ContinuousAddMonoidHom.instTopologicalSpace
code: @[to_additive]
instance : TopologicalSpace (ContinuousMonoidHom A B) 
goal: TopologicalSpace (ContinuousAddMonoidHom A B)

full_name: ContinuousMonoidHom.inducing_toContinuousMap
code: @[to_additive]
theorem inducing_toContinuousMap : Inducing (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: Inducing ContinuousMonoidHom.toContinuousMap

full_name: ContinuousAddMonoidHom.inducing_toContinuousMap
code: @[to_additive]
theorem inducing_toContinuousMap : Inducing (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: Inducing ContinuousAddMonoidHom.toContinuousMap

full_name: ContinuousAddMonoidHom.embedding_toContinuousMap
code: @[to_additive]
theorem embedding_toContinuousMap :
    Embedding (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: Embedding ContinuousAddMonoidHom.toContinuousMap

full_name: ContinuousMonoidHom.embedding_toContinuousMap
code: @[to_additive]
theorem embedding_toContinuousMap :
    Embedding (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: Embedding ContinuousMonoidHom.toContinuousMap

full_name: ContinuousAddMonoidHom.range_toContinuousMap
code: @[to_additive]
lemma range_toContinuousMap :
    Set.range (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) =
      {f : C(A, B) | f 1 = 1 ∧ ∀ x y, f (x * y) = f x * f y} 
goal: Set.range ContinuousAddMonoidHom.toContinuousMap = {f | f 0 = 0 ∧ ∀ (x y : A), f (x + y) = f x + f y}

full_name: ContinuousMonoidHom.range_toContinuousMap
code: @[to_additive]
lemma range_toContinuousMap :
    Set.range (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) =
      {f : C(A, B) | f 1 = 1 ∧ ∀ x y, f (x * y) = f x * f y} 
goal: Set.range ContinuousMonoidHom.toContinuousMap = {f | f 1 = 1 ∧ ∀ (x y : A), f (x * y) = f x * f y}

full_name: ContinuousAddMonoidHom.closedEmbedding_toContinuousMap
code: @[to_additive]
theorem closedEmbedding_toContinuousMap [ContinuousMul B] [T2Space B] :
    ClosedEmbedding (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: ClosedEmbedding ContinuousAddMonoidHom.toContinuousMap

full_name: ContinuousMonoidHom.closedEmbedding_toContinuousMap
code: @[to_additive]
theorem closedEmbedding_toContinuousMap [ContinuousMul B] [T2Space B] :
    ClosedEmbedding (toContinuousMap : ContinuousMonoidHom A B → C(A, B)) 
goal: ClosedEmbedding ContinuousMonoidHom.toContinuousMap

full_name: ContinuousAddMonoidHom.instT2Space
code: @[to_additive]
instance [T2Space B] : T2Space (ContinuousMonoidHom A B) 
goal: T2Space (ContinuousAddMonoidHom A B)

full_name: ContinuousMonoidHom.instT2Space
code: @[to_additive]
instance [T2Space B] : T2Space (ContinuousMonoidHom A B) 
goal: T2Space (ContinuousMonoidHom A B)

full_name: ContinuousAddMonoidHom.instTopologicalAddGroup
code: @[to_additive]
instance : TopologicalGroup (ContinuousMonoidHom A E) 
goal: TopologicalAddGroup (ContinuousAddMonoidHom A E)

full_name: ContinuousMonoidHom.instTopologicalGroup
code: @[to_additive]
instance : TopologicalGroup (ContinuousMonoidHom A E) 
goal: TopologicalGroup (ContinuousMonoidHom A E)

full_name: ContinuousAddMonoidHom.continuous_of_continuous_uncurry
code: @[to_additive]
theorem continuous_of_continuous_uncurry {A : Type*} [TopologicalSpace A]
    (f : A → ContinuousMonoidHom B C) (h : Continuous (Function.uncurry fun x y => f x y)) :
    Continuous f 
goal: Continuous f

full_name: ContinuousMonoidHom.continuous_of_continuous_uncurry
code: @[to_additive]
theorem continuous_of_continuous_uncurry {A : Type*} [TopologicalSpace A]
    (f : A → ContinuousMonoidHom B C) (h : Continuous (Function.uncurry fun x y => f x y)) :
    Continuous f 
goal: Continuous f

full_name: ContinuousMonoidHom.continuous_comp
code: @[to_additive]
theorem continuous_comp [LocallyCompactSpace B] :
    Continuous fun f : ContinuousMonoidHom A B × ContinuousMonoidHom B C => f.2.comp f.1 
goal: Continuous fun f => f.2.comp f.1

full_name: ContinuousAddMonoidHom.continuous_comp
code: @[to_additive]
theorem continuous_comp [LocallyCompactSpace B] :
    Continuous fun f : ContinuousMonoidHom A B × ContinuousMonoidHom B C => f.2.comp f.1 
goal: Continuous fun f => f.2.comp f.1

full_name: ContinuousMonoidHom.continuous_comp_left
code: @[to_additive]
theorem continuous_comp_left (f : ContinuousMonoidHom A B) :
    Continuous fun g : ContinuousMonoidHom B C => g.comp f 
goal: Continuous fun g => g.comp f

full_name: ContinuousAddMonoidHom.continuous_comp_left
code: @[to_additive]
theorem continuous_comp_left (f : ContinuousMonoidHom A B) :
    Continuous fun g : ContinuousMonoidHom B C => g.comp f 
goal: Continuous fun g => g.comp f

full_name: ContinuousAddMonoidHom.continuous_comp_right
code: @[to_additive]
theorem continuous_comp_right (f : ContinuousMonoidHom B C) :
    Continuous fun g : ContinuousMonoidHom A B => f.comp g 
goal: Continuous fun g => f.comp g

full_name: ContinuousMonoidHom.continuous_comp_right
code: @[to_additive]
theorem continuous_comp_right (f : ContinuousMonoidHom B C) :
    Continuous fun g : ContinuousMonoidHom A B => f.comp g 
goal: Continuous fun g => f.comp g

full_name: ContinuousMonoidHom.compLeft
code: /-- `ContinuousMonoidHom _ f` is a functor. -/
@[to_additive "`ContinuousAddMonoidHom _ f` is a functor."]
def compLeft (f : ContinuousMonoidHom A B) :
    ContinuousMonoidHom (ContinuousMonoidHom B E) (ContinuousMonoidHom A E) 
goal: ContinuousMonoidHom (ContinuousMonoidHom B E) (ContinuousMonoidHom A E)

full_name: ContinuousAddMonoidHom.compLeft
code: /-- `ContinuousMonoidHom _ f` is a functor. -/
@[to_additive "`ContinuousAddMonoidHom _ f` is a functor."]
def compLeft (f : ContinuousMonoidHom A B) :
    ContinuousMonoidHom (ContinuousMonoidHom B E) (ContinuousMonoidHom A E) 
goal: ContinuousAddMonoidHom (ContinuousAddMonoidHom B E) (ContinuousAddMonoidHom A E)

full_name: ContinuousAddMonoidHom.compRight
code: /-- `ContinuousMonoidHom f _` is a functor. -/
@[to_additive "`ContinuousAddMonoidHom f _` is a functor."]
def compRight {B : Type*} [CommGroup B] [TopologicalSpace B] [TopologicalGroup B]
    (f : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (ContinuousMonoidHom A B) (ContinuousMonoidHom A E) 
goal: ContinuousAddMonoidHom (ContinuousAddMonoidHom A B) (ContinuousAddMonoidHom A E)

full_name: ContinuousMonoidHom.compRight
code: /-- `ContinuousMonoidHom f _` is a functor. -/
@[to_additive "`ContinuousAddMonoidHom f _` is a functor."]
def compRight {B : Type*} [CommGroup B] [TopologicalSpace B] [TopologicalGroup B]
    (f : ContinuousMonoidHom B E) :
    ContinuousMonoidHom (ContinuousMonoidHom A B) (ContinuousMonoidHom A E) 
goal: ContinuousMonoidHom (ContinuousMonoidHom A B) (ContinuousMonoidHom A E)

full_name: ContinuousMonoidHom.locallyCompactSpace_of_equicontinuousAt
code: @[to_additive]
theorem locallyCompactSpace_of_equicontinuousAt (U : Set X) (V : Set Y)
    (hU : IsCompact U) (hV : V ∈ nhds (1 : Y))
    (h : EquicontinuousAt (fun f : {f : X →* Y | Set.MapsTo f U V} ↦ (f : X → Y)) 1) :
    LocallyCompactSpace (ContinuousMonoidHom X Y) 
goal: LocallyCompactSpace (ContinuousMonoidHom X Y)

full_name: ContinuousAddMonoidHom.locallyCompactSpace_of_equicontinuousAt
code: @[to_additive]
theorem locallyCompactSpace_of_equicontinuousAt (U : Set X) (V : Set Y)
    (hU : IsCompact U) (hV : V ∈ nhds (1 : Y))
    (h : EquicontinuousAt (fun f : {f : X →* Y | Set.MapsTo f U V} ↦ (f : X → Y)) 1) :
    LocallyCompactSpace (ContinuousMonoidHom X Y) 
goal: LocallyCompactSpace (ContinuousAddMonoidHom X Y)

full_name: ContinuousMonoidHom.locallyCompactSpace_of_hasBasis
code: @[to_additive]
theorem locallyCompactSpace_of_hasBasis (V : ℕ → Set Y)
    (hV : ∀ {n x}, x ∈ V n → x * x ∈ V n → x ∈ V (n + 1))
    (hVo : Filter.HasBasis (nhds 1) (fun _ ↦ True) V) :
    LocallyCompactSpace (ContinuousMonoidHom X Y) 
goal: LocallyCompactSpace (ContinuousMonoidHom X Y)

full_name: ContinuousAddMonoidHom.locallyCompactSpace_of_hasBasis
code: @[to_additive]
theorem locallyCompactSpace_of_hasBasis (V : ℕ → Set Y)
    (hV : ∀ {n x}, x ∈ V n → x * x ∈ V n → x ∈ V (n + 1))
    (hVo : Filter.HasBasis (nhds 1) (fun _ ↦ True) V) :
    LocallyCompactSpace (ContinuousMonoidHom X Y) 
goal: LocallyCompactSpace (ContinuousAddMonoidHom X Y)