File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_PiL2___macroRules_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: PiLp.innerProductSpace
code: instance PiLp.innerProductSpace {ι : Type*} [Fintype ι] (f : ι → Type*)
    [∀ i, NormedAddCommGroup (f i)] [∀ i, InnerProductSpace 𝕜 (f i)] :
    InnerProductSpace 𝕜 (PiLp 2 f) 
goal: InnerProductSpace 𝕜 (PiLp 2 f)

full_name: PiLp.inner_apply
code: @[simp]
theorem PiLp.inner_apply {ι : Type*} [Fintype ι] {f : ι → Type*} [∀ i, NormedAddCommGroup (f i)]
    [∀ i, InnerProductSpace 𝕜 (f i)] (x y : PiLp 2 f) : ⟪x, y⟫ = ∑ i, ⟪x i, y i⟫ 
goal: ⟪x, y⟫_𝕜 = ∑ i : ι, ⟪x i, y i⟫_𝕜

full_name: EuclideanSpace
code: /-- The standard real/complex Euclidean space, functions on a finite type. For an `n`-dimensional
space use `EuclideanSpace 𝕜 (Fin n)`. -/
abbrev EuclideanSpace (𝕜 : Type*) (n : Type*) : Type _ 
goal: Type (max u_8 u_9)

full_name: EuclideanSpace.nnnorm_eq
code: theorem EuclideanSpace.nnnorm_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x : EuclideanSpace 𝕜 n) : ‖x‖₊ = NNReal.sqrt (∑ i, ‖x i‖₊ ^ 2) 
goal: ‖x‖₊ = NNReal.sqrt (∑ i : n, ‖x i‖₊ ^ 2)

full_name: EuclideanSpace.norm_eq
code: theorem EuclideanSpace.norm_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x : EuclideanSpace 𝕜 n) : ‖x‖ = √(∑ i, ‖x i‖ ^ 2) 
goal: ‖x‖ = √(∑ i : n, ‖x i‖ ^ 2)

full_name: EuclideanSpace.dist_eq
code: theorem EuclideanSpace.dist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : dist x y = √(∑ i, dist (x i) (y i) ^ 2) 
goal: dist x y = √(∑ i : n, dist (x i) (y i) ^ 2)

full_name: EuclideanSpace.nndist_eq
code: theorem EuclideanSpace.nndist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : nndist x y = NNReal.sqrt (∑ i, nndist (x i) (y i) ^ 2) 
goal: nndist x y = NNReal.sqrt (∑ i : n, nndist (x i) (y i) ^ 2)

full_name: EuclideanSpace.edist_eq
code: theorem EuclideanSpace.edist_eq {𝕜 : Type*} [RCLike 𝕜] {n : Type*} [Fintype n]
    (x y : EuclideanSpace 𝕜 n) : edist x y = (∑ i, edist (x i) (y i) ^ 2) ^ (1 / 2 : ℝ) 
goal: edist x y = (∑ i : n, edist (x i) (y i) ^ 2) ^ (1 / 2)

full_name: EuclideanSpace.ball_zero_eq
code: theorem EuclideanSpace.ball_zero_eq {n : Type*} [Fintype n] (r : ℝ) (hr : 0 ≤ r) :
    Metric.ball (0 : EuclideanSpace ℝ n) r = {x | ∑ i, x i ^ 2 < r ^ 2} 
goal: Metric.ball 0 r = {x | ∑ i : n, x i ^ 2 < r ^ 2}

full_name: EuclideanSpace.closedBall_zero_eq
code: theorem EuclideanSpace.closedBall_zero_eq {n : Type*} [Fintype n] (r : ℝ) (hr : 0 ≤ r) :
    Metric.closedBall (0 : EuclideanSpace ℝ n) r = {x | ∑ i, x i ^ 2 ≤ r ^ 2} 
goal: Metric.closedBall 0 r = {x | ∑ i : n, x i ^ 2 ≤ r ^ 2}

full_name: EuclideanSpace.sphere_zero_eq
code: theorem EuclideanSpace.sphere_zero_eq {n : Type*} [Fintype n] (r : ℝ) (hr : 0 ≤ r) :
    Metric.sphere (0 : EuclideanSpace ℝ n) r = {x | ∑ i, x i ^ 2 = r ^ 2} 
goal: Metric.sphere 0 r = {x | ∑ i : n, x i ^ 2 = r ^ 2}

full_name: finrank_euclideanSpace
code: @[simp]
theorem finrank_euclideanSpace :
    FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 ι) = Fintype.card ι 
goal: FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 ι) = Fintype.card ι

full_name: finrank_euclideanSpace_fin
code: theorem finrank_euclideanSpace_fin {n : ℕ} :
    FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 (Fin n)) = n 
goal: FiniteDimensional.finrank 𝕜 (EuclideanSpace 𝕜 (Fin n)) = n

full_name: EuclideanSpace.inner_eq_star_dotProduct
code: theorem EuclideanSpace.inner_eq_star_dotProduct (x y : EuclideanSpace 𝕜 ι) :
    ⟪x, y⟫ = Matrix.dotProduct (star <| WithLp.equiv _ _ x) (WithLp.equiv _ _ y) 
goal: ⟪x, y⟫_𝕜 = Matrix.dotProduct (star ((WithLp.equiv 2 (ι → 𝕜)) x)) ((WithLp.equiv 2 (ι → 𝕜)) y)

full_name: EuclideanSpace.inner_piLp_equiv_symm
code: theorem EuclideanSpace.inner_piLp_equiv_symm (x y : ι → 𝕜) :
    ⟪(WithLp.equiv 2 _).symm x, (WithLp.equiv 2 _).symm y⟫ = Matrix.dotProduct (star x) y 
goal: ⟪(WithLp.equiv 2 (ι → 𝕜)).symm x, (WithLp.equiv 2 (ι → 𝕜)).symm y⟫_𝕜 = Matrix.dotProduct (star x) y

full_name: DirectSum.IsInternal.isometryL2OfOrthogonalFamily
code: /-- A finite, mutually orthogonal family of subspaces of `E`, which span `E`, induce an isometry
from `E` to `PiLp 2` of the subspaces equipped with the `L2` inner product. -/
def DirectSum.IsInternal.isometryL2OfOrthogonalFamily [DecidableEq ι] {V : ι → Submodule 𝕜 E}
    (hV : DirectSum.IsInternal V)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    E ≃ₗᵢ[𝕜] PiLp 2 fun i => V i 
goal: E ≃ₗᵢ[𝕜] PiLp 2 fun i => ↥(V i)

