File: Mathlib/Topology/Algebra/GroupCompletion.lean

full_name: instZeroCompletion
code: instance [Zero α] : Zero (Completion α) 
goal: Zero (UniformSpace.Completion α)

full_name: instNegCompletion
code: instance [Neg α] : Neg (Completion α) 
goal: Neg (UniformSpace.Completion α)

full_name: instAddCompletion
code: instance [Add α] : Add (Completion α) 
goal: Add (UniformSpace.Completion α)

full_name: instSubCompletion
code: instance [Sub α] : Sub (Completion α) 
goal: Sub (UniformSpace.Completion α)

full_name: UniformSpace.Completion.coe_zero
code: @[norm_cast]
theorem UniformSpace.Completion.coe_zero [Zero α] : ((0 : α) : Completion α) = 0 
goal: ↑α 0 = 0

full_name: UniformSpace.Completion.instMulActionWithZeroOfUniformContinuousConstSMul
code: instance [UniformSpace α] [MonoidWithZero M] [Zero α] [MulActionWithZero M α]
    [UniformContinuousConstSMul M α] : MulActionWithZero M (Completion α) 
goal: MulActionWithZero M (UniformSpace.Completion α)

full_name: UniformSpace.Completion.coe_neg
code: @[norm_cast]
theorem coe_neg (a : α) : ((-a : α) : Completion α) = -a 
goal: ↑α (-a) = -↑α a

full_name: UniformSpace.Completion.coe_sub
code: @[norm_cast]
theorem coe_sub (a b : α) : ((a - b : α) : Completion α) = a - b 
goal: ↑α (a - b) = ↑α a - ↑α b

full_name: UniformSpace.Completion.coe_add
code: @[norm_cast]
theorem coe_add (a b : α) : ((a + b : α) : Completion α) = a + b 
goal: ↑α (a + b) = ↑α a + ↑α b

full_name: UniformSpace.Completion.instAddMonoid
code: instance : AddMonoid (Completion α) 
goal: AddMonoid (UniformSpace.Completion α)

full_name: UniformSpace.Completion.instSubNegMonoid
code: instance : SubNegMonoid (Completion α) 
goal: SubNegMonoid (UniformSpace.Completion α)

full_name: UniformSpace.Completion.addGroup
code: instance addGroup : AddGroup (Completion α) 
goal: AddGroup (UniformSpace.Completion α)

full_name: UniformSpace.Completion.uniformAddGroup
code: instance uniformAddGroup : UniformAddGroup (Completion α) 
goal: UniformAddGroup (UniformSpace.Completion α)

full_name: UniformSpace.Completion.instDistribMulActionOfUniformContinuousConstSMul
code: instance {M} [Monoid M] [DistribMulAction M α] [UniformContinuousConstSMul M α] :
    DistribMulAction M (Completion α) 
goal: DistribMulAction M (UniformSpace.Completion α)

full_name: UniformSpace.Completion.toCompl
code: /-- The map from a group to its completion as a group hom. -/
@[simps]
def toCompl : α →+ Completion α 
goal: α →+ UniformSpace.Completion α

full_name: UniformSpace.Completion.toCompl_apply
code: /-- The map from a group to its completion as a group hom. -/
@[simps]
def toCompl : α →+ Completion α 
goal: ∀ (a : α), UniformSpace.Completion.toCompl a = ↑α a

full_name: UniformSpace.Completion.continuous_toCompl
code: theorem continuous_toCompl : Continuous (toCompl : α → Completion α) 
goal: Continuous ⇑UniformSpace.Completion.toCompl

full_name: UniformSpace.Completion.denseInducing_toCompl
code: theorem denseInducing_toCompl : DenseInducing (toCompl : α → Completion α) 
goal: DenseInducing ⇑UniformSpace.Completion.toCompl

full_name: UniformSpace.Completion.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup (Completion α) 
goal: AddCommGroup (UniformSpace.Completion α)

full_name: UniformSpace.Completion.instModule
code: instance instModule [Semiring R] [Module R α] [UniformContinuousConstSMul R α] :
    Module R (Completion α) 
goal: Module R (UniformSpace.Completion α)

full_name: AddMonoidHom.extension
code: /-- Extension to the completion of a continuous group hom. -/
def AddMonoidHom.extension [CompleteSpace β] [T0Space β] (f : α →+ β) (hf : Continuous f) :
    Completion α →+ β 
goal: UniformSpace.Completion α →+ β

full_name: AddMonoidHom.extension_coe
code: theorem AddMonoidHom.extension_coe [CompleteSpace β] [T0Space β] (f : α →+ β)
    (hf : Continuous f) (a : α) : f.extension hf a = f a 
goal: (f.extension hf) (↑α a) = f a

full_name: AddMonoidHom.continuous_extension
code: @[continuity]
theorem AddMonoidHom.continuous_extension [CompleteSpace β] [T0Space β] (f : α →+ β)
    (hf : Continuous f) : Continuous (f.extension hf) 
goal: Continuous ⇑(f.extension hf)

full_name: AddMonoidHom.completion
code: /-- Completion of a continuous group hom, as a group hom. -/
def AddMonoidHom.completion (f : α →+ β) (hf : Continuous f) : Completion α →+ Completion β 
goal: UniformSpace.Completion α →+ UniformSpace.Completion β

full_name: AddMonoidHom.continuous_completion
code: @[continuity]
theorem AddMonoidHom.continuous_completion (f : α →+ β) (hf : Continuous f) :
    Continuous (AddMonoidHom.completion f hf : Completion α → Completion β) 
goal: Continuous ⇑(f.completion hf)

full_name: AddMonoidHom.completion_coe
code: theorem AddMonoidHom.completion_coe (f : α →+ β) (hf : Continuous f) (a : α) :
    AddMonoidHom.completion f hf a = f a 
goal: (f.completion hf) (↑α a) = ↑β (f a)

full_name: AddMonoidHom.completion_zero
code: theorem AddMonoidHom.completion_zero :
    AddMonoidHom.completion (0 : α →+ β) continuous_const = 0 
goal: AddMonoidHom.completion 0 ⋯ = 0

full_name: AddMonoidHom.completion_add
code: theorem AddMonoidHom.completion_add {γ : Type*} [AddCommGroup γ] [UniformSpace γ]
    [UniformAddGroup γ] (f g : α →+ γ) (hf : Continuous f) (hg : Continuous g) :
    AddMonoidHom.completion (f + g) (hf.add hg) =
    AddMonoidHom.completion f hf + AddMonoidHom.completion g hg 
goal: (f + g).completion ⋯ = f.completion hf + g.completion hg