Loogle!
Result
Found 29 declarations mentioning Pi.map.
- Pi.map 📋 Mathlib.Logic.Function.Defs
{ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) : ((i : ι) → α i) → (i : ι) → β i - Pi.map_apply 📋 Mathlib.Logic.Function.Defs
{ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} (f : (i : ι) → α i → β i) (a : (i : ι) → α i) (i : ι) : Pi.map f a i = f i (a i) - Function.Bijective.piMap 📋 Mathlib.Logic.Function.Basic
{ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} {f : (i : ι) → α i → β i} (hf : ∀ (i : ι), Function.Bijective (f i)) : Function.Bijective (Pi.map f) - Function.Injective.piMap 📋 Mathlib.Logic.Function.Basic
{ι : Sort u_4} {α : ι → Sort u_5} {β : ι → Sort u_6} {f : (i : ι) → α i → β i} (hf : ∀ (i : ι), Function.Injective (f i)) : Function.Injective (Pi.map f) - Function.Surjective.piMap 📋 Mathlib.Logic.Function.Basic
{ι : Sort u_1} {α : ι → Sort u_2} {β : ι → Sort u_3} {f : (i : ι) → α i → β i} (hf : ∀ (i : ι), Function.Surjective (f i)) : Function.Surjective (Pi.map f) - Equiv.piCongrRight_apply 📋 Mathlib.Logic.Equiv.Basic
{α : Sort u_1} {β₁ : α → Sort u_9} {β₂ : α → Sort u_10} (F : (a : α) → β₁ a ≃ β₂ a) (a✝ : (i : α) → β₁ i) (i : α) : (Equiv.piCongrRight F) a✝ i = Pi.map (fun a => ⇑(F a)) a✝ i - Equiv.piCongrRight_symm_apply 📋 Mathlib.Logic.Equiv.Basic
{α : Sort u_1} {β₁ : α → Sort u_9} {β₂ : α → Sort u_10} (F : (a : α) → β₁ a ≃ β₂ a) (a✝ : (i : α) → β₂ i) (i : α) : (Equiv.piCongrRight F).symm a✝ i = Pi.map (fun a => ⇑(F a).symm) a✝ i - Equiv.piCongrRight.eq_1 📋 Mathlib.Logic.Equiv.Basic
{α : Sort u_1} {β₁ : α → Sort u_9} {β₂ : α → Sort u_10} (F : (a : α) → β₁ a ≃ β₂ a) : Equiv.piCongrRight F = { toFun := Pi.map fun a => ⇑(F a), invFun := Pi.map fun a => ⇑(F a).symm, left_inv := ⋯, right_inv := ⋯ } - Set.range_piMap 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} (f : (i : ι) → α i → β i) : Set.range (Pi.map f) = Set.univ.pi fun i => Set.range (f i) - Set.piMap_image_univ_pi 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} (f : (i : ι) → α i → β i) (t : (i : ι) → Set (α i)) : Pi.map f '' Set.univ.pi t = Set.univ.pi fun i => f i '' t i - Set.piMap_image_pi_subset 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {s : Set ι} {f : (i : ι) → α i → β i} (t : (i : ι) → Set (α i)) : Pi.map f '' s.pi t ⊆ s.pi fun i => f i '' t i - Set.piMap_mapsTo_pi 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {I : Set ι} {f : (i : ι) → α i → β i} {s : (i : ι) → Set (α i)} {t : (i : ι) → Set (β i)} (h : ∀ i ∈ I, Set.MapsTo (f i) (s i) (t i)) : Set.MapsTo (Pi.map f) (I.pi s) (I.pi t) - Set.piMap_image_pi 📋 Mathlib.Data.Set.Prod
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {s : Set ι} {f : (i : ι) → α i → β i} (hf : ∀ i ∉ s, Function.Surjective (f i)) (t : (i : ι) → Set (α i)) : Pi.map f '' s.pi t = s.pi fun i => f i '' t i - Filter.tendsto_piMap_pi 📋 Mathlib.Order.Filter.Pi
{ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {f : (i : ι) → α i → β i} {l : (i : ι) → Filter (α i)} {l' : (i : ι) → Filter (β i)} (h : ∀ (i : ι), Filter.Tendsto (f i) (l i) (l' i)) : Filter.Tendsto (Pi.map f) (Filter.pi l) (Filter.pi l') - Filter.map_piMap_pi_finite 📋 Mathlib.Order.Filter.Cofinite
{ι : Type u_1} {α : ι → Type u_4} {β : ι → Type u_5} [Finite ι] (f : (i : ι) → α i → β i) (l : (i : ι) → Filter (α i)) : Filter.map (Pi.map f) (Filter.pi l) = Filter.pi fun i => Filter.map (f i) (l i) - Filter.map_piMap_pi 📋 Mathlib.Order.Filter.Cofinite
{ι : Type u_1} {α : ι → Type u_4} {β : ι → Type u_5} {f : (i : ι) → α i → β i} (hf : ∀ᶠ (i : ι) in Filter.cofinite, Function.Surjective (f i)) (l : (i : ι) → Filter (α i)) : Filter.map (Pi.map f) (Filter.pi l) = Filter.pi fun i => Filter.map (f i) (l i) - Continuous.piMap 📋 Mathlib.Topology.Constructions
{ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {Y : ι → Type u_8} [(i : ι) → TopologicalSpace (Y i)] {f : (i : ι) → π i → Y i} (hf : ∀ (i : ι), Continuous (f i)) : Continuous (Pi.map f) - IsOpenQuotientMap.piMap 📋 Mathlib.Topology.Constructions
{ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {Y : ι → Type u_8} [(i : ι) → TopologicalSpace (Y i)] {f : (i : ι) → π i → Y i} (hf : ∀ (i : ι), IsOpenQuotientMap (f i)) : IsOpenQuotientMap (Pi.map f) - ContinuousAt.piMap 📋 Mathlib.Topology.Constructions
{ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {Y : ι → Type u_8} [(i : ι) → TopologicalSpace (Y i)] {f : (i : ι) → π i → Y i} {x : (i : ι) → π i} (hf : ∀ (i : ι), ContinuousAt (f i) (x i)) : ContinuousAt (Pi.map f) x - IsOpenMap.piMap 📋 Mathlib.Topology.Constructions
{ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] {Y : ι → Type u_8} [(i : ι) → TopologicalSpace (Y i)] {f : (i : ι) → π i → Y i} (hfo : ∀ (i : ι), IsOpenMap (f i)) (hsurj : ∀ᶠ (i : ι) in Filter.cofinite, Function.Surjective (f i)) : IsOpenMap (Pi.map f) - DenseRange.piMap 📋 Mathlib.Topology.ContinuousOn
{ι : Type u_5} {X : ι → Type u_6} {Y : ι → Type u_7} [(i : ι) → TopologicalSpace (Y i)] {f : (i : ι) → X i → Y i} (hf : ∀ (i : ι), DenseRange (f i)) : DenseRange (Pi.map f) - PartialEquiv.pi_apply 📋 Mathlib.Logic.Equiv.PartialEquiv
{ι : Type u_5} {αi : ι → Type u_6} {βi : ι → Type u_7} (ei : (i : ι) → PartialEquiv (αi i) (βi i)) : ↑(PartialEquiv.pi ei) = Pi.map fun i => ↑(ei i) - Isometry.piMap 📋 Mathlib.Topology.MetricSpace.Isometry
{ι : Type u_5} [Fintype ι] {α : ι → Type u_3} {β : ι → Type u_4} [(i : ι) → PseudoEMetricSpace (α i)] [(i : ι) → PseudoEMetricSpace (β i)] (f : (i : ι) → α i → β i) (hf : ∀ (i : ι), Isometry (f i)) : Isometry (Pi.map f) - pi_polarCoord_symm_target_ae_eq_univ 📋 Mathlib.Analysis.SpecialFunctions.PolarCoord
{ι : Type u_1} [Fintype ι] : ((Pi.map fun x => ↑polarCoord.symm) '' Set.univ.pi fun x => polarCoord.target) =ᵐ[MeasureTheory.volume] Set.univ - NumberField.mixedEmbedding.polarCoord_apply 📋 Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord
(K : Type u_1) [Field K] [NumberField K] (p : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) : ↑(NumberField.mixedEmbedding.polarCoord K) p = (p.1, Pi.map (fun i => ↑Complex.polarCoord) p.2) - NumberField.mixedEmbedding.polarCoordReal_apply 📋 Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord
(K : Type u_1) [Field K] [NumberField K] (p : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℝ × ℝ)) : ↑(NumberField.mixedEmbedding.polarCoordReal K) p = (p.1, Pi.map (fun i => ↑polarCoord) p.2) - NumberField.mixedEmbedding.polarSpaceCoord_symm_apply 📋 Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord
(K : Type u_1) [Field K] [NumberField K] (a✝ : NumberField.mixedEmbedding.polarSpace K) : ↑(NumberField.mixedEmbedding.polarSpaceCoord K).symm a✝ = (fun w => a✝.1 ↑w, Pi.map (fun i => ↑Complex.polarCoord.symm) fun w => (a✝.1 ↑w, a✝.2 w)) - NumberField.mixedEmbedding.polarCoord_symm_apply 📋 Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord
(K : Type u_1) [Field K] [NumberField K] (p : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℝ × ℝ)) : ↑(NumberField.mixedEmbedding.polarCoord K).symm p = (p.1, Pi.map (fun i => ↑Complex.polarCoord.symm) p.2) - NumberField.mixedEmbedding.polarSpaceCoord_apply 📋 Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord
(K : Type u_1) [Field K] [NumberField K] (a✝ : NumberField.mixedEmbedding.mixedSpace K) : ↑(NumberField.mixedEmbedding.polarSpaceCoord K) a✝ = (NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace K) (a✝.1, Pi.map (fun i => ↑Complex.polarCoord) a✝.2)
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