Loogle!
Result
Found 14 declarations mentioning DirectSum.map.
- DirectSum.map 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) : (DirectSum ι fun i => α i) →+ DirectSum ι fun i => β i - DirectSum.map_id 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} [(i : ι) → AddCommMonoid (α i)] : (DirectSum.map fun i => AddMonoidHom.id (α i)) = AddMonoidHom.id (DirectSum ι fun i => α i) - DirectSum.map_injective 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) : Function.Injective ⇑(DirectSum.map f) ↔ ∀ (i : ι), Function.Injective ⇑(f i) - DirectSum.map_surjective 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) : Function.Surjective ⇑(DirectSum.map f) ↔ ∀ (i : ι), Function.Surjective ⇑(f i) - DirectSum.map_comp 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) {γ : ι → Type u_6} [(i : ι) → AddCommMonoid (γ i)] (g : (i : ι) → β i →+ γ i) : (DirectSum.map fun i => (g i).comp (f i)) = (DirectSum.map g).comp (DirectSum.map f) - DirectSum.map_apply 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) (i : ι) (x : DirectSum ι fun i => α i) : ((DirectSum.map f) x) i = (f i) (x i) - DirectSum.map_of 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) [DecidableEq ι] (i : ι) (x : α i) : (DirectSum.map f) ((DirectSum.of α i) x) = (DirectSum.of β i) ((f i) x) - DirectSum.map_eq_iff 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u_3} {α : ι → Type u_4} {β : ι → Type u_5} [(i : ι) → AddCommMonoid (α i)] [(i : ι) → AddCommMonoid (β i)] (f : (i : ι) → α i →+ β i) (x y : DirectSum ι fun i => α i) : (DirectSum.map f) x = (DirectSum.map f) y ↔ ∀ (i : ι), (f i) (x i) = (f i) (y i) - DirectSum.toAddMonoidHom_lmap 📋 Mathlib.Algebra.DirectSum.Module
{R : Type u} [Semiring R] {ι : Type v} {M : ι → Type w} [(i : ι) → AddCommMonoid (M i)] [(i : ι) → Module R (M i)] {N : ι → Type u_1} [(i : ι) → AddCommMonoid (N i)] [(i : ι) → Module R (N i)] (f : (i : ι) → M i →ₗ[R] N i) : (DirectSum.lmap f).toAddMonoidHom = DirectSum.map fun i => (f i).toAddMonoidHom - DirectSum.ker_map 📋 Mathlib.Algebra.DirectSum.Module
{ι : Type v} {M : ι → Type w} {N : ι → Type u_2} [(i : ι) → AddCommGroup (M i)] [(i : ι) → AddCommMonoid (N i)] (f : (i : ι) → M i →+ N i) : (DirectSum.map f).ker = AddSubgroup.comap (DirectSum.coeFnAddMonoidHom M) (AddSubgroup.pi Set.univ fun x => (f x).ker) - DirectSum.range_map 📋 Mathlib.Algebra.DirectSum.Module
{ι : Type v} {M : ι → Type w} {N : ι → Type u_2} [(i : ι) → AddCommGroup (M i)] [(i : ι) → AddCommGroup (N i)] (f : (i : ι) → M i →+ N i) : (DirectSum.map f).range = AddSubgroup.comap (DirectSum.coeFnAddMonoidHom N) (AddSubgroup.pi Set.univ fun x => (f x).range) - DirectSum.lmap_eq_map 📋 Mathlib.Algebra.DirectSum.Module
{R : Type u} [Semiring R] {ι : Type v} {M : ι → Type w} [(i : ι) → AddCommMonoid (M i)] [(i : ι) → Module R (M i)] {N : ι → Type u_1} [(i : ι) → AddCommMonoid (N i)] [(i : ι) → Module R (N i)] (f : (i : ι) → M i →ₗ[R] N i) (x : DirectSum ι fun i => M i) : (DirectSum.lmap f) x = (DirectSum.map fun i => (f i).toAddMonoidHom) x - DirectSum.mker_map 📋 Mathlib.Algebra.DirectSum.Module
{ι : Type v} {M : ι → Type w} [(i : ι) → AddCommMonoid (M i)] {N : ι → Type u_1} [(i : ι) → AddCommMonoid (N i)] (f : (i : ι) → M i →+ N i) : AddMonoidHom.mker (DirectSum.map f) = AddSubmonoid.comap (DirectSum.coeFnAddMonoidHom M) (AddSubmonoid.pi Set.univ fun i => AddMonoidHom.mker (f i)) - DirectSum.mrange_map 📋 Mathlib.Algebra.DirectSum.Module
{ι : Type v} {M : ι → Type w} [(i : ι) → AddCommMonoid (M i)] {N : ι → Type u_1} [(i : ι) → AddCommMonoid (N i)] (f : (i : ι) → M i →+ N i) : AddMonoidHom.mrange (DirectSum.map f) = AddSubmonoid.comap (DirectSum.coeFnAddMonoidHom N) (AddSubmonoid.pi Set.univ fun i => AddMonoidHom.mrange (f i))
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