File: Mathlib/Topology/Algebra/Algebra.lean

full_name: continuous_algebraMap
code: @[continuity, fun_prop]
theorem continuous_algebraMap [ContinuousSMul R A] : Continuous (algebraMap R A) 
goal: Continuous ⇑(algebraMap R A)

full_name: continuous_algebraMap_iff_smul
code: theorem continuous_algebraMap_iff_smul [TopologicalSemiring A] :
    Continuous (algebraMap R A) ↔ Continuous fun p : R × A => p.1 • p.2 
goal: Continuous ⇑(algebraMap R A) ↔ Continuous fun p => p.1 • p.2

full_name: continuousSMul_of_algebraMap
code: theorem continuousSMul_of_algebraMap [TopologicalSemiring A] (h : Continuous (algebraMap R A)) :
    ContinuousSMul R A 
goal: ContinuousSMul R A

full_name: algebraMapCLM
code: /-- The inclusion of the base ring in a topological algebra as a continuous linear map. -/
@[simps]
def algebraMapCLM : R →L[R] A 
goal: R →L[R] A

full_name: algebraMapCLM_toFun
code: /-- The inclusion of the base ring in a topological algebra as a continuous linear map. -/
@[simps]
def algebraMapCLM : R →L[R] A 
goal: (algebraMapCLM R A) a = (algebraMap R A) a

full_name: algebraMapCLM_apply
code: /-- The inclusion of the base ring in a topological algebra as a continuous linear map. -/
@[simps]
def algebraMapCLM : R →L[R] A 
goal: (algebraMapCLM R A) a = (algebraMap R A) a

full_name: algebraMapCLM_coe
code: theorem algebraMapCLM_coe : ⇑(algebraMapCLM R A) = algebraMap R A 
goal: ⇑(algebraMapCLM R A) = ⇑(algebraMap R A)

full_name: algebraMapCLM_toLinearMap
code: theorem algebraMapCLM_toLinearMap : (algebraMapCLM R A).toLinearMap = Algebra.linearMap R A 
goal: ↑(algebraMapCLM R A) = Algebra.linearMap R A

full_name: instContinuousSMulOfTopologicalSemiringOfDiscreteTopology
code: /-- If `R` is a discrete topological ring, then any topological ring `S` which is an `R`-algebra
is also a topological `R`-algebra. -/
instance [TopologicalSemiring A] [DiscreteTopology R] :
    ContinuousSMul R A 
goal: ContinuousSMul R A

full_name: ContinuousAlgHom
code: /-- Continuous algebra homomorphisms between algebras. We only put the type classes that are
necessary for the definition, although in applications `M` and `B` will be topological algebras
over the topological ring `R`. -/
structure ContinuousAlgHom (R : Type*) [CommSemiring R] (A : Type*) [Semiring A]
    [TopologicalSpace A] (B : Type*) [Semiring B] [TopologicalSpace B] [Algebra R A] [Algebra R B]
    extends A →ₐ[R] B where
-- TODO: replace with `fun_prop` when that is stable
  cont : Continuous toFun := by continuity
goal: Type (max u_4 u_5)

full_name: ContinuousAlgHom.cont
code: /-- Continuous algebra homomorphisms between algebras. We only put the type classes that are
necessary for the definition, although in applications `M` and `B` will be topological algebras
over the topological ring `R`. -/
structure ContinuousAlgHom (R : Type*) [CommSemiring R] (A : Type*) [Semiring A]
    [TopologicalSpace A] (B : Type*) [Semiring B] [TopologicalSpace B] [Algebra R A] [Algebra R B]
    extends A →ₐ[R] B where
-- TODO: replace with `fun_prop` when that is stable
  cont : Continuous toFun := by continuity
goal: Continuous (↑↑self.toRingHom).toFun

full_name: «_aux_Mathlib_Topology_Algebra_Algebra___macroRules_term_→A[_]__1»
code: @[inherit_doc]
notation:25 A " →A[" R "] " B => ContinuousAlgHom R A B
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Algebra_Algebra___unexpand_ContinuousAlgHom_1
code: @[inherit_doc]
notation:25 A " →A[" R "] " B => ContinuousAlgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousAlgHom.instFunLike
code: instance : FunLike (A →A[R] B) A B 
goal: FunLike (A →A[R] B) A B

