File: Mathlib/Analysis/NormedSpace/MStructure.lean

full_name: IsLprojection.proj
code: /-- A projection on a normed space `X` is said to be an L-projection if, for all `x` in `X`,
$\|x\| = \|P x\| + \|(1 - P) x\|$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsLprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Lnorm : ∀ x : X, ‖x‖ = ‖P • x‖ + ‖(1 - P) • x‖
goal: IsIdempotentElem P

full_name: IsLprojection.Lnorm
code: /-- A projection on a normed space `X` is said to be an L-projection if, for all `x` in `X`,
$\|x\| = \|P x\| + \|(1 - P) x\|$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsLprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Lnorm : ∀ x : X, ‖x‖ = ‖P • x‖ + ‖(1 - P) • x‖
goal: ‖x‖ = ‖P • x‖ + ‖(1 - P) • x‖

full_name: IsLprojection
code: /-- A projection on a normed space `X` is said to be an L-projection if, for all `x` in `X`,
$\|x\| = \|P x\| + \|(1 - P) x\|$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsLprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Lnorm : ∀ x : X, ‖x‖ = ‖P • x‖ + ‖(1 - P) • x‖
goal: Prop

full_name: IsMprojection.proj
code: /-- A projection on a normed space `X` is said to be an M-projection if, for all `x` in `X`,
$\|x\| = max(\|P x\|,\|(1 - P) x\|)$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsMprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Mnorm : ∀ x : X, ‖x‖ = max ‖P • x‖ ‖(1 - P) • x‖
goal: IsIdempotentElem P

full_name: IsMprojection
code: /-- A projection on a normed space `X` is said to be an M-projection if, for all `x` in `X`,
$\|x\| = max(\|P x\|,\|(1 - P) x\|)$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsMprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Mnorm : ∀ x : X, ‖x‖ = max ‖P • x‖ ‖(1 - P) • x‖
goal: Prop

full_name: IsMprojection.Mnorm
code: /-- A projection on a normed space `X` is said to be an M-projection if, for all `x` in `X`,
$\|x\| = max(\|P x\|,\|(1 - P) x\|)$.

Note that we write `P • x` instead of `P x` for reasons described in the module docstring.
-/
structure IsMprojection (P : M) : Prop where
  proj : IsIdempotentElem P
  Mnorm : ∀ x : X, ‖x‖ = max ‖P • x‖ ‖(1 - P) • x‖
goal: ‖x‖ = max ‖P • x‖ ‖(1 - P) • x‖

full_name: IsLprojection.Lcomplement
code: theorem Lcomplement {P : M} (h : IsLprojection X P) : IsLprojection X (1 - P) 
goal: IsLprojection X (1 - P)

full_name: IsLprojection.Lcomplement_iff
code: theorem Lcomplement_iff (P : M) : IsLprojection X P ↔ IsLprojection X (1 - P) 
goal: IsLprojection X P ↔ IsLprojection X (1 - P)

full_name: IsLprojection.commute
code: theorem commute [FaithfulSMul M X] {P Q : M} (h₁ : IsLprojection X P) (h₂ : IsLprojection X Q) :
    Commute P Q 
goal: Commute P Q

full_name: IsLprojection.mul
code: theorem mul [FaithfulSMul M X] {P Q : M} (h₁ : IsLprojection X P) (h₂ : IsLprojection X Q) :
    IsLprojection X (P * Q) 
goal: IsLprojection X (P * Q)

full_name: IsLprojection.join
code: theorem join [FaithfulSMul M X] {P Q : M} (h₁ : IsLprojection X P) (h₂ : IsLprojection X Q) :
    IsLprojection X (P + Q - P * Q) 
goal: IsLprojection X (P + Q - P * Q)

