l3lab/ntp-mathlib huggingface dataset:
theorem coreflective [Full ι] [Faithful ι] [∀ X, HasColimitsOfShape (CostructuredArrow ι X) D] :
    IsIso (adjunction D ι).unit := by
  suffices ∀ (X : S ⥤ D), IsIso (NatTrans.app (adjunction D ι).unit X) by
    apply NatIso.isIso_of_isIso_app
  intro F
  suffices ∀ (X : S), IsIso (NatTrans.app (NatTrans.app (adjunction D ι).unit F) X) by
    

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝⁵ : Category.{v₁, u₁} S
inst✝⁴ : Category.{v₂, u₂} L
inst✝³ : Category.{v₃, u₃} D
ι : S ⥤ L
inst✝² : Full ι
inst✝¹ : Faithful ι
inst✝ : ∀ (X : L), HasColimitsOfShape (CostructuredArrow ι X) D
F : S ⥤ D
this : ∀ (X : S), IsIso (((adjunction D ι).unit.app F).app X)
⊢ IsIso ((adjunction D ι).unit.app F)

Next tactic:
apply NatIso.isIso_of_isIso_app
theorem coreflective [Full ι] [Faithful ι] [∀ X, HasColimitsOfShape (CostructuredArrow ι X) D] :
    IsIso (adjunction D ι).unit := by
  suffices ∀ (X : S ⥤ D), IsIso (NatTrans.app (adjunction D ι).unit X) by
    apply NatIso.isIso_of_isIso_app
  intro F
  suffices ∀ (X : S), IsIso (NatTrans.app (NatTrans.app (adjunction D ι).unit F) X) by
    apply NatIso.isIso_of_isIso_app
  

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝⁵ : Category.{v₁, u₁} S
inst✝⁴ : Category.{v₂, u₂} L
inst✝³ : Category.{v₃, u₃} D
ι : S ⥤ L
inst✝² : Full ι
inst✝¹ : Faithful ι
inst✝ : ∀ (X : L), HasColimitsOfShape (CostructuredArrow ι X) D
F : S ⥤ D
⊢ ∀ (X : S), IsIso (((adjunction D ι).unit.app F).app X)

Next tactic:
intro X
theorem coreflective [Full ι] [Faithful ι] [∀ X, HasColimitsOfShape (CostructuredArrow ι X) D] :
    IsIso (adjunction D ι).unit := by
  suffices ∀ (X : S ⥤ D), IsIso (NatTrans.app (adjunction D ι).unit X) by
    apply NatIso.isIso_of_isIso_app
  intro F
  suffices ∀ (X : S), IsIso (NatTrans.app (NatTrans.app (adjunction D ι).unit F) X) by
    apply NatIso.isIso_of_isIso_app
  intro X
  

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝⁵ : Category.{v₁, u₁} S
inst✝⁴ : Category.{v₂, u₂} L
inst✝³ : Category.{v₃, u₃} D
ι : S ⥤ L
inst✝² : Full ι
inst✝¹ : Faithful ι
inst✝ : ∀ (X : L), HasColimitsOfShape (CostructuredArrow ι X) D
F : S ⥤ D
X : S
⊢ IsIso (((adjunction D ι).unit.app F).app X)

Next tactic:
dsimp [adjunction, equiv]
theorem coreflective [Full ι] [Faithful ι] [∀ X, HasColimitsOfShape (CostructuredArrow ι X) D] :
    IsIso (adjunction D ι).unit := by
  suffices ∀ (X : S ⥤ D), IsIso (NatTrans.app (adjunction D ι).unit X) by
    apply NatIso.isIso_of_isIso_app
  intro F
  suffices ∀ (X : S), IsIso (NatTrans.app (NatTrans.app (adjunction D ι).unit F) X) by
    apply NatIso.isIso_of_isIso_app
  intro X
  dsimp [adjunction, equiv]
  

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝⁵ : Category.{v₁, u₁} S
inst✝⁴ : Category.{v₂, u₂} L
inst✝³ : Category.{v₃, u₃} D
ι : S ⥤ L
inst✝² : Full ι
inst✝¹ : Faithful ι
inst✝ : ∀ (X : L), HasColimitsOfShape (CostructuredArrow ι X) D
F : S ⥤ D
X : S
⊢ IsIso (colimit.ι (diagram ι F (ι.obj X)) (CostructuredArrow.mk (𝟙 (ι.obj X))) ≫ 𝟙 (colimit (diagram ι F (ι.obj X))))