full_name: ContinuousAlgHom.instAlgHomClass
code: instance : AlgHomClass (A →A[R] B) R A B 
goal: AlgHomClass (A →A[R] B) R A B

full_name: ContinuousAlgHom.toAlgHom_eq_coe
code: @[simp]
theorem toAlgHom_eq_coe (f : A →A[R] B) : f.toAlgHom = f 
goal: f.toAlgHom = ↑f

full_name: ContinuousAlgHom.coe_inj
code: @[simp, norm_cast]
theorem coe_inj {f g : A →A[R] B} : (f : A →ₐ[R] B) = g ↔ f = g 
goal: ↑f = ↑g ↔ f = g

full_name: ContinuousAlgHom.coe_mk
code: @[simp]
theorem coe_mk (f : A →ₐ[R] B) (h) : (mk f h : A →ₐ[R] B) = f 
goal: ↑{ toAlgHom := f, cont := h } = f

full_name: ContinuousAlgHom.coe_mk'
code: @[simp]
theorem coe_mk' (f : A →ₐ[R] B) (h) : (mk f h : A → B) = f 
goal: ⇑{ toAlgHom := f, cont := h } = ⇑f

full_name: ContinuousAlgHom.coe_coe
code: @[simp, norm_cast]
theorem coe_coe (f : A →A[R] B) : ⇑(f : A →ₐ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: ContinuousAlgHom.instContinuousMapClass
code: instance : ContinuousMapClass (A →A[R] B) A B 
goal: ContinuousMapClass (A →A[R] B) A B

full_name: ContinuousAlgHom.continuous
code: @[fun_prop]
protected theorem continuous (f : A →A[R] B) : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousAlgHom.uniformContinuous
code: protected theorem uniformContinuous {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂]
    [Ring E₁] [Ring E₂] [Algebra R E₁] [Algebra R E₂] [UniformAddGroup E₁]
    [UniformAddGroup E₂] (f : E₁ →A[R] E₂) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: ContinuousAlgHom.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
because it is a composition of multiple projections. -/
def Simps.apply (h : A →A[R] B) : A → B 
goal: A → B

full_name: ContinuousAlgHom.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (h : A →A[R] B) : A →ₐ[R] B 
goal: A →ₐ[R] B

full_name: ContinuousAlgHom.ext
code: @[ext]
theorem ext {f g : A →A[R] B} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousAlgHom.ext_iff
code: theorem ext_iff {f g : A →A[R] B} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : A), f x = g x

