l3lab/ntp-mathlib huggingface dataset:
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, zero_mul]
    mul_zero := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, mul_zero]
    one_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_id) fun a => by
        rw [← coe_one, ← coe_mul, one_mul]
    mul_one := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_id) fun a => by
        rw [← coe_one, ← coe_mul, mul_one]
    mul_assoc := fun a b c =>
      Completion.induction_on₃ a b c
        (isClosed_eq
          (Continuous.mul (Continuous.mul continuous_fst (continuous_fst.comp continuous_snd))
            (continuous_snd.comp continuous_snd))
          (Continuous.mul continuous_fst
            (Continuous.mul (continuous_fst.comp continuous_snd)
              (continuous_snd.comp continuous_snd))))
                fun a b c => by rw [← coe_mul, ← coe_mul, ← coe_mul, ← coe_mul, mul_assoc]
    left_distrib := fun a b c =>
      Completion.induction_on₃ a b c
        (isClosed_eq
          (Continuous.mul continuous_fst
            (Continuous.add (continuous_fst.comp continuous_snd)
              (continuous_snd.comp continuous_snd)))
          (Continuous.add (Continuous.mul continuous_fst (continuous_fst.comp continuous_snd))
            (Continuous.mul continuous_fst (continuous_snd.comp continuous_snd))))
        fun a b c => by rw [← coe_add, ← coe_mul, ← coe_mul, ← coe_mul, ← coe_add, mul_add]
    right_distrib := fun a b c =>
      Completion.induction_on₃ a b c
        (isClosed_eq
          (Continuous.mul (Continuous.add continuous_fst (continuous_fst.comp continuous_snd))
            (continuous_snd.comp continuous_snd))
          (Continuous.add (Continuous.mul continuous_fst (continuous_snd.comp continuous_snd))
            (Continuous.mul (continuous_fst.comp continuous_snd)
              (continuous_snd.comp continuous_snd))))
        fun a b c => by 

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ b✝ c✝ : Completion α
a b c : α
⊢ (↑α a + ↑α b) * ↑α c = ↑α a * ↑α c + ↑α b * ↑α c

Next tactic:
rw [← coe_add, ← coe_mul, ← coe_mul, ← coe_mul, ← coe_add, add_mul]
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by 

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ : Completion α
a : α
⊢ 0 * ↑α a = 0

Next tactic:
rw [← coe_zero, ← coe_mul, zero_mul]
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, zero_mul]
    mul_zero := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_const)
        fun a => by 

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ : Completion α
a : α
⊢ ↑α a * 0 = 0

Next tactic:
rw [← coe_zero, ← coe_mul, mul_zero]
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, zero_mul]
    mul_zero := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, mul_zero]
    one_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_id) fun a => by
        rw [← coe_one, ← coe_mul, one_mul]
    mul_one := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_id) fun a => by
        rw [← coe_one, ← coe_mul, mul_one]
    mul_assoc := fun a b c =>
      Completion.induction_on₃ a b c
        (isClosed_eq
          (Continuous.mul (Continuous.mul continuous_fst (continuous_fst.comp continuous_snd))
            (continuous_snd.comp continuous_snd))
          (Continuous.mul continuous_fst
            (Continuous.mul (continuous_fst.comp continuous_snd)
              (continuous_snd.comp continuous_snd))))
                fun a b c => by 

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ b✝ c✝ : Completion α
a b c : α
⊢ ↑α a * ↑α b * ↑α c = ↑α a * (↑α b * ↑α c)

Next tactic:
rw [← coe_mul, ← coe_mul, ← coe_mul, ← coe_mul, mul_assoc]
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, zero_mul]
    mul_zero := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, mul_zero]
    one_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_id) fun a => by
        

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ : Completion α
a : α
⊢ 1 * ↑α a = ↑α a

Next tactic:
rw [← coe_one, ← coe_mul, one_mul]
instance ring : Ring (Completion α) :=
  { AddMonoidWithOne.unary, (inferInstanceAs (AddCommGroup (Completion α))),
      (inferInstanceAs (Mul (Completion α))), (inferInstanceAs (One (Completion α))) with
    zero_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, zero_mul]
    mul_zero := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_const)
        fun a => by rw [← coe_zero, ← coe_mul, mul_zero]
    one_mul := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_const continuous_id) continuous_id) fun a => by
        rw [← coe_one, ← coe_mul, one_mul]
    mul_one := fun a =>
      Completion.induction_on a
        (isClosed_eq (Continuous.mul continuous_id continuous_const) continuous_id) fun a => by
        