full_name: DirectSum.IsInternal.isometryL2OfOrthogonalFamily_symm_apply
code: @[simp]
theorem DirectSum.IsInternal.isometryL2OfOrthogonalFamily_symm_apply [DecidableEq ι]
    {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) (w : PiLp 2 fun i => V i) :
    (hV.isometryL2OfOrthogonalFamily hV').symm w = ∑ i, (w i : E) 
goal: (hV.isometryL2OfOrthogonalFamily hV').symm w = ∑ i : ι, ↑(w i)

full_name: EuclideanSpace.equiv
code: /-- A shorthand for `PiLp.continuousLinearEquiv`. -/
abbrev EuclideanSpace.equiv : EuclideanSpace 𝕜 ι ≃L[𝕜] ι → 𝕜 
goal: EuclideanSpace 𝕜 ι ≃L[𝕜] ι → 𝕜

full_name: EuclideanSpace.projₗ
code: /-- The projection on the `i`-th coordinate of `EuclideanSpace 𝕜 ι`, as a linear map. -/
@[simps!]
def EuclideanSpace.projₗ (i : ι) : EuclideanSpace 𝕜 ι →ₗ[𝕜] 𝕜 
goal: EuclideanSpace 𝕜 ι →ₗ[𝕜] 𝕜

full_name: EuclideanSpace.projₗ_apply
code: /-- The projection on the `i`-th coordinate of `EuclideanSpace 𝕜 ι`, as a linear map. -/
@[simps!]
def EuclideanSpace.projₗ (i : ι) : EuclideanSpace 𝕜 ι →ₗ[𝕜] 𝕜 
goal: ∀ (a : WithLp 2 (ι → 𝕜)), (EuclideanSpace.projₗ i) a = a i

full_name: EuclideanSpace.proj_coe
code: /-- The projection on the `i`-th coordinate of `EuclideanSpace 𝕜 ι`,
as a continuous linear map. -/
@[simps! apply coe]
def EuclideanSpace.proj (i : ι) : EuclideanSpace 𝕜 ι →L[𝕜] 𝕜 
goal: ↑(EuclideanSpace.proj i) = EuclideanSpace.projₗ i

full_name: EuclideanSpace.proj_apply
code: /-- The projection on the `i`-th coordinate of `EuclideanSpace 𝕜 ι`,
as a continuous linear map. -/
@[simps! apply coe]
def EuclideanSpace.proj (i : ι) : EuclideanSpace 𝕜 ι →L[𝕜] 𝕜 
goal: ∀ (a : WithLp 2 (ι → 𝕜)), (EuclideanSpace.proj i) a = a i

full_name: EuclideanSpace.proj
code: /-- The projection on the `i`-th coordinate of `EuclideanSpace 𝕜 ι`,
as a continuous linear map. -/
@[simps! apply coe]
def EuclideanSpace.proj (i : ι) : EuclideanSpace 𝕜 ι →L[𝕜] 𝕜 
goal: EuclideanSpace 𝕜 ι →L[𝕜] 𝕜

full_name: EuclideanSpace.single
code: /-- The vector given in euclidean space by being `a : 𝕜` at coordinate `i : ι` and `0 : 𝕜` at
all other coordinates. -/
def EuclideanSpace.single (i : ι) (a : 𝕜) : EuclideanSpace 𝕜 ι 
goal: EuclideanSpace 𝕜 ι

full_name: WithLp.equiv_single
code: @[simp]
theorem WithLp.equiv_single (i : ι) (a : 𝕜) :
    WithLp.equiv _ _ (EuclideanSpace.single i a) = Pi.single i a 
goal: (WithLp.equiv 2 ((i : ι) → (fun x => 𝕜) i)) (EuclideanSpace.single i a) = Pi.single i a

full_name: WithLp.equiv_symm_single
code: @[simp]
theorem WithLp.equiv_symm_single (i : ι) (a : 𝕜) :
    (WithLp.equiv _ _).symm (Pi.single i a) = EuclideanSpace.single i a 
goal: (WithLp.equiv 2 (ι → 𝕜)).symm (Pi.single i a) = EuclideanSpace.single i a

full_name: EuclideanSpace.single_apply
code: @[simp]
theorem EuclideanSpace.single_apply (i : ι) (a : 𝕜) (j : ι) :
    (EuclideanSpace.single i a) j = ite (j = i) a 0 
goal: EuclideanSpace.single i a j = if j = i then a else 0

full_name: EuclideanSpace.inner_single_left
code: theorem EuclideanSpace.inner_single_left (i : ι) (a : 𝕜) (v : EuclideanSpace 𝕜 ι) :
    ⟪EuclideanSpace.single i (a : 𝕜), v⟫ = conj a * v i 
goal: ⟪EuclideanSpace.single i a, v⟫_𝕜 = (starRingEnd 𝕜) a * v i

full_name: EuclideanSpace.inner_single_right
code: theorem EuclideanSpace.inner_single_right (i : ι) (a : 𝕜) (v : EuclideanSpace 𝕜 ι) :
    ⟪v, EuclideanSpace.single i (a : 𝕜)⟫ = a * conj (v i) 
goal: ⟪v, EuclideanSpace.single i a⟫_𝕜 = a * (starRingEnd ((fun x => 𝕜) i)) (v i)

full_name: EuclideanSpace.norm_single
code: @[simp]
theorem EuclideanSpace.norm_single (i : ι) (a : 𝕜) :
    ‖EuclideanSpace.single i (a : 𝕜)‖ = ‖a‖ 
goal: ‖EuclideanSpace.single i a‖ = ‖a‖

full_name: EuclideanSpace.nnnorm_single
code: @[simp]
theorem EuclideanSpace.nnnorm_single (i : ι) (a : 𝕜) :
    ‖EuclideanSpace.single i (a : 𝕜)‖₊ = ‖a‖₊ 
goal: ‖EuclideanSpace.single i a‖₊ = ‖a‖₊

full_name: EuclideanSpace.dist_single_same
code: @[simp]
theorem EuclideanSpace.dist_single_same (i : ι) (a b : 𝕜) :
    dist (EuclideanSpace.single i (a : 𝕜)) (EuclideanSpace.single i (b : 𝕜)) = dist a b 
goal: dist (EuclideanSpace.single i a) (EuclideanSpace.single i b) = dist a b

full_name: EuclideanSpace.nndist_single_same
code: @[simp]
theorem EuclideanSpace.nndist_single_same (i : ι) (a b : 𝕜) :
    nndist (EuclideanSpace.single i (a : 𝕜)) (EuclideanSpace.single i (b : 𝕜)) = nndist a b 
goal: nndist (EuclideanSpace.single i a) (EuclideanSpace.single i b) = nndist a b

full_name: EuclideanSpace.edist_single_same
code: @[simp]
theorem EuclideanSpace.edist_single_same (i : ι) (a b : 𝕜) :
    edist (EuclideanSpace.single i (a : 𝕜)) (EuclideanSpace.single i (b : 𝕜)) = edist a b 
goal: edist (EuclideanSpace.single i a) (EuclideanSpace.single i b) = edist a b

full_name: EuclideanSpace.orthonormal_single
code: /-- `EuclideanSpace.single` forms an orthonormal family. -/
theorem EuclideanSpace.orthonormal_single :
    Orthonormal 𝕜 fun i : ι => EuclideanSpace.single i (1 : 𝕜) 
goal: Orthonormal 𝕜 fun i => EuclideanSpace.single i 1

full_name: EuclideanSpace.piLpCongrLeft_single
code: theorem EuclideanSpace.piLpCongrLeft_single
    {ι' : Type*} [Fintype ι'] [DecidableEq ι'] (e : ι' ≃ ι) (i' : ι') (v : 𝕜) :
    LinearIsometryEquiv.piLpCongrLeft 2 𝕜 𝕜 e (EuclideanSpace.single i' v) =
      EuclideanSpace.single (e i') v 
goal: (LinearIsometryEquiv.piLpCongrLeft 2 𝕜 𝕜 e) (EuclideanSpace.single i' v) = EuclideanSpace.single (e i') v

full_name: OrthonormalBasis
code: /-- An orthonormal basis on E is an identification of `E` with its dimensional-matching
`EuclideanSpace 𝕜 ι`. -/
structure OrthonormalBasis where ofRepr ::
  /-- Linear isometry between `E` and `EuclideanSpace 𝕜 ι` representing the orthonormal basis. -/
  repr : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
goal: Type (max (max u_1 u_3) u_4)

full_name: OrthonormalBasis.ofRepr
code: /-- An orthonormal basis on E is an identification of `E` with its dimensional-matching
`EuclideanSpace 𝕜 ι`. -/
structure OrthonormalBasis where ofRepr ::
  /-- Linear isometry between `E` and `EuclideanSpace 𝕜 ι` representing the orthonormal basis. -/
  repr : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
goal: OrthonormalBasis ι 𝕜 E

full_name: OrthonormalBasis.repr
code: /-- An orthonormal basis on E is an identification of `E` with its dimensional-matching
`EuclideanSpace 𝕜 ι`. -/
structure OrthonormalBasis where ofRepr ::
  /-- Linear isometry between `E` and `EuclideanSpace 𝕜 ι` representing the orthonormal basis. -/
  repr : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
goal: E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι

full_name: OrthonormalBasis.repr_injective
code: theorem repr_injective :
    Injective (repr : OrthonormalBasis ι 𝕜 E → E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι) 
goal: Function.Injective OrthonormalBasis.repr

full_name: OrthonormalBasis.instFunLike
code: /-- `b i` is the `i`th basis vector. -/
instance instFunLike : FunLike (OrthonormalBasis ι 𝕜 E) ι E 
goal: FunLike (OrthonormalBasis ι 𝕜 E) ι E

full_name: OrthonormalBasis.coe_ofRepr
code: @[simp]
theorem coe_ofRepr [DecidableEq ι] (e : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι) :
    ⇑(OrthonormalBasis.ofRepr e) = fun i => e.symm (EuclideanSpace.single i (1 : 𝕜)) 
goal: ⇑{ repr := e } = fun i => e.symm (EuclideanSpace.single i 1)

full_name: OrthonormalBasis.repr_symm_single
code: @[simp]
protected theorem repr_symm_single [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
    b.repr.symm (EuclideanSpace.single i (1 : 𝕜)) = b i 
goal: b.repr.symm (EuclideanSpace.single i 1) = b i

full_name: OrthonormalBasis.repr_self
code: @[simp]
protected theorem repr_self [DecidableEq ι] (b : OrthonormalBasis ι 𝕜 E) (i : ι) :
    b.repr (b i) = EuclideanSpace.single i (1 : 𝕜) 
goal: b.repr (b i) = EuclideanSpace.single i 1

full_name: OrthonormalBasis.repr_apply_apply
code: protected theorem repr_apply_apply (b : OrthonormalBasis ι 𝕜 E) (v : E) (i : ι) :
    b.repr v i = ⟪b i, v⟫ 
goal: b.repr v i = ⟪b i, v⟫_𝕜

full_name: OrthonormalBasis.orthonormal
code: @[simp]
protected theorem orthonormal (b : OrthonormalBasis ι 𝕜 E) : Orthonormal 𝕜 b 
goal: Orthonormal 𝕜 ⇑b

full_name: OrthonormalBasis.toBasis
code: /-- The `Basis ι 𝕜 E` underlying the `OrthonormalBasis` -/
protected def toBasis (b : OrthonormalBasis ι 𝕜 E) : Basis ι 𝕜 E 
goal: Basis ι 𝕜 E

full_name: OrthonormalBasis.coe_toBasis
code: @[simp]
protected theorem coe_toBasis (b : OrthonormalBasis ι 𝕜 E) : (⇑b.toBasis : ι → E) = ⇑b 
goal: ⇑b.toBasis = ⇑b

full_name: OrthonormalBasis.coe_toBasis_repr
code: @[simp]
protected theorem coe_toBasis_repr (b : OrthonormalBasis ι 𝕜 E) :
    b.toBasis.equivFun = b.repr.toLinearEquiv 
goal: b.toBasis.equivFun = b.repr.toLinearEquiv

full_name: OrthonormalBasis.coe_toBasis_repr_apply
code: @[simp]
protected theorem coe_toBasis_repr_apply (b : OrthonormalBasis ι 𝕜 E) (x : E) (i : ι) :
    b.toBasis.repr x i = b.repr x i 
goal: (b.toBasis.repr x) i = b.repr x i

full_name: OrthonormalBasis.sum_repr
code: protected theorem sum_repr (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, b.repr x i • b i = x 
goal: ∑ i : ι, b.repr x i • b i = x

full_name: OrthonormalBasis.sum_repr'
code: protected theorem sum_repr' (b : OrthonormalBasis ι 𝕜 E) (x : E) : ∑ i, ⟪b i, x⟫_𝕜 • b i = x 
goal: ∑ i : ι, ⟪b i, x⟫_𝕜 • b i = x

full_name: OrthonormalBasis.sum_repr_symm
code: protected theorem sum_repr_symm (b : OrthonormalBasis ι 𝕜 E) (v : EuclideanSpace 𝕜 ι) :
    ∑ i, v i • b i = b.repr.symm v 
goal: ∑ i : ι, v i • b i = b.repr.symm v

full_name: OrthonormalBasis.sum_inner_mul_inner
code: protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E) :
    ∑ i, ⟪x, b i⟫ * ⟪b i, y⟫ = ⟪x, y⟫ 
goal: ∑ i : ι, ⟪x, b i⟫_𝕜 * ⟪b i, y⟫_𝕜 = ⟪x, y⟫_𝕜

full_name: OrthonormalBasis.orthogonalProjection_eq_sum
code: protected theorem orthogonalProjection_eq_sum {U : Submodule 𝕜 E} [CompleteSpace U]
    (b : OrthonormalBasis ι 𝕜 U) (x : E) :
    orthogonalProjection U x = ∑ i, ⟪(b i : E), x⟫ • b i 
goal: (orthogonalProjection U) x = ∑ i : ι, ⟪↑(b i), x⟫_𝕜 • b i

full_name: OrthonormalBasis.map
code: /-- Mapping an orthonormal basis along a `LinearIsometryEquiv`. -/
protected def map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
    (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) : OrthonormalBasis ι 𝕜 G 
goal: OrthonormalBasis ι 𝕜 G

full_name: OrthonormalBasis.map_apply
code: @[simp]
protected theorem map_apply {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
    (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) (i : ι) : b.map L i = L (b i) 
goal: (b.map L) i = L (b i)

full_name: OrthonormalBasis.toBasis_map
code: @[simp]
protected theorem toBasis_map {G : Type*} [NormedAddCommGroup G] [InnerProductSpace 𝕜 G]
    (b : OrthonormalBasis ι 𝕜 E) (L : E ≃ₗᵢ[𝕜] G) :
    (b.map L).toBasis = b.toBasis.map L.toLinearEquiv 
goal: (b.map L).toBasis = b.toBasis.map L.toLinearEquiv

full_name: Basis.toOrthonormalBasis
code: /-- A basis that is orthonormal is an orthonormal basis. -/
def _root_.Basis.toOrthonormalBasis (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    OrthonormalBasis ι 𝕜 E 
goal: OrthonormalBasis ι 𝕜 E

full_name: Basis.coe_toOrthonormalBasis_repr
code: @[simp]
theorem _root_.Basis.coe_toOrthonormalBasis_repr (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    ((v.toOrthonormalBasis hv).repr : E → EuclideanSpace 𝕜 ι) = v.equivFun 
goal: ⇑(v.toOrthonormalBasis hv).repr = ⇑v.equivFun

full_name: Basis.coe_toOrthonormalBasis_repr_symm
code: @[simp]
theorem _root_.Basis.coe_toOrthonormalBasis_repr_symm (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    ((v.toOrthonormalBasis hv).repr.symm : EuclideanSpace 𝕜 ι → E) = v.equivFun.symm 
goal: ⇑(v.toOrthonormalBasis hv).repr.symm = ⇑v.equivFun.symm

full_name: Basis.toBasis_toOrthonormalBasis
code: @[simp]
theorem _root_.Basis.toBasis_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    (v.toOrthonormalBasis hv).toBasis = v 
goal: (v.toOrthonormalBasis hv).toBasis = v

full_name: Basis.coe_toOrthonormalBasis
code: @[simp]
theorem _root_.Basis.coe_toOrthonormalBasis (v : Basis ι 𝕜 E) (hv : Orthonormal 𝕜 v) :
    (v.toOrthonormalBasis hv : ι → E) = (v : ι → E) 
goal: ⇑(v.toOrthonormalBasis hv) = ⇑v

full_name: Pi.orthonormalBasis
code: /-- `Pi.orthonormalBasis (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i))` is the
`Σ i, ι i`-indexed orthonormal basis on `Π i, E i` given by `B i` on each component. -/
protected def _root_.Pi.orthonormalBasis {η : Type*} [Fintype η] {ι : η → Type*}
    [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, InnerProductSpace 𝕜 (E i)] (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i)) :
    OrthonormalBasis ((i : η) × ι i) 𝕜 (PiLp 2 E) 
goal: OrthonormalBasis ((i : η) × ι i) 𝕜 (PiLp 2 E)

full_name: Pi.orthonormalBasis.toBasis
code: theorem _root_.Pi.orthonormalBasis.toBasis {η : Type*} [Fintype η] {ι : η → Type*}
    [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, InnerProductSpace 𝕜 (E i)] (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i)) :
    (Pi.orthonormalBasis B).toBasis =
      ((Pi.basis fun i : η ↦ (B i).toBasis).map (WithLp.linearEquiv 2 _ _).symm) 
goal: (Pi.orthonormalBasis B).toBasis = (Pi.basis fun i => (B i).toBasis).map (WithLp.linearEquiv 2 𝕜 ((j : η) → E j)).symm

full_name: Pi.orthonormalBasis_apply
code: @[simp]
theorem _root_.Pi.orthonormalBasis_apply {η : Type*} [Fintype η] [DecidableEq η] {ι : η → Type*}
    [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, InnerProductSpace 𝕜 (E i)] (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i))
    (j : (i : η) × (ι i)) :
    Pi.orthonormalBasis B j = (WithLp.equiv _ _).symm (Pi.single _ (B j.fst j.snd)) 
goal: (Pi.orthonormalBasis B) j = (WithLp.equiv 2 ((j : η) → E j)).symm (Pi.single j.fst ((B j.fst) j.snd))

full_name: Pi.orthonormalBasis_repr
code: @[simp]
theorem _root_.Pi.orthonormalBasis_repr {η : Type*} [Fintype η] {ι : η → Type*}
    [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, InnerProductSpace 𝕜 (E i)] (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i)) (x : (i : η ) → E i)
    (j : (i : η) × (ι i)) :
    (Pi.orthonormalBasis B).repr x j = (B j.fst).repr (x j.fst) j.snd 
goal: (Pi.orthonormalBasis B).repr x j = (B j.fst).repr (x j.fst) j.snd

full_name: OrthonormalBasis.mk
code: /-- A finite orthonormal set that spans is an orthonormal basis -/
protected def mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (Set.range v)) :
    OrthonormalBasis ι 𝕜 E 
goal: OrthonormalBasis ι 𝕜 E

full_name: OrthonormalBasis.coe_mk
code: @[simp]
protected theorem coe_mk (hon : Orthonormal 𝕜 v) (hsp : ⊤ ≤ Submodule.span 𝕜 (Set.range v)) :
    ⇑(OrthonormalBasis.mk hon hsp) = v 
goal: ⇑(OrthonormalBasis.mk hon hsp) = v

full_name: OrthonormalBasis.span
code: /-- Any finite subset of an orthonormal family is an `OrthonormalBasis` for its span. -/
protected def span [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s : Finset ι') :
    OrthonormalBasis s 𝕜 (span 𝕜 (s.image v' : Set E)) 
goal: OrthonormalBasis { x // x ∈ s } 𝕜 ↥(Submodule.span 𝕜 ↑(Finset.image v' s))

full_name: OrthonormalBasis.span_apply
code: @[simp]
protected theorem span_apply [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s : Finset ι')
    (i : s) : (OrthonormalBasis.span h s i : E) = v' i 
goal: ↑((OrthonormalBasis.span h s) i) = v' ↑i

full_name: OrthonormalBasis.mkOfOrthogonalEqBot
code: /-- A finite orthonormal family of vectors whose span has trivial orthogonal complement is an
orthonormal basis. -/
protected def mkOfOrthogonalEqBot (hon : Orthonormal 𝕜 v) (hsp : (span 𝕜 (Set.range v))ᗮ = ⊥) :
    OrthonormalBasis ι 𝕜 E 
goal: OrthonormalBasis ι 𝕜 E

full_name: OrthonormalBasis.coe_of_orthogonal_eq_bot_mk
code: @[simp]
protected theorem coe_of_orthogonal_eq_bot_mk (hon : Orthonormal 𝕜 v)
    (hsp : (span 𝕜 (Set.range v))ᗮ = ⊥) : ⇑(OrthonormalBasis.mkOfOrthogonalEqBot hon hsp) = v 
goal: ⇑(OrthonormalBasis.mkOfOrthogonalEqBot hon hsp) = v

full_name: OrthonormalBasis.reindex
code: /-- `b.reindex (e : ι ≃ ι')` is an `OrthonormalBasis` indexed by `ι'` -/
def reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') : OrthonormalBasis ι' 𝕜 E 
goal: OrthonormalBasis ι' 𝕜 E

full_name: OrthonormalBasis.reindex_apply
code: protected theorem reindex_apply (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (i' : ι') :
    (b.reindex e) i' = b (e.symm i') 
goal: (b.reindex e) i' = b (e.symm i')

full_name: OrthonormalBasis.reindex_toBasis
code: @[simp]
theorem reindex_toBasis (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
    (b.reindex e).toBasis = b.toBasis.reindex e 
goal: (b.reindex e).toBasis = b.toBasis.reindex e

full_name: OrthonormalBasis.coe_reindex
code: @[simp]
protected theorem coe_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') :
    ⇑(b.reindex e) = b ∘ e.symm 
goal: ⇑(b.reindex e) = ⇑b ∘ ⇑e.symm

full_name: OrthonormalBasis.repr_reindex
code: @[simp]
protected theorem repr_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (x : E) (i' : ι') :
    (b.reindex e).repr x i' = b.repr x (e.symm i') 
goal: (b.reindex e).repr x i' = b.repr x (e.symm i')

full_name: EuclideanSpace.basisFun
code: /-- The basis `Pi.basisFun`, bundled as an orthornormal basis of `EuclideanSpace 𝕜 ι`. -/
noncomputable def basisFun : OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι) 
goal: OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι)

full_name: EuclideanSpace.basisFun_apply
code: @[simp]
theorem basisFun_apply [DecidableEq ι] (i : ι) : basisFun ι 𝕜 i = EuclideanSpace.single i 1 
goal: (EuclideanSpace.basisFun ι 𝕜) i = EuclideanSpace.single i 1

full_name: EuclideanSpace.basisFun_repr
code: @[simp]
theorem basisFun_repr (x : EuclideanSpace 𝕜 ι) (i : ι) : (basisFun ι 𝕜).repr x i = x i 
goal: (EuclideanSpace.basisFun ι 𝕜).repr x i = x i

full_name: EuclideanSpace.basisFun_toBasis
code: theorem basisFun_toBasis : (basisFun ι 𝕜).toBasis = PiLp.basisFun _ 𝕜 ι 
goal: (EuclideanSpace.basisFun ι 𝕜).toBasis = PiLp.basisFun 2 𝕜 ι

full_name: OrthonormalBasis.instInhabited
code: instance OrthonormalBasis.instInhabited : Inhabited (OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι)) 
goal: Inhabited (OrthonormalBasis ι 𝕜 (EuclideanSpace 𝕜 ι))

full_name: Complex.orthonormalBasisOneI
code: /-- `![1, I]` is an orthonormal basis for `ℂ` considered as a real inner product space. -/
def Complex.orthonormalBasisOneI : OrthonormalBasis (Fin 2) ℝ ℂ 
goal: OrthonormalBasis (Fin 2) ℝ ℂ

full_name: Complex.orthonormalBasisOneI_repr_apply
code: @[simp]
theorem Complex.orthonormalBasisOneI_repr_apply (z : ℂ) :
    Complex.orthonormalBasisOneI.repr z = ![z.re, z.im] 
goal: Complex.orthonormalBasisOneI.repr z = ![z.re, z.im]

full_name: Complex.orthonormalBasisOneI_repr_symm_apply
code: @[simp]
theorem Complex.orthonormalBasisOneI_repr_symm_apply (x : EuclideanSpace ℝ (Fin 2)) :
    Complex.orthonormalBasisOneI.repr.symm x = x 0 + x 1 * I 
goal: Complex.orthonormalBasisOneI.repr.symm x = ↑(x 0) + ↑(x 1) * Complex.I

full_name: Complex.toBasis_orthonormalBasisOneI
code: @[simp]
theorem Complex.toBasis_orthonormalBasisOneI :
    Complex.orthonormalBasisOneI.toBasis = Complex.basisOneI 
goal: Complex.orthonormalBasisOneI.toBasis = Complex.basisOneI

full_name: Complex.coe_orthonormalBasisOneI
code: @[simp]
theorem Complex.coe_orthonormalBasisOneI :
    (Complex.orthonormalBasisOneI : Fin 2 → ℂ) = ![1, I] 
goal: ⇑Complex.orthonormalBasisOneI = ![1, Complex.I]

full_name: Complex.isometryOfOrthonormal
code: /-- The isometry between `ℂ` and a two-dimensional real inner product space given by a basis. -/
def Complex.isometryOfOrthonormal (v : OrthonormalBasis (Fin 2) ℝ F) : ℂ ≃ₗᵢ[ℝ] F 
goal: ℂ ≃ₗᵢ[ℝ] F

full_name: Complex.map_isometryOfOrthonormal
code: @[simp]
theorem Complex.map_isometryOfOrthonormal (v : OrthonormalBasis (Fin 2) ℝ F) (f : F ≃ₗᵢ[ℝ] F') :
    Complex.isometryOfOrthonormal (v.map f) = (Complex.isometryOfOrthonormal v).trans f 
goal: Complex.isometryOfOrthonormal (v.map f) = (Complex.isometryOfOrthonormal v).trans f

full_name: Complex.isometryOfOrthonormal_symm_apply
code: theorem Complex.isometryOfOrthonormal_symm_apply (v : OrthonormalBasis (Fin 2) ℝ F) (f : F) :
    (Complex.isometryOfOrthonormal v).symm f =
      (v.toBasis.coord 0 f : ℂ) + (v.toBasis.coord 1 f : ℂ) * I 
goal: (Complex.isometryOfOrthonormal v).symm f = ↑((v.toBasis.coord 0) f) + ↑((v.toBasis.coord 1) f) * Complex.I

full_name: Complex.isometryOfOrthonormal_apply
code: theorem Complex.isometryOfOrthonormal_apply (v : OrthonormalBasis (Fin 2) ℝ F) (z : ℂ) :
    Complex.isometryOfOrthonormal v z = z.re • v 0 + z.im • v 1 
goal: (Complex.isometryOfOrthonormal v) z = z.re • v 0 + z.im • v 1

full_name: OrthonormalBasis.toMatrix_orthonormalBasis_mem_unitary
code: /-- The change-of-basis matrix between two orthonormal bases `a`, `b` is a unitary matrix. -/
theorem OrthonormalBasis.toMatrix_orthonormalBasis_mem_unitary :
    a.toBasis.toMatrix b ∈ Matrix.unitaryGroup ι 𝕜 
goal: a.toBasis.toMatrix ⇑b ∈ Matrix.unitaryGroup ι 𝕜

full_name: OrthonormalBasis.det_to_matrix_orthonormalBasis
code: /-- The determinant of the change-of-basis matrix between two orthonormal bases `a`, `b` has
unit length. -/
@[simp]
theorem OrthonormalBasis.det_to_matrix_orthonormalBasis : ‖a.toBasis.det b‖ = 1 
goal: ‖a.toBasis.det ⇑b‖ = 1

full_name: OrthonormalBasis.toMatrix_orthonormalBasis_mem_orthogonal
code: /-- The change-of-basis matrix between two orthonormal bases `a`, `b` is an orthogonal matrix. -/
theorem OrthonormalBasis.toMatrix_orthonormalBasis_mem_orthogonal :
    a.toBasis.toMatrix b ∈ Matrix.orthogonalGroup ι ℝ 
goal: a.toBasis.toMatrix ⇑b ∈ Matrix.orthogonalGroup ι ℝ

full_name: OrthonormalBasis.det_to_matrix_orthonormalBasis_real
code: /-- The determinant of the change-of-basis matrix between two orthonormal bases `a`, `b` is ±1. -/
theorem OrthonormalBasis.det_to_matrix_orthonormalBasis_real :
    a.toBasis.det b = 1 ∨ a.toBasis.det b = -1 
goal: a.toBasis.det ⇑b = 1 ∨ a.toBasis.det ⇑b = -1

full_name: DirectSum.IsInternal.collectedOrthonormalBasis
code: /-- Given an internal direct sum decomposition of a module `M`, and an orthonormal basis for each
of the components of the direct sum, the disjoint union of these orthonormal bases is an
orthonormal basis for `M`. -/
noncomputable def DirectSum.IsInternal.collectedOrthonormalBasis
    (hV : OrthogonalFamily 𝕜 (fun i => A i) fun i => (A i).subtypeₗᵢ) [DecidableEq ι]
    (hV_sum : DirectSum.IsInternal fun i => A i) {α : ι → Type*} [∀ i, Fintype (α i)]
    (v_family : ∀ i, OrthonormalBasis (α i) 𝕜 (A i)) : OrthonormalBasis (Σi, α i) 𝕜 E 
goal: OrthonormalBasis ((i : ι) × α i) 𝕜 E

full_name: DirectSum.IsInternal.collectedOrthonormalBasis_mem
code: theorem DirectSum.IsInternal.collectedOrthonormalBasis_mem [DecidableEq ι]
    (h : DirectSum.IsInternal A) {α : ι → Type*} [∀ i, Fintype (α i)]
    (hV : OrthogonalFamily 𝕜 (fun i => A i) fun i => (A i).subtypeₗᵢ)
    (v : ∀ i, OrthonormalBasis (α i) 𝕜 (A i)) (a : Σi, α i) :
    h.collectedOrthonormalBasis hV v a ∈ A a.1 
goal: (DirectSum.IsInternal.collectedOrthonormalBasis hV h v) a ∈ A a.fst

full_name: Orthonormal.exists_orthonormalBasis_extension
code: /-- In a finite-dimensional `InnerProductSpace`, any orthonormal subset can be extended to an
orthonormal basis. -/
theorem Orthonormal.exists_orthonormalBasis_extension (hv : Orthonormal 𝕜 ((↑) : v → E)) :
    ∃ (u : Finset E) (b : OrthonormalBasis u 𝕜 E), v ⊆ u ∧ ⇑b = ((↑) : u → E) 
goal: ∃ u b, v ⊆ ↑u ∧ ⇑b = Subtype.val

full_name: Orthonormal.exists_orthonormalBasis_extension_of_card_eq
code: theorem Orthonormal.exists_orthonormalBasis_extension_of_card_eq {ι : Type*} [Fintype ι]
    (card_ι : finrank 𝕜 E = Fintype.card ι) {v : ι → E} {s : Set ι}
    (hv : Orthonormal 𝕜 (s.restrict v)) : ∃ b : OrthonormalBasis ι 𝕜 E, ∀ i ∈ s, b i = v i 
goal: ∃ b, ∀ i ∈ s, b i = v i

full_name: exists_orthonormalBasis
code: /-- A finite-dimensional inner product space admits an orthonormal basis. -/
theorem _root_.exists_orthonormalBasis :
    ∃ (w : Finset E) (b : OrthonormalBasis w 𝕜 E), ⇑b = ((↑) : w → E) 
goal: ∃ w b, ⇑b = Subtype.val

full_name: definition._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.14077
code: /-- A finite-dimensional `InnerProductSpace` has an orthonormal basis. -/
irreducible_def stdOrthonormalBasis : OrthonormalBasis (Fin (finrank 𝕜 E)) 𝕜 E 
goal: OrthonormalBasis (Fin (FiniteDimensional.finrank 𝕜 E)) 𝕜 E

full_name: wrapped._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.14077
code: /-- A finite-dimensional `InnerProductSpace` has an orthonormal basis. -/
irreducible_def stdOrthonormalBasis : OrthonormalBasis (Fin (finrank 𝕜 E)) 𝕜 E 
goal: Subtype (Eq definition✝)

full_name: stdOrthonormalBasis_def
code: /-- A finite-dimensional `InnerProductSpace` has an orthonormal basis. -/
irreducible_def stdOrthonormalBasis : OrthonormalBasis (Fin (finrank 𝕜 E)) 𝕜 E 
goal: stdOrthonormalBasis 𝕜 E =
  let b := Classical.choose ⋯;
  ⋯.mpr (b.reindex (Fintype.equivFinOfCardEq ⋯))

full_name: stdOrthonormalBasis
code: /-- A finite-dimensional `InnerProductSpace` has an orthonormal basis. -/
irreducible_def stdOrthonormalBasis : OrthonormalBasis (Fin (finrank 𝕜 E)) 𝕜 E 
goal: OrthonormalBasis (Fin (FiniteDimensional.finrank 𝕜 E)) 𝕜 E

full_name: orthonormalBasis_one_dim
code: /-- An orthonormal basis of `ℝ` is made either of the vector `1`, or of the vector `-1`. -/
theorem orthonormalBasis_one_dim (b : OrthonormalBasis ι ℝ ℝ) :
    (⇑b = fun _ => (1 : ℝ)) ∨ ⇑b = fun _ => (-1 : ℝ) 
goal: (⇑b = fun x => 1) ∨ ⇑b = fun x => -1

full_name: definition._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.14958
code: /-- Exhibit a bijection between `Fin n` and the index set of a certain basis of an `n`-dimensional
inner product space `E`.  This should not be accessed directly, but only via the subsequent API. -/
irreducible_def DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    (Σi, Fin (finrank 𝕜 (V i))) ≃ Fin n 
goal: (i : ι) × Fin (FiniteDimensional.finrank 𝕜 ↥(V i)) ≃ Fin n

full_name: DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv
code: /-- Exhibit a bijection between `Fin n` and the index set of a certain basis of an `n`-dimensional
inner product space `E`.  This should not be accessed directly, but only via the subsequent API. -/
irreducible_def DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    (Σi, Fin (finrank 𝕜 (V i))) ≃ Fin n 
goal: (i : ι) × Fin (FiniteDimensional.finrank 𝕜 ↥(V i)) ≃ Fin n

full_name: DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv_def
code: /-- Exhibit a bijection between `Fin n` and the index set of a certain basis of an `n`-dimensional
inner product space `E`.  This should not be accessed directly, but only via the subsequent API. -/
irreducible_def DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    (Σi, Fin (finrank 𝕜 (V i))) ≃ Fin n 
goal: DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv hn hV hV' =
  let b := DirectSum.IsInternal.collectedOrthonormalBasis hV' hV fun i => stdOrthonormalBasis 𝕜 ↥(V i);
  Fintype.equivFinOfCardEq ⋯

full_name: wrapped._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.14958
code: /-- Exhibit a bijection between `Fin n` and the index set of a certain basis of an `n`-dimensional
inner product space `E`.  This should not be accessed directly, but only via the subsequent API. -/
irreducible_def DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    (Σi, Fin (finrank 𝕜 (V i))) ≃ Fin n 
goal: Subtype (Eq @definition✝)

full_name: DirectSum.IsInternal.subordinateOrthonormalBasis_def
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasis
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    OrthonormalBasis (Fin n) 𝕜 E 
goal: DirectSum.IsInternal.subordinateOrthonormalBasis hn hV hV' =
  (DirectSum.IsInternal.collectedOrthonormalBasis hV' hV fun i => stdOrthonormalBasis 𝕜 ↥(V i)).reindex
    (DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv hn hV hV')

full_name: wrapped._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.15456
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasis
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    OrthonormalBasis (Fin n) 𝕜 E 
goal: Subtype (Eq @definition✝)

full_name: DirectSum.IsInternal.subordinateOrthonormalBasis
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasis
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    OrthonormalBasis (Fin n) 𝕜 E 
goal: OrthonormalBasis (Fin n) 𝕜 E

full_name: definition._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.15456
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasis
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    OrthonormalBasis (Fin n) 𝕜 E 
goal: OrthonormalBasis (Fin n) 𝕜 E

full_name: DirectSum.IsInternal.subordinateOrthonormalBasisIndex_def
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasisIndex (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) : ι 
goal: DirectSum.IsInternal.subordinateOrthonormalBasisIndex hn hV a hV' =
  ((DirectSum.IsInternal.sigmaOrthonormalBasisIndexEquiv hn hV hV').symm a).fst

full_name: wrapped._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.15936
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasisIndex (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) : ι 
goal: Subtype (Eq @definition✝)

full_name: definition._@.Mathlib.Analysis.InnerProductSpace.PiL2._hyg.15936
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasisIndex (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) : ι 
goal: ι

full_name: DirectSum.IsInternal.subordinateOrthonormalBasisIndex
code: /-- An `n`-dimensional `InnerProductSpace` equipped with a decomposition as an internal direct
sum has an orthonormal basis indexed by `Fin n` and subordinate to that direct sum. This function
provides the mapping by which it is subordinate. -/
irreducible_def DirectSum.IsInternal.subordinateOrthonormalBasisIndex (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) : ι 
goal: ι

full_name: DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate
code: /-- The basis constructed in `DirectSum.IsInternal.subordinateOrthonormalBasis` is subordinate to
the `OrthogonalFamily` in question. -/
theorem DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate (a : Fin n)
    (hV' : OrthogonalFamily 𝕜 (fun i => V i) fun i => (V i).subtypeₗᵢ) :
    hV.subordinateOrthonormalBasis hn hV' a ∈ V (hV.subordinateOrthonormalBasisIndex hn a hV') 
goal: (DirectSum.IsInternal.subordinateOrthonormalBasis hn hV hV') a ∈
  V (DirectSum.IsInternal.subordinateOrthonormalBasisIndex hn hV a hV')

full_name: OrthonormalBasis.fromOrthogonalSpanSingleton
code: /-- Given a natural number `n` one less than the `finrank` of a finite-dimensional inner product
space, there exists an isometry from the orthogonal complement of a nonzero singleton to
`EuclideanSpace 𝕜 (Fin n)`. -/
def OrthonormalBasis.fromOrthogonalSpanSingleton (n : ℕ) [Fact (finrank 𝕜 E = n + 1)] {v : E}
    (hv : v ≠ 0) : OrthonormalBasis (Fin n) 𝕜 (𝕜 ∙ v)ᗮ 
goal: OrthonormalBasis (Fin n) 𝕜 ↥(Submodule.span 𝕜 {v})ᗮ

full_name: LinearIsometry.extend
code: /-- Let `S` be a subspace of a finite-dimensional complex inner product space `V`.  A linear
isometry mapping `S` into `V` can be extended to a full isometry of `V`.

TODO:  The case when `S` is a finite-dimensional subspace of an infinite-dimensional `V`. -/
noncomputable def LinearIsometry.extend (L : S →ₗᵢ[𝕜] V) : V →ₗᵢ[𝕜] V 
goal: V →ₗᵢ[𝕜] V

full_name: LinearIsometry.extend_apply
code: theorem LinearIsometry.extend_apply (L : S →ₗᵢ[𝕜] V) (s : S) : L.extend s = L s 
goal: L.extend ↑s = L s

full_name: Matrix.toEuclideanLin
code: /-- `Matrix.toLin'` adapted for `EuclideanSpace 𝕜 _`. -/
def toEuclideanLin : Matrix m n 𝕜 ≃ₗ[𝕜] EuclideanSpace 𝕜 n →ₗ[𝕜] EuclideanSpace 𝕜 m 
goal: Matrix m n 𝕜 ≃ₗ[𝕜] EuclideanSpace 𝕜 n →ₗ[𝕜] EuclideanSpace 𝕜 m

full_name: Matrix.toEuclideanLin_piLp_equiv_symm
code: @[simp]
theorem toEuclideanLin_piLp_equiv_symm (A : Matrix m n 𝕜) (x : n → 𝕜) :
    Matrix.toEuclideanLin A ((WithLp.equiv _ _).symm x) =
      (WithLp.equiv _ _).symm (Matrix.toLin' A x) 
goal: (Matrix.toEuclideanLin A) ((WithLp.equiv 2 ((i : n) → (fun x => 𝕜) i)).symm x) =
  (WithLp.equiv 2 (m → 𝕜)).symm ((Matrix.toLin' A) x)

full_name: Matrix.piLp_equiv_toEuclideanLin
code: @[simp]
theorem piLp_equiv_toEuclideanLin (A : Matrix m n 𝕜) (x : EuclideanSpace 𝕜 n) :
    WithLp.equiv _ _ (Matrix.toEuclideanLin A x) = Matrix.toLin' A (WithLp.equiv _ _ x) 
goal: (WithLp.equiv 2 ((i : m) → (fun x => 𝕜) i)) ((Matrix.toEuclideanLin A) x) =
  (Matrix.toLin' A) ((WithLp.equiv 2 (n → 𝕜)) x)

full_name: Matrix.toEuclideanLin_apply
code: theorem toEuclideanLin_apply (M : Matrix m n 𝕜) (v : EuclideanSpace 𝕜 n) :
    toEuclideanLin M v = (WithLp.equiv 2 (m → 𝕜)).symm (M *ᵥ (WithLp.equiv 2 (n → 𝕜)) v) 
goal: (Matrix.toEuclideanLin M) v = (WithLp.equiv 2 (m → 𝕜)).symm (M.mulVec ((WithLp.equiv 2 (n → 𝕜)) v))

full_name: Matrix.piLp_equiv_toEuclideanLin_apply
code: @[simp]
theorem piLp_equiv_toEuclideanLin_apply (M : Matrix m n 𝕜) (v : EuclideanSpace 𝕜 n) :
    WithLp.equiv 2 (m → 𝕜) (toEuclideanLin M v) = M *ᵥ WithLp.equiv 2 (n → 𝕜) v 
goal: (WithLp.equiv 2 (m → 𝕜)) ((Matrix.toEuclideanLin M) v) = M.mulVec ((WithLp.equiv 2 (n → 𝕜)) v)

full_name: Matrix.toEuclideanLin_apply_piLp_equiv_symm
code: @[simp]
theorem toEuclideanLin_apply_piLp_equiv_symm (M : Matrix m n 𝕜) (v : n → 𝕜) :
    toEuclideanLin M ((WithLp.equiv 2 (n→ 𝕜)).symm v) = (WithLp.equiv 2 (m → 𝕜)).symm (M *ᵥ v) 
goal: (Matrix.toEuclideanLin M) ((WithLp.equiv 2 (n → 𝕜)).symm v) = (WithLp.equiv 2 (m → 𝕜)).symm (M.mulVec v)

full_name: Matrix.toEuclideanLin_eq_toLin
code: theorem toEuclideanLin_eq_toLin [Finite m] :
    (toEuclideanLin : Matrix m n 𝕜 ≃ₗ[𝕜] _) =
      Matrix.toLin (PiLp.basisFun _ _ _) (PiLp.basisFun _ _ _) 
goal: Matrix.toEuclideanLin = Matrix.toLin (PiLp.basisFun 2 𝕜 n) (PiLp.basisFun 2 𝕜 m)

full_name: Matrix.toEuclideanLin_eq_toLin_orthonormal
code: lemma toEuclideanLin_eq_toLin_orthonormal [Fintype m] :
    toEuclideanLin = toLin (basisFun n 𝕜).toBasis (basisFun m 𝕜).toBasis 
goal: Matrix.toEuclideanLin = Matrix.toLin (EuclideanSpace.basisFun n 𝕜).toBasis (EuclideanSpace.basisFun m 𝕜).toBasis

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_PiL2___macroRules_term⟪_,_⟫ₑ_1»
code: local notation "⟪" x ", " y "⟫ₑ" =>
  @inner 𝕜 _ _ (Equiv.symm (WithLp.equiv 2 _) x) (Equiv.symm (WithLp.equiv 2 _) y)
goal: Lean.Macro

full_name: inner_matrix_row_row
code: /-- The inner product of a row of `A` and a row of `B` is an entry of `B * Aᴴ`. -/
theorem inner_matrix_row_row [Fintype n] (A B : Matrix m n 𝕜) (i j : m) :
    ⟪A i, B j⟫ₑ = (B * Aᴴ) j i 
goal: ⟪(WithLp.equiv 2 (n → 𝕜)).symm (A i), (WithLp.equiv 2 (n → 𝕜)).symm (B j)⟫_𝕜 = (B * A.conjTranspose) j i

full_name: inner_matrix_col_col
code: /-- The inner product of a column of `A` and a column of `B` is an entry of `Aᴴ * B`. -/
theorem inner_matrix_col_col [Fintype m] (A B : Matrix m n 𝕜) (i j : n) :
    ⟪Aᵀ i, Bᵀ j⟫ₑ = (Aᴴ * B) i j 
goal: ⟪(WithLp.equiv 2 (m → 𝕜)).symm (A.transpose i), (WithLp.equiv 2 (m → 𝕜)).symm (B.transpose j)⟫_𝕜 =
  (A.conjTranspose * B) i j