l3lab/ntp-mathlib huggingface dataset:
theorem ring_sep_quot (α : Type u) [r : CommRing α] [UniformSpace α] [UniformAddGroup α]
    [TopologicalRing α] : Quotient (separationSetoid α) = (α ⧸ (⊥ : Ideal α).closure) := by
  rw [@ring_sep_rel α r]
  

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

Next tactic:
rfl
/-- Given a topological ring `α` equipped with a uniform structure that makes subtraction uniformly
continuous, get an equivalence between the separated quotient of `α` and the quotient ring
corresponding to the closure of zero. -/
def sepQuotEquivRingQuot (α) [r : CommRing α] [UniformSpace α] [UniformAddGroup α]
    [TopologicalRing α] : Quotient (separationSetoid α) ≃ α ⧸ (⊥ : Ideal α).closure :=
  Quotient.congrRight fun x y =>
    (addGroup_separationRel x y).trans <| Iff.trans (by 

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

Next tactic:
rfl
instance commRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    CommRing (Quotient (separationSetoid α)) := by
  

Proof state:
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ CommRing (Quotient (separationSetoid α))

Next tactic:
rw [ring_sep_quot α]
instance commRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    CommRing (Quotient (separationSetoid α)) := by
  rw [ring_sep_quot α]; 

Proof state:
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ CommRing (α ⧸ Ideal.closure ⊥)

Next tactic:
infer_instance
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  

Proof state:
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ TopologicalRing (Quotient (separationSetoid α))

Next tactic:
convert topologicalRing_quotient (⊥ : Ideal α).closure
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (

Proof state:
case h.e'_1
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)

Next tactic:
try congr; apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try 

Proof state:
case h.e'_1
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)

Next tactic:
congr
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try congr; 

Proof state:
case h.e'_1.e_s
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
⊢ separationSetoid α = Submodule.quotientRel (Ideal.closure ⊥)

Next tactic:
apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (

Proof state:
case h.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq instTopologicalSpaceQuotient (topologicalRingQuotientTopology (Ideal.closure ⊥))

Next tactic:
try congr; apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try 

Proof state:
case h.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq instTopologicalSpaceQuotient (topologicalRingQuotientTopology (Ideal.closure ⊥))

Next tactic:
congr
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try congr; 

Proof state:
case h.e'_2.e_2.h
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ separationSetoid α = Submodule.quotientRel (Ideal.closure ⊥)

Next tactic:
apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (

Proof state:
case h.e'_3.e'_2.e'_2.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq commRing (Ideal.Quotient.commRing (Ideal.closure ⊥))

Next tactic:
try congr; apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try 

Proof state:
case h.e'_3.e'_2.e'_2.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq commRing (Ideal.Quotient.commRing (Ideal.closure ⊥))

Next tactic:
congr
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try congr; 

Proof state:
case h.e'_3.e'_2.e'_2.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq commRing (Ideal.Quotient.commRing (Ideal.closure ⊥))

Next tactic:
apply ring_sep_rel
instance topologicalRing [CommRing α] [UniformSpace α] [UniformAddGroup α] [TopologicalRing α] :
    TopologicalRing (Quotient (separationSetoid α)) := by
  convert topologicalRing_quotient (⊥ : Ideal α).closure
  <;> (try congr; apply ring_sep_rel)
  

Proof state:
case h.e'_3.e'_2.e'_2.e'_2
α : Type u_1
inst✝³ : CommRing α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
inst✝ : TopologicalRing α
e_1✝ : Quotient (separationSetoid α) = (α ⧸ Ideal.closure ⊥)
⊢ HEq commRing (Ideal.Quotient.commRing (Ideal.closure ⊥))

Next tactic:
simp [commRing]
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    

Proof state:
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1

Next tactic:
convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    

Proof state:
case h.e'_2.h.e'_10
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ 1 = i 1
case h.e'_3
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ 1 = f 1

Next tactic:
exacts [i.map_one.symm, f.map_one.symm]
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    simp only [map_zero]
  map_add' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · exact isClosed_eq (Continuous.comp h continuous_add)
        ((h.comp continuous_fst).add (h.comp continuous_snd))
    · simp_rw [← i.map_add, DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous _,
        ← f.map_add]
  map_mul' := by
    

Proof state:
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ ∀ (x y : β),
    OneHom.toFun
        { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
        (x * y) =
      OneHom.toFun
          { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) } x *
        OneHom.toFun
          { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) } y

Next tactic:
have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    simp only [map_zero]
  map_add' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · exact isClosed_eq (Continuous.comp h continuous_add)
        ((h.comp continuous_fst).add (h.comp continuous_snd))
    · simp_rw [← i.map_add, DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous _,
        ← f.map_add]
  map_mul' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    

Proof state:
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
h : Continuous (extend (_ : DenseInducing ⇑i) ⇑f)
⊢ ∀ (x y : β),
    OneHom.toFun
        { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
        (x * y) =
      OneHom.toFun
          { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) } x *
        OneHom.toFun
          { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) } y

