l3lab/ntp-mathlib huggingface dataset:
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
⊢ ↑(IsUnit.unit h)⁻¹ ∈ S

Next tactic:
have hx := h.star.mul h
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
⊢ ↑(IsUnit.unit h)⁻¹ ∈ S

Next tactic:
suffices this : (↑hx.unit⁻¹ : A) ∈ S
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · 

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : ↑(IsUnit.unit hx)⁻¹ ∈ S
⊢ ↑(IsUnit.unit h)⁻¹ ∈ S

Next tactic:
rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : ↑(IsUnit.unit hx)⁻¹ ∈ S
⊢ ↑(IsUnit.unit hx)⁻¹ * star x ∈ S

Next tactic:
exact mul_mem this (star_mem hxS)
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  

Proof state:
case this
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
⊢ ↑(IsUnit.unit hx)⁻¹ ∈ S

Next tactic:
refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
  

Proof state:
case this
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
⊢ ↑(IsUnit.unit hx)⁻¹ ∈ elementalStarAlgebra ℂ (star x * x)

Next tactic:
haveI := (IsSelfAdjoint.star_mul_self x).isStarNormal
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
  haveI := (IsSelfAdjoint.star_mul_self x).isStarNormal
  

Proof state:
case this
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : IsStarNormal (star x * x)
⊢ ↑(IsUnit.unit hx)⁻¹ ∈ elementalStarAlgebra ℂ (star x * x)

Next tactic:
have hx' := elementalStarAlgebra.isUnit_of_isUnit_of_isStarNormal hx
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
  haveI := (IsSelfAdjoint.star_mul_self x).isStarNormal
  have hx' := elementalStarAlgebra.isUnit_of_isUnit_of_isStarNormal hx
  

Proof state:
case this
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : IsStarNormal (star x * x)
hx' : IsUnit { val := star x * x, property := (_ : star x * x ∈ elementalStarAlgebra ℂ (star x * x)) }
⊢ ↑(IsUnit.unit hx)⁻¹ ∈ elementalStarAlgebra ℂ (star x * x)

