Loogle!
Result
Found 22 declarations mentioning Matrix.mulVecLin.
- Matrix.mulVecLin š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M : Matrix m n R) : (n ā R) āā[R] m ā R - Matrix.mulVecLin_transpose š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype m] (M : Matrix m n R) : M.transpose.mulVecLin = M.vecMulLinear - Matrix.vecMulLinear_transpose š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M : Matrix m n R) : M.transpose.vecMulLinear = M.mulVecLin - Matrix.mulVecLin_one š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {n : Type u_5} [Fintype n] [DecidableEq n] : Matrix.mulVecLin 1 = LinearMap.id - Matrix.coe_mulVecLin š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M : Matrix m n R) : āM.mulVecLin = M.mulVec - Matrix.mulVecLin_apply š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M : Matrix m n R) (v : n ā R) : M.mulVecLin v = M.mulVec v - Matrix.mulVecLin_mul š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {l : Type u_3} {m : Type u_4} {n : Type u_5} [Fintype n] [Fintype m] (M : Matrix l m R) (N : Matrix m n R) : (M * N).mulVecLin = M.mulVecLin āā N.mulVecLin - Matrix.mulVecLin_zero š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] : Matrix.mulVecLin 0 = 0 - Matrix.range_mulVecLin š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M : Matrix m n R) : LinearMap.range M.mulVecLin = Submodule.span R (Set.range M.col) - Matrix.mulVecLin_submatrix š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5} [Fintype n] [Fintype l] (fā : m ā k) (eā : n ā l) (M : Matrix k l R) : (M.submatrix fā āeā).mulVecLin = LinearMap.funLeft R R fā āā M.mulVecLin āā LinearMap.funLeft R R āeā.symm - Matrix.ker_mulVecLin_eq_bot_iff š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] {M : Matrix m n R} : LinearMap.ker M.mulVecLin = ā„ ā ā (v : n ā R), M.mulVec v = 0 ā v = 0 - Matrix.mulVecLin_add š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [Fintype n] (M N : Matrix m n R) : (M + N).mulVecLin = M.mulVecLin + N.mulVecLin - Matrix.mulVecLin_reindex š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {k : Type u_2} {l : Type u_3} {m : Type u_4} {n : Type u_5} [Fintype n] [Fintype l] (eā : k ā m) (eā : l ā n) (M : Matrix k l R) : ((Matrix.reindex eā eā) M).mulVecLin = ā(LinearEquiv.funCongrLeft R R eā.symm) āā M.mulVecLin āā ā(LinearEquiv.funCongrLeft R R eā) - Matrix.toLin'_apply' š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [DecidableEq n] [Fintype n] (M : Matrix m n R) : Matrix.toLin' M = M.mulVecLin - LinearMap.toMatrix'.eq_1 š Mathlib.LinearAlgebra.Matrix.ToLin
{R : Type u_1} [CommSemiring R] {m : Type u_4} {n : Type u_5} [DecidableEq n] [Fintype n] : LinearMap.toMatrix' = { toFun := fun f => Matrix.of fun i j => f (Pi.single j 1) i, map_add' := āÆ, map_smul' := āÆ, invFun := Matrix.mulVecLin, left_inv := āÆ, right_inv := ⯠} - Matrix.GeneralLinearGroup.coe_toLin š Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs
{n : Type u} [DecidableEq n] [Fintype n] {R : Type v} [CommRing R] (A : GL n R) : ā(Matrix.GeneralLinearGroup.toLin A) = (āA).mulVecLin - Matrix.GeneralLinearGroup.toLin_apply š Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs
{n : Type u} [DecidableEq n] [Fintype n] {R : Type v} [CommRing R] (A : GL n R) (v : n ā R) : ā(Matrix.GeneralLinearGroup.toLin A) v = (āA).mulVecLin v - Matrix.linfty_opNorm_eq_opNorm š Mathlib.Analysis.Matrix
{m : Type u_3} {n : Type u_4} {α : Type u_5} [Fintype m] [Fintype n] [NontriviallyNormedField α] [NormedAlgebra ā α] (A : Matrix m n α) : āAā = ā{ toLinearMap := A.mulVecLin, cont := ⯠}ā - Matrix.linfty_opNNNorm_eq_opNNNorm š Mathlib.Analysis.Matrix
{m : Type u_3} {n : Type u_4} {α : Type u_5} [Fintype m] [Fintype n] [NontriviallyNormedField α] [NormedAlgebra ā α] (A : Matrix m n α) : āAāā = ā{ toLinearMap := A.mulVecLin, cont := ⯠}āā - Matrix.ker_mulVecLin_transpose_mul_self š Mathlib.Data.Matrix.Rank
{m : Type um} {n : Type un} {R : Type uR} [Fintype n] [Fintype m] [Field R] [LinearOrder R] [IsStrictOrderedRing R] (A : Matrix m n R) : LinearMap.ker (A.transpose * A).mulVecLin = LinearMap.ker A.mulVecLin - Matrix.ker_mulVecLin_conjTranspose_mul_self š Mathlib.Data.Matrix.Rank
{m : Type um} {n : Type un} {R : Type uR} [Fintype n] [Fintype m] [Field R] [PartialOrder R] [StarRing R] [StarOrderedRing R] (A : Matrix m n R) : LinearMap.ker (A.conjTranspose * A).mulVecLin = LinearMap.ker A.mulVecLin - Matrix.rank.eq_1 š Mathlib.Data.Matrix.Rank
{m : Type um} {n : Type un} {R : Type uR} [Fintype n] [CommRing R] (A : Matrix m n R) : A.rank = Module.finrank R ā„(LinearMap.range A.mulVecLin)
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