full_name: IsLprojection.Subtype.hasCompl
code: instance Subtype.hasCompl : HasCompl { f : M // IsLprojection X f } 
goal: HasCompl { f // IsLprojection X f }

full_name: IsLprojection.coe_compl
code: @[simp]
theorem coe_compl (P : { P : M // IsLprojection X P }) : ↑Pᶜ = (1 : M) - ↑P 
goal: ↑Pᶜ = 1 - ↑P

full_name: IsLprojection.Subtype.inf
code: instance Subtype.inf [FaithfulSMul M X] : Inf { P : M // IsLprojection X P } 
goal: Inf { P // IsLprojection X P }

full_name: IsLprojection.coe_inf
code: @[simp]
theorem coe_inf [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    ↑(P ⊓ Q) = (↑P : M) * ↑Q 
goal: ↑(P ⊓ Q) = ↑P * ↑Q

full_name: IsLprojection.Subtype.sup
code: instance Subtype.sup [FaithfulSMul M X] : Sup { P : M // IsLprojection X P } 
goal: Sup { P // IsLprojection X P }

full_name: IsLprojection.coe_sup
code: @[simp]
theorem coe_sup [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    ↑(P ⊔ Q) = (↑P : M) + ↑Q - ↑P * ↑Q 
goal: ↑(P ⊔ Q) = ↑P + ↑Q - ↑P * ↑Q

full_name: IsLprojection.Subtype.sdiff
code: instance Subtype.sdiff [FaithfulSMul M X] : SDiff { P : M // IsLprojection X P } 
goal: SDiff { P // IsLprojection X P }

full_name: IsLprojection.coe_sdiff
code: @[simp]
theorem coe_sdiff [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    ↑(P \ Q) = (↑P : M) * (1 - ↑Q) 
goal: ↑(P \ Q) = ↑P * (1 - ↑Q)

full_name: IsLprojection.Subtype.partialOrder
code: instance Subtype.partialOrder [FaithfulSMul M X] :
    PartialOrder { P : M // IsLprojection X P } 
goal: PartialOrder { P // IsLprojection X P }

full_name: IsLprojection.le_def
code: theorem le_def [FaithfulSMul M X] (P Q : { P : M // IsLprojection X P }) :
    P ≤ Q ↔ (P : M) = ↑(P ⊓ Q) 
goal: P ≤ Q ↔ ↑P = ↑(P ⊓ Q)

full_name: IsLprojection.Subtype.zero
code: instance Subtype.zero : Zero { P : M // IsLprojection X P } 
goal: Zero { P // IsLprojection X P }

full_name: IsLprojection.coe_zero
code: @[simp]
theorem coe_zero : ↑(0 : { P : M // IsLprojection X P }) = (0 : M) 
goal: ↑0 = 0

full_name: IsLprojection.Subtype.one
code: instance Subtype.one : One { P : M // IsLprojection X P } 
goal: One { P // IsLprojection X P }

full_name: IsLprojection.coe_one
code: @[simp]
theorem coe_one : ↑(1 : { P : M // IsLprojection X P }) = (1 : M) 
goal: ↑1 = 1

full_name: IsLprojection.Subtype.boundedOrder
code: instance Subtype.boundedOrder [FaithfulSMul M X] :
    BoundedOrder { P : M // IsLprojection X P } 
goal: BoundedOrder { P // IsLprojection X P }

full_name: IsLprojection.coe_bot
code: @[simp]
theorem coe_bot [FaithfulSMul M X] :
    -- Porting note: Manual correction of name required here
    ↑(BoundedOrder.toOrderBot.toBot.bot : { P : M // IsLprojection X P }) = (0 : M) 
goal: ↑⊥ = 0

full_name: IsLprojection.coe_top
code: @[simp]
theorem coe_top [FaithfulSMul M X] :
    -- Porting note: Manual correction of name required here
    ↑(BoundedOrder.toOrderTop.toTop.top : { P : M // IsLprojection X P }) = (1 : M) 
goal: ↑⊤ = 1

full_name: IsLprojection.compl_mul
code: theorem compl_mul {P : { P : M // IsLprojection X P }} {Q : M} : ↑Pᶜ * Q = Q - ↑P * Q 
goal: ↑Pᶜ * Q = Q - ↑P * Q

full_name: IsLprojection.mul_compl_self
code: theorem mul_compl_self {P : { P : M // IsLprojection X P }} : (↑P : M) * ↑Pᶜ = 0 
goal: ↑P * ↑Pᶜ = 0

full_name: IsLprojection.distrib_lattice_lemma
code: theorem distrib_lattice_lemma [FaithfulSMul M X] {P Q R : { P : M // IsLprojection X P }} :
    ((↑P : M) + ↑Pᶜ * R) * (↑P + ↑Q * ↑R * ↑Pᶜ) = ↑P + ↑Q * ↑R * ↑Pᶜ 
goal: (↑P + ↑Pᶜ * ↑R) * (↑P + ↑Q * ↑R * ↑Pᶜ) = ↑P + ↑Q * ↑R * ↑Pᶜ

full_name: IsLprojection.instLatticeSubtypeOfFaithfulSMul
code: instance [FaithfulSMul M X] : Lattice { P : M // IsLprojection X P } 
goal: Lattice { P // IsLprojection X P }

full_name: IsLprojection.Subtype.distribLattice
code: instance Subtype.distribLattice [FaithfulSMul M X] :
    DistribLattice { P : M // IsLprojection X P } 
goal: DistribLattice { P // IsLprojection X P }

full_name: IsLprojection.Subtype.BooleanAlgebra
code: instance Subtype.BooleanAlgebra [FaithfulSMul M X] :
    BooleanAlgebra { P : M // IsLprojection X P } 
goal: BooleanAlgebra { P // IsLprojection X P }