Proof state:
α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
src✝³ : AddMonoidWithOne (Completion α) := AddMonoidWithOne.unary
src✝² : AddCommGroup (Completion α) := inferInstanceAs (AddCommGroup (Completion α))
src✝¹ : Mul (Completion α) := inferInstanceAs (Mul (Completion α))
src✝ : One (Completion α) := inferInstanceAs (One (Completion α))
a✝ : Completion α
a : α
⊢ ↑α a * 1 = ↑α a

Next tactic:
rw [← coe_one, ← coe_mul, mul_one]
/-- The completion extension as a ring morphism. -/
def extensionHom [CompleteSpace β] [SeparatedSpace β] : Completion α →+* β :=
  have hf' : Continuous (f : α →+ β) := hf
  -- helping the elaborator
  have hf : UniformContinuous f := uniformContinuous_addMonoidHom_of_continuous hf'
  { toFun := Completion.extension f
    map_zero' := by simp_rw [← coe_zero, extension_coe hf, f.map_zero]
    map_add' := fun a b =>
      Completion.induction_on₂ a b
        (isClosed_eq (continuous_extension.comp continuous_add)
          ((continuous_extension.comp continuous_fst).add
            (continuous_extension.comp continuous_snd)))
        fun a b => by
        simp_rw [← coe_add, extension_coe hf, f.map_add]
    map_one' := by 

Proof state:
α : Type u_1
inst✝⁹ : Ring α
inst✝⁸ : UniformSpace α
inst✝⁷ : TopologicalRing α
inst✝⁶ : UniformAddGroup α
β : Type u
inst✝⁵ : UniformSpace β
inst✝⁴ : Ring β
inst✝³ : UniformAddGroup β
inst✝² : TopologicalRing β
f : α →+* β
hf✝ : Continuous ⇑f
inst✝¹ : CompleteSpace β
inst✝ : SeparatedSpace β
hf' : Continuous ⇑↑f
hf : UniformContinuous ⇑f
⊢ Completion.extension (⇑f) 1 = 1

Next tactic:
rw [← coe_one, extension_coe hf, f.map_one]
/-- The completion extension as a ring morphism. -/
def extensionHom [CompleteSpace β] [SeparatedSpace β] : Completion α →+* β :=
  have hf' : Continuous (f : α →+ β) := hf
  -- helping the elaborator
  have hf : UniformContinuous f := uniformContinuous_addMonoidHom_of_continuous hf'
  { toFun := Completion.extension f
    map_zero' := by simp_rw [← coe_zero, extension_coe hf, f.map_zero]
    map_add' := fun a b =>
      Completion.induction_on₂ a b
        (isClosed_eq (continuous_extension.comp continuous_add)
          ((continuous_extension.comp continuous_fst).add
            (continuous_extension.comp continuous_snd)))
        fun a b => by
        simp_rw [← coe_add, extension_coe hf, f.map_add]
    map_one' := by rw [← coe_one, extension_coe hf, f.map_one]
    map_mul' := fun a b =>
      Completion.induction_on₂ a b
        (isClosed_eq (continuous_extension.comp continuous_mul)
          ((continuous_extension.comp continuous_fst).mul
            (continuous_extension.comp continuous_snd)))
        fun a b => by
        

Proof state:
α : Type u_1
inst✝⁹ : Ring α
inst✝⁸ : UniformSpace α
inst✝⁷ : TopologicalRing α
inst✝⁶ : UniformAddGroup α
β : Type u
inst✝⁵ : UniformSpace β
inst✝⁴ : Ring β
inst✝³ : UniformAddGroup β
inst✝² : TopologicalRing β
f : α →+* β
hf✝ : Continuous ⇑f
inst✝¹ : CompleteSpace β
inst✝ : SeparatedSpace β
hf' : Continuous ⇑↑f
hf : UniformContinuous ⇑f
a✝ b✝ : Completion α
a b : α
⊢ OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) } (↑α a * ↑α b) =
    OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) } (↑α a) *
      OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) } (↑α b)