Next tactic:
simp only [Category.comp_id]
theorem coreflective [Full ι] [Faithful ι] [∀ X, HasColimitsOfShape (CostructuredArrow ι X) D] :
    IsIso (adjunction D ι).unit := by
  suffices ∀ (X : S ⥤ D), IsIso (NatTrans.app (adjunction D ι).unit X) by
    apply NatIso.isIso_of_isIso_app
  intro F
  suffices ∀ (X : S), IsIso (NatTrans.app (NatTrans.app (adjunction D ι).unit F) X) by
    apply NatIso.isIso_of_isIso_app
  intro X
  dsimp [adjunction, equiv]
  simp only [Category.comp_id]
  

Proof state:
S : Type u₁
L : Type u₂
D : Type u₃
inst✝⁵ : Category.{v₁, u₁} S
inst✝⁴ : Category.{v₂, u₂} L
inst✝³ : Category.{v₃, u₃} D
ι : S ⥤ L
inst✝² : Full ι
inst✝¹ : Faithful ι
inst✝ : ∀ (X : L), HasColimitsOfShape (CostructuredArrow ι X) D
F : S ⥤ D
X : S
⊢ IsIso (colimit.ι (diagram ι F (ι.obj X)) (CostructuredArrow.mk (𝟙 (ι.obj X))))

Next tactic:
exact
    IsIso.of_iso
      ((colimit.isColimit _).coconePointUniqueUpToIso
          (colimitOfDiagramTerminal CostructuredArrow.mkIdTerminal _)).symm
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  

Proof state:
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
⊢ IsConformalMap (restrictScalars ℝ map)

Next tactic:
have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by 

Proof state:
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
⊢ ‖map 1‖ ≠ 0

Next tactic:
simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  

Proof state:
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
⊢ IsConformalMap (restrictScalars ℝ map)

