Loogle!
Result
Found 20 declarations mentioning AdicCompletion.map.
- AdicCompletion.map 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) : AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N - AdicCompletion.map_id 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) (M : Type u_2) [AddCommGroup M] [Module R M] : AdicCompletion.map I LinearMap.id = LinearMap.id - AdicCompletion.sum.eq_1 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [DecidableEq ι] : AdicCompletion.sum I M = DirectSum.toModule (AdicCompletion I R) ι (AdicCompletion I (DirectSum ι fun j => M j)) fun j => AdicCompletion.map I (DirectSum.lof R ι M j) - AdicCompletion.map_zero 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] : AdicCompletion.map I 0 = 0 - AdicCompletion.map_comp 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) : AdicCompletion.map I g ∘ₗ AdicCompletion.map I f = AdicCompletion.map I (g ∘ₗ f) - AdicCompletion.map_mk 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) (a : AdicCompletion.AdicCauchySequence I M) : (AdicCompletion.map I f) ((AdicCompletion.mk I M) a) = (AdicCompletion.mk I N) ((AdicCompletion.AdicCauchySequence.map I f) a) - AdicCompletion.map_comp_apply 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] {P : Type u_4} [AddCommGroup P] [Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M) : (AdicCompletion.map I g) ((AdicCompletion.map I f) x) = (AdicCompletion.map I (g ∘ₗ f)) x - AdicCompletion.congr_apply 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M ≃ₗ[R] N) (x : AdicCompletion I M) : (AdicCompletion.congr I f) x = (AdicCompletion.map I ↑f) x - AdicCompletion.sumInv_apply 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I (DirectSum ι fun j => M j)) (j : ι) : ((AdicCompletion.sumInv I M) x) j = (AdicCompletion.map I (DirectSum.component R ι M j)) x - AdicCompletion.congr_symm_apply 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M ≃ₗ[R] N) (x : AdicCompletion I N) : (AdicCompletion.congr I f).symm x = (AdicCompletion.map I ↑f.symm) x - AdicCompletion.sum_of 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [DecidableEq ι] (j : ι) (x : AdicCompletion I (M j)) : (AdicCompletion.sum I M) ((DirectSum.of (fun i => AdicCompletion I (M i)) j) x) = (AdicCompletion.map I (DirectSum.lof R ι M j)) x - AdicCompletion.sum_lof 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [DecidableEq ι] (j : ι) (x : AdicCompletion I (M j)) : (AdicCompletion.sum I M) ((DirectSum.lof (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) x) = (AdicCompletion.map I (DirectSum.lof R ι M j)) x - AdicCompletion.component_sumInv 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] (x : AdicCompletion I (DirectSum ι fun j => M j)) (j : ι) : (DirectSum.component (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) ((AdicCompletion.sumInv I M) x) = (AdicCompletion.map I (DirectSum.component R ι M j)) x - AdicCompletion.sumInv.eq_1 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {ι : Type u_6} (M : ι → Type u_7) [(i : ι) → AddCommGroup (M i)] [(i : ι) → Module R (M i)] [Fintype ι] : AdicCompletion.sumInv I M = ↑(DirectSum.linearEquivFunOnFintype (AdicCompletion I R) ι fun j => AdicCompletion I (M j)).symm ∘ₗ AdicCompletion.pi I M ∘ₗ AdicCompletion.map I ↑(DirectSum.linearEquivFunOnFintype R ι M) - AdicCompletion.map_val_apply 📋 Mathlib.RingTheory.AdicCompletion.Functoriality
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) : ↑((AdicCompletion.map I f) x) n = (LinearMap.reduceModIdeal (I ^ n) f) (↑x n) - AdicCompletion.map_surjective 📋 Mathlib.RingTheory.AdicCompletion.Exactness
{R : Type u} [CommRing R] (I : Ideal R) {M : Type v} [AddCommGroup M] [Module R M] {N : Type w} [AddCommGroup N] [Module R N] {f : M →ₗ[R] N} (hf : Function.Surjective ⇑f) : Function.Surjective ⇑(AdicCompletion.map I f) - AdicCompletion.map_injective 📋 Mathlib.RingTheory.AdicCompletion.Exactness
{R : Type u} [CommRing R] (I : Ideal R) {M : Type u} [AddCommGroup M] [Module R M] {N : Type u} [AddCommGroup N] [Module R N] [IsNoetherianRing R] [Module.Finite R N] {f : M →ₗ[R] N} (hf : Function.Injective ⇑f) : Function.Injective ⇑(AdicCompletion.map I f) - AdicCompletion.map_exact 📋 Mathlib.RingTheory.AdicCompletion.Exactness
{R : Type u} [CommRing R] {I : Ideal R} {M : Type u} [AddCommGroup M] [Module R M] {N : Type u} [AddCommGroup N] [Module R N] {P : Type u} [AddCommGroup P] [Module R P] [IsNoetherianRing R] [Module.Finite R N] {f : M →ₗ[R] N} {g : N →ₗ[R] P} (hf : Function.Injective ⇑f) (hfg : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g) : Function.Exact ⇑(AdicCompletion.map I f) ⇑(AdicCompletion.map I g) - AdicCompletion.ofTensorProduct_naturality 📋 Mathlib.RingTheory.AdicCompletion.AsTensorProduct
{R : Type u_1} [CommRing R] (I : Ideal R) {M : Type u_2} [AddCommGroup M] [Module R M] {N : Type u_3} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) : AdicCompletion.map I f ∘ₗ AdicCompletion.ofTensorProduct I M = AdicCompletion.ofTensorProduct I N ∘ₗ TensorProduct.AlgebraTensorModule.map LinearMap.id f - AdicCompletion.tensor_map_id_left_eq_map 📋 Mathlib.RingTheory.AdicCompletion.AsTensorProduct
{R : Type u} [CommRing R] (I : Ideal R) [IsNoetherianRing R] {M : Type u} [AddCommGroup M] [Module R M] {N : Type u} [AddCommGroup N] [Module R N] (f : M →ₗ[R] N) [Module.Finite R M] [Module.Finite R N] : TensorProduct.AlgebraTensorModule.map LinearMap.id f = ↑(AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I N).symm ∘ₗ AdicCompletion.map I f ∘ₗ ↑(AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I M)
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