Next tactic:
convert (↑hx'.unit⁻¹ : elementalStarAlgebra ℂ (star x * x)).prop using 1
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
  haveI := (IsSelfAdjoint.star_mul_self x).isStarNormal
  have hx' := elementalStarAlgebra.isUnit_of_isUnit_of_isStarNormal hx
  convert (↑hx'.unit⁻¹ : elementalStarAlgebra ℂ (star x * x)).prop using 1
  

Proof state:
case h.e'_4
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : IsStarNormal (star x * x)
hx' : IsUnit { val := star x * x, property := (_ : star x * x ∈ elementalStarAlgebra ℂ (star x * x)) }
⊢ ↑(IsUnit.unit hx)⁻¹ = ↑↑(IsUnit.unit hx')⁻¹

Next tactic:
refine left_inv_eq_right_inv hx.unit.inv_mul ?_
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S := by
  have hx := h.star.mul h
  suffices this : (↑hx.unit⁻¹ : A) ∈ S
  · rw [← one_mul (↑h.unit⁻¹ : A), ← hx.unit.inv_mul, mul_assoc, IsUnit.unit_spec, mul_assoc,
      h.mul_val_inv, mul_one]
    exact mul_mem this (star_mem hxS)
  refine' le_of_isClosed_of_mem ℂ hS (mul_mem (star_mem hxS) hxS) _
  haveI := (IsSelfAdjoint.star_mul_self x).isStarNormal
  have hx' := elementalStarAlgebra.isUnit_of_isUnit_of_isStarNormal hx
  convert (↑hx'.unit⁻¹ : elementalStarAlgebra ℂ (star x * x)).prop using 1
  refine left_inv_eq_right_inv hx.unit.inv_mul ?_
  

Proof state:
case h.e'_4
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : A
h : IsUnit x
hxS : x ∈ S
hx : IsUnit (star x * x)
this : IsStarNormal (star x * x)
hx' : IsUnit { val := star x * x, property := (_ : star x * x ∈ elementalStarAlgebra ℂ (star x * x)) }
⊢ ↑(IsUnit.unit hx) * ↑↑(IsUnit.unit hx')⁻¹ = 1

Next tactic:
exact (congr_arg ((↑) : _ → A) hx'.unit.mul_inv)
/-- For a unital C⋆-subalgebra `S` of `A` and `x : S`, if `↑x : A` is invertible in `A`, then
`x` is invertible in `S`. -/
theorem StarSubalgebra.coe_isUnit {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A)) {x : S} :
    IsUnit (x : A) ↔ IsUnit x := by
  

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
⊢ IsUnit ↑x ↔ IsUnit x

Next tactic:
refine'
    ⟨fun hx => ⟨⟨x, ⟨(↑hx.unit⁻¹ : A), StarSubalgebra.isUnit_coe_inv_mem hS hx x.prop⟩, _, _⟩, rfl⟩,
      fun hx => hx.map S.subtype⟩
/-- For a unital C⋆-subalgebra `S` of `A` and `x : S`, if `↑x : A` is invertible in `A`, then
`x` is invertible in `S`. -/
theorem StarSubalgebra.coe_isUnit {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A)) {x : S} :
    IsUnit (x : A) ↔ IsUnit x := by
  refine'
    ⟨fun hx => ⟨⟨x, ⟨(↑hx.unit⁻¹ : A), StarSubalgebra.isUnit_coe_inv_mem hS hx x.prop⟩, _, _⟩, rfl⟩,
      fun hx => hx.map S.subtype⟩
  

Proof state:
case refine'_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ x * { val := ↑(IsUnit.unit hx)⁻¹, property := (_ : ↑(IsUnit.unit hx)⁻¹ ∈ S) } = 1
case refine'_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S✝ S : StarSubalgebra ℂ A
hS : IsClosed ↑S
x : ↥S
hx : IsUnit ↑x
⊢ { val := ↑(IsUnit.unit hx)⁻¹, property := (_ : ↑(IsUnit.unit hx)⁻¹ ∈ S) } * x = 1

Next tactic:
exacts [Subtype.coe_injective hx.mul_val_inv, Subtype.coe_injective hx.val_inv_mul]
/-- The natural map from `characterSpace ℂ (elementalStarAlgebra ℂ x)` to `spectrum ℂ x` given
by evaluating `φ` at `x`. This is essentially just evaluation of the `gelfandTransform` of `x`,
but because we want something in `spectrum ℂ x`, as opposed to
`spectrum ℂ ⟨x, elementalStarAlgebra.self_mem ℂ x⟩` there is slightly more work to do. -/
@[simps]
noncomputable def elementalStarAlgebra.characterSpaceToSpectrum (x : A)
    (φ : characterSpace ℂ (elementalStarAlgebra ℂ x)) : spectrum ℂ x where
  val := φ ⟨x, self_mem ℂ x⟩
  property := by
    

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
x : A
φ : ↑(characterSpace ℂ ↥(elementalStarAlgebra ℂ x))
⊢ φ { val := x, property := (_ : x ∈ elementalStarAlgebra ℂ x) } ∈ spectrum ℂ x

Next tactic:
simpa only [StarSubalgebra.spectrum_eq (elementalStarAlgebra.isClosed ℂ x)
        ⟨x, self_mem ℂ x⟩] using
      AlgHom.apply_mem_spectrum φ ⟨x, self_mem ℂ x⟩
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  

Proof state:
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
⊢ Function.Bijective (characterSpaceToSpectrum a)

Next tactic:
refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · 

Proof state:
case refine'_1
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
φ ψ : ↑(characterSpace ℂ ↥(elementalStarAlgebra ℂ a))
h : characterSpaceToSpectrum a φ = characterSpaceToSpectrum a ψ
⊢ Continuous ⇑φ

Next tactic:
exact (map_continuous φ)
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · 

Proof state:
case refine'_2
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
φ ψ : ↑(characterSpace ℂ ↥(elementalStarAlgebra ℂ a))
h : characterSpaceToSpectrum a φ = characterSpaceToSpectrum a ψ
⊢ Continuous ⇑ψ

Next tactic:
exact (map_continuous ψ)
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · 

Proof state:
case refine'_3
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
φ ψ : ↑(characterSpace ℂ ↥(elementalStarAlgebra ℂ a))
h : characterSpaceToSpectrum a φ = characterSpaceToSpectrum a ψ
⊢ φ { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) } =
    ψ { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) }

Next tactic:
simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
  · 

Proof state:
case refine'_4
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
⊢ Function.Surjective (characterSpaceToSpectrum a)

Next tactic:
rintro ⟨z, hz⟩
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
  · rintro ⟨z, hz⟩
    

Proof state:
case refine'_4.mk
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
z : ℂ
hz : z ∈ spectrum ℂ a
⊢ ∃ a_1, characterSpaceToSpectrum a a_1 = { val := z, property := hz }

Next tactic:
have hz' := (StarSubalgebra.spectrum_eq (elementalStarAlgebra.isClosed ℂ a)
      ⟨a, self_mem ℂ a⟩).symm.subst hz
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
  · rintro ⟨z, hz⟩
    have hz' := (StarSubalgebra.spectrum_eq (elementalStarAlgebra.isClosed ℂ a)
      ⟨a, self_mem ℂ a⟩).symm.subst hz
    

