l3lab/ntp-mathlib huggingface dataset:
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      

Proof state:
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : 𝓝 0 ⊓ F = ⊥
this : NeBot F
⊢ Cauchy (map (fun x => x⁻¹) F)

Next tactic:
rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
      

Proof state:
case intro
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : 𝓝 0 ⊓ F = ⊥
this : NeBot F
x : L
hx : F ≤ 𝓝 x
⊢ Cauchy (map (fun x => x⁻¹) F)

Next tactic:
have hx' : x ≠ 0 := by
        rintro rfl
        rw [inf_eq_right.mpr hx] at hF
        exact cau_F.1.ne hF
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
      have hx' : x ≠ 0 := by
        

Proof state:
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : 𝓝 0 ⊓ F = ⊥
this : NeBot F
x : L
hx : F ≤ 𝓝 x
⊢ x ≠ 0

Next tactic:
rintro rfl
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
      have hx' : x ≠ 0 := by
        rintro rfl
        

Proof state:
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : 𝓝 0 ⊓ F = ⊥
this : NeBot F
hx : F ≤ 𝓝 0
⊢ False

Next tactic:
rw [inf_eq_right.mpr hx] at hF
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
      have hx' : x ≠ 0 := by
        rintro rfl
        rw [inf_eq_right.mpr hx] at hF
        

Proof state:
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : F = ⊥
this : NeBot F
hx : F ≤ 𝓝 0
⊢ False