Next tactic:
refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · 

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
⊢ ∀ (x : ℂ), ‖(‖map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖

Next tactic:
intro x
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
⊢ ‖(‖map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖

Next tactic:
simp only [LinearMap.smul_apply]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
⊢ ‖‖map 1‖⁻¹ • (↑ℝ ↑map) x‖ = ‖x‖

Next tactic:
have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by 

Proof state:
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
⊢ x = x • 1

Next tactic:
rw [smul_eq_mul, mul_one]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖map 1‖⁻¹ • (↑ℝ ↑map) x‖ = ‖x‖

Next tactic:
nth_rw 1 [this]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    nth_rw 1 [this]
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖map 1‖⁻¹ • (↑ℝ ↑map) (x • 1)‖ = ‖x‖

Next tactic:
rw [LinearMap.coe_restrictScalars]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    nth_rw 1 [this]
    rw [LinearMap.coe_restrictScalars]
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖‖map 1‖⁻¹ • ↑map (x • 1)‖ = ‖x‖

Next tactic:
simp only [map.coe_coe, map.map_smul, norm_smul, norm_inv, norm_norm]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    nth_rw 1 [this]
    rw [LinearMap.coe_restrictScalars]
    simp only [map.coe_coe, map.map_smul, norm_smul, norm_inv, norm_norm]
    

Proof state:
case refine'_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x : ℂ
this : x = x • 1
⊢ ‖map 1‖⁻¹ * (‖x‖ * ‖map 1‖) = ‖x‖

Next tactic:
field_simp only [one_mul]
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    nth_rw 1 [this]
    rw [LinearMap.coe_restrictScalars]
    simp only [map.coe_coe, map.map_smul, norm_smul, norm_inv, norm_norm]
    field_simp only [one_mul]
  · 

Proof state:
case refine'_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
⊢ restrictScalars ℝ map =
    ‖map 1‖ •
      LinearIsometry.toContinuousLinearMap
        { toLinearMap := ‖map 1‖⁻¹ • ↑ℝ ↑map, norm_map' := (_ : ∀ (x : ℂ), ‖(‖map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖) }

Next tactic:
ext1
theorem isConformalMap_complex_linear {map : ℂ →L[ℂ] E} (nonzero : map ≠ 0) :
    IsConformalMap (map.restrictScalars ℝ) := by
  have minor₁ : ‖map 1‖ ≠ 0 := by simpa only [ext_ring_iff, Ne.def, norm_eq_zero] using nonzero
  refine' ⟨‖map 1‖, minor₁, ⟨‖map 1‖⁻¹ • ((map : ℂ →ₗ[ℂ] E) : ℂ →ₗ[ℝ] E), _⟩, _⟩
  · intro x
    simp only [LinearMap.smul_apply]
    have : x = x • (1 : ℂ) := by rw [smul_eq_mul, mul_one]
    nth_rw 1 [this]
    rw [LinearMap.coe_restrictScalars]
    simp only [map.coe_coe, map.map_smul, norm_smul, norm_inv, norm_norm]
    field_simp only [one_mul]
  · ext1
    -- Porting note: was simp
    

Proof state:
case refine'_2.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℂ E
z : ℂ
g : ℂ →L[ℝ] E
f : ℂ → E
map : ℂ →L[ℂ] E
nonzero : map ≠ 0
minor₁ : ‖map 1‖ ≠ 0
x✝ : ℂ
⊢ (restrictScalars ℝ map) x✝ =
    (‖map 1‖ •
        LinearIsometry.toContinuousLinearMap
          { toLinearMap := ‖map 1‖⁻¹ • ↑ℝ ↑map, norm_map' := (_ : ∀ (x : ℂ), ‖(‖map 1‖⁻¹ • ↑ℝ ↑map) x‖ = ‖x‖) })
      x✝

Next tactic:
rw [coe_restrictScalars', coe_smul', LinearIsometry.coe_toContinuousLinearMap,
      LinearIsometry.coe_mk, Pi.smul_apply, LinearMap.smul_apply, LinearMap.coe_restrictScalars,
      coe_coe, smul_inv_smul₀ minor₁]
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  

Proof state:
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
h : IsConformalMap g
⊢ (∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = ContinuousLinearMap.comp g ↑conjCle

Next tactic:
rcases h with ⟨c, -, li, rfl⟩
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  

Proof state:
case intro.intro.intro
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
⊢ (∃ map, restrictScalars ℝ map = c • LinearIsometry.toContinuousLinearMap li) ∨
    ∃ map, restrictScalars ℝ map = ContinuousLinearMap.comp (c • LinearIsometry.toContinuousLinearMap li) ↑conjCle

Next tactic:
obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by 

Proof state:
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
⊢ LinearIsometryEquiv.toLinearIsometry
      (LinearIsometry.toLinearIsometryEquiv li (_ : FiniteDimensional.finrank ℝ ℂ = FiniteDimensional.finrank ℝ ℂ)) =
    li

Next tactic:
ext1
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; 

Proof state:
case h
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ →ₗᵢ[ℝ] ℂ
x✝ : ℂ
⊢ (LinearIsometryEquiv.toLinearIsometry
        (LinearIsometry.toLinearIsometryEquiv li (_ : FiniteDimensional.finrank ℝ ℂ = FiniteDimensional.finrank ℝ ℂ)))
      x✝ =
    li x✝

Next tactic:
rfl
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  

Proof state:
case intro.intro.intro.intro
f : ℂ → ℂ
z : ℂ
c : ℝ
li : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ (∃ map, restrictScalars ℝ map = c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry li)) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp (c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry li))
          ↑conjCle

Next tactic:
rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · 

Proof state:
case intro.intro.intro.intro.intro.inl
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
⊢ (∃ map,
      restrictScalars ℝ map =
        c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (rotation a))) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp
          (c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (rotation a))) ↑conjCle

Next tactic:
refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    

Proof state:
case intro.intro.intro.intro.intro.inl
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
⊢ restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ) =
    c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (rotation a))

Next tactic:
ext1
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    ext1
    -- Porting note: was simp
    

Proof state:
case intro.intro.intro.intro.intro.inl.h
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
x✝ : ℂ
⊢ (restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ)) x✝ =
    (c • LinearIsometry.toContinuousLinearMap (LinearIsometryEquiv.toLinearIsometry (rotation a))) x✝

