File: Mathlib/Topology/Algebra/Constructions.lean

full_name: MulOpposite.instTopologicalSpaceMulOpposite
code: /-- Put the same topological space structure on the opposite monoid as on the original space. -/
@[to_additive "Put the same topological space structure on the opposite monoid as on the original
space."]
instance instTopologicalSpaceMulOpposite [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ 
goal: TopologicalSpace Mᵐᵒᵖ

full_name: AddOpposite.instTopologicalSpaceAddOpposite
code: /-- Put the same topological space structure on the opposite monoid as on the original space. -/
@[to_additive "Put the same topological space structure on the opposite monoid as on the original
space."]
instance instTopologicalSpaceMulOpposite [TopologicalSpace M] : TopologicalSpace Mᵐᵒᵖ 
goal: TopologicalSpace Mᵃᵒᵖ

full_name: AddOpposite.continuous_unop
code: @[to_additive (attr := continuity)]
theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) 
goal: Continuous AddOpposite.unop

full_name: MulOpposite.continuous_unop
code: @[to_additive (attr := continuity)]
theorem continuous_unop : Continuous (unop : Mᵐᵒᵖ → M) 
goal: Continuous MulOpposite.unop

full_name: AddOpposite.continuous_op
code: @[to_additive (attr := continuity)]
theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) 
goal: Continuous AddOpposite.op

full_name: MulOpposite.continuous_op
code: @[to_additive (attr := continuity)]
theorem continuous_op : Continuous (op : M → Mᵐᵒᵖ) 
goal: Continuous MulOpposite.op

full_name: AddOpposite.opHomeomorph_apply
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: ∀ (a : M), AddOpposite.opHomeomorph a = AddOpposite.op a

full_name: MulOpposite.opHomeomorph_apply
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: ∀ (a : M), MulOpposite.opHomeomorph a = MulOpposite.op a

full_name: AddOpposite.opHomeomorph
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: M ≃ₜ Mᵃᵒᵖ

full_name: MulOpposite.opHomeomorph_symm_apply
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: ∀ (a : Mᵐᵒᵖ), MulOpposite.opHomeomorph.symm a = MulOpposite.unop a

full_name: AddOpposite.opHomeomorph_symm_apply
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: ∀ (a : Mᵃᵒᵖ), AddOpposite.opHomeomorph.symm a = AddOpposite.unop a

full_name: MulOpposite.opHomeomorph
code: /-- `MulOpposite.op` as a homeomorphism. -/
@[to_additive (attr := simps!) "`AddOpposite.op` as a homeomorphism."]
def opHomeomorph : M ≃ₜ Mᵐᵒᵖ 
goal: M ≃ₜ Mᵐᵒᵖ

full_name: AddOpposite.instT2Space
code: @[to_additive]
instance instT2Space [T2Space M] : T2Space Mᵐᵒᵖ 
goal: T2Space Mᵃᵒᵖ

full_name: MulOpposite.instT2Space
code: @[to_additive]
instance instT2Space [T2Space M] : T2Space Mᵐᵒᵖ 
goal: T2Space Mᵐᵒᵖ

full_name: MulOpposite.instDiscreteTopology
code: @[to_additive]
instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mᵐᵒᵖ 
goal: DiscreteTopology Mᵐᵒᵖ

full_name: AddOpposite.instDiscreteTopology
code: @[to_additive]
instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mᵐᵒᵖ 
goal: DiscreteTopology Mᵃᵒᵖ

full_name: AddOpposite.map_op_nhds
code: @[to_additive (attr := simp)]
theorem map_op_nhds (x : M) : map (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (op x) 
goal: Filter.map AddOpposite.op (𝓝 x) = 𝓝 (AddOpposite.op x)

full_name: MulOpposite.map_op_nhds
code: @[to_additive (attr := simp)]
theorem map_op_nhds (x : M) : map (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (op x) 
goal: Filter.map MulOpposite.op (𝓝 x) = 𝓝 (MulOpposite.op x)

full_name: AddOpposite.map_unop_nhds
code: @[to_additive (attr := simp)]
theorem map_unop_nhds (x : Mᵐᵒᵖ) : map (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (unop x) 
goal: Filter.map AddOpposite.unop (𝓝 x) = 𝓝 (AddOpposite.unop x)

full_name: MulOpposite.map_unop_nhds
code: @[to_additive (attr := simp)]
theorem map_unop_nhds (x : Mᵐᵒᵖ) : map (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (unop x) 
goal: Filter.map MulOpposite.unop (𝓝 x) = 𝓝 (MulOpposite.unop x)

full_name: AddOpposite.comap_op_nhds
code: @[to_additive (attr := simp)]
theorem comap_op_nhds (x : Mᵐᵒᵖ) : comap (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (unop x) 
goal: Filter.comap AddOpposite.op (𝓝 x) = 𝓝 (AddOpposite.unop x)

full_name: MulOpposite.comap_op_nhds
code: @[to_additive (attr := simp)]
theorem comap_op_nhds (x : Mᵐᵒᵖ) : comap (op : M → Mᵐᵒᵖ) (𝓝 x) = 𝓝 (unop x) 
goal: Filter.comap MulOpposite.op (𝓝 x) = 𝓝 (MulOpposite.unop x)

full_name: MulOpposite.comap_unop_nhds
code: @[to_additive (attr := simp)]
theorem comap_unop_nhds (x : M) : comap (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (op x) 
goal: Filter.comap MulOpposite.unop (𝓝 x) = 𝓝 (MulOpposite.op x)

full_name: AddOpposite.comap_unop_nhds
code: @[to_additive (attr := simp)]
theorem comap_unop_nhds (x : M) : comap (unop : Mᵐᵒᵖ → M) (𝓝 x) = 𝓝 (op x) 
goal: Filter.comap AddOpposite.unop (𝓝 x) = 𝓝 (AddOpposite.op x)

full_name: AddUnits.instTopologicalSpaceAddUnits
code: /-- The units of a monoid are equipped with a topology, via the embedding into `M × M`. -/
@[to_additive "The additive units of a monoid are equipped with a topology, via the embedding into
`M × M`."]
instance instTopologicalSpaceUnits : TopologicalSpace Mˣ 
goal: TopologicalSpace (AddUnits M)

full_name: Units.instTopologicalSpaceUnits
code: /-- The units of a monoid are equipped with a topology, via the embedding into `M × M`. -/
@[to_additive "The additive units of a monoid are equipped with a topology, via the embedding into
`M × M`."]
instance instTopologicalSpaceUnits : TopologicalSpace Mˣ 
goal: TopologicalSpace Mˣ

full_name: AddUnits.inducing_embedProduct
code: @[to_additive]
theorem inducing_embedProduct : Inducing (embedProduct M) 
goal: Inducing ⇑(AddUnits.embedProduct M)

full_name: Units.inducing_embedProduct
code: @[to_additive]
theorem inducing_embedProduct : Inducing (embedProduct M) 
goal: Inducing ⇑(Units.embedProduct M)

full_name: AddUnits.embedding_embedProduct
code: @[to_additive]
theorem embedding_embedProduct : Embedding (embedProduct M) 
goal: Embedding ⇑(AddUnits.embedProduct M)

full_name: Units.embedding_embedProduct
code: @[to_additive]
theorem embedding_embedProduct : Embedding (embedProduct M) 
goal: Embedding ⇑(Units.embedProduct M)

full_name: Units.instT2Space
code: @[to_additive]
instance instT2Space [T2Space M] : T2Space Mˣ 
goal: T2Space Mˣ

full_name: AddUnits.instT2Space
code: @[to_additive]
instance instT2Space [T2Space M] : T2Space Mˣ 
goal: T2Space (AddUnits M)

full_name: Units.instDiscreteTopology
code: @[to_additive]
instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mˣ 
goal: DiscreteTopology Mˣ

full_name: AddUnits.instDiscreteTopology
code: @[to_additive]
instance instDiscreteTopology [DiscreteTopology M] : DiscreteTopology Mˣ 
goal: DiscreteTopology (AddUnits M)

full_name: Units.topology_eq_inf
code: @[to_additive] lemma topology_eq_inf :
    instTopologicalSpaceUnits =
      .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› 
goal: Units.instTopologicalSpaceUnits =
  TopologicalSpace.induced Units.val inst✝ ⊓ TopologicalSpace.induced (fun u => ↑u⁻¹) inst✝

full_name: AddUnits.topology_eq_inf
code: @[to_additive] lemma topology_eq_inf :
    instTopologicalSpaceUnits =
      .induced (val : Mˣ → M) ‹_› ⊓ .induced (fun u ↦ ↑u⁻¹ : Mˣ → M) ‹_› 
goal: AddUnits.instTopologicalSpaceAddUnits =
  TopologicalSpace.induced AddUnits.val inst✝ ⊓ TopologicalSpace.induced (fun u => ↑(-u)) inst✝

full_name: AddUnits.embedding_val_mk'
code: /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk' {M : Type*} [Monoid M] [TopologicalSpace M] {f : M → M}
    (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
    Embedding (val : Mˣ → M) 
goal: Embedding AddUnits.val

full_name: Units.embedding_val_mk'
code: /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk' {M : Type*} [Monoid M] [TopologicalSpace M] {f : M → M}
    (hc : ContinuousOn f {x : M | IsUnit x}) (hf : ∀ u : Mˣ, f u.1 = ↑u⁻¹) :
    Embedding (val : Mˣ → M) 
goal: Embedding Units.val

full_name: Units.embedding_val_mk
code: /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk {M : Type*} [DivisionMonoid M] [TopologicalSpace M]
    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) 
goal: Embedding Units.val

full_name: AddUnits.embedding_val_mk
code: /-- An auxiliary lemma that can be used to prove that coercion `Mˣ → M` is a topological embedding.
Use `Units.embedding_val₀`, `Units.embedding_val`, or `toUnits_homeomorph` instead. -/
@[to_additive "An auxiliary lemma that can be used to prove that coercion `AddUnits M → M` is a
topological embedding. Use `AddUnits.embedding_val` or `toAddUnits_homeomorph` instead."]
lemma embedding_val_mk {M : Type*} [DivisionMonoid M] [TopologicalSpace M]
    (h : ContinuousOn Inv.inv {x : M | IsUnit x}) : Embedding (val : Mˣ → M) 
goal: Embedding AddUnits.val

full_name: AddUnits.continuous_embedProduct
code: @[to_additive]
theorem continuous_embedProduct : Continuous (embedProduct M) 
goal: Continuous ⇑(AddUnits.embedProduct M)

full_name: Units.continuous_embedProduct
code: @[to_additive]
theorem continuous_embedProduct : Continuous (embedProduct M) 
goal: Continuous ⇑(Units.embedProduct M)

full_name: Units.continuous_val
code: @[to_additive]
theorem continuous_val : Continuous ((↑) : Mˣ → M) 
goal: Continuous Units.val

full_name: AddUnits.continuous_val
code: @[to_additive]
theorem continuous_val : Continuous ((↑) : Mˣ → M) 
goal: Continuous AddUnits.val

full_name: Units.continuous_iff
code: @[to_additive]
protected theorem continuous_iff {f : X → Mˣ} :
    Continuous f ↔ Continuous (val ∘ f) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) 
goal: Continuous f ↔ Continuous (Units.val ∘ f) ∧ Continuous fun x => ↑(f x)⁻¹

full_name: AddUnits.continuous_iff
code: @[to_additive]
protected theorem continuous_iff {f : X → Mˣ} :
    Continuous f ↔ Continuous (val ∘ f) ∧ Continuous (fun x => ↑(f x)⁻¹ : X → M) 
goal: Continuous f ↔ Continuous (AddUnits.val ∘ f) ∧ Continuous fun x => ↑(-f x)

full_name: AddUnits.continuous_coe_neg
code: @[to_additive]
theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) 
goal: Continuous fun u => ↑(-u)

full_name: Units.continuous_coe_inv
code: @[to_additive]
theorem continuous_coe_inv : Continuous (fun u => ↑u⁻¹ : Mˣ → M) 
goal: Continuous fun u => ↑u⁻¹