Next tactic:
exact cau_F.1.ne hF
instance (priority := 100) completableTopField_of_complete (L : Type*) [Field L] [UniformSpace L]
    [TopologicalDivisionRing L] [SeparatedSpace L] [CompleteSpace L] : CompletableTopField L :=
  { ‹SeparatedSpace L› with
    nice := fun F cau_F hF => by
      haveI : NeBot F := cau_F.1
      rcases CompleteSpace.complete cau_F with ⟨x, hx⟩
      have hx' : x ≠ 0 := by
        rintro rfl
        rw [inf_eq_right.mpr hx] at hF
        exact cau_F.1.ne hF
      

Proof state:
case intro
K : Type u_1
inst✝⁹ : Field K
inst✝⁸ : UniformSpace K
L✝ : Type u_2
inst✝⁷ : Field L✝
inst✝⁶ : UniformSpace L✝
inst✝⁵ : CompletableTopField L✝
L : Type u_3
inst✝⁴ : Field L
inst✝³ : UniformSpace L
inst✝² : TopologicalDivisionRing L
inst✝¹ : SeparatedSpace L
inst✝ : CompleteSpace L
src✝ : SeparatedSpace L := inst✝¹
F : Filter L
cau_F : Cauchy F
hF : 𝓝 0 ⊓ F = ⊥
this : NeBot F
x : L
hx : F ≤ 𝓝 x
hx' : x ≠ 0
⊢ Cauchy (map (fun x => x⁻¹) F)

Next tactic:
exact
        Filter.Tendsto.cauchy_map
          (calc
            map (fun x => x⁻¹) F ≤ map (fun x => x⁻¹) (𝓝 x) := map_mono hx
            _ ≤ 𝓝 x⁻¹ := continuousAt_inv₀ hx'
            )
instance : ConcreteCategory SemiNormedGroupCat := by
  

Proof state:
⊢ ConcreteCategory SemiNormedGroupCat

Next tactic:
dsimp [SemiNormedGroupCat]
instance : ConcreteCategory SemiNormedGroupCat := by
  dsimp [SemiNormedGroupCat]
  

Proof state:
⊢ ConcreteCategory (Bundled SeminormedAddCommGroup)

Next tactic:
infer_instance
instance toAddMonoidHomClass {V W : SemiNormedGroupCat} : AddMonoidHomClass (V ⟶ W) V W where
  coe := (forget SemiNormedGroupCat).map
  coe_injective' := fun f g h => by 

Proof state:
V W : SemiNormedGroupCat
f g : V ⟶ W
h : (forget SemiNormedGroupCat).map f = (forget SemiNormedGroupCat).map g
⊢ f = g

Next tactic:
cases f
instance toAddMonoidHomClass {V W : SemiNormedGroupCat} : AddMonoidHomClass (V ⟶ W) V W where
  coe := (forget SemiNormedGroupCat).map
  coe_injective' := fun f g h => by cases f; 

Proof state:
case mk
V W : SemiNormedGroupCat
g : V ⟶ W
toFun✝ : ↑V → ↑W
map_add'✝ : ∀ (v₁ v₂ : ↑V), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : ↑V), ‖toFun✝ v‖ ≤ C * ‖v‖
h :
  (forget SemiNormedGroupCat).map { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } =
    (forget SemiNormedGroupCat).map g
⊢ { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ } = g

Next tactic:
cases g
instance toAddMonoidHomClass {V W : SemiNormedGroupCat} : AddMonoidHomClass (V ⟶ W) V W where
  coe := (forget SemiNormedGroupCat).map
  coe_injective' := fun f g h => by cases f; cases g; 

Proof state:
case mk.mk
V W : SemiNormedGroupCat
toFun✝¹ : ↑V → ↑W
map_add'✝¹ : ∀ (v₁ v₂ : ↑V), toFun✝¹ (v₁ + v₂) = toFun✝¹ v₁ + toFun✝¹ v₂
bound'✝¹ : ∃ C, ∀ (v : ↑V), ‖toFun✝¹ v‖ ≤ C * ‖v‖
toFun✝ : ↑V → ↑W
map_add'✝ : ∀ (v₁ v₂ : ↑V), toFun✝ (v₁ + v₂) = toFun✝ v₁ + toFun✝ v₂
bound'✝ : ∃ C, ∀ (v : ↑V), ‖toFun✝ v‖ ≤ C * ‖v‖
h :
  (forget SemiNormedGroupCat).map { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    (forget SemiNormedGroupCat).map { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }
⊢ { toFun := toFun✝¹, map_add' := map_add'✝¹, bound' := bound'✝¹ } =
    { toFun := toFun✝, map_add' := map_add'✝, bound' := bound'✝ }

Next tactic:
congr
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  

Proof state:
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
⊢ Limits.IsZero V

Next tactic:
refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · 

Proof state:
case refine'_1
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
⊢ f = default

Next tactic:
ext x
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; 

Proof state:
case refine'_1.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
x : ↑V
⊢ f x = default x

Next tactic:
have : x = 0 := Subsingleton.elim _ _
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; 

Proof state:
case refine'_1.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : V ⟶ X
x : ↑V
this : x = 0
⊢ f x = default x

Next tactic:
simp only [this, map_zero]
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; simp only [this, map_zero]
  · 

Proof state:
case refine'_2
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : X ⟶ V
⊢ f = default

Next tactic:
ext
theorem isZero_of_subsingleton (V : SemiNormedGroupCat) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; simp only [this, map_zero]
  · ext; 

Proof state:
case refine'_2.h
V : SemiNormedGroupCat
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat
f : X ⟶ V
x✝ : ↑X
⊢ f x✝ = default x✝

Next tactic:
apply Subsingleton.elim
theorem iso_isometry_of_normNoninc {V W : SemiNormedGroupCat} (i : V ≅ W) (h1 : i.hom.NormNoninc)
    (h2 : i.inv.NormNoninc) : Isometry i.hom := by
  

Proof state:
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
⊢ Isometry ⇑i.hom

Next tactic:
apply AddMonoidHomClass.isometry_of_norm
theorem iso_isometry_of_normNoninc {V W : SemiNormedGroupCat} (i : V ≅ W) (h1 : i.hom.NormNoninc)
    (h2 : i.inv.NormNoninc) : Isometry i.hom := by
  apply AddMonoidHomClass.isometry_of_norm
  

Proof state:
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
⊢ ∀ (x : ↑V), ‖i.hom x‖ = ‖x‖

Next tactic:
intro v
theorem iso_isometry_of_normNoninc {V W : SemiNormedGroupCat} (i : V ≅ W) (h1 : i.hom.NormNoninc)
    (h2 : i.inv.NormNoninc) : Isometry i.hom := by
  apply AddMonoidHomClass.isometry_of_norm
  intro v
  

Proof state:
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖i.hom v‖ = ‖v‖

Next tactic:
apply le_antisymm (h1 v)
theorem iso_isometry_of_normNoninc {V W : SemiNormedGroupCat} (i : V ≅ W) (h1 : i.hom.NormNoninc)
    (h2 : i.inv.NormNoninc) : Isometry i.hom := by
  apply AddMonoidHomClass.isometry_of_norm
  intro v
  apply le_antisymm (h1 v)
  

Proof state:
case a
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖v‖ ≤ ‖i.hom v‖

Next tactic:
calc
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    ‖v‖ = ‖i.inv (i.hom v)‖ := by erw [Iso.hom_inv_id_apply]
    _ ≤ ‖i.hom v‖ := h2 _
theorem iso_isometry_of_normNoninc {V W : SemiNormedGroupCat} (i : V ≅ W) (h1 : i.hom.NormNoninc)
    (h2 : i.inv.NormNoninc) : Isometry i.hom := by
  apply AddMonoidHomClass.isometry_of_norm
  intro v
  apply le_antisymm (h1 v)
  calc
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    ‖v‖ = ‖i.inv (i.hom v)‖ := by 

Proof state:
V W : SemiNormedGroupCat
i : V ≅ W
h1 : NormedAddGroupHom.NormNoninc i.hom
h2 : NormedAddGroupHom.NormNoninc i.inv
v : ↑V
⊢ ‖v‖ = ‖i.inv (i.hom v)‖

Next tactic:
erw [Iso.hom_inv_id_apply]
/-- Promote an isomorphism in `SemiNormedGroupCat` to an isomorphism in `SemiNormedGroupCat₁`. -/
@[simps]
def mkIso {M N : SemiNormedGroupCat} (f : M ≅ N) (i : f.hom.NormNoninc) (i' : f.inv.NormNoninc) :
    SemiNormedGroupCat₁.of M ≅ SemiNormedGroupCat₁.of N where
  hom := mkHom f.hom i
  inv := mkHom f.inv i'
  hom_inv_id := by 

Proof state:
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ mkHom f.hom i ≫ mkHom f.inv i' = 𝟙 (of ↑M)

Next tactic:
apply Subtype.eq
/-- Promote an isomorphism in `SemiNormedGroupCat` to an isomorphism in `SemiNormedGroupCat₁`. -/
@[simps]
def mkIso {M N : SemiNormedGroupCat} (f : M ≅ N) (i : f.hom.NormNoninc) (i' : f.inv.NormNoninc) :
    SemiNormedGroupCat₁.of M ≅ SemiNormedGroupCat₁.of N where
  hom := mkHom f.hom i
  inv := mkHom f.inv i'
  hom_inv_id := by apply Subtype.eq; 

Proof state:
case a
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ ↑(mkHom f.hom i ≫ mkHom f.inv i') = ↑(𝟙 (of ↑M))

Next tactic:
exact f.hom_inv_id
/-- Promote an isomorphism in `SemiNormedGroupCat` to an isomorphism in `SemiNormedGroupCat₁`. -/
@[simps]
def mkIso {M N : SemiNormedGroupCat} (f : M ≅ N) (i : f.hom.NormNoninc) (i' : f.inv.NormNoninc) :
    SemiNormedGroupCat₁.of M ≅ SemiNormedGroupCat₁.of N where
  hom := mkHom f.hom i
  inv := mkHom f.inv i'
  hom_inv_id := by apply Subtype.eq; exact f.hom_inv_id
  inv_hom_id := by 

Proof state:
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ mkHom f.inv i' ≫ mkHom f.hom i = 𝟙 (of ↑N)

Next tactic:
apply Subtype.eq
/-- Promote an isomorphism in `SemiNormedGroupCat` to an isomorphism in `SemiNormedGroupCat₁`. -/
@[simps]
def mkIso {M N : SemiNormedGroupCat} (f : M ≅ N) (i : f.hom.NormNoninc) (i' : f.inv.NormNoninc) :
    SemiNormedGroupCat₁.of M ≅ SemiNormedGroupCat₁.of N where
  hom := mkHom f.hom i
  inv := mkHom f.inv i'
  hom_inv_id := by apply Subtype.eq; exact f.hom_inv_id
  inv_hom_id := by apply Subtype.eq; 

Proof state:
case a
M N : SemiNormedGroupCat
f : M ≅ N
i : NormedAddGroupHom.NormNoninc f.hom
i' : NormedAddGroupHom.NormNoninc f.inv
⊢ ↑(mkHom f.inv i' ≫ mkHom f.hom i) = ↑(𝟙 (of ↑N))

Next tactic:
exact f.inv_hom_id
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  

Proof state:
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
⊢ Limits.IsZero V

Next tactic:
refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · 

Proof state:
case refine'_1
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
⊢ f = default

Next tactic:
ext x
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; 

Proof state:
case refine'_1.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
x : ↑V
⊢ f x = default x

Next tactic:
have : x = 0 := Subsingleton.elim _ _
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; 

Proof state:
case refine'_1.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : V ⟶ X
x : ↑V
this : x = 0
⊢ f x = default x

Next tactic:
simp only [this, map_zero]
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; simp only [this, map_zero]
  · 

Proof state:
case refine'_2
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : X ⟶ V
⊢ f = default

Next tactic:
ext
theorem isZero_of_subsingleton (V : SemiNormedGroupCat₁) [Subsingleton V] : Limits.IsZero V := by
  refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
  · ext x; have : x = 0 := Subsingleton.elim _ _; simp only [this, map_zero]
  · ext; 

Proof state:
case refine'_2.w.h
V : SemiNormedGroupCat₁
inst✝ : Subsingleton ↑V
X : SemiNormedGroupCat₁
f : X ⟶ V
x✝ : ↑X
⊢ f x✝ = default x✝

Next tactic:
apply Subsingleton.elim
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ Isometry ⇑i.hom

Next tactic:
change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
  

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ Isometry
    ⇑{ toZeroHom := { toFun := ⇑i.hom, map_zero' := (_ : i.hom 0 = 0) },
        map_add' := (_ : ∀ (x x_1 : ↑V), i.hom (x + x_1) = i.hom x + i.hom x_1) }

Next tactic:
refine' AddMonoidHomClass.isometry_of_norm _ _
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
  refine' AddMonoidHomClass.isometry_of_norm _ _
  

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
⊢ ∀ (x : ↑V),
    ‖{ toZeroHom := { toFun := ⇑i.hom, map_zero' := (_ : i.hom 0 = 0) },
            map_add' := (_ : ∀ (x x_1 : ↑V), i.hom (x + x_1) = i.hom x + i.hom x_1) }
          x‖ =
      ‖x‖

Next tactic:
intro v
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
  refine' AddMonoidHomClass.isometry_of_norm _ _
  intro v
  

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖{ toZeroHom := { toFun := ⇑i.hom, map_zero' := (_ : i.hom 0 = 0) },
          map_add' := (_ : ∀ (x x_1 : ↑V), i.hom (x + x_1) = i.hom x + i.hom x_1) }
        v‖ =
    ‖v‖

Next tactic:
apply le_antisymm (i.hom.2 v)
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
  refine' AddMonoidHomClass.isometry_of_norm _ _
  intro v
  apply le_antisymm (i.hom.2 v)
  

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖v‖ ≤ ‖↑i.hom v‖

Next tactic:
calc
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    ‖v‖ = ‖i.inv (i.hom v)‖ := by erw [Iso.hom_inv_id_apply]
    _ ≤ ‖i.hom v‖ := i.inv.2 _
theorem iso_isometry {V W : SemiNormedGroupCat₁} (i : V ≅ W) : Isometry i.hom := by
  change Isometry (⟨⟨i.hom, map_zero _⟩, fun _ _ => map_add _ _ _⟩ : V →+ W)
  refine' AddMonoidHomClass.isometry_of_norm _ _
  intro v
  apply le_antisymm (i.hom.2 v)
  calc
    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
    ‖v‖ = ‖i.inv (i.hom v)‖ := by 

Proof state:
V W : SemiNormedGroupCat₁
i : V ≅ W
v : ↑V
⊢ ‖v‖ = ‖i.inv (i.hom v)‖

Next tactic:
erw [Iso.hom_inv_id_apply]
/-- If `X` is isomorphic to `X₁` and `Y` is isomorphic to `Y₁`, then
there is a natural bijection between `X ⟶ Y` and `X₁ ⟶ Y₁`. See also `Equiv.arrowCongr`. -/
def homCongr {X Y X₁ Y₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) : (X ⟶ Y) ≃ (X₁ ⟶ Y₁) where
  toFun f := α.inv ≫ f ≫ β.hom
  invFun f := α.hom ≫ f ≫ β.inv
  left_inv f :=
    show α.hom ≫ (α.inv ≫ f ≫ β.hom) ≫ β.inv = f by
      

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ α.hom ≫ (α.inv ≫ f ≫ β.hom) ≫ β.inv = f

Next tactic:
rw [Category.assoc, Category.assoc, β.hom_inv_id, α.hom_inv_id_assoc, Category.comp_id]
/-- If `X` is isomorphic to `X₁` and `Y` is isomorphic to `Y₁`, then
there is a natural bijection between `X ⟶ Y` and `X₁ ⟶ Y₁`. See also `Equiv.arrowCongr`. -/
def homCongr {X Y X₁ Y₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) : (X ⟶ Y) ≃ (X₁ ⟶ Y₁) where
  toFun f := α.inv ≫ f ≫ β.hom
  invFun f := α.hom ≫ f ≫ β.inv
  left_inv f :=
    show α.hom ≫ (α.inv ≫ f ≫ β.hom) ≫ β.inv = f by
      rw [Category.assoc, Category.assoc, β.hom_inv_id, α.hom_inv_id_assoc, Category.comp_id]
  right_inv f :=
    show α.inv ≫ (α.hom ≫ f ≫ β.inv) ≫ β.hom = f by
      

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X₁ ⟶ Y₁
⊢ α.inv ≫ (α.hom ≫ f ≫ β.inv) ≫ β.hom = f

Next tactic:
rw [Category.assoc, Category.assoc, β.inv_hom_id, α.inv_hom_id_assoc, Category.comp_id]
@[simp]
theorem homCongr_apply {X Y X₁ Y₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) (f : X ⟶ Y) :
    α.homCongr β f = α.inv ≫ f ≫ β.hom := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ (homCongr α β) f = α.inv ≫ f ≫ β.hom

Next tactic:
rfl
theorem homCongr_comp {X Y Z X₁ Y₁ Z₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) (γ : Z ≅ Z₁) (f : X ⟶ Y)
    (g : Y ⟶ Z) : α.homCongr γ (f ≫ g) = α.homCongr β f ≫ β.homCongr γ g := by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y Z X₁ Y₁ Z₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
γ : Z ≅ Z₁
f : X ⟶ Y
g : Y ⟶ Z
⊢ (homCongr α γ) (f ≫ g) = (homCongr α β) f ≫ (homCongr β γ) g

Next tactic:
simp
theorem homCongr_refl {X Y : C} (f : X ⟶ Y) : (Iso.refl X).homCongr (Iso.refl Y) f = f := by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
⊢ (homCongr (refl X) (refl Y)) f = f

Next tactic:
simp
theorem homCongr_trans {X₁ Y₁ X₂ Y₂ X₃ Y₃ : C} (α₁ : X₁ ≅ X₂) (β₁ : Y₁ ≅ Y₂) (α₂ : X₂ ≅ X₃)
    (β₂ : Y₂ ≅ Y₃) (f : X₁ ⟶ Y₁) :
    (α₁ ≪≫ α₂).homCongr (β₁ ≪≫ β₂) f = (α₁.homCongr β₁).trans (α₂.homCongr β₂) f := by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X₁ Y₁ X₂ Y₂ X₃ Y₃ : C
α₁ : X₁ ≅ X₂
β₁ : Y₁ ≅ Y₂
α₂ : X₂ ≅ X₃
β₂ : Y₂ ≅ Y₃
f : X₁ ⟶ Y₁
⊢ (homCongr (α₁ ≪≫ α₂) (β₁ ≪≫ β₂)) f = ((homCongr α₁ β₁).trans (homCongr α₂ β₂)) f

Next tactic:
simp
@[simp]
theorem refl_conj (f : End X) : (Iso.refl X).conj f = f := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
f : End X
⊢ (conj (refl X)) f = f

Next tactic:
rw [conj_apply, Iso.refl_inv, Iso.refl_hom, Category.id_comp, Category.comp_id]
@[simp]
theorem symm_self_conj (f : End X) : α.symm.conj (α.conj f) = f := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
f : End X
⊢ (conj α.symm) ((conj α) f) = f

Next tactic:
rw [← trans_conj, α.self_symm_id, refl_conj]
theorem conjAut_apply (f : Aut X) : α.conjAut f = α.symm ≪≫ f ≪≫ α := by 

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
f : Aut X
⊢ (conjAut α) f = α.symm ≪≫ f ≪≫ α

Next tactic:
aesop_cat
@[simp]
theorem trans_conjAut {Z : C} (β : Y ≅ Z) (f : Aut X) :
    (α ≪≫ β).conjAut f = β.conjAut (α.conjAut f) := by
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
Z : C
β : Y ≅ Z
f : Aut X
⊢ (conjAut (α ≪≫ β)) f = (conjAut β) ((conjAut α) f)

Next tactic:
simp only [conjAut_apply, Iso.trans_symm, Iso.trans_assoc]
theorem map_homCongr {X Y X₁ Y₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) (f : X ⟶ Y) :
    F.map (Iso.homCongr α β f) = Iso.homCongr (F.mapIso α) (F.mapIso β) (F.map f) := by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
F : C ⥤ D
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ F.map ((Iso.homCongr α β) f) = (Iso.homCongr (F.mapIso α) (F.mapIso β)) (F.map f)

Next tactic:
simp
theorem map_conjAut (F : C ⥤ D) {X Y : C} (α : X ≅ Y) (f : Aut X) :
    F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f) := by
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
F✝ F : C ⥤ D
X Y : C
α : X ≅ Y
f : Aut X
⊢ F.mapIso ((Iso.conjAut α) f) = (Iso.conjAut (F.mapIso α)) (F.mapIso f)

Next tactic:
ext
theorem map_conjAut (F : C ⥤ D) {X Y : C} (α : X ≅ Y) (f : Aut X) :
    F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f) := by
  ext; 

Proof state:
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
F✝ F : C ⥤ D
X Y : C
α : X ≅ Y
f : Aut X
⊢ (F.mapIso ((Iso.conjAut α) f)).hom = ((Iso.conjAut (F.mapIso α)) (F.mapIso f)).hom

Next tactic:
simp only [mapIso_hom, Iso.conjAut_hom, F.map_conj]