Next tactic:
rw [coe_restrictScalars', smul_apply, smul_apply, smul_apply,
      LinearIsometry.coe_toContinuousLinearMap,
      LinearIsometryEquiv.coe_toLinearIsometry, rotation_apply, id_apply, smul_eq_mul]
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    ext1
    -- Porting note: was simp
    rw [coe_restrictScalars', smul_apply, smul_apply, smul_apply,
      LinearIsometry.coe_toContinuousLinearMap,
      LinearIsometryEquiv.coe_toLinearIsometry, rotation_apply, id_apply, smul_eq_mul]
  · 

Proof state:
case intro.intro.intro.intro.intro.inr
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
⊢ (∃ map,
      restrictScalars ℝ map =
        c •
          LinearIsometry.toContinuousLinearMap
            (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (rotation a)))) ∨
    ∃ map,
      restrictScalars ℝ map =
        ContinuousLinearMap.comp
          (c •
            LinearIsometry.toContinuousLinearMap
              (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (rotation a))))
          ↑conjCle

Next tactic:
refine' Or.inr ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    ext1
    -- Porting note: was simp
    rw [coe_restrictScalars', smul_apply, smul_apply, smul_apply,
      LinearIsometry.coe_toContinuousLinearMap,
      LinearIsometryEquiv.coe_toLinearIsometry, rotation_apply, id_apply, smul_eq_mul]
  · refine' Or.inr ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    

Proof state:
case intro.intro.intro.intro.intro.inr
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
⊢ restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ) =
    ContinuousLinearMap.comp
      (c •
        LinearIsometry.toContinuousLinearMap
          (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (rotation a))))
      ↑conjCle

Next tactic:
ext1
theorem IsConformalMap.is_complex_or_conj_linear (h : IsConformalMap g) :
    (∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
      ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle := by
  rcases h with ⟨c, -, li, rfl⟩
  obtain ⟨li, rfl⟩ : ∃ li' : ℂ ≃ₗᵢ[ℝ] ℂ, li'.toLinearIsometry = li :=
    ⟨li.toLinearIsometryEquiv rfl, by ext1; rfl⟩
  rcases linear_isometry_complex li with ⟨a, rfl | rfl⟩
  -- let rot := c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ,
  · refine' Or.inl ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    ext1
    -- Porting note: was simp
    rw [coe_restrictScalars', smul_apply, smul_apply, smul_apply,
      LinearIsometry.coe_toContinuousLinearMap,
      LinearIsometryEquiv.coe_toLinearIsometry, rotation_apply, id_apply, smul_eq_mul]
  · refine' Or.inr ⟨c • (a : ℂ) • ContinuousLinearMap.id ℂ ℂ, _⟩
    ext1
    -- Porting note: was simp
    

Proof state:
case intro.intro.intro.intro.intro.inr.h
f : ℂ → ℂ
z : ℂ
c : ℝ
a : ↥circle
x✝ : ℂ
⊢ (restrictScalars ℝ (c • ↑a • ContinuousLinearMap.id ℂ ℂ)) x✝ =
    (ContinuousLinearMap.comp
        (c •
          LinearIsometry.toContinuousLinearMap
            (LinearIsometryEquiv.toLinearIsometry (LinearIsometryEquiv.trans conjLie (rotation a))))
        ↑conjCle)
      x✝

Next tactic:
rw [coe_restrictScalars', smul_apply, smul_apply, comp_apply, smul_apply,
      LinearIsometry.coe_toContinuousLinearMap, LinearIsometryEquiv.coe_toLinearIsometry,
      LinearIsometryEquiv.trans_apply, rotation_apply, id_apply, smul_eq_mul,
      ContinuousLinearEquiv.coe_coe, conjCle_apply, conjLie_apply, conj_conj]
/-- A real continuous linear map on the complex plane is conformal if and only if the map or its
    conjugate is complex linear, and the map is nonvanishing. -/
theorem isConformalMap_iff_is_complex_or_conj_linear :
    IsConformalMap g ↔
      ((∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g) ∨
          ∃ map : ℂ →L[ℂ] ℂ, map.restrictScalars ℝ = g ∘L ↑conjCle) ∧
        g ≠ 0 := by
  

Proof state:
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ IsConformalMap g ↔ ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = comp g ↑conjCle) ∧ g ≠ 0

Next tactic:
constructor