Next tactic:
simp_rw [← coe_mul, extension_coe hf, f.map_mul]
/-- The completion extension as a ring morphism. -/
def extensionHom [CompleteSpace β] [SeparatedSpace β] : Completion α →+* β :=
  have hf' : Continuous (f : α →+ β) := hf
  -- helping the elaborator
  have hf : UniformContinuous f := uniformContinuous_addMonoidHom_of_continuous hf'
  { toFun := Completion.extension f
    map_zero' := by 

Proof state:
α : Type u_1
inst✝⁹ : Ring α
inst✝⁸ : UniformSpace α
inst✝⁷ : TopologicalRing α
inst✝⁶ : UniformAddGroup α
β : Type u
inst✝⁵ : UniformSpace β
inst✝⁴ : Ring β
inst✝³ : UniformAddGroup β
inst✝² : TopologicalRing β
f : α →+* β
hf✝ : Continuous ⇑f
inst✝¹ : CompleteSpace β
inst✝ : SeparatedSpace β
hf' : Continuous ⇑↑f
hf : UniformContinuous ⇑f
⊢ OneHom.toFun
      (↑{ toOneHom := { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (a b : Completion α),
                OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                    (a * b) =
                  OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      a *
                    OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      b) })
      0 =
    0

Next tactic:
simp_rw [← coe_zero, extension_coe hf, f.map_zero]
/-- The completion extension as a ring morphism. -/
def extensionHom [CompleteSpace β] [SeparatedSpace β] : Completion α →+* β :=
  have hf' : Continuous (f : α →+ β) := hf
  -- helping the elaborator
  have hf : UniformContinuous f := uniformContinuous_addMonoidHom_of_continuous hf'
  { toFun := Completion.extension f
    map_zero' := by simp_rw [← coe_zero, extension_coe hf, f.map_zero]
    map_add' := fun a b =>
      Completion.induction_on₂ a b
        (isClosed_eq (continuous_extension.comp continuous_add)
          ((continuous_extension.comp continuous_fst).add
            (continuous_extension.comp continuous_snd)))
        fun a b => by
        

Proof state:
α : Type u_1
inst✝⁹ : Ring α
inst✝⁸ : UniformSpace α
inst✝⁷ : TopologicalRing α
inst✝⁶ : UniformAddGroup α
β : Type u
inst✝⁵ : UniformSpace β
inst✝⁴ : Ring β
inst✝³ : UniformAddGroup β
inst✝² : TopologicalRing β
f : α →+* β
hf✝ : Continuous ⇑f
inst✝¹ : CompleteSpace β
inst✝ : SeparatedSpace β
hf' : Continuous ⇑↑f
hf : UniformContinuous ⇑f
a✝ b✝ : Completion α
a b : α
⊢ OneHom.toFun
      (↑{ toOneHom := { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (a b : Completion α),
                OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                    (a * b) =
                  OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      a *
                    OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      b) })
      (↑α a + ↑α b) =
    OneHom.toFun
        (↑{ toOneHom := { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (a b : Completion α),
                  OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      (a * b) =
                    OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                        a *
                      OneHom.toFun
                        { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) } b) })
        (↑α a) +
      OneHom.toFun
        (↑{ toOneHom := { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (a b : Completion α),
                  OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                      (a * b) =
                    OneHom.toFun { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) }
                        a *
                      OneHom.toFun
                        { toFun := Completion.extension ⇑f, map_one' := (_ : Completion.extension (⇑f) 1 = 1) } b) })
        (↑α b)

Next tactic:
simp_rw [← coe_add, extension_coe hf, f.map_add]
@[simp]
theorem map_smul_eq_mul_coe (r : R) :
    Completion.map (r • ·) = ((algebraMap R A r : Completion A) * ·) := by
  

Proof state:
α : Type u_1
inst✝¹⁴ : Ring α
inst✝¹³ : UniformSpace α
inst✝¹² : TopologicalRing α
inst✝¹¹ : UniformAddGroup α
β : Type u
inst✝¹⁰ : UniformSpace β
inst✝⁹ : Ring β
inst✝⁸ : UniformAddGroup β
inst✝⁷ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
A : Type u_2
inst✝⁶ : Ring A
inst✝⁵ : UniformSpace A
inst✝⁴ : UniformAddGroup A
inst✝³ : TopologicalRing A
R : Type u_3
inst✝² : CommSemiring R
inst✝¹ : Algebra R A
inst✝ : UniformContinuousConstSMul R A
r : R
⊢ (Completion.map fun x => r • x) = fun x => ↑A ((algebraMap R A) r) * x

Next tactic:
ext x
@[simp]
theorem map_smul_eq_mul_coe (r : R) :
    Completion.map (r • ·) = ((algebraMap R A r : Completion A) * ·) := by
  ext x
  

Proof state:
case h
α : Type u_1
inst✝¹⁴ : Ring α
inst✝¹³ : UniformSpace α
inst✝¹² : TopologicalRing α
inst✝¹¹ : UniformAddGroup α
β : Type u
inst✝¹⁰ : UniformSpace β
inst✝⁹ : Ring β
inst✝⁸ : UniformAddGroup β
inst✝⁷ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
A : Type u_2
inst✝⁶ : Ring A
inst✝⁵ : UniformSpace A
inst✝⁴ : UniformAddGroup A
inst✝³ : TopologicalRing A
R : Type u_3
inst✝² : CommSemiring R
inst✝¹ : Algebra R A
inst✝ : UniformContinuousConstSMul R A
r : R
x : Completion A
⊢ Completion.map (fun x => r • x) x = ↑A ((algebraMap R A) r) * x

Next tactic:
refine' Completion.induction_on x _ fun a => _
@[simp]
theorem map_smul_eq_mul_coe (r : R) :
    Completion.map (r • ·) = ((algebraMap R A r : Completion A) * ·) := by
  ext x
  refine' Completion.induction_on x _ fun a => _
  · 

Proof state:
case h.refine'_1
α : Type u_1
inst✝¹⁴ : Ring α
inst✝¹³ : UniformSpace α
inst✝¹² : TopologicalRing α
inst✝¹¹ : UniformAddGroup α
β : Type u
inst✝¹⁰ : UniformSpace β
inst✝⁹ : Ring β
inst✝⁸ : UniformAddGroup β
inst✝⁷ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
A : Type u_2
inst✝⁶ : Ring A
inst✝⁵ : UniformSpace A
inst✝⁴ : UniformAddGroup A
inst✝³ : TopologicalRing A
R : Type u_3
inst✝² : CommSemiring R
inst✝¹ : Algebra R A
inst✝ : UniformContinuousConstSMul R A
r : R
x : Completion A
⊢ IsClosed {a | Completion.map (fun x => r • x) a = ↑A ((algebraMap R A) r) * a}

Next tactic:
exact isClosed_eq Completion.continuous_map (continuous_mul_left _)
@[simp]
theorem map_smul_eq_mul_coe (r : R) :
    Completion.map (r • ·) = ((algebraMap R A r : Completion A) * ·) := by
  ext x
  refine' Completion.induction_on x _ fun a => _
  · exact isClosed_eq Completion.continuous_map (continuous_mul_left _)
  · 

Proof state:
case h.refine'_2
α : Type u_1
inst✝¹⁴ : Ring α
inst✝¹³ : UniformSpace α
inst✝¹² : TopologicalRing α
inst✝¹¹ : UniformAddGroup α
β : Type u
inst✝¹⁰ : UniformSpace β
inst✝⁹ : Ring β
inst✝⁸ : UniformAddGroup β
inst✝⁷ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
A : Type u_2
inst✝⁶ : Ring A
inst✝⁵ : UniformSpace A
inst✝⁴ : UniformAddGroup A
inst✝³ : TopologicalRing A
R : Type u_3
inst✝² : CommSemiring R
inst✝¹ : Algebra R A
inst✝ : UniformContinuousConstSMul R A
r : R
x : Completion A
a : A
⊢ Completion.map (fun x => r • x) (↑A a) = ↑A ((algebraMap R A) r) * ↑A a

Next tactic:
simp_rw [map_coe (uniformContinuous_const_smul r) a, Algebra.smul_def, coe_mul]
instance algebra : Algebra R (Completion A) :=
  { (UniformSpace.Completion.coeRingHom : A →+* Completion A).comp (algebraMap R A) with
    commutes' := fun r x =>
      Completion.induction_on x (isClosed_eq (continuous_mul_left _) (continuous_mul_right _))
        fun a => by
        

Proof state:
α : Type u_1
inst✝¹⁴ : Ring α
inst✝¹³ : UniformSpace α
inst✝¹² : TopologicalRing α
inst✝¹¹ : UniformAddGroup α
β : Type u
inst✝¹⁰ : UniformSpace β
inst✝⁹ : Ring β
inst✝⁸ : UniformAddGroup β
inst✝⁷ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
A : Type u_2
inst✝⁶ : Ring A
inst✝⁵ : UniformSpace A
inst✝⁴ : UniformAddGroup A
inst✝³ : TopologicalRing A
R : Type u_3
inst✝² : CommSemiring R
inst✝¹ : Algebra R A
inst✝ : UniformContinuousConstSMul R A
src✝ : R →+* Completion A := RingHom.comp coeRingHom (algebraMap R A)
r : R
x : Completion A
a : A
⊢ { toMonoidHom := ↑src✝, map_zero' := (_ : OneHom.toFun (↑↑src✝) 0 = 0),
          map_add' :=
            (_ : ∀ (x y : R), OneHom.toFun (↑↑src✝) (x + y) = OneHom.toFun (↑↑src✝) x + OneHom.toFun (↑↑src✝) y) }
        r *
      ↑A a =
    ↑A a *
      { toMonoidHom := ↑src✝, map_zero' := (_ : OneHom.toFun (↑↑src✝) 0 = 0),
          map_add' :=
            (_ : ∀ (x y : R), OneHom.toFun (↑↑src✝) (x + y) = OneHom.toFun (↑↑src✝) x + OneHom.toFun (↑↑src✝) y) }
        r

Next tactic:
simpa only [coe_mul] using congr_arg ((↑) : A → Completion A) (Algebra.commutes r a)
instance commRing : CommRing (Completion R) :=
  { Completion.ring with
    mul_comm := fun a b =>
      Completion.induction_on₂ a b
        (isClosed_eq (continuous_fst.mul continuous_snd) (continuous_snd.mul continuous_fst))
        fun a b => by 

Proof state:
α : Type u_1
inst✝¹¹ : Ring α
inst✝¹⁰ : UniformSpace α
inst✝⁹ : TopologicalRing α
inst✝⁸ : UniformAddGroup α
β : Type u
inst✝⁷ : UniformSpace β
inst✝⁶ : Ring β
inst✝⁵ : UniformAddGroup β
inst✝⁴ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
R : Type u_2
inst✝³ : CommRing R
inst✝² : UniformSpace R
inst✝¹ : UniformAddGroup R
inst✝ : TopologicalRing R
src✝ : Ring (Completion R) := ring
a✝ b✝ : Completion R
a b : R
⊢ ↑R a * ↑R b = ↑R b * ↑R a

Next tactic:
rw [← coe_mul, ← coe_mul, mul_comm]
/-- A shortcut instance for the common case -/
instance algebra' : Algebra R (Completion R) := by 

Proof state:
α : Type u_1
inst✝¹¹ : Ring α
inst✝¹⁰ : UniformSpace α
inst✝⁹ : TopologicalRing α
inst✝⁸ : UniformAddGroup α
β : Type u
inst✝⁷ : UniformSpace β
inst✝⁶ : Ring β
inst✝⁵ : UniformAddGroup β
inst✝⁴ : TopologicalRing β
f : α →+* β
hf : Continuous ⇑f
R : Type u_2
inst✝³ : CommRing R
inst✝² : UniformSpace R
inst✝¹ : UniformAddGroup R
inst✝ : TopologicalRing R
⊢ Algebra R (Completion R)

Next tactic:
infer_instance
theorem ring_sep_rel (α) [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    separationSetoid α = Submodule.quotientRel (Ideal.closure ⊥) :=
  Setoid.ext fun x y =>
    (addGroup_separationRel x y).trans <| Iff.trans (by 

Proof state:
α✝ : Type u_1
α : Type u_2
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
x y : α
⊢ x - y ∈ closure {0} ↔ x - y ∈ Ideal.closure ⊥

Next tactic:
rfl
theorem ring_sep_quot (α : Type u) [r : CommRing α] [UniformSpace α] [UniformAddGroup α]
    [TopologicalRing α] : Quotient (separationSetoid α) = (α ⧸ (⊥ : Ideal α).closure) := by
  

Proof state:
α✝ : Type u_1
α : Type u
r : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)

Next tactic:
rw [@ring_sep_rel α r]