Loogle!
Result
Found 16 declarations mentioning CStarMatrix.map.
- CStarMatrix.map 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} (M : CStarMatrix m n A) (f : A → B) : CStarMatrix m n B - CStarMatrix.map_id 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} (M : CStarMatrix m n A) : M.map id = M - CStarMatrix.map_id' 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} (M : CStarMatrix m n A) : (M.map fun x => x) = M - CStarMatrix.map_apply 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {M : CStarMatrix m n A} {f : A → B} {i : m} {j : n} : M.map f i j = f (M i j) - CStarMatrix.map_injective 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {f : A → B} (hf : Function.Injective f) : Function.Injective fun M => M.map f - CStarMatrix.map.eq_1 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} (M : CStarMatrix m n A) (f : A → B) : M.map f = CStarMatrix.ofMatrix fun i j => f (M i j) - CStarMatrix.mapₗ_apply 📋 Mathlib.Analysis.CStarAlgebra.CStarMatrix
{m : Type u_1} {n : Type u_2} {R : Type u_3} {S : Type u_4} {A : Type u_5} {B : Type u_6} [Semiring R] [Semiring S] {σ : R →+* S} [AddCommMonoid A] [AddCommMonoid B] [Module R A] [Module S B] (f : A →ₛₗ[σ] B) (M : CStarMatrix m n A) : (CStarMatrix.mapₗ f) M = M.map ⇑f - CompletelyPositiveMap.map_cstarMatrix_nonneg 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{A₁ : Type u_1} {A₂ : Type u_2} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] {n : Type u_3} [Fintype n] (φ : CompletelyPositiveMap A₁ A₂) (M : CStarMatrix n n A₁) (hM : 0 ≤ M) : 0 ≤ M.map ⇑φ - CompletelyPositiveMapClass.map_cstarMatrix_nonneg' 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{F : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} {inst✝ : NonUnitalCStarAlgebra A₁} {inst✝¹ : NonUnitalCStarAlgebra A₂} {inst✝² : PartialOrder A₁} {inst✝³ : PartialOrder A₂} {inst✝⁴ : StarOrderedRing A₁} {inst✝⁵ : StarOrderedRing A₂} {inst✝⁶ : FunLike F A₁ A₂} [self : CompletelyPositiveMapClass F A₁ A₂] (φ : F) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁) (hM : 0 ≤ M) : 0 ≤ M.map ⇑φ - CompletelyPositiveMapClass.mk 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{F : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] [FunLike F A₁ A₂] (map_cstarMatrix_nonneg' : ∀ (φ : F) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑φ) : CompletelyPositiveMapClass F A₁ A₂ - CStarMatrix.mapₗ.eq_1 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{m : Type u_1} {n : Type u_2} {R : Type u_3} {S : Type u_4} {A : Type u_5} {B : Type u_6} [Semiring R] [Semiring S] {σ : R →+* S} [AddCommMonoid A] [AddCommMonoid B] [Module R A] [Module S B] (f : A →ₛₗ[σ] B) : CStarMatrix.mapₗ f = { toFun := fun M => M.map ⇑f, map_add' := ⋯, map_smul' := ⋯ } - OrderHomClass.of_map_cstarMatrix_nonneg 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{F : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] [FunLike F A₁ A₂] [LinearMapClass F ℂ A₁ A₂] (h : ∀ (φ : F) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑φ) : OrderHomClass F A₁ A₂ - CompletelyPositiveMap.map_cstarMatrix_nonneg' 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{A₁ : Type u_1} {A₂ : Type u_2} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] (self : CompletelyPositiveMap A₁ A₂) (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁) (hM : 0 ≤ M) : 0 ≤ M.map ⇑self.toLinearMap - CompletelyPositiveMap.mk 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{A₁ : Type u_1} {A₂ : Type u_2} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] (toLinearMap : A₁ →ₗ[ℂ] A₂) (map_cstarMatrix_nonneg' : ∀ (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑toLinearMap) : CompletelyPositiveMap A₁ A₂ - CompletelyPositiveMap.mk.sizeOf_spec 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{A₁ : Type u_1} {A₂ : Type u_2} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] [SizeOf A₁] [SizeOf A₂] (toLinearMap : A₁ →ₗ[ℂ] A₂) (map_cstarMatrix_nonneg' : ∀ (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑toLinearMap) : sizeOf { toLinearMap := toLinearMap, map_cstarMatrix_nonneg' := map_cstarMatrix_nonneg' } = 1 + sizeOf toLinearMap - CompletelyPositiveMap.mk.injEq 📋 Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap
{A₁ : Type u_1} {A₂ : Type u_2} [NonUnitalCStarAlgebra A₁] [NonUnitalCStarAlgebra A₂] [PartialOrder A₁] [PartialOrder A₂] [StarOrderedRing A₁] [StarOrderedRing A₂] (toLinearMap : A₁ →ₗ[ℂ] A₂) (map_cstarMatrix_nonneg' : ∀ (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑toLinearMap) (toLinearMap✝ : A₁ →ₗ[ℂ] A₂) (map_cstarMatrix_nonneg'✝ : ∀ (k : ℕ) (M : CStarMatrix (Fin k) (Fin k) A₁), 0 ≤ M → 0 ≤ M.map ⇑toLinearMap✝) : ({ toLinearMap := toLinearMap, map_cstarMatrix_nonneg' := map_cstarMatrix_nonneg' } = { toLinearMap := toLinearMap✝, map_cstarMatrix_nonneg' := map_cstarMatrix_nonneg'✝ }) = (toLinearMap = toLinearMap✝)
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using (by default) Ctrl-K Ctrl-S. You can also try the
#loogle
command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
🔍Real.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
🔍"differ"
finds all lemmas that have"differ"
somewhere in their lemma name.By subexpression:
🔍_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
🔍Real.sqrt ?a * Real.sqrt ?a
If the pattern has parameters, they are matched in any order. Both of these will find
List.map
:
🔍(?a -> ?b) -> List ?a -> List ?b
🔍List ?a -> (?a -> ?b) -> List ?b
By main conclusion:
🔍|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all→
and∀
) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍|- _ < _ → tsum _ < tsum _
will findtsum_lt_tsum
even though the hypothesisf i < g i
is not the last.
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin
and tsum
, have "two"
as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _
(if
there were any such lemmas). Metavariables (?a
) are
assigned independently in each filter.
The #lucky
button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.
This is Loogle revision 19971e9
serving mathlib revision bce1d65