full_name: ContinuousAlgHom.copy
code: /-- Copy of a `ContinuousAlgHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
def copy (f : A →A[R] B) (f' : A → B) (h : f' = ⇑f) : A →A[R] B 
goal: A →A[R] B

full_name: ContinuousAlgHom.coe_copy
code: @[simp]
theorem coe_copy (f : A →A[R] B) (f' : A → B) (h : f' = ⇑f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: ContinuousAlgHom.copy_eq
code: theorem copy_eq (f : A →A[R] B) (f' : A → B) (h : f' = ⇑f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: ContinuousAlgHom.map_zero
code: protected theorem map_zero (f : A →A[R] B) : f (0 : A) = 0 
goal: f 0 = 0

full_name: ContinuousAlgHom.map_add
code: protected theorem map_add (f : A →A[R] B) (x y : A) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: ContinuousAlgHom.map_smul
code: protected theorem map_smul (f : A →A[R] B) (c : R) (x : A) :
    f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: ContinuousAlgHom.map_smul_of_tower
code: theorem map_smul_of_tower {R S : Type*} [CommSemiring S] [SMul R A] [Algebra S A] [SMul R B]
    [Algebra S B] [MulActionHomClass (A →A[S] B) R A B] (f : A →A[S] B) (c : R) (x : A) :
    f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: ContinuousAlgHom.map_sum
code: protected theorem map_sum {ι : Type*} (f : A →A[R] B) (s : Finset ι) (g : ι → A) :
    f (∑ i in s, g i) = ∑ i in s, f (g i) 
goal: f (∑ i ∈ s, g i) = ∑ i ∈ s, f (g i)

full_name: ContinuousAlgHom.ext_ring
code: /-- Any two continuous `R`-algebra morphisms from `R` are equal -/
@[ext]
theorem ext_ring [TopologicalSpace R] {f g : R →A[R] A} : f = g 
goal: f = g

full_name: ContinuousAlgHom.ext_ring_iff
code: theorem ext_ring_iff [TopologicalSpace R] {f g : R →A[R] A} : f = g ↔ f 1 = g 1 
goal: f = g ↔ f 1 = g 1

full_name: ContinuousAlgHom.eqOn_closure_adjoin
code: /-- If two continuous algebra maps are equal on a set `s`, then they are equal on the closure
of the `Algebra.adjoin` of this set. -/
theorem eqOn_closure_adjoin [T2Space B] {s : Set A} {f g : A →A[R] B} (h : Set.EqOn f g s) :
    Set.EqOn f g (closure (Algebra.adjoin R s : Set A)) 
goal: Set.EqOn (⇑f) (⇑g) (closure ↑(Algebra.adjoin R s))

full_name: ContinuousAlgHom.ext_on
code: /-- If the subalgebra generated by a set `s` is dense in the ambient module, then two continuous
algebra maps equal on `s` are equal. -/
theorem ext_on [T2Space B] {s : Set A} (hs : Dense (Algebra.adjoin R s : Set A))
    {f g : A →A[R] B} (h : Set.EqOn f g s) : f = g 
goal: f = g

full_name: Subalgebra.topologicalClosure
code: /-- The topological closure of a subalgebra -/
def _root_.Subalgebra.topologicalClosure (s : Subalgebra R A) : Subalgebra R A 
goal: Subalgebra R A

full_name: Subalgebra.topologicalClosure_map
code: /-- Under a continuous algebra map, the image of the `TopologicalClosure` of a subalgebra is
contained in the `TopologicalClosure` of its image. -/
theorem _root_.Subalgebra.topologicalClosure_map
    [TopologicalSemiring B] (f : A →A[R] B) (s : Subalgebra R A) :
    s.topologicalClosure.map f ≤ (s.map f.toAlgHom).topologicalClosure 
goal: Subalgebra.map (↑f) s.topologicalClosure ≤ (Subalgebra.map f.toAlgHom s).topologicalClosure

full_name: Subalgebra.topologicalClosure_coe
code: @[simp]
theorem _root_.Subalgebra.topologicalClosure_coe
    (s : Subalgebra R A) :
  (s.topologicalClosure : Set A) = closure ↑s 
goal: ↑s.topologicalClosure = closure ↑s

full_name: DenseRange.topologicalClosure_map_subalgebra
code: /-- Under a dense continuous algebra map, a subalgebra
whose `TopologicalClosure` is `⊤` is sent to another such submodule.
That is, the image of a dense subalgebra under a map with dense range is dense.
-/
theorem _root_.DenseRange.topologicalClosure_map_subalgebra
    [TopologicalSemiring B] {f : A →A[R] B}  (hf' : DenseRange f) {s : Subalgebra R A}
    (hs : s.topologicalClosure = ⊤) : (s.map (f : A →ₐ[R] B)).topologicalClosure = ⊤ 
goal: (Subalgebra.map (↑f) s).topologicalClosure = ⊤

full_name: ContinuousAlgHom.id
code: /-- The identity map as a continuous algebra homomorphism. -/
protected def id : A →A[R] A 
goal: A →A[R] A

full_name: ContinuousAlgHom.instOne
code: instance : One (A →A[R] A) 
goal: One (A →A[R] A)

full_name: ContinuousAlgHom.one_def
code: theorem one_def : (1 : A →A[R] A) = ContinuousAlgHom.id R A 
goal: 1 = ContinuousAlgHom.id R A

full_name: ContinuousAlgHom.id_apply
code: theorem id_apply (x : A) : ContinuousAlgHom.id R A x = x 
goal: (ContinuousAlgHom.id R A) x = x

full_name: ContinuousAlgHom.coe_id
code: @[simp, norm_cast]
theorem coe_id : ((ContinuousAlgHom.id R A) : A →ₐ[R] A) = AlgHom.id R A
goal: ↑(ContinuousAlgHom.id R A) = AlgHom.id R A

full_name: ContinuousAlgHom.coe_id'
code: @[simp, norm_cast]
theorem coe_id' : ⇑(ContinuousAlgHom.id R A ) = _root_.id 
goal: ⇑(ContinuousAlgHom.id R A) = id

full_name: ContinuousAlgHom.coe_eq_id
code: @[simp, norm_cast]
theorem coe_eq_id {f : A →A[R] A} :
    (f : A →ₐ[R] A) = AlgHom.id R A ↔ f = ContinuousAlgHom.id R A
goal: ↑f = AlgHom.id R A ↔ f = ContinuousAlgHom.id R A

full_name: ContinuousAlgHom.one_apply
code: @[simp]
theorem one_apply (x : A) : (1 : A →A[R] A) x = x 
goal: 1 x = x

full_name: ContinuousAlgHom.comp
code: /-- Composition of continuous algebra homomorphisms. -/
def comp (g : B →A[R] C) (f : A →A[R] B) : A →A[R] C 
goal: A →A[R] C

full_name: ContinuousAlgHom.coe_comp
code: @[simp, norm_cast]
theorem coe_comp (h : B →A[R] C) (f : A →A[R] B) :
    (h.comp f : A →ₐ[R] C) = (h : B →ₐ[R] C).comp (f : A →ₐ[R] B) 
goal: ↑(h.comp f) = (↑h).comp ↑f

full_name: ContinuousAlgHom.coe_comp'
code: @[simp, norm_cast]
theorem coe_comp' (h : B →A[R] C) (f : A →A[R] B) : ⇑(h.comp f) = h ∘ f 
goal: ⇑(h.comp f) = ⇑h ∘ ⇑f

full_name: ContinuousAlgHom.comp_apply
code: theorem comp_apply (g : B →A[R] C) (f : A →A[R] B) (x : A) : (g.comp f) x = g (f x) 
goal: (g.comp f) x = g (f x)

full_name: ContinuousAlgHom.comp_id
code: @[simp]
theorem comp_id (f : A →A[R] B) : f.comp (ContinuousAlgHom.id R A) = f 
goal: f.comp (ContinuousAlgHom.id R A) = f

full_name: ContinuousAlgHom.id_comp
code: @[simp]
theorem id_comp (f : A →A[R] B) : (ContinuousAlgHom.id R B).comp f = f 
goal: (ContinuousAlgHom.id R B).comp f = f

full_name: ContinuousAlgHom.comp_assoc
code: theorem comp_assoc {D : Type*} [Semiring D] [Algebra R D] [TopologicalSpace D] (h : C →A[R] D)
    (g : B →A[R] C) (f : A →A[R] B) : (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

full_name: ContinuousAlgHom.instMul
code: instance : Mul (A →A[R] A) 
goal: Mul (A →A[R] A)

full_name: ContinuousAlgHom.mul_def
code: theorem mul_def (f g : A →A[R] A) : f * g = f.comp g 
goal: f * g = f.comp g

full_name: ContinuousAlgHom.coe_mul
code: @[simp]
theorem coe_mul (f g : A →A[R] A) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: ContinuousAlgHom.mul_apply
code: theorem mul_apply (f g : A →A[R] A) (x : A) : (f * g) x = f (g x) 
goal: (f * g) x = f (g x)

full_name: ContinuousAlgHom.instMonoid
code: instance : Monoid (A →A[R] A) 
goal: Monoid (A →A[R] A)

full_name: ContinuousAlgHom.coe_pow
code: theorem coe_pow (f : A →A[R] A) (n : ℕ) : ⇑(f ^ n) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: ContinuousAlgHom.toAlgHomMonoidHom
code: /-- coercion from `ContinuousAlgHom` to `AlgHom` as a `RingHom`. -/
@[simps]
def toAlgHomMonoidHom : (A →A[R] A) →* A →ₐ[R] A 
goal: (A →A[R] A) →* A →ₐ[R] A

full_name: ContinuousAlgHom.toAlgHomMonoidHom_apply
code: /-- coercion from `ContinuousAlgHom` to `AlgHom` as a `RingHom`. -/
@[simps]
def toAlgHomMonoidHom : (A →A[R] A) →* A →ₐ[R] A 
goal: ContinuousAlgHom.toAlgHomMonoidHom f = ↑f

full_name: ContinuousAlgHom.prod
code: /-- The cartesian product of two continuous algebra morphisms as a continuous algebra morphism. -/
protected def prod (f₁ : A →A[R] B) (f₂ : A →A[R] C) :
    A →A[R] B × C 
goal: A →A[R] B × C

full_name: ContinuousAlgHom.coe_prod
code: @[simp, norm_cast]
theorem coe_prod (f₁ : A →A[R] B) (f₂ : A →A[R] C) :
    (f₁.prod f₂ : A →ₐ[R] B × C) = AlgHom.prod f₁ f₂ 
goal: ↑(f₁.prod f₂) = (↑f₁).prod ↑f₂

full_name: ContinuousAlgHom.prod_apply
code: @[simp, norm_cast]
theorem prod_apply (f₁ : A →A[R] B) (f₂ : A →A[R] C) (x : A) :
    f₁.prod f₂ x = (f₁ x, f₂ x) 
goal: (f₁.prod f₂) x = (f₁ x, f₂ x)

full_name: ContinuousAlgHom.instCompleteSpaceSubtypeMemSubalgebraEqualizerOfT2SpaceOfContinuousMapClass
code: instance {D : Type*} [UniformSpace D] [CompleteSpace D]
    [Semiring D] [Algebra R D] [T2Space B]
    [FunLike F D B] [AlgHomClass F R D B] [ContinuousMapClass F D B]
    (f g : F) : CompleteSpace (AlgHom.equalizer f g) 
goal: CompleteSpace ↥(AlgHom.equalizer f g)

full_name: ContinuousAlgHom.fst
code: /-- `Prod.fst` as a `ContinuousAlgHom`. -/
def fst : A × B →A[R] A 
goal: A × B →A[R] A

full_name: ContinuousAlgHom.snd
code: /-- `Prod.snd` as a `ContinuousAlgHom`. -/
def snd : A × B →A[R] B 
goal: A × B →A[R] B

full_name: ContinuousAlgHom.coe_fst
code: @[simp, norm_cast]
theorem coe_fst : ↑(fst R A B) = AlgHom.fst R A B 
goal: ↑(ContinuousAlgHom.fst R A B) = AlgHom.fst R A B

full_name: ContinuousAlgHom.coe_fst'
code: @[simp, norm_cast]
theorem coe_fst' : ⇑(fst R A B) = Prod.fst 
goal: ⇑(ContinuousAlgHom.fst R A B) = Prod.fst

full_name: ContinuousAlgHom.coe_snd
code: @[simp, norm_cast]
theorem coe_snd : ↑(snd R A B) = AlgHom.snd R A B 
goal: ↑(ContinuousAlgHom.snd R A B) = AlgHom.snd R A B

full_name: ContinuousAlgHom.coe_snd'
code: @[simp, norm_cast]
theorem coe_snd' : ⇑(snd R A B) = Prod.snd 
goal: ⇑(ContinuousAlgHom.snd R A B) = Prod.snd

full_name: ContinuousAlgHom.fst_prod_snd
code: @[simp]
theorem fst_prod_snd  : (fst R A B).prod (snd R A B) = ContinuousAlgHom.id R (A × B) 
goal: (ContinuousAlgHom.fst R A B).prod (ContinuousAlgHom.snd R A B) = ContinuousAlgHom.id R (A × B)

full_name: ContinuousAlgHom.fst_comp_prod
code: @[simp]
theorem fst_comp_prod (f : A →A[R] B) (g : A →A[R] C) :
    (fst R B C).comp (f.prod g) = f 
goal: (ContinuousAlgHom.fst R B C).comp (f.prod g) = f

full_name: ContinuousAlgHom.snd_comp_prod
code: @[simp]
theorem snd_comp_prod  (f : A →A[R] B) (g : A →A[R] C) :
    (snd R B C).comp (f.prod g) = g 
goal: (ContinuousAlgHom.snd R B C).comp (f.prod g) = g

full_name: ContinuousAlgHom.prodMap
code: /-- `Prod.map` of two continuous algebra homomorphisms. -/
def prodMap {D : Type*} [Semiring D] [TopologicalSpace D] [Algebra R D] (f₁ : A →A[R] B)
    (f₂ : C →A[R] D) : A × C →A[R] B × D 
goal: A × C →A[R] B × D

full_name: ContinuousAlgHom.coe_prodMap
code: @[simp, norm_cast]
theorem coe_prodMap {D : Type*} [Semiring D] [TopologicalSpace D] [Algebra R D] (f₁ : A →A[R] B)
    (f₂ : C →A[R] D) :
    (f₁.prodMap f₂ : A × C →ₐ[R] B × D) = (f₁ : A →ₐ[R] B).prodMap (f₂ : C →ₐ[R] D) 
goal: ↑(f₁.prodMap f₂) = (↑f₁).prodMap ↑f₂

full_name: ContinuousAlgHom.coe_prodMap'
code: @[simp, norm_cast]
theorem coe_prodMap' {D : Type*} [Semiring D] [TopologicalSpace D] [Algebra R D] (f₁ : A →A[R] B)
    (f₂ : C →A[R] D) : ⇑(f₁.prodMap f₂) = Prod.map f₁ f₂ 
goal: ⇑(f₁.prodMap f₂) = Prod.map ⇑f₁ ⇑f₂

full_name: ContinuousAlgHom.prodEquiv
code: /-- `ContinuousAlgHom.prod` as an `Equiv`. -/
@[simps apply]
def prodEquiv : (A →A[R] B) × (A →A[R] C) ≃ (A →A[R] B × C) 
goal: (A →A[R] B) × (A →A[R] C) ≃ (A →A[R] B × C)

full_name: ContinuousAlgHom.prodEquiv_apply
code: /-- `ContinuousAlgHom.prod` as an `Equiv`. -/
@[simps apply]
def prodEquiv : (A →A[R] B) × (A →A[R] C) ≃ (A →A[R] B × C) 
goal: ContinuousAlgHom.prodEquiv f = f.1.prod f.2

full_name: ContinuousAlgHom.codRestrict
code: /-- Restrict codomain of a continuous algebra morphism. -/
def codRestrict (f : A →A[R] B) (p : Subalgebra R B) (h : ∀ x, f x ∈ p) : A →A[R] p 
goal: A →A[R] ↥p

full_name: ContinuousAlgHom.coe_codRestrict
code: @[norm_cast]
theorem coe_codRestrict (f : A →A[R] B) (p : Subalgebra R B) (h : ∀ x, f x ∈ p) :
    (f.codRestrict p h : A →ₐ[R] p) = (f : A →ₐ[R] B).codRestrict p h 
goal: ↑(f.codRestrict p h) = (↑f).codRestrict p h

full_name: ContinuousAlgHom.coe_codRestrict_apply
code: @[simp]
theorem coe_codRestrict_apply (f : A →A[R] B) (p : Subalgebra R B) (h : ∀ x, f x ∈ p) (x) :
    (f.codRestrict p h x : B) = f x 
goal: ↑((f.codRestrict p h) x) = f x

full_name: ContinuousAlgHom.rangeRestrict
code: /-- Restrict the codomain of a continuous algebra homomorphism `f` to `f.range`. -/
@[reducible]
def rangeRestrict (f : A →A[R] B) 
goal: A →A[R] ↥(↑f).range

full_name: ContinuousAlgHom.coe_rangeRestrict
code: @[simp]
theorem coe_rangeRestrict (f : A →A[R] B) :
    (f.rangeRestrict : A →ₐ[R] (@AlgHom.range R A B  _ _ _ _ _ f)) =
      (f : A →ₐ[R] B).rangeRestrict 
goal: ↑f.rangeRestrict = (↑f).rangeRestrict

full_name: Subalgebra.valA
code: /-- `Subalgebra.val` as a `ContinuousAlgHom`. -/
def _root_.Subalgebra.valA (p : Subalgebra R A) : p →A[R] A 
goal: ↥p →A[R] A

full_name: Subalgebra.coe_valA
code: @[simp, norm_cast]
theorem _root_.Subalgebra.coe_valA (p : Subalgebra R A) :
    (p.valA : p →ₐ[R] A) = p.subtype 
goal: ↑↑p.valA = p.subtype

full_name: Subalgebra.coe_valA'
code: @[simp]
theorem _root_.Subalgebra.coe_valA' (p : Subalgebra R A) : ⇑p.valA = p.subtype 
goal: ⇑p.valA = ⇑p.subtype

full_name: Subalgebra.valA_apply
code: @[simp]
theorem _root_.Subalgebra.valA_apply (p : Subalgebra R A) (x : p) : p.valA x = x 
goal: p.valA x = ↑x

full_name: Submodule.range_valA
code: @[simp]
theorem _root_.Submodule.range_valA (p : Subalgebra R A) :
    @AlgHom.range R p A _ _ _ _ _ p.valA = p 
goal: (↑p.valA).range = p

full_name: ContinuousAlgHom.map_neg
code: protected theorem map_neg (f : S →A[R] B) (x : S) : f (-x) = -f x 
goal: f (-x) = -f x

full_name: ContinuousAlgHom.map_sub
code: protected theorem map_sub (f : S →A[R] B) (x y : S) : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: ContinuousAlgHom.restrictScalars
code: /-- If `A` is an `R`-algebra, then a continuous `A`-algebra morphism can be interpreted as a
continuous `R`-algebra morphism. -/
def restrictScalars (f : B →A[S] C) : B →A[R] C 
goal: B →A[R] C

full_name: ContinuousAlgHom.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (f : B →A[S] C) :
    (f.restrictScalars R : B →ₐ[R] C) = (f : B →ₐ[S] C).restrictScalars R 
goal: ↑(ContinuousAlgHom.restrictScalars R f) = AlgHom.restrictScalars R ↑f

full_name: ContinuousAlgHom.coe_restrictScalars'
code: @[simp]
theorem coe_restrictScalars' (f : B →A[S] C) : ⇑(f.restrictScalars R) = f 
goal: ⇑(ContinuousAlgHom.restrictScalars R f) = ⇑f

full_name: instTopologicalSemiringSubtypeMemSubalgebra
code: instance (s : Subalgebra R A) : TopologicalSemiring s 
goal: TopologicalSemiring ↥s

full_name: Subalgebra.le_topologicalClosure
code: theorem Subalgebra.le_topologicalClosure (s : Subalgebra R A) : s ≤ s.topologicalClosure 
goal: s ≤ s.topologicalClosure

full_name: Subalgebra.isClosed_topologicalClosure
code: theorem Subalgebra.isClosed_topologicalClosure (s : Subalgebra R A) :
    IsClosed (s.topologicalClosure : Set A) 
goal: IsClosed ↑s.topologicalClosure

full_name: Subalgebra.topologicalClosure_minimal
code: theorem Subalgebra.topologicalClosure_minimal (s : Subalgebra R A) {t : Subalgebra R A} (h : s ≤ t)
    (ht : IsClosed (t : Set A)) : s.topologicalClosure ≤ t 
goal: s.topologicalClosure ≤ t

full_name: Subalgebra.commSemiringTopologicalClosure
code: /-- If a subalgebra of a topological algebra is commutative, then so is its topological closure. -/
def Subalgebra.commSemiringTopologicalClosure [T2Space A] (s : Subalgebra R A)
    (hs : ∀ x y : s, x * y = y * x) : CommSemiring s.topologicalClosure 
goal: CommSemiring ↥s.topologicalClosure

full_name: Subalgebra.topologicalClosure_comap_homeomorph
code: /-- This is really a statement about topological algebra isomorphisms,
but we don't have those, so we use the clunky approach of talking about
an algebra homomorphism, and a separate homeomorphism,
along with a witness that as functions they are the same.
-/
theorem Subalgebra.topologicalClosure_comap_homeomorph (s : Subalgebra R A) {B : Type*}
    [TopologicalSpace B] [Ring B] [TopologicalRing B] [Algebra R B] (f : B →ₐ[R] A) (f' : B ≃ₜ A)
    (w : (f : B → A) = f') : s.topologicalClosure.comap f = (s.comap f).topologicalClosure 
goal: Subalgebra.comap f s.topologicalClosure = (Subalgebra.comap f s).topologicalClosure

full_name: Subalgebra.commRingTopologicalClosure
code: /-- If a subalgebra of a topological algebra is commutative, then so is its topological closure.
See note [reducible non-instances]. -/
abbrev Subalgebra.commRingTopologicalClosure [T2Space A] (s : Subalgebra R A)
    (hs : ∀ x y : s, x * y = y * x) : CommRing s.topologicalClosure 
goal: CommRing ↥s.topologicalClosure

full_name: Algebra.elementalAlgebra
code: /-- The topological closure of the subalgebra generated by a single element. -/
def Algebra.elementalAlgebra (x : A) : Subalgebra R A 
goal: Subalgebra R A

full_name: Algebra.self_mem_elementalAlgebra
code: @[aesop safe apply (rule_sets := [SetLike])]
theorem Algebra.self_mem_elementalAlgebra (x : A) : x ∈ Algebra.elementalAlgebra R x 
goal: x ∈ Algebra.elementalAlgebra R x

full_name: instCommRingSubtypeMemSubalgebraElementalAlgebraOfT2Space
code: instance [T2Space A] {x : A} : CommRing (Algebra.elementalAlgebra R x) 
goal: CommRing ↥(Algebra.elementalAlgebra R x)