Loogle!
Result
Found 25 declarations mentioning limUnder.
- limUnder 📋 Mathlib.Topology.Defs.Filter
{X : Type u_1} [TopologicalSpace X] {α : Type u_3} [Nonempty X] (f : Filter α) (g : α → X) : X - limUnder_of_not_tendsto 📋 Mathlib.Topology.Basic
{X : Type u} {α : Type u_1} [TopologicalSpace X] [hX : Nonempty X] {f : Filter α} {g : α → X} (h : ¬∃ x, Filter.Tendsto g f (nhds x)) : limUnder f g = Classical.choice hX - tendsto_nhds_limUnder 📋 Mathlib.Topology.Basic
{X : Type u} {α : Type u_1} [TopologicalSpace X] {f : Filter α} {g : α → X} (h : ∃ x, Filter.Tendsto g f (nhds x)) : Filter.Tendsto g f (nhds (limUnder f g)) - limUnder_nhds_id 📋 Mathlib.Topology.Separation.Hausdorff
{X : Type u_1} [TopologicalSpace X] [T2Space X] (x : X) : limUnder (nhds x) id = x - Continuous.limUnder_eq 📋 Mathlib.Topology.Separation.Hausdorff
{X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [T2Space X] [TopologicalSpace Y] {f : Y → X} (h : Continuous f) (y : Y) : limUnder (nhds y) f = f y - Filter.Tendsto.limUnder_eq 📋 Mathlib.Topology.Separation.Hausdorff
{X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [T2Space X] {x : X} {f : Filter Y} [f.NeBot] {g : Y → X} (h : Filter.Tendsto g f (nhds x)) : limUnder f g = x - limUnder_nhdsWithin_id 📋 Mathlib.Topology.Separation.Hausdorff
{X : Type u_1} [TopologicalSpace X] [T2Space X] {x : X} {s : Set X} (h : x ∈ closure s) : limUnder (nhdsWithin x s) id = x - Filter.limUnder_eq_iff 📋 Mathlib.Topology.Separation.Hausdorff
{X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [T2Space X] {f : Filter Y} [f.NeBot] {g : Y → X} (h : ∃ x, Filter.Tendsto g f (nhds x)) {x : X} : limUnder f g = x ↔ Filter.Tendsto g f (nhds x) - CauchySeq.tendsto_limUnder 📋 Mathlib.Topology.UniformSpace.Cauchy
{α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [Preorder β] [CompleteSpace α] {u : β → α} (h : CauchySeq u) : Filter.Tendsto u Filter.atTop (nhds (limUnder Filter.atTop u)) - BoundedVariationOn.tendsto_atBot_limUnder 📋 Mathlib.Topology.EMetricSpace.BoundedVariation
{α : Type u_1} [LinearOrder α] {E : Type u_2} [PseudoEMetricSpace E] [CompleteSpace E] [hE : Nonempty E] {f : α → E} (hf : BoundedVariationOn f Set.univ) : Filter.Tendsto f Filter.atBot (nhds (limUnder Filter.atBot f)) - BoundedVariationOn.tendsto_atTop_limUnder 📋 Mathlib.Topology.EMetricSpace.BoundedVariation
{α : Type u_1} [LinearOrder α] {E : Type u_2} [PseudoEMetricSpace E] [CompleteSpace E] [hE : Nonempty E] {f : α → E} (hf : BoundedVariationOn f Set.univ) : Filter.Tendsto f Filter.atTop (nhds (limUnder Filter.atTop f)) - MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Iic 📋 Mathlib.MeasureTheory.Integral.IntegralEqImproper
{E : Type u_1} {f f' : ℝ → E} {a : ℝ} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (hderiv : ∀ x ∈ Set.Iic a, HasDerivAt f (f' x) x) (f'int : MeasureTheory.IntegrableOn f' (Set.Iic a) MeasureTheory.volume) : Filter.Tendsto f Filter.atBot (nhds (limUnder Filter.atBot f)) - MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi 📋 Mathlib.MeasureTheory.Integral.IntegralEqImproper
{E : Type u_1} {f f' : ℝ → E} {a : ℝ} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] (hderiv : ∀ x ∈ Set.Ioi a, HasDerivAt f (f' x) x) (f'int : MeasureTheory.IntegrableOn f' (Set.Ioi a) MeasureTheory.volume) : Filter.Tendsto f Filter.atTop (nhds (limUnder Filter.atTop f)) - Complex.differentiableOn_update_limUnder_of_bddAbove 📋 Mathlib.Analysis.Complex.RemovableSingularity
{E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ nhds c) (hd : DifferentiableOn ℂ f (s \ {c})) (hb : BddAbove (norm ∘ f '' (s \ {c}))) : DifferentiableOn ℂ (Function.update f c (limUnder (nhdsWithin c {c}ᶜ) f)) s - Complex.tendsto_limUnder_of_differentiable_on_punctured_nhds_of_bounded_under 📋 Mathlib.Analysis.Complex.RemovableSingularity
{E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {c : ℂ} (hd : ∀ᶠ (z : ℂ) in nhdsWithin c {c}ᶜ, DifferentiableAt ℂ f z) (hb : Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) (nhdsWithin c {c}ᶜ) fun z => ‖f z - f c‖) : Filter.Tendsto f (nhdsWithin c {c}ᶜ) (nhds (limUnder (nhdsWithin c {c}ᶜ) f)) - Complex.tendsto_limUnder_of_differentiable_on_punctured_nhds_of_isLittleO 📋 Mathlib.Analysis.Complex.RemovableSingularity
{E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {c : ℂ} (hd : ∀ᶠ (z : ℂ) in nhdsWithin c {c}ᶜ, DifferentiableAt ℂ f z) (ho : (fun z => f z - f c) =o[nhdsWithin c {c}ᶜ] fun z => (z - c)⁻¹) : Filter.Tendsto f (nhdsWithin c {c}ᶜ) (nhds (limUnder (nhdsWithin c {c}ᶜ) f)) - Complex.differentiableOn_update_limUnder_of_isLittleO 📋 Mathlib.Analysis.Complex.RemovableSingularity
{E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ nhds c) (hd : DifferentiableOn ℂ f (s \ {c})) (ho : (fun z => f z - f c) =o[nhdsWithin c {c}ᶜ] fun z => (z - c)⁻¹) : DifferentiableOn ℂ (Function.update f c (limUnder (nhdsWithin c {c}ᶜ) f)) s - Complex.differentiableOn_update_limUnder_insert_of_isLittleO 📋 Mathlib.Analysis.Complex.RemovableSingularity
{E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ nhdsWithin c {c}ᶜ) (hd : DifferentiableOn ℂ f s) (ho : (fun z => f z - f c) =o[nhdsWithin c {c}ᶜ] fun z => (z - c)⁻¹) : DifferentiableOn ℂ (Function.update f c (limUnder (nhdsWithin c {c}ᶜ) f)) (insert c s) - Function.Periodic.cuspFunction_zero_eq_limUnder_nhds_ne 📋 Mathlib.Analysis.Complex.Periodic
(h : ℝ) (f : ℂ → ℂ) : Function.Periodic.cuspFunction h f 0 = limUnder (nhdsWithin 0 {0}ᶜ) (Function.Periodic.cuspFunction h f) - MeasureTheory.StronglyMeasurable.limUnder 📋 Mathlib.MeasureTheory.Constructions.Polish.StronglyMeasurable
{ι : Type u_1} {X : Type u_2} {E : Type u_3} [MeasurableSpace X] [TopologicalSpace E] [TopologicalSpace.IsCompletelyMetrizableSpace E] [Countable ι] {l : Filter ι} [l.IsCountablyGenerated] {f : ι → X → E} [hE : Nonempty E] (hf : ∀ (i : ι), MeasureTheory.StronglyMeasurable (f i)) : MeasureTheory.StronglyMeasurable fun x => limUnder l fun x_1 => f x_1 x - BoundedVariationOn.vectorMeasure_Ici 📋 Mathlib.MeasureTheory.VectorMeasure.BoundedVariation
{α : Type u_1} [LinearOrder α] [DenselyOrdered α] [TopologicalSpace α] [OrderTopology α] [SecondCountableTopology α] [CompactIccSpace α] [hα : MeasurableSpace α] [BorelSpace α] {E : Type u_2} [NormedAddCommGroup E] [CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) (a : α) : ↑hf.vectorMeasure (Set.Ici a) = limUnder Filter.atTop f - Function.leftLim f a - BoundedVariationOn.vectorMeasure_Iic 📋 Mathlib.MeasureTheory.VectorMeasure.BoundedVariation
{α : Type u_1} [LinearOrder α] [DenselyOrdered α] [TopologicalSpace α] [OrderTopology α] [SecondCountableTopology α] [CompactIccSpace α] [hα : MeasurableSpace α] [BorelSpace α] {E : Type u_2} [NormedAddCommGroup E] [CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) (a : α) : ↑hf.vectorMeasure (Set.Iic a) = Function.rightLim f a - limUnder Filter.atBot f - BoundedVariationOn.vectorMeasure_Iio 📋 Mathlib.MeasureTheory.VectorMeasure.BoundedVariation
{α : Type u_1} [LinearOrder α] [DenselyOrdered α] [TopologicalSpace α] [OrderTopology α] [SecondCountableTopology α] [CompactIccSpace α] [hα : MeasurableSpace α] [BorelSpace α] {E : Type u_2} [NormedAddCommGroup E] [CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) (a : α) : ↑hf.vectorMeasure (Set.Iio a) = Function.leftLim f a - limUnder Filter.atBot f - BoundedVariationOn.vectorMeasure_Ioi 📋 Mathlib.MeasureTheory.VectorMeasure.BoundedVariation
{α : Type u_1} [LinearOrder α] [DenselyOrdered α] [TopologicalSpace α] [OrderTopology α] [SecondCountableTopology α] [CompactIccSpace α] [hα : MeasurableSpace α] [BorelSpace α] {E : Type u_2} [NormedAddCommGroup E] [CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) (a : α) : ↑hf.vectorMeasure (Set.Ioi a) = limUnder Filter.atTop f - Function.rightLim f a - BoundedVariationOn.vectorMeasure_univ 📋 Mathlib.MeasureTheory.VectorMeasure.BoundedVariation
{α : Type u_1} [LinearOrder α] [DenselyOrdered α] [TopologicalSpace α] [OrderTopology α] [SecondCountableTopology α] [CompactIccSpace α] [hα : MeasurableSpace α] [BorelSpace α] {E : Type u_2} [NormedAddCommGroup E] [CompleteSpace E] {f : α → E} (hf : BoundedVariationOn f Set.univ) : ↑hf.vectorMeasure Set.univ = limUnder Filter.atTop f - limUnder Filter.atBot f
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 ?aIf 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 ?bBy 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_tsumeven though the hypothesisf i < g iis 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 401c76f serving mathlib revision b87935d