File: Mathlib/Analysis/Normed/Operator/LinearIsometry.lean

full_name: LinearIsometry.norm_map'
code: /-- A `σ₁₂`-semilinear isometric embedding of a normed `R`-module into an `R₂`-module. -/
structure LinearIsometry (σ₁₂ : R →+* R₂) (E E₂ : Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] extends E →ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearMap x‖ = ‖x‖
goal: ‖self.toLinearMap x‖ = ‖x‖

full_name: LinearIsometry
code: /-- A `σ₁₂`-semilinear isometric embedding of a normed `R`-module into an `R₂`-module. -/
structure LinearIsometry (σ₁₂ : R →+* R₂) (E E₂ : Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] extends E →ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearMap x‖ = ‖x‖
goal: Type (max u_11 u_12)

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_→ₛₗᵢ[_]__1»
code: @[inherit_doc]
notation:25 E " →ₛₗᵢ[" σ₁₂:25 "] " E₂:0 => LinearIsometry σ₁₂ E E₂
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometry_1
code: @[inherit_doc]
notation:25 E " →ₛₗᵢ[" σ₁₂:25 "] " E₂:0 => LinearIsometry σ₁₂ E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_→ₗᵢ[_]__1»
code: /-- A linear isometric embedding of a normed `R`-module into another one. -/
notation:25 E " →ₗᵢ[" R:25 "] " E₂:0 => LinearIsometry (RingHom.id R) E E₂
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometry_2
code: /-- A linear isometric embedding of a normed `R`-module into another one. -/
notation:25 E " →ₗᵢ[" R:25 "] " E₂:0 => LinearIsometry (RingHom.id R) E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_→ₗᵢ⋆[_]__1»
code: /-- An antilinear isometric embedding of a normed `R`-module into another one. -/
notation:25 E " →ₗᵢ⋆[" R:25 "] " E₂:0 => LinearIsometry (starRingEnd R) E E₂
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometry_3
code: /-- An antilinear isometric embedding of a normed `R`-module into another one. -/
notation:25 E " →ₗᵢ⋆[" R:25 "] " E₂:0 => LinearIsometry (starRingEnd R) E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: SemilinearIsometryClass.norm_map
code: /-- `SemilinearIsometryClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear isometries
`E → E₂`.

See also `LinearIsometryClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R] [Semiring R₂]
  (σ₁₂ : outParam <| R →+* R₂) (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [FunLike 𝓕 E E₂] extends
  SemilinearMapClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
goal: ‖f x‖ = ‖x‖

full_name: SemilinearIsometryClass
code: /-- `SemilinearIsometryClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear isometries
`E → E₂`.

See also `LinearIsometryClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R] [Semiring R₂]
  (σ₁₂ : outParam <| R →+* R₂) (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [FunLike 𝓕 E E₂] extends
  SemilinearMapClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
goal: Prop

full_name: LinearIsometryClass
code: /-- `LinearIsometryClass F R E E₂` asserts `F` is a type of bundled `R`-linear isometries
`M → M₂`.

This is an abbreviation for `SemilinearIsometryClass F (RingHom.id R) E E₂`.
-/
abbrev LinearIsometryClass (𝓕 : Type*) (R E E₂ : outParam Type*) [Semiring R]
    [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂] [Module R E] [Module R E₂]
    [FunLike 𝓕 E E₂] 
goal: Prop

full_name: SemilinearIsometryClass.isometry
code: protected theorem isometry [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) : Isometry f 
goal: Isometry ⇑f

full_name: SemilinearIsometryClass.continuous
code: @[continuity]
protected theorem continuous [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) : Continuous f 
goal: Continuous ⇑f

full_name: SemilinearIsometryClass.nnnorm_map
code: theorem nnnorm_map [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) (x : E) : ‖f x‖₊ = ‖x‖₊ 
goal: ‖f x‖₊ = ‖x‖₊

full_name: SemilinearIsometryClass.lipschitz
code: protected theorem lipschitz [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) : LipschitzWith 1 f 
goal: LipschitzWith 1 ⇑f

full_name: SemilinearIsometryClass.antilipschitz
code: protected theorem antilipschitz [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) :
    AntilipschitzWith 1 f 
goal: AntilipschitzWith 1 ⇑f

full_name: SemilinearIsometryClass.ediam_image
code: theorem ediam_image [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) (s : Set E) :
    EMetric.diam (f '' s) = EMetric.diam s 
goal: EMetric.diam (⇑f '' s) = EMetric.diam s

full_name: SemilinearIsometryClass.ediam_range
code: theorem ediam_range [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) :
    EMetric.diam (range f) = EMetric.diam (univ : Set E) 
goal: EMetric.diam (Set.range ⇑f) = EMetric.diam Set.univ

full_name: SemilinearIsometryClass.diam_image
code: theorem diam_image [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) (s : Set E) :
    Metric.diam (f '' s) = Metric.diam s 
goal: Metric.diam (⇑f '' s) = Metric.diam s

full_name: SemilinearIsometryClass.diam_range
code: theorem diam_range [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) :
    Metric.diam (range f) = Metric.diam (univ : Set E) 
goal: Metric.diam (Set.range ⇑f) = Metric.diam Set.univ

full_name: SemilinearIsometryClass.toContinuousSemilinearMapClass
code: instance (priority := 100) toContinuousSemilinearMapClass
    [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] : ContinuousSemilinearMapClass 𝓕 σ₁₂ E E₂ 
goal: ContinuousSemilinearMapClass 𝓕 σ₁₂ E E₂

full_name: LinearIsometry.toLinearMap_injective
code: theorem toLinearMap_injective : Injective (toLinearMap : (E →ₛₗᵢ[σ₁₂] E₂) → E →ₛₗ[σ₁₂] E₂)
  
goal: Function.Injective LinearIsometry.toLinearMap

full_name: LinearIsometry.toLinearMap_inj
code: @[simp]
theorem toLinearMap_inj {f g : E →ₛₗᵢ[σ₁₂] E₂} : f.toLinearMap = g.toLinearMap ↔ f = g 
goal: f.toLinearMap = g.toLinearMap ↔ f = g

full_name: LinearIsometry.instFunLike
code: instance instFunLike : FunLike (E →ₛₗᵢ[σ₁₂] E₂) E E₂ 
goal: FunLike (E →ₛₗᵢ[σ₁₂] E₂) E E₂

full_name: LinearIsometry.instSemilinearIsometryClass
code: instance instSemilinearIsometryClass : SemilinearIsometryClass (E →ₛₗᵢ[σ₁₂] E₂) σ₁₂ E E₂ 
goal: SemilinearIsometryClass (E →ₛₗᵢ[σ₁₂] E₂) σ₁₂ E E₂

full_name: LinearIsometry.coe_toLinearMap
code: @[simp]
theorem coe_toLinearMap : ⇑f.toLinearMap = f 
goal: ⇑f.toLinearMap = ⇑f

full_name: LinearIsometry.coe_mk
code: @[simp]
theorem coe_mk (f : E →ₛₗ[σ₁₂] E₂) (hf) : ⇑(mk f hf) = f 
goal: ⇑{ toLinearMap := f, norm_map' := hf } = ⇑f

full_name: LinearIsometry.coe_injective
code: theorem coe_injective : @Injective (E →ₛₗᵢ[σ₁₂] E₂) (E → E₂) (fun f => f) 
goal: Function.Injective fun f => ⇑f

full_name: LinearIsometry.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (σ₁₂ : R →+* R₂) (E E₂ : Type*) [SeminormedAddCommGroup E]
    [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] (h : E →ₛₗᵢ[σ₁₂] E₂) : E → E₂ 
goal: E → E₂

full_name: LinearIsometry.ext
code: @[ext]
theorem ext {f g : E →ₛₗᵢ[σ₁₂] E₂} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: LinearIsometry.congr_arg
code: protected theorem congr_arg {f : 𝓕} :
    ∀ {x x' : E}, x = x' → f x = f x'
  
goal: x = x' → f x = f x'

full_name: LinearIsometry.congr_fun
code: protected theorem congr_fun {f g : 𝓕} (h : f = g) (x : E) :
    f x = g x 
goal: f x = g x

full_name: LinearIsometry.map_zero
code: protected theorem map_zero : f 0 = 0 
goal: f 0 = 0

full_name: LinearIsometry.map_add
code: protected theorem map_add (x y : E) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: LinearIsometry.map_neg
code: protected theorem map_neg (x : E) : f (-x) = -f x 
goal: f (-x) = -f x

full_name: LinearIsometry.map_sub
code: protected theorem map_sub (x y : E) : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: LinearIsometry.map_smulₛₗ
code: protected theorem map_smulₛₗ (c : R) (x : E) : f (c • x) = σ₁₂ c • f x 
goal: f (c • x) = σ₁₂ c • f x

full_name: LinearIsometry.map_smul
code: protected theorem map_smul [Module R E₂] (f : E →ₗᵢ[R] E₂) (c : R) (x : E) : f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: LinearIsometry.norm_map
code: @[simp]
theorem norm_map (x : E) : ‖f x‖ = ‖x‖ 
goal: ‖f x‖ = ‖x‖

full_name: LinearIsometry.nnnorm_map
code: @[simp] -- Should be replaced with `SemilinearIsometryClass.nnorm_map` when `lean4#3107` is fixed.
theorem nnnorm_map (x : E) : ‖f x‖₊ = ‖x‖₊ 
goal: ‖f x‖₊ = ‖x‖₊

full_name: LinearIsometry.isometry
code: protected theorem isometry : Isometry f 
goal: Isometry ⇑f

full_name: LinearIsometry.isComplete_image_iff
code: theorem isComplete_image_iff [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) {s : Set E} :
    IsComplete (f '' s) ↔ IsComplete s 
goal: IsComplete (⇑f '' s) ↔ IsComplete s

full_name: LinearIsometry.isComplete_image_iff'
code: @[simp] -- Should be replaced with `LinearIsometry.isComplete_image_iff` when `lean4#3107` is fixed.
theorem isComplete_image_iff' (f : LinearIsometry σ₁₂ E E₂) {s : Set E} :
    IsComplete (f '' s) ↔ IsComplete s 
goal: IsComplete (⇑f '' s) ↔ IsComplete s

full_name: LinearIsometry.isComplete_map_iff
code: theorem isComplete_map_iff [RingHomSurjective σ₁₂] {p : Submodule R E} :
    IsComplete (p.map f.toLinearMap : Set E₂) ↔ IsComplete (p : Set E) 
goal: IsComplete ↑(Submodule.map f.toLinearMap p) ↔ IsComplete ↑p

full_name: LinearIsometry.isComplete_map_iff'
code: theorem isComplete_map_iff' [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) [RingHomSurjective σ₁₂]
    {p : Submodule R E} : IsComplete (p.map f : Set E₂) ↔ IsComplete (p : Set E) 
goal: IsComplete ↑(Submodule.map f p) ↔ IsComplete ↑p

full_name: LinearIsometry.completeSpace_map
code: instance completeSpace_map [SemilinearIsometryClass 𝓕 σ₁₂ E E₂] (f : 𝓕) [RingHomSurjective σ₁₂]
    (p : Submodule R E) [CompleteSpace p] : CompleteSpace (p.map f) 
goal: CompleteSpace ↥(Submodule.map f p)

full_name: LinearIsometry.completeSpace_map'
code: instance completeSpace_map' [RingHomSurjective σ₁₂] (p : Submodule R E) [CompleteSpace p] :
    CompleteSpace (p.map f.toLinearMap) 
goal: CompleteSpace ↥(Submodule.map f.toLinearMap p)

full_name: LinearIsometry.dist_map
code: @[simp]
theorem dist_map (x y : E) : dist (f x) (f y) = dist x y 
goal: dist (f x) (f y) = dist x y

full_name: LinearIsometry.edist_map
code: @[simp]
theorem edist_map (x y : E) : edist (f x) (f y) = edist x y 
goal: edist (f x) (f y) = edist x y

full_name: LinearIsometry.injective
code: protected theorem injective : Injective f₁ 
goal: Function.Injective ⇑f₁

full_name: LinearIsometry.map_eq_iff
code: @[simp]
theorem map_eq_iff {x y : F} : f₁ x = f₁ y ↔ x = y 
goal: f₁ x = f₁ y ↔ x = y

full_name: LinearIsometry.map_ne
code: theorem map_ne {x y : F} (h : x ≠ y) : f₁ x ≠ f₁ y 
goal: f₁ x ≠ f₁ y

full_name: LinearIsometry.lipschitz
code: protected theorem lipschitz : LipschitzWith 1 f 
goal: LipschitzWith 1 ⇑f

full_name: LinearIsometry.antilipschitz
code: protected theorem antilipschitz : AntilipschitzWith 1 f 
goal: AntilipschitzWith 1 ⇑f

full_name: LinearIsometry.continuous
code: @[continuity]
protected theorem continuous : Continuous f 
goal: Continuous ⇑f

full_name: LinearIsometry.preimage_ball
code: @[simp]
theorem preimage_ball (x : E) (r : ℝ) : f ⁻¹' Metric.ball (f x) r = Metric.ball x r 
goal: ⇑f ⁻¹' Metric.ball (f x) r = Metric.ball x r

full_name: LinearIsometry.preimage_sphere
code: @[simp]
theorem preimage_sphere (x : E) (r : ℝ) : f ⁻¹' Metric.sphere (f x) r = Metric.sphere x r 
goal: ⇑f ⁻¹' Metric.sphere (f x) r = Metric.sphere x r

full_name: LinearIsometry.preimage_closedBall
code: @[simp]
theorem preimage_closedBall (x : E) (r : ℝ) :
    f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r 
goal: ⇑f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r

full_name: LinearIsometry.ediam_image
code: theorem ediam_image (s : Set E) : EMetric.diam (f '' s) = EMetric.diam s 
goal: EMetric.diam (⇑f '' s) = EMetric.diam s

full_name: LinearIsometry.ediam_range
code: theorem ediam_range : EMetric.diam (range f) = EMetric.diam (univ : Set E) 
goal: EMetric.diam (Set.range ⇑f) = EMetric.diam Set.univ

full_name: LinearIsometry.diam_image
code: theorem diam_image (s : Set E) : Metric.diam (f '' s) = Metric.diam s 
goal: Metric.diam (⇑f '' s) = Metric.diam s

full_name: LinearIsometry.diam_range
code: theorem diam_range : Metric.diam (range f) = Metric.diam (univ : Set E) 
goal: Metric.diam (Set.range ⇑f) = Metric.diam Set.univ

full_name: LinearIsometry.toContinuousLinearMap
code: /-- Interpret a linear isometry as a continuous linear map. -/
def toContinuousLinearMap : E →SL[σ₁₂] E₂ 
goal: E →SL[σ₁₂] E₂

full_name: LinearIsometry.toContinuousLinearMap_injective
code: theorem toContinuousLinearMap_injective :
    Function.Injective (toContinuousLinearMap : _ → E →SL[σ₁₂] E₂) 
goal: Function.Injective LinearIsometry.toContinuousLinearMap

full_name: LinearIsometry.toContinuousLinearMap_inj
code: @[simp]
theorem toContinuousLinearMap_inj {f g : E →ₛₗᵢ[σ₁₂] E₂} :
    f.toContinuousLinearMap = g.toContinuousLinearMap ↔ f = g 
goal: f.toContinuousLinearMap = g.toContinuousLinearMap ↔ f = g

full_name: LinearIsometry.coe_toContinuousLinearMap
code: @[simp]
theorem coe_toContinuousLinearMap : ⇑f.toContinuousLinearMap = f 
goal: ⇑f.toContinuousLinearMap = ⇑f

full_name: LinearIsometry.comp_continuous_iff
code: @[simp]
theorem comp_continuous_iff {α : Type*} [TopologicalSpace α] {g : α → E} :
    Continuous (f ∘ g) ↔ Continuous g 
goal: Continuous (⇑f ∘ g) ↔ Continuous g

full_name: LinearIsometry.id
code: /-- The identity linear isometry. -/
def id : E →ₗᵢ[R] E 
goal: E →ₗᵢ[R] E

full_name: LinearIsometry.coe_id
code: @[simp]
theorem coe_id : ((id : E →ₗᵢ[R] E) : E → E) = _root_.id 
goal: ⇑LinearIsometry.id = id

full_name: LinearIsometry.id_apply
code: @[simp]
theorem id_apply (x : E) : (id : E →ₗᵢ[R] E) x = x 
goal: LinearIsometry.id x = x

full_name: LinearIsometry.id_toLinearMap
code: @[simp]
theorem id_toLinearMap : (id.toLinearMap : E →ₗ[R] E) = LinearMap.id 
goal: LinearIsometry.id.toLinearMap = LinearMap.id

full_name: LinearIsometry.id_toContinuousLinearMap
code: @[simp]
theorem id_toContinuousLinearMap : id.toContinuousLinearMap = ContinuousLinearMap.id R E 
goal: LinearIsometry.id.toContinuousLinearMap = ContinuousLinearMap.id R E

full_name: LinearIsometry.instInhabited
code: instance instInhabited : Inhabited (E →ₗᵢ[R] E) 
goal: Inhabited (E →ₗᵢ[R] E)

full_name: LinearIsometry.comp
code: /-- Composition of linear isometries. -/
def comp (g : E₂ →ₛₗᵢ[σ₂₃] E₃) (f : E →ₛₗᵢ[σ₁₂] E₂) : E →ₛₗᵢ[σ₁₃] E₃ 
goal: E →ₛₗᵢ[σ₁₃] E₃

full_name: LinearIsometry.coe_comp
code: @[simp]
theorem coe_comp (g : E₂ →ₛₗᵢ[σ₂₃] E₃) (f : E →ₛₗᵢ[σ₁₂] E₂) : ⇑(g.comp f) = g ∘ f 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: LinearIsometry.id_comp
code: @[simp]
theorem id_comp : (id : E₂ →ₗᵢ[R₂] E₂).comp f = f 
goal: LinearIsometry.id.comp f = f

full_name: LinearIsometry.comp_id
code: @[simp]
theorem comp_id : f.comp id = f 
goal: f.comp LinearIsometry.id = f

full_name: LinearIsometry.comp_assoc
code: theorem comp_assoc (f : E₃ →ₛₗᵢ[σ₃₄] E₄) (g : E₂ →ₛₗᵢ[σ₂₃] E₃) (h : E →ₛₗᵢ[σ₁₂] E₂) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: LinearIsometry.instMonoid
code: instance instMonoid : Monoid (E →ₗᵢ[R] E) 
goal: Monoid (E →ₗᵢ[R] E)

full_name: LinearIsometry.coe_one
code: @[simp]
theorem coe_one : ((1 : E →ₗᵢ[R] E) : E → E) = _root_.id 
goal: ⇑1 = id

full_name: LinearIsometry.coe_mul
code: @[simp]
theorem coe_mul (f g : E →ₗᵢ[R] E) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: LinearIsometry.one_def
code: theorem one_def : (1 : E →ₗᵢ[R] E) = id 
goal: 1 = LinearIsometry.id

full_name: LinearIsometry.mul_def
code: theorem mul_def (f g : E →ₗᵢ[R] E) : (f * g : E →ₗᵢ[R] E) = f.comp g 
goal: f * g = f.comp g

full_name: LinearIsometry.coe_pow
code: theorem coe_pow (f : E →ₗᵢ[R] E) (n : ℕ) : ⇑(f ^ n) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: LinearMap.toLinearIsometry
code: /-- Construct a `LinearIsometry` from a `LinearMap` satisfying `Isometry`. -/
def LinearMap.toLinearIsometry (f : E →ₛₗ[σ₁₂] E₂) (hf : Isometry f) : E →ₛₗᵢ[σ₁₂] E₂ 
goal: E →ₛₗᵢ[σ₁₂] E₂

full_name: Submodule.subtypeₗᵢ
code: /-- `Submodule.subtype` as a `LinearIsometry`. -/
def subtypeₗᵢ : p →ₗᵢ[R'] E 
goal: ↥p →ₗᵢ[R'] E

full_name: Submodule.coe_subtypeₗᵢ
code: @[simp]
theorem coe_subtypeₗᵢ : ⇑p.subtypeₗᵢ = p.subtype 
goal: ⇑p.subtypeₗᵢ = ⇑p.subtype

full_name: Submodule.subtypeₗᵢ_toLinearMap
code: @[simp]
theorem subtypeₗᵢ_toLinearMap : p.subtypeₗᵢ.toLinearMap = p.subtype 
goal: p.subtypeₗᵢ.toLinearMap = p.subtype

full_name: Submodule.subtypeₗᵢ_toContinuousLinearMap
code: @[simp]
theorem subtypeₗᵢ_toContinuousLinearMap : p.subtypeₗᵢ.toContinuousLinearMap = p.subtypeL 
goal: p.subtypeₗᵢ.toContinuousLinearMap = p.subtypeL

full_name: LinearIsometryEquiv.norm_map'
code: /-- A semilinear isometric equivalence between two normed vector spaces. -/
structure LinearIsometryEquiv (σ₁₂ : R →+* R₂) {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : Type*) [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂]
  [Module R E] [Module R₂ E₂] extends E ≃ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearEquiv x‖ = ‖x‖
goal: ‖self.toLinearEquiv x‖ = ‖x‖

full_name: LinearIsometryEquiv
code: /-- A semilinear isometric equivalence between two normed vector spaces. -/
structure LinearIsometryEquiv (σ₁₂ : R →+* R₂) {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : Type*) [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂]
  [Module R E] [Module R₂ E₂] extends E ≃ₛₗ[σ₁₂] E₂ where
  norm_map' : ∀ x, ‖toLinearEquiv x‖ = ‖x‖
goal: Type (max u_11 u_12)

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_≃ₛₗᵢ[_]__1»
code: @[inherit_doc]
notation:25 E " ≃ₛₗᵢ[" σ₁₂:25 "] " E₂:0 => LinearIsometryEquiv σ₁₂ E E₂
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_1
code: @[inherit_doc]
notation:25 E " ≃ₛₗᵢ[" σ₁₂:25 "] " E₂:0 => LinearIsometryEquiv σ₁₂ E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_≃ₗᵢ[_]__1»
code: /-- A linear isometric equivalence between two normed vector spaces. -/
notation:25 E " ≃ₗᵢ[" R:25 "] " E₂:0 => LinearIsometryEquiv (RingHom.id R) E E₂
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_2
code: /-- A linear isometric equivalence between two normed vector spaces. -/
notation:25 E " ≃ₗᵢ[" R:25 "] " E₂:0 => LinearIsometryEquiv (RingHom.id R) E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_3
code: /-- An antilinear isometric equivalence between two normed vector spaces. -/
notation:25 E " ≃ₗᵢ⋆[" R:25 "] " E₂:0 => LinearIsometryEquiv (starRingEnd R) E E₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___macroRules_term_≃ₗᵢ⋆[_]__1»
code: /-- An antilinear isometric equivalence between two normed vector spaces. -/
notation:25 E " ≃ₗᵢ⋆[" R:25 "] " E₂:0 => LinearIsometryEquiv (starRingEnd R) E E₂
goal: Lean.Macro

full_name: SemilinearIsometryEquivClass
code: /-- `SemilinearIsometryEquivClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear
isometric equivs `E → E₂`.

See also `LinearIsometryEquivClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryEquivClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R]
  [Semiring R₂] (σ₁₂ : outParam <| R →+* R₂) {σ₂₁ : outParam <| R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [EquivLike 𝓕 E E₂]
  extends SemilinearEquivClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
goal: Prop

full_name: SemilinearIsometryEquivClass.norm_map
code: /-- `SemilinearIsometryEquivClass F σ E E₂` asserts `F` is a type of bundled `σ`-semilinear
isometric equivs `E → E₂`.

See also `LinearIsometryEquivClass F R E E₂` for the case where `σ` is the identity map on `R`.

A map `f` between an `R`-module and an `S`-module over a ring homomorphism `σ : R →+* S`
is semilinear if it satisfies the two properties `f (x + y) = f x + f y` and
`f (c • x) = (σ c) • f x`. -/
class SemilinearIsometryEquivClass (𝓕 : Type*) {R R₂ : outParam Type*} [Semiring R]
  [Semiring R₂] (σ₁₂ : outParam <| R →+* R₂) {σ₂₁ : outParam <| R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
  [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : outParam Type*) [SeminormedAddCommGroup E]
  [SeminormedAddCommGroup E₂] [Module R E] [Module R₂ E₂] [EquivLike 𝓕 E E₂]
  extends SemilinearEquivClass 𝓕 σ₁₂ E E₂ : Prop where
  norm_map : ∀ (f : 𝓕) (x : E), ‖f x‖ = ‖x‖
goal: ‖f x‖ = ‖x‖

full_name: LinearIsometryEquivClass
code: /-- `LinearIsometryEquivClass F R E E₂` asserts `F` is a type of bundled `R`-linear isometries
`M → M₂`.

This is an abbreviation for `SemilinearIsometryEquivClass F (RingHom.id R) E E₂`.
-/
abbrev LinearIsometryEquivClass (𝓕 : Type*) (R E E₂ : outParam Type*) [Semiring R]
    [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂] [Module R E] [Module R E₂]
    [EquivLike 𝓕 E E₂] 
goal: Prop

full_name: SemilinearIsometryEquivClass.toSemilinearIsometryClass
code: instance (priority := 100) toSemilinearIsometryClass [EquivLike 𝓕 E E₂]
    [s : SemilinearIsometryEquivClass 𝓕 σ₁₂ E E₂] : SemilinearIsometryClass 𝓕 σ₁₂ E E₂ 
goal: SemilinearIsometryClass 𝓕 σ₁₂ E E₂

full_name: LinearIsometryEquiv.toLinearEquiv_injective
code: theorem toLinearEquiv_injective : Injective (toLinearEquiv : (E ≃ₛₗᵢ[σ₁₂] E₂) → E ≃ₛₗ[σ₁₂] E₂)
  
goal: Function.Injective LinearIsometryEquiv.toLinearEquiv

full_name: LinearIsometryEquiv.toLinearEquiv_inj
code: @[simp]
theorem toLinearEquiv_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} : f.toLinearEquiv = g.toLinearEquiv ↔ f = g 
goal: f.toLinearEquiv = g.toLinearEquiv ↔ f = g

full_name: LinearIsometryEquiv.instEquivLike
code: instance instEquivLike : EquivLike (E ≃ₛₗᵢ[σ₁₂] E₂) E E₂ 
goal: EquivLike (E ≃ₛₗᵢ[σ₁₂] E₂) E E₂

full_name: LinearIsometryEquiv.instSemilinearIsometryEquivClass
code: instance instSemilinearIsometryEquivClass :
    SemilinearIsometryEquivClass (E ≃ₛₗᵢ[σ₁₂] E₂) σ₁₂ E E₂ 
goal: SemilinearIsometryEquivClass (E ≃ₛₗᵢ[σ₁₂] E₂) σ₁₂ E E₂

full_name: LinearIsometryEquiv.instCoeFun
code: /-- Helper instance for when there's too many metavariables to apply `DFunLike.hasCoeToFun`
directly. -/
instance instCoeFun : CoeFun (E ≃ₛₗᵢ[σ₁₂] E₂) fun _ ↦ E → E₂ 
goal: CoeFun (E ≃ₛₗᵢ[σ₁₂] E₂) fun x => E → E₂

full_name: LinearIsometryEquiv.coe_injective
code: theorem coe_injective : @Function.Injective (E ≃ₛₗᵢ[σ₁₂] E₂) (E → E₂) (↑) 
goal: Function.Injective DFunLike.coe

full_name: LinearIsometryEquiv.coe_mk
code: @[simp]
theorem coe_mk (e : E ≃ₛₗ[σ₁₂] E₂) (he : ∀ x, ‖e x‖ = ‖x‖) : ⇑(mk e he) = e 
goal: ⇑{ toLinearEquiv := e, norm_map' := he } = ⇑e

full_name: LinearIsometryEquiv.coe_toLinearEquiv
code: @[simp]
theorem coe_toLinearEquiv (e : E ≃ₛₗᵢ[σ₁₂] E₂) : ⇑e.toLinearEquiv = e 
goal: ⇑e.toLinearEquiv = ⇑e

full_name: LinearIsometryEquiv.ext
code: @[ext]
theorem ext {e e' : E ≃ₛₗᵢ[σ₁₂] E₂} (h : ∀ x, e x = e' x) : e = e' 
goal: e = e'

full_name: LinearIsometryEquiv.congr_arg
code: protected theorem congr_arg {f : E ≃ₛₗᵢ[σ₁₂] E₂} : ∀ {x x' : E}, x = x' → f x = f x'
  
goal: x = x' → f x = f x'

full_name: LinearIsometryEquiv.congr_fun
code: protected theorem congr_fun {f g : E ≃ₛₗᵢ[σ₁₂] E₂} (h : f = g) (x : E) : f x = g x 
goal: f x = g x

full_name: LinearIsometryEquiv.ofBounds
code: /-- Construct a `LinearIsometryEquiv` from a `LinearEquiv` and two inequalities:
`∀ x, ‖e x‖ ≤ ‖x‖` and `∀ y, ‖e.symm y‖ ≤ ‖y‖`. -/
def ofBounds (e : E ≃ₛₗ[σ₁₂] E₂) (h₁ : ∀ x, ‖e x‖ ≤ ‖x‖) (h₂ : ∀ y, ‖e.symm y‖ ≤ ‖y‖) :
    E ≃ₛₗᵢ[σ₁₂] E₂ 
goal: E ≃ₛₗᵢ[σ₁₂] E₂

full_name: LinearIsometryEquiv.norm_map
code: @[simp]
theorem norm_map (x : E) : ‖e x‖ = ‖x‖ 
goal: ‖e x‖ = ‖x‖

full_name: LinearIsometryEquiv.toLinearIsometry
code: /-- Reinterpret a `LinearIsometryEquiv` as a `LinearIsometry`. -/
def toLinearIsometry : E →ₛₗᵢ[σ₁₂] E₂ 
goal: E →ₛₗᵢ[σ₁₂] E₂

full_name: LinearIsometryEquiv.toLinearIsometry_injective
code: theorem toLinearIsometry_injective : Function.Injective (toLinearIsometry : _ → E →ₛₗᵢ[σ₁₂] E₂) 
goal: Function.Injective LinearIsometryEquiv.toLinearIsometry

full_name: LinearIsometryEquiv.toLinearIsometry_inj
code: @[simp]
theorem toLinearIsometry_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} :
    f.toLinearIsometry = g.toLinearIsometry ↔ f = g 
goal: f.toLinearIsometry = g.toLinearIsometry ↔ f = g

full_name: LinearIsometryEquiv.coe_toLinearIsometry
code: @[simp]
theorem coe_toLinearIsometry : ⇑e.toLinearIsometry = e 
goal: ⇑e.toLinearIsometry = ⇑e

full_name: LinearIsometryEquiv.isometry
code: protected theorem isometry : Isometry e 
goal: Isometry ⇑e

full_name: LinearIsometryEquiv.toIsometryEquiv
code: /-- Reinterpret a `LinearIsometryEquiv` as an `IsometryEquiv`. -/
def toIsometryEquiv : E ≃ᵢ E₂ 
goal: E ≃ᵢ E₂

full_name: LinearIsometryEquiv.toIsometryEquiv_injective
code: theorem toIsometryEquiv_injective :
    Function.Injective (toIsometryEquiv : (E ≃ₛₗᵢ[σ₁₂] E₂) → E ≃ᵢ E₂) 
goal: Function.Injective LinearIsometryEquiv.toIsometryEquiv

full_name: LinearIsometryEquiv.toIsometryEquiv_inj
code: @[simp]
theorem toIsometryEquiv_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} :
    f.toIsometryEquiv = g.toIsometryEquiv ↔ f = g 
goal: f.toIsometryEquiv = g.toIsometryEquiv ↔ f = g

full_name: LinearIsometryEquiv.coe_toIsometryEquiv
code: @[simp]
theorem coe_toIsometryEquiv : ⇑e.toIsometryEquiv = e 
goal: ⇑e.toIsometryEquiv = ⇑e

full_name: LinearIsometryEquiv.range_eq_univ
code: theorem range_eq_univ (e : E ≃ₛₗᵢ[σ₁₂] E₂) : Set.range e = Set.univ 
goal: Set.range ⇑e = Set.univ

full_name: LinearIsometryEquiv.toHomeomorph
code: /-- Reinterpret a `LinearIsometryEquiv` as a `Homeomorph`. -/
def toHomeomorph : E ≃ₜ E₂ 
goal: E ≃ₜ E₂

full_name: LinearIsometryEquiv.toHomeomorph_injective
code: theorem toHomeomorph_injective : Function.Injective (toHomeomorph : (E ≃ₛₗᵢ[σ₁₂] E₂) → E ≃ₜ E₂) 
goal: Function.Injective LinearIsometryEquiv.toHomeomorph

full_name: LinearIsometryEquiv.toHomeomorph_inj
code: @[simp]
theorem toHomeomorph_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} : f.toHomeomorph = g.toHomeomorph ↔ f = g 
goal: f.toHomeomorph = g.toHomeomorph ↔ f = g

full_name: LinearIsometryEquiv.coe_toHomeomorph
code: @[simp]
theorem coe_toHomeomorph : ⇑e.toHomeomorph = e 
goal: ⇑e.toHomeomorph = ⇑e

full_name: LinearIsometryEquiv.continuous
code: protected theorem continuous : Continuous e 
goal: Continuous ⇑e

full_name: LinearIsometryEquiv.continuousAt
code: protected theorem continuousAt {x} : ContinuousAt e x 
goal: ContinuousAt (⇑e) x

full_name: LinearIsometryEquiv.continuousOn
code: protected theorem continuousOn {s} : ContinuousOn e s 
goal: ContinuousOn (⇑e) s

full_name: LinearIsometryEquiv.continuousWithinAt
code: protected theorem continuousWithinAt {s x} : ContinuousWithinAt e s x 
goal: ContinuousWithinAt (⇑e) s x

full_name: LinearIsometryEquiv.toContinuousLinearEquiv
code: /-- Interpret a `LinearIsometryEquiv` as a `ContinuousLinearEquiv`. -/
def toContinuousLinearEquiv : E ≃SL[σ₁₂] E₂ 
goal: E ≃SL[σ₁₂] E₂

full_name: LinearIsometryEquiv.toContinuousLinearEquiv_injective
code: theorem toContinuousLinearEquiv_injective :
    Function.Injective (toContinuousLinearEquiv : _ → E ≃SL[σ₁₂] E₂) 
goal: Function.Injective LinearIsometryEquiv.toContinuousLinearEquiv

full_name: LinearIsometryEquiv.toContinuousLinearEquiv_inj
code: @[simp]
theorem toContinuousLinearEquiv_inj {f g : E ≃ₛₗᵢ[σ₁₂] E₂} :
    f.toContinuousLinearEquiv = g.toContinuousLinearEquiv ↔ f = g 
goal: f.toContinuousLinearEquiv = g.toContinuousLinearEquiv ↔ f = g

full_name: LinearIsometryEquiv.coe_toContinuousLinearEquiv
code: @[simp]
theorem coe_toContinuousLinearEquiv : ⇑e.toContinuousLinearEquiv = e 
goal: ⇑e.toContinuousLinearEquiv = ⇑e

full_name: LinearIsometryEquiv.refl
code: /-- Identity map as a `LinearIsometryEquiv`. -/
def refl : E ≃ₗᵢ[R] E 
goal: E ≃ₗᵢ[R] E

full_name: LinearIsometryEquiv.ulift
code: /-- Linear isometry equiv between a space and its lift to another universe. -/
def ulift : ULift E ≃ₗᵢ[R] E 
goal: ULift.{u_11, u_5} E ≃ₗᵢ[R] E

full_name: LinearIsometryEquiv.instInhabited
code: instance instInhabited : Inhabited (E ≃ₗᵢ[R] E) 
goal: Inhabited (E ≃ₗᵢ[R] E)

full_name: LinearIsometryEquiv.coe_refl
code: @[simp]
theorem coe_refl : ⇑(refl R E) = id 
goal: ⇑(LinearIsometryEquiv.refl R E) = id

full_name: LinearIsometryEquiv.symm
code: /-- The inverse `LinearIsometryEquiv`. -/
def symm : E₂ ≃ₛₗᵢ[σ₂₁] E 
goal: E₂ ≃ₛₗᵢ[σ₂₁] E

full_name: LinearIsometryEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (x : E₂) : e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: LinearIsometryEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (x : E) : e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: LinearIsometryEquiv.map_eq_zero_iff
code: theorem map_eq_zero_iff {x : E} : e x = 0 ↔ x = 0 
goal: e x = 0 ↔ x = 0

full_name: LinearIsometryEquiv.symm_symm
code: @[simp]
theorem symm_symm : e.symm.symm = e 
goal: e.symm.symm = e

full_name: LinearIsometryEquiv.toLinearEquiv_symm
code: @[simp]
theorem toLinearEquiv_symm : e.toLinearEquiv.symm = e.symm.toLinearEquiv 
goal: e.symm = e.symm.toLinearEquiv

full_name: LinearIsometryEquiv.toIsometryEquiv_symm
code: @[simp]
theorem toIsometryEquiv_symm : e.toIsometryEquiv.symm = e.symm.toIsometryEquiv 
goal: e.toIsometryEquiv.symm = e.symm.toIsometryEquiv

full_name: LinearIsometryEquiv.toHomeomorph_symm
code: @[simp]
theorem toHomeomorph_symm : e.toHomeomorph.symm = e.symm.toHomeomorph 
goal: e.toHomeomorph.symm = e.symm.toHomeomorph

full_name: LinearIsometryEquiv.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (σ₁₂ : R →+* R₂) {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
    (E E₂ : Type*) [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂] [Module R E]
    [Module R₂ E₂] (h : E ≃ₛₗᵢ[σ₁₂] E₂) : E → E₂ 
goal: E → E₂

full_name: LinearIsometryEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (σ₁₂ : R →+* R₂) {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁]
    [RingHomInvPair σ₂₁ σ₁₂] (E E₂ : Type*) [SeminormedAddCommGroup E] [SeminormedAddCommGroup E₂]
    [Module R E] [Module R₂ E₂] (h : E ≃ₛₗᵢ[σ₁₂] E₂) : E₂ → E 
goal: E₂ → E

full_name: LinearIsometryEquiv.trans
code: /-- Composition of `LinearIsometryEquiv`s as a `LinearIsometryEquiv`. -/
def trans (e' : E₂ ≃ₛₗᵢ[σ₂₃] E₃) : E ≃ₛₗᵢ[σ₁₃] E₃ 
goal: E ≃ₛₗᵢ[σ₁₃] E₃

full_name: LinearIsometryEquiv.coe_trans
code: @[simp]
theorem coe_trans (e₁ : E ≃ₛₗᵢ[σ₁₂] E₂) (e₂ : E₂ ≃ₛₗᵢ[σ₂₃] E₃) : ⇑(e₁.trans e₂) = e₂ ∘ e₁ 
goal: ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁

full_name: LinearIsometryEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : E ≃ₛₗᵢ[σ₁₂] E₂) (e₂ : E₂ ≃ₛₗᵢ[σ₂₃] E₃) (c : E) :
    (e₁.trans e₂ : E ≃ₛₗᵢ[σ₁₃] E₃) c = e₂ (e₁ c) 
goal: (e₁.trans e₂) c = e₂ (e₁ c)

full_name: LinearIsometryEquiv.toLinearEquiv_trans
code: @[simp]
theorem toLinearEquiv_trans (e' : E₂ ≃ₛₗᵢ[σ₂₃] E₃) :
    (e.trans e').toLinearEquiv = e.toLinearEquiv.trans e'.toLinearEquiv 
goal: (e.trans e').toLinearEquiv = e.trans e'.toLinearEquiv

full_name: LinearIsometryEquiv.trans_refl
code: @[simp]
theorem trans_refl : e.trans (refl R₂ E₂) = e 
goal: e.trans (LinearIsometryEquiv.refl R₂ E₂) = e

full_name: LinearIsometryEquiv.refl_trans
code: @[simp]
theorem refl_trans : (refl R E).trans e = e 
goal: (LinearIsometryEquiv.refl R E).trans e = e

full_name: LinearIsometryEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm : e.trans e.symm = refl R E 
goal: e.trans e.symm = LinearIsometryEquiv.refl R E

full_name: LinearIsometryEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self : e.symm.trans e = refl R₂ E₂ 
goal: e.symm.trans e = LinearIsometryEquiv.refl R₂ E₂

full_name: LinearIsometryEquiv.symm_comp_self
code: @[simp]
theorem symm_comp_self : e.symm ∘ e = id 
goal: ⇑e.symm ∘ ⇑e = id

full_name: LinearIsometryEquiv.self_comp_symm
code: @[simp]
theorem self_comp_symm : e ∘ e.symm = id 
goal: ⇑e ∘ ⇑e.symm = id

full_name: LinearIsometryEquiv.symm_trans
code: @[simp]
theorem symm_trans (e₁ : E ≃ₛₗᵢ[σ₁₂] E₂) (e₂ : E₂ ≃ₛₗᵢ[σ₂₃] E₃) :
    (e₁.trans e₂).symm = e₂.symm.trans e₁.symm 
goal: (e₁.trans e₂).symm = e₂.symm.trans e₁.symm

full_name: LinearIsometryEquiv.coe_symm_trans
code: theorem coe_symm_trans (e₁ : E ≃ₛₗᵢ[σ₁₂] E₂) (e₂ : E₂ ≃ₛₗᵢ[σ₂₃] E₃) :
    ⇑(e₁.trans e₂).symm = e₁.symm ∘ e₂.symm 
goal: ⇑(e₁.trans e₂).symm = ⇑e₁.symm ∘ ⇑e₂.symm

full_name: LinearIsometryEquiv.trans_assoc
code: theorem trans_assoc (eEE₂ : E ≃ₛₗᵢ[σ₁₂] E₂) (eE₂E₃ : E₂ ≃ₛₗᵢ[σ₂₃] E₃) (eE₃E₄ : E₃ ≃ₛₗᵢ[σ₃₄] E₄) :
    eEE₂.trans (eE₂E₃.trans eE₃E₄) = (eEE₂.trans eE₂E₃).trans eE₃E₄ 
goal: eEE₂.trans (eE₂E₃.trans eE₃E₄) = (eEE₂.trans eE₂E₃).trans eE₃E₄

full_name: LinearIsometryEquiv.instGroup
code: instance instGroup : Group (E ≃ₗᵢ[R] E) 
goal: Group (E ≃ₗᵢ[R] E)

full_name: LinearIsometryEquiv.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : E ≃ₗᵢ[R] E) = id 
goal: ⇑1 = id

full_name: LinearIsometryEquiv.coe_mul
code: @[simp]
theorem coe_mul (e e' : E ≃ₗᵢ[R] E) : ⇑(e * e') = e ∘ e' 
goal: ⇑(e * e') = ⇑e ∘ ⇑e'

full_name: LinearIsometryEquiv.coe_inv
code: @[simp]
theorem coe_inv (e : E ≃ₗᵢ[R] E) : ⇑e⁻¹ = e.symm 
goal: ⇑e⁻¹ = ⇑e.symm

full_name: LinearIsometryEquiv.one_def
code: theorem one_def : (1 : E ≃ₗᵢ[R] E) = refl _ _ 
goal: 1 = LinearIsometryEquiv.refl R E

full_name: LinearIsometryEquiv.mul_def
code: theorem mul_def (e e' : E ≃ₗᵢ[R] E) : (e * e' : E ≃ₗᵢ[R] E) = e'.trans e 
goal: e * e' = e'.trans e

full_name: LinearIsometryEquiv.inv_def
code: theorem inv_def (e : E ≃ₗᵢ[R] E) : (e⁻¹ : E ≃ₗᵢ[R] E) = e.symm 
goal: e⁻¹ = e.symm

full_name: LinearIsometryEquiv.trans_one
code: @[simp]
theorem trans_one : e.trans (1 : E₂ ≃ₗᵢ[R₂] E₂) = e 
goal: e.trans 1 = e

full_name: LinearIsometryEquiv.one_trans
code: @[simp]
theorem one_trans : (1 : E ≃ₗᵢ[R] E).trans e = e 
goal: LinearIsometryEquiv.trans 1 e = e

full_name: LinearIsometryEquiv.refl_mul
code: @[simp]
theorem refl_mul (e : E ≃ₗᵢ[R] E) : refl _ _ * e = e 
goal: LinearIsometryEquiv.refl R E * e = e

full_name: LinearIsometryEquiv.mul_refl
code: @[simp]
theorem mul_refl (e : E ≃ₗᵢ[R] E) : e * refl _ _ = e 
goal: e * LinearIsometryEquiv.refl R E = e

full_name: LinearIsometryEquiv.instCoeTCContinuousLinearEquiv
code: /-- Reinterpret a `LinearIsometryEquiv` as a `ContinuousLinearEquiv`. -/
instance instCoeTCContinuousLinearEquiv : CoeTC (E ≃ₛₗᵢ[σ₁₂] E₂) (E ≃SL[σ₁₂] E₂) 
goal: CoeTC (E ≃ₛₗᵢ[σ₁₂] E₂) (E ≃SL[σ₁₂] E₂)

full_name: LinearIsometryEquiv.instCoeTCContinuousLinearMap
code: instance instCoeTCContinuousLinearMap : CoeTC (E ≃ₛₗᵢ[σ₁₂] E₂) (E →SL[σ₁₂] E₂) 
goal: CoeTC (E ≃ₛₗᵢ[σ₁₂] E₂) (E →SL[σ₁₂] E₂)

full_name: LinearIsometryEquiv.coe_coe
code: @[simp]
theorem coe_coe : ⇑(e : E ≃SL[σ₁₂] E₂) = e 
goal: ⇑{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } = ⇑e

full_name: LinearIsometryEquiv.coe_coe''
code: @[simp]
theorem coe_coe'' : ⇑(e : E →SL[σ₁₂] E₂) = e 
goal: ⇑↑{ toLinearEquiv := e.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } = ⇑e

full_name: LinearIsometryEquiv.map_zero
code: theorem map_zero : e 0 = 0 
goal: e 0 = 0

full_name: LinearIsometryEquiv.map_add
code: theorem map_add (x y : E) : e (x + y) = e x + e y 
goal: e (x + y) = e x + e y

full_name: LinearIsometryEquiv.map_sub
code: theorem map_sub (x y : E) : e (x - y) = e x - e y 
goal: e (x - y) = e x - e y

full_name: LinearIsometryEquiv.map_smulₛₗ
code: theorem map_smulₛₗ (c : R) (x : E) : e (c • x) = σ₁₂ c • e x 
goal: e (c • x) = σ₁₂ c • e x

full_name: LinearIsometryEquiv.map_smul
code: theorem map_smul [Module R E₂] {e : E ≃ₗᵢ[R] E₂} (c : R) (x : E) : e (c • x) = c • e x 
goal: e (c • x) = c • e x

full_name: LinearIsometryEquiv.nnnorm_map
code: @[simp] -- Should be replaced with `SemilinearIsometryClass.nnorm_map` when `lean4#3107` is fixed.
theorem nnnorm_map (x : E) : ‖e x‖₊ = ‖x‖₊ 
goal: ‖e x‖₊ = ‖x‖₊

full_name: LinearIsometryEquiv.dist_map
code: @[simp]
theorem dist_map (x y : E) : dist (e x) (e y) = dist x y 
goal: dist (e x) (e y) = dist x y

full_name: LinearIsometryEquiv.edist_map
code: @[simp]
theorem edist_map (x y : E) : edist (e x) (e y) = edist x y 
goal: edist (e x) (e y) = edist x y

full_name: LinearIsometryEquiv.bijective
code: protected theorem bijective : Bijective e 
goal: Function.Bijective ⇑e

full_name: LinearIsometryEquiv.injective
code: protected theorem injective : Injective e 
goal: Function.Injective ⇑e

full_name: LinearIsometryEquiv.surjective
code: protected theorem surjective : Surjective e 
goal: Function.Surjective ⇑e

full_name: LinearIsometryEquiv.map_eq_iff
code: theorem map_eq_iff {x y : E} : e x = e y ↔ x = y 
goal: e x = e y ↔ x = y

full_name: LinearIsometryEquiv.map_ne
code: theorem map_ne {x y : E} (h : x ≠ y) : e x ≠ e y 
goal: e x ≠ e y

full_name: LinearIsometryEquiv.lipschitz
code: protected theorem lipschitz : LipschitzWith 1 e 
goal: LipschitzWith 1 ⇑e

full_name: LinearIsometryEquiv.antilipschitz
code: protected theorem antilipschitz : AntilipschitzWith 1 e 
goal: AntilipschitzWith 1 ⇑e

full_name: LinearIsometryEquiv.image_eq_preimage
code: theorem image_eq_preimage (s : Set E) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: LinearIsometryEquiv.ediam_image
code: @[simp]
theorem ediam_image (s : Set E) : EMetric.diam (e '' s) = EMetric.diam s 
goal: EMetric.diam (⇑e '' s) = EMetric.diam s

full_name: LinearIsometryEquiv.diam_image
code: @[simp]
theorem diam_image (s : Set E) : Metric.diam (e '' s) = Metric.diam s 
goal: Metric.diam (⇑e '' s) = Metric.diam s

full_name: LinearIsometryEquiv.preimage_ball
code: @[simp]
theorem preimage_ball (x : E₂) (r : ℝ) : e ⁻¹' Metric.ball x r = Metric.ball (e.symm x) r 
goal: ⇑e ⁻¹' Metric.ball x r = Metric.ball (e.symm x) r

full_name: LinearIsometryEquiv.preimage_sphere
code: @[simp]
theorem preimage_sphere (x : E₂) (r : ℝ) : e ⁻¹' Metric.sphere x r = Metric.sphere (e.symm x) r 
goal: ⇑e ⁻¹' Metric.sphere x r = Metric.sphere (e.symm x) r

full_name: LinearIsometryEquiv.preimage_closedBall
code: @[simp]
theorem preimage_closedBall (x : E₂) (r : ℝ) :
    e ⁻¹' Metric.closedBall x r = Metric.closedBall (e.symm x) r 
goal: ⇑e ⁻¹' Metric.closedBall x r = Metric.closedBall (e.symm x) r

full_name: LinearIsometryEquiv.image_ball
code: @[simp]
theorem image_ball (x : E) (r : ℝ) : e '' Metric.ball x r = Metric.ball (e x) r 
goal: ⇑e '' Metric.ball x r = Metric.ball (e x) r

full_name: LinearIsometryEquiv.image_sphere
code: @[simp]
theorem image_sphere (x : E) (r : ℝ) : e '' Metric.sphere x r = Metric.sphere (e x) r 
goal: ⇑e '' Metric.sphere x r = Metric.sphere (e x) r

full_name: LinearIsometryEquiv.image_closedBall
code: @[simp]
theorem image_closedBall (x : E) (r : ℝ) : e '' Metric.closedBall x r = Metric.closedBall (e x) r 
goal: ⇑e '' Metric.closedBall x r = Metric.closedBall (e x) r

full_name: LinearIsometryEquiv.comp_continuousOn_iff
code: @[simp]
theorem comp_continuousOn_iff {f : α → E} {s : Set α} : ContinuousOn (e ∘ f) s ↔ ContinuousOn f s 
goal: ContinuousOn (⇑e ∘ f) s ↔ ContinuousOn f s

full_name: LinearIsometryEquiv.comp_continuous_iff
code: @[simp]
theorem comp_continuous_iff {f : α → E} : Continuous (e ∘ f) ↔ Continuous f 
goal: Continuous (⇑e ∘ f) ↔ Continuous f

full_name: LinearIsometryEquiv.completeSpace_map
code: instance completeSpace_map (p : Submodule R E) [CompleteSpace p] :
    CompleteSpace (p.map (e.toLinearEquiv : E →ₛₗ[σ₁₂] E₂)) 
goal: CompleteSpace ↥(Submodule.map (↑e.toLinearEquiv) p)

full_name: LinearIsometryEquiv.ofSurjective
code: /-- Construct a linear isometry equiv from a surjective linear isometry. -/
noncomputable def ofSurjective (f : F →ₛₗᵢ[σ₁₂] E₂) (hfr : Function.Surjective f) :
    F ≃ₛₗᵢ[σ₁₂] E₂ 
goal: F ≃ₛₗᵢ[σ₁₂] E₂

full_name: LinearIsometryEquiv.coe_ofSurjective
code: @[simp]
theorem coe_ofSurjective (f : F →ₛₗᵢ[σ₁₂] E₂) (hfr : Function.Surjective f) :
    ⇑(LinearIsometryEquiv.ofSurjective f hfr) = f 
goal: ⇑(LinearIsometryEquiv.ofSurjective f hfr) = ⇑f

full_name: LinearIsometryEquiv.ofLinearIsometry
code: /-- If a linear isometry has an inverse, it is a linear isometric equivalence. -/
def ofLinearIsometry (f : E →ₛₗᵢ[σ₁₂] E₂) (g : E₂ →ₛₗ[σ₂₁] E)
    (h₁ : f.toLinearMap.comp g = LinearMap.id) (h₂ : g.comp f.toLinearMap = LinearMap.id) :
    E ≃ₛₗᵢ[σ₁₂] E₂ 
goal: E ≃ₛₗᵢ[σ₁₂] E₂

full_name: LinearIsometryEquiv.coe_ofLinearIsometry
code: @[simp]
theorem coe_ofLinearIsometry (f : E →ₛₗᵢ[σ₁₂] E₂) (g : E₂ →ₛₗ[σ₂₁] E)
    (h₁ : f.toLinearMap.comp g = LinearMap.id) (h₂ : g.comp f.toLinearMap = LinearMap.id) :
    (ofLinearIsometry f g h₁ h₂ : E → E₂) = (f : E → E₂) 
goal: ⇑(LinearIsometryEquiv.ofLinearIsometry f g h₁ h₂) = ⇑f

full_name: LinearIsometryEquiv.coe_ofLinearIsometry_symm
code: @[simp]
theorem coe_ofLinearIsometry_symm (f : E →ₛₗᵢ[σ₁₂] E₂) (g : E₂ →ₛₗ[σ₂₁] E)
    (h₁ : f.toLinearMap.comp g = LinearMap.id) (h₂ : g.comp f.toLinearMap = LinearMap.id) :
    ((ofLinearIsometry f g h₁ h₂).symm : E₂ → E) = (g : E₂ → E) 
goal: ⇑(LinearIsometryEquiv.ofLinearIsometry f g h₁ h₂).symm = ⇑g

full_name: LinearIsometryEquiv.neg
code: /-- The negation operation on a normed space `E`, considered as a linear isometry equivalence. -/
def neg : E ≃ₗᵢ[R] E 
goal: E ≃ₗᵢ[R] E

full_name: LinearIsometryEquiv.coe_neg
code: @[simp]
theorem coe_neg : (neg R : E → E) = fun x => -x 
goal: ⇑(LinearIsometryEquiv.neg R) = fun x => -x

full_name: LinearIsometryEquiv.symm_neg
code: @[simp]
theorem symm_neg : (neg R : E ≃ₗᵢ[R] E).symm = neg R 
goal: (LinearIsometryEquiv.neg R).symm = LinearIsometryEquiv.neg R

full_name: LinearIsometryEquiv.prodAssoc
code: /-- The natural equivalence `(E × E₂) × E₃ ≃ E × (E₂ × E₃)` is a linear isometry. -/
def prodAssoc [Module R E₂] [Module R E₃] : (E × E₂) × E₃ ≃ₗᵢ[R] E × E₂ × E₃ 
goal: (E × E₂) × E₃ ≃ₗᵢ[R] E × E₂ × E₃

full_name: LinearIsometryEquiv.coe_prodAssoc
code: @[simp]
theorem coe_prodAssoc [Module R E₂] [Module R E₃] :
    (prodAssoc R E E₂ E₃ : (E × E₂) × E₃ → E × E₂ × E₃) = Equiv.prodAssoc E E₂ E₃ 
goal: ⇑(LinearIsometryEquiv.prodAssoc R E E₂ E₃) = ⇑(Equiv.prodAssoc E E₂ E₃)

full_name: LinearIsometryEquiv.coe_prodAssoc_symm
code: @[simp]
theorem coe_prodAssoc_symm [Module R E₂] [Module R E₃] :
    ((prodAssoc R E E₂ E₃).symm : E × E₂ × E₃ → (E × E₂) × E₃) = (Equiv.prodAssoc E E₂ E₃).symm 
goal: ⇑(LinearIsometryEquiv.prodAssoc R E E₂ E₃).symm = ⇑(Equiv.prodAssoc E E₂ E₃).symm

full_name: LinearIsometryEquiv.ofTop_toLinearEquiv
code: /-- If `p` is a submodule that is equal to `⊤`, then `LinearIsometryEquiv.ofTop p hp` is the
"identity" equivalence between `p` and `E`. -/
@[simps! toLinearEquiv apply symm_apply_coe]
def ofTop {R : Type*} [Ring R] [Module R E] (p : Submodule R E) (hp : p = ⊤) : p ≃ₗᵢ[R] E 
goal: (LinearIsometryEquiv.ofTop E p hp).toLinearEquiv = LinearEquiv.ofTop p hp

full_name: LinearIsometryEquiv.ofTop_symm_apply_coe
code: /-- If `p` is a submodule that is equal to `⊤`, then `LinearIsometryEquiv.ofTop p hp` is the
"identity" equivalence between `p` and `E`. -/
@[simps! toLinearEquiv apply symm_apply_coe]
def ofTop {R : Type*} [Ring R] [Module R E] (p : Submodule R E) (hp : p = ⊤) : p ≃ₗᵢ[R] E 
goal: ↑((LinearIsometryEquiv.ofTop E p hp).symm x) = x

full_name: LinearIsometryEquiv.ofTop_apply
code: /-- If `p` is a submodule that is equal to `⊤`, then `LinearIsometryEquiv.ofTop p hp` is the
"identity" equivalence between `p` and `E`. -/
@[simps! toLinearEquiv apply symm_apply_coe]
def ofTop {R : Type*} [Ring R] [Module R E] (p : Submodule R E) (hp : p = ⊤) : p ≃ₗᵢ[R] E 
goal: (LinearIsometryEquiv.ofTop E p hp) self = ↑self

full_name: LinearIsometryEquiv.ofTop
code: /-- If `p` is a submodule that is equal to `⊤`, then `LinearIsometryEquiv.ofTop p hp` is the
"identity" equivalence between `p` and `E`. -/
@[simps! toLinearEquiv apply symm_apply_coe]
def ofTop {R : Type*} [Ring R] [Module R E] (p : Submodule R E) (hp : p = ⊤) : p ≃ₗᵢ[R] E 
goal: ↥p ≃ₗᵢ[R] E

full_name: LinearIsometryEquiv.ofEq
code: /-- `LinearEquiv.ofEq` as a `LinearIsometryEquiv`. -/
def ofEq (hpq : p = q) : p ≃ₗᵢ[R'] q 
goal: ↥p ≃ₗᵢ[R'] ↥q

full_name: LinearIsometryEquiv.coe_ofEq_apply
code: @[simp]
theorem coe_ofEq_apply (h : p = q) (x : p) : (ofEq p q h x : E) = x 
goal: ↑((LinearIsometryEquiv.ofEq p q h) x) = ↑x

full_name: LinearIsometryEquiv.ofEq_symm
code: @[simp]
theorem ofEq_symm (h : p = q) : (ofEq p q h).symm = ofEq q p h.symm 
goal: (LinearIsometryEquiv.ofEq p q h).symm = LinearIsometryEquiv.ofEq q p ⋯

full_name: LinearIsometryEquiv.ofEq_rfl
code: @[simp]
theorem ofEq_rfl : ofEq p p rfl = LinearIsometryEquiv.refl R' p 
goal: LinearIsometryEquiv.ofEq p p ⋯ = LinearIsometryEquiv.refl R' ↥p

full_name: Basis.ext_linearIsometry
code: /-- Two linear isometries are equal if they are equal on basis vectors. -/
theorem Basis.ext_linearIsometry {ι : Type*} (b : Basis ι R E) {f₁ f₂ : E →ₛₗᵢ[σ₁₂] E₂}
    (h : ∀ i, f₁ (b i) = f₂ (b i)) : f₁ = f₂ 
goal: f₁ = f₂

full_name: Basis.ext_linearIsometryEquiv
code: /-- Two linear isometric equivalences are equal if they are equal on basis vectors. -/
theorem Basis.ext_linearIsometryEquiv {ι : Type*} (b : Basis ι R E) {f₁ f₂ : E ≃ₛₗᵢ[σ₁₂] E₂}
    (h : ∀ i, f₁ (b i) = f₂ (b i)) : f₁ = f₂ 
goal: f₁ = f₂

full_name: LinearIsometry.equivRange_apply_coe
code: /-- Reinterpret a `LinearIsometry` as a `LinearIsometryEquiv` to the range. -/
@[simps! apply_coe] -- Porting note: `toLinearEquiv` projection does not simplify using itself
noncomputable def LinearIsometry.equivRange {R S : Type*} [Semiring R] [Ring S] [Module S E]
    [Module R F] {σ₁₂ : R →+* S} {σ₂₁ : S →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
    (f : F →ₛₗᵢ[σ₁₂] E) : F ≃ₛₗᵢ[σ₁₂] (LinearMap.range f.toLinearMap) 
goal: ↑(f.equivRange a) = f a

full_name: LinearIsometry.equivRange
code: /-- Reinterpret a `LinearIsometry` as a `LinearIsometryEquiv` to the range. -/
@[simps! apply_coe] -- Porting note: `toLinearEquiv` projection does not simplify using itself
noncomputable def LinearIsometry.equivRange {R S : Type*} [Semiring R] [Ring S] [Module S E]
    [Module R F] {σ₁₂ : R →+* S} {σ₂₁ : S →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
    (f : F →ₛₗᵢ[σ₁₂] E) : F ≃ₛₗᵢ[σ₁₂] (LinearMap.range f.toLinearMap) 
goal: F ≃ₛₗᵢ[σ₁₂] ↥(LinearMap.range f.toLinearMap)