Next tactic:
refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    simp only [map_zero]
  map_add' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · exact isClosed_eq (Continuous.comp h continuous_add)
        ((h.comp continuous_fst).add (h.comp continuous_snd))
    · simp_rw [← i.map_add, DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous _,
        ← f.map_add]
  map_mul' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · 

Proof state:
case refine'_1
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
h : Continuous (extend (_ : DenseInducing ⇑i) ⇑f)
x y : β
⊢ IsClosed
    {q |
      OneHom.toFun
          { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
          (q.1 * q.2) =
        OneHom.toFun
            { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
            q.1 *
          OneHom.toFun
            { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
            q.2}

Next tactic:
exact isClosed_eq (Continuous.comp h continuous_mul)
        ((h.comp continuous_fst).mul (h.comp continuous_snd))
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    simp only [map_zero]
  map_add' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · exact isClosed_eq (Continuous.comp h continuous_add)
        ((h.comp continuous_fst).add (h.comp continuous_snd))
    · simp_rw [← i.map_add, DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous _,
        ← f.map_add]
  map_mul' := by
    have h := (uniformContinuous_uniformly_extend ue dr hf).continuous
    refine' fun x y => DenseRange.induction_on₂ dr _ (fun a b => _) x y
    · exact isClosed_eq (Continuous.comp h continuous_mul)
        ((h.comp continuous_fst).mul (h.comp continuous_snd))
    · 

Proof state:
case refine'_2
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
h : Continuous (extend (_ : DenseInducing ⇑i) ⇑f)
x y : β
a b : α
⊢ OneHom.toFun { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
      (i a * i b) =
    OneHom.toFun
        { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
        (i a) *
      OneHom.toFun
        { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) } (i b)

Next tactic:
simp_rw [← i.map_mul, DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous _,
        ← f.map_mul]
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    

Proof state:
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ OneHom.toFun
      (↑{
          toOneHom :=
            { toFun := extend (_ : DenseInducing ⇑i) ⇑f, map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (x y : β),
                OneHom.toFun
                    { toFun := extend (_ : DenseInducing ⇑i) ⇑f,
                      map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
                    (x * y) =
                  OneHom.toFun
                      { toFun := extend (_ : DenseInducing ⇑i) ⇑f,
                        map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
                      x *
                    OneHom.toFun
                      { toFun := extend (_ : DenseInducing ⇑i) ⇑f,
                        map_one' := (_ : extend (_ : DenseInducing ⇑i) (⇑f) 1 = 1) }
                      y) })
      0 =
    0

Next tactic:
convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    

Proof state:
case h.e'_2.h.e'_1
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ 0 = i 0

Next tactic:
simp only [map_zero]
/-- The dense inducing extension as a ring homomorphism. -/
noncomputable def DenseInducing.extendRingHom {i : α →+* β} {f : α →+* γ} (ue : UniformInducing i)
    (dr : DenseRange i) (hf : UniformContinuous f) : β →+* γ where
  toFun := (ue.denseInducing dr).extend f
  map_one' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 1
    exacts [i.map_one.symm, f.map_one.symm]
  map_zero' := by
    convert DenseInducing.extend_eq (ue.denseInducing dr) hf.continuous 0 <;>
    

Proof state:
case h.e'_3
α : Type u_1
inst✝⁹ : UniformSpace α
inst✝⁸ : Semiring α
β : Type u_2
inst✝⁷ : UniformSpace β
inst✝⁶ : Semiring β
inst✝⁵ : TopologicalSemiring β
γ : Type u_3
inst✝⁴ : UniformSpace γ
inst✝³ : Semiring γ
inst✝² : TopologicalSemiring γ
inst✝¹ : T2Space γ
inst✝ : CompleteSpace γ
i : α →+* β
f : α →+* γ
ue : UniformInducing ⇑i
dr : DenseRange ⇑i
hf : UniformContinuous ⇑f
⊢ 0 = f 0

Next tactic:
simp only [map_zero]
theorem toDerivation_injective :
    Function.Injective (toDerivation : LeftInvariantDerivation I G → _) :=
  fun X Y h => by 

Proof state:
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝³ : TopologicalSpace G
inst✝² : ChartedSpace H G
inst✝¹ : Monoid G
inst✝ : SmoothMul I G
g h✝ : G
X Y : LeftInvariantDerivation I G
h : ↑X = ↑Y
⊢ X = Y

Next tactic:
cases X
theorem toDerivation_injective :
    Function.Injective (toDerivation : LeftInvariantDerivation I G → _) :=
  fun X Y h => by cases X; 

Proof state:
case mk
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝³ : TopologicalSpace G
inst✝² : ChartedSpace H G
inst✝¹ : Monoid G
inst✝ : SmoothMul I G
g h✝ : G
Y : LeftInvariantDerivation I G
toDerivation✝ : Derivation 𝕜 C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯
left_invariant''✝ :
  ∀ (g : G), (𝒅ₕ (_ : (𝑳 I g) 1 = g)) ((Derivation.evalAt 1) toDerivation✝) = (Derivation.evalAt g) toDerivation✝
h : ↑{ toDerivation := toDerivation✝, left_invariant'' := left_invariant''✝ } = ↑Y
⊢ { toDerivation := toDerivation✝, left_invariant'' := left_invariant''✝ } = Y

Next tactic:
cases Y
theorem toDerivation_injective :
    Function.Injective (toDerivation : LeftInvariantDerivation I G → _) :=
  fun X Y h => by cases X; cases Y; 

Proof state:
case mk.mk
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁴ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
G : Type u_4
inst✝³ : TopologicalSpace G
inst✝² : ChartedSpace H G
inst✝¹ : Monoid G
inst✝ : SmoothMul I G
g h✝ : G
toDerivation✝¹ : Derivation 𝕜 C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯
left_invariant''✝¹ :
  ∀ (g : G), (𝒅ₕ (_ : (𝑳 I g) 1 = g)) ((Derivation.evalAt 1) toDerivation✝¹) = (Derivation.evalAt g) toDerivation✝¹
toDerivation✝ : Derivation 𝕜 C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯
left_invariant''✝ :
  ∀ (g : G), (𝒅ₕ (_ : (𝑳 I g) 1 = g)) ((Derivation.evalAt 1) toDerivation✝) = (Derivation.evalAt g) toDerivation✝
h :
  ↑{ toDerivation := toDerivation✝¹, left_invariant'' := left_invariant''✝¹ } =
    ↑{ toDerivation := toDerivation✝, left_invariant'' := left_invariant''✝ }
⊢ { toDerivation := toDerivation✝¹, left_invariant'' := left_invariant''✝¹ } =
    { toDerivation := toDerivation✝, left_invariant'' := left_invariant''✝ }

Next tactic:
congr