Proof state:
case refine'_4.mk
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
z : ℂ
hz : z ∈ spectrum ℂ a
hz' : z ∈ spectrum ℂ { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) }
⊢ ∃ a_1, characterSpaceToSpectrum a a_1 = { val := z, property := hz }

Next tactic:
rw [CharacterSpace.mem_spectrum_iff_exists] at hz'
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
  · rintro ⟨z, hz⟩
    have hz' := (StarSubalgebra.spectrum_eq (elementalStarAlgebra.isClosed ℂ a)
      ⟨a, self_mem ℂ a⟩).symm.subst hz
    rw [CharacterSpace.mem_spectrum_iff_exists] at hz'
    

Proof state:
case refine'_4.mk
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
z : ℂ
hz : z ∈ spectrum ℂ a
hz' : ∃ f, f { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) } = z
⊢ ∃ a_1, characterSpaceToSpectrum a a_1 = { val := z, property := hz }

Next tactic:
obtain ⟨φ, rfl⟩ := hz'
theorem elementalStarAlgebra.bijective_characterSpaceToSpectrum :
    Function.Bijective (elementalStarAlgebra.characterSpaceToSpectrum a) := by
  refine' ⟨fun φ ψ h => starAlgHomClass_ext ℂ _ _ _, _⟩
  · exact (map_continuous φ)
  · exact (map_continuous ψ)
  · simpa only [elementalStarAlgebra.characterSpaceToSpectrum, Subtype.mk_eq_mk,
      ContinuousMap.coe_mk] using h
  · rintro ⟨z, hz⟩
    have hz' := (StarSubalgebra.spectrum_eq (elementalStarAlgebra.isClosed ℂ a)
      ⟨a, self_mem ℂ a⟩).symm.subst hz
    rw [CharacterSpace.mem_spectrum_iff_exists] at hz'
    obtain ⟨φ, rfl⟩ := hz'
    

Proof state:
case refine'_4.mk.intro
A : Type u_1
inst✝⁶ : NormedRing A
inst✝⁵ : NormedAlgebra ℂ A
inst✝⁴ : StarRing A
inst✝³ : CstarRing A
inst✝² : StarModule ℂ A
inst✝¹ : CompleteSpace A
a : A
inst✝ : IsStarNormal a
S : StarSubalgebra ℂ A
φ : ↑(characterSpace ℂ ↥(elementalStarAlgebra ℂ a))
hz : φ { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) } ∈ spectrum ℂ a
⊢ ∃ a_1,
    characterSpaceToSpectrum a a_1 =
      { val := φ { val := a, property := (_ : a ∈ elementalStarAlgebra ℂ a) }, property := hz }

Next tactic:
exact ⟨φ, rfl⟩
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    

Proof state:
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
⊢ Smooth (ModelWithCorners.prod 𝓘(𝕜, R) 𝓘(𝕜, R)) 𝓘(𝕜, R) fun p => p.1 * p.2

Next tactic:
apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
    

Proof state:
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
⊢ ContMDiff (ModelWithCorners.prod 𝓘(𝕜, R) 𝓘(𝕜, R)) 𝓘(𝕜, R) ⊤ (val ∘ fun p => p.1 * p.2)

Next tactic:
have : (val : Rˣ → R) ∘ (fun x : Rˣ × Rˣ => x.1 * x.2) =
      (fun x : R × R => x.1 * x.2) ∘ (fun x : Rˣ × Rˣ => (x.1, x.2)) := by ext; simp
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
    have : (val : Rˣ → R) ∘ (fun x : Rˣ × Rˣ => x.1 * x.2) =
      (fun x : R × R => x.1 * x.2) ∘ (fun x : Rˣ × Rˣ => (x.1, x.2)) := by 

Proof state:
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
⊢ (val ∘ fun x => x.1 * x.2) = (fun x => x.1 * x.2) ∘ fun x => (↑x.1, ↑x.2)

Next tactic:
ext
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
    have : (val : Rˣ → R) ∘ (fun x : Rˣ × Rˣ => x.1 * x.2) =
      (fun x : R × R => x.1 * x.2) ∘ (fun x : Rˣ × Rˣ => (x.1, x.2)) := by ext; 

Proof state:
case h
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
x✝ : Rˣ × Rˣ
⊢ (val ∘ fun x => x.1 * x.2) x✝ = ((fun x => x.1 * x.2) ∘ fun x => (↑x.1, ↑x.2)) x✝

Next tactic:
simp
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
    have : (val : Rˣ → R) ∘ (fun x : Rˣ × Rˣ => x.1 * x.2) =
      (fun x : R × R => x.1 * x.2) ∘ (fun x : Rˣ × Rˣ => (x.1, x.2)) := by ext; simp
    

Proof state:
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
this : (val ∘ fun x => x.1 * x.2) = (fun x => x.1 * x.2) ∘ fun x => (↑x.1, ↑x.2)
⊢ ContMDiff (ModelWithCorners.prod 𝓘(𝕜, R) 𝓘(𝕜, R)) 𝓘(𝕜, R) ⊤ (val ∘ fun p => p.1 * p.2)

Next tactic:
rw [this]
/-- The units of a complete normed ring form a Lie group. -/
instance : LieGroup 𝓘(𝕜, R) Rˣ where
  smooth_mul := by
    apply ContMDiff.of_comp_openEmbedding Units.openEmbedding_val
    have : (val : Rˣ → R) ∘ (fun x : Rˣ × Rˣ => x.1 * x.2) =
      (fun x : R × R => x.1 * x.2) ∘ (fun x : Rˣ × Rˣ => (x.1, x.2)) := by ext; simp
    rw [this]
    

Proof state:
R : Type u_1
inst✝³ : NormedRing R
inst✝² : CompleteSpace R
𝕜 : Type u_2
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 R
this : (val ∘ fun x => x.1 * x.2) = (fun x => x.1 * x.2) ∘ fun x => (↑x.1, ↑x.2)
⊢ ContMDiff (ModelWithCorners.prod 𝓘(𝕜, R) 𝓘(𝕜, R)) 𝓘(𝕜, R) ⊤ ((fun x => x.1 * x.2) ∘ fun x => (↑x.1, ↑x.2))

Next tactic:
have : ContMDiff (𝓘(𝕜, R).prod 𝓘(𝕜, R)) 𝓘(𝕜, R × R) ∞
      (fun x : Rˣ × Rˣ => ((x.1 : R), (x.2 : R))) :=
      (contMDiff_val.comp contMDiff_fst).prod_mk_space (contMDiff_val.comp contMDiff_snd)