Loogle!
Result
Found 19 declarations mentioning Exists, nhds, and Set.Ioo.
- nhds_order_unbounded 📋 Mathlib.Topology.Order.Basic
{α : Type u} [ts : TopologicalSpace α] [Preorder α] [OrderTopology α] {a : α} (hu : ∃ u, a < u) (hl : ∃ l, l < a) : nhds a = ⨅ l, ⨅ (_ : l < a), ⨅ u, ⨅ (_ : a < u), Filter.principal (Set.Ioo l u) - mem_nhds_iff_exists_Ioo_subset 📋 Mathlib.Topology.Order.Basic
{α : Type u} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [NoMaxOrder α] [NoMinOrder α] {a : α} {s : Set α} : s ∈ nhds a ↔ ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ s - Filter.Eventually.exists_Ioo_subset 📋 Mathlib.Topology.Order.Basic
{α : Type u} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [NoMaxOrder α] [NoMinOrder α] {a : α} {p : α → Prop} (hp : ∀ᶠ (x : α) in nhds a, p x) : ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ {x | p x} - mem_nhds_iff_exists_Ioo_subset' 📋 Mathlib.Topology.Order.Basic
{α : Type u} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α} {s : Set α} (hl : ∃ l, l < a) (hu : ∃ u, a < u) : s ∈ nhds a ↔ ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ s - nhds_basis_Ioo' 📋 Mathlib.Topology.Order.Basic
{α : Type u} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α} (hl : ∃ l, l < a) (hu : ∃ u, a < u) : (nhds a).HasBasis (fun b => b.1 < a ∧ a < b.2) fun b => Set.Ioo b.1 b.2 - exists_seq_strictAnti_tendsto' 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [FirstCountableTopology α] {x y : α} (hy : x < y) : ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo x y) ∧ Filter.Tendsto u Filter.atTop (nhds x) - exists_seq_strictMono_tendsto' 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_3} [LinearOrder α] [TopologicalSpace α] [DenselyOrdered α] [OrderTopology α] [FirstCountableTopology α] {x y : α} (hy : y < x) : ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo y x) ∧ Filter.Tendsto u Filter.atTop (nhds x) - Dense.exists_seq_strictAnti_tendsto_of_lt 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [FirstCountableTopology α] {s : Set α} (hs : Dense s) {x y : α} (hy : x < y) : ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo x y ∩ s) ∧ Filter.Tendsto u Filter.atTop (nhds x) - Dense.exists_seq_strictMono_tendsto_of_lt 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [FirstCountableTopology α] {s : Set α} (hs : Dense s) {x y : α} (hy : y < x) : ∃ u, StrictMono u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo y x ∩ s) ∧ Filter.Tendsto u Filter.atTop (nhds x) - DenseRange.exists_seq_strictAnti_tendsto_of_lt 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {β : Type u_3} [LinearOrder β] [DenselyOrdered α] [FirstCountableTopology α] {f : β → α} {x y : α} (hf : DenseRange f) (hmono : Monotone f) (hlt : x < y) : ∃ u, StrictAnti u ∧ (∀ (n : ℕ), f (u n) ∈ Set.Ioo x y) ∧ Filter.Tendsto (f ∘ u) Filter.atTop (nhds x) - DenseRange.exists_seq_strictMono_tendsto_of_lt 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {β : Type u_3} [LinearOrder β] [DenselyOrdered α] [FirstCountableTopology α] {f : β → α} {x y : α} (hf : DenseRange f) (hmono : Monotone f) (hlt : y < x) : ∃ u, StrictMono u ∧ (∀ (n : ℕ), f (u n) ∈ Set.Ioo y x) ∧ Filter.Tendsto (f ∘ u) Filter.atTop (nhds x) - exists_seq_strictAnti_strictMono_tendsto 📋 Mathlib.Topology.Order.IsLUB
{α : Type u_1} [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [DenselyOrdered α] [FirstCountableTopology α] {x y : α} (h : x < y) : ∃ u v, StrictAnti u ∧ StrictMono v ∧ (∀ (k : ℕ), u k ∈ Set.Ioo x y) ∧ (∀ (l : ℕ), v l ∈ Set.Ioo x y) ∧ (∀ (k l : ℕ), u k < v l) ∧ Filter.Tendsto u Filter.atTop (nhds x) ∧ Filter.Tendsto v Filter.atTop (nhds y) - continuousAt_of_monotoneOn_of_exists_between 📋 Mathlib.Topology.Order.MonotoneContinuity
{α : Type u_1} {β : Type u_2} [LinearOrder α] [TopologicalSpace α] [OrderTopology α] [LinearOrder β] [TopologicalSpace β] [OrderTopology β] {f : α → β} {s : Set α} {a : α} (h_mono : MonotoneOn f s) (hs : s ∈ nhds a) (hfs_l : ∀ b < f a, ∃ c ∈ s, f c ∈ Set.Ioo b (f a)) (hfs_r : ∀ b > f a, ∃ c ∈ s, f c ∈ Set.Ioo (f a) b) : ContinuousAt f a - exists_isLocalExtr_Ioo_of_tendsto 📋 Mathlib.Topology.Order.Rolle
{X : Type u_1} {Y : Type u_2} [ConditionallyCompleteLinearOrder X] [DenselyOrdered X] [TopologicalSpace X] [OrderTopology X] [LinearOrder Y] [TopologicalSpace Y] [OrderTopology Y] {f : X → Y} {a b : X} {l : Y} (hab : a < b) (hfc : ContinuousOn f (Set.Ioo a b)) (ha : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds l)) (hb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds l)) : ∃ c ∈ Set.Ioo a b, IsLocalExtr f c - exists_isExtrOn_Ioo_of_tendsto 📋 Mathlib.Topology.Order.Rolle
{X : Type u_1} {Y : Type u_2} [ConditionallyCompleteLinearOrder X] [DenselyOrdered X] [TopologicalSpace X] [OrderTopology X] [LinearOrder Y] [TopologicalSpace Y] [OrderTopology Y] {f : X → Y} {a b : X} {l : Y} (hab : a < b) (hfc : ContinuousOn f (Set.Ioo a b)) (ha : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds l)) (hb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds l)) : ∃ c ∈ Set.Ioo a b, IsExtrOn f (Set.Ioo a b) c - exists_deriv_eq_zero' 📋 Mathlib.Analysis.Calculus.LocalExtr.Rolle
{f : ℝ → ℝ} {a b l : ℝ} (hab : a < b) (hfa : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds l)) (hfb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds l)) : ∃ c ∈ Set.Ioo a b, deriv f c = 0 - exists_hasDerivAt_eq_zero' 📋 Mathlib.Analysis.Calculus.LocalExtr.Rolle
{f f' : ℝ → ℝ} {a b l : ℝ} (hab : a < b) (hfa : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds l)) (hfb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds l)) (hff' : ∀ x ∈ Set.Ioo a b, HasDerivAt f (f' x) x) : ∃ c ∈ Set.Ioo a b, f' c = 0 - exists_ratio_deriv_eq_ratio_slope' 📋 Mathlib.Analysis.Calculus.Deriv.MeanValue
(f : ℝ → ℝ) {a b : ℝ} (hab : a < b) (g : ℝ → ℝ) {lfa lga lfb lgb : ℝ} (hdf : DifferentiableOn ℝ f (Set.Ioo a b)) (hdg : DifferentiableOn ℝ g (Set.Ioo a b)) (hfa : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds lfa)) (hga : Filter.Tendsto g (nhdsWithin a (Set.Ioi a)) (nhds lga)) (hfb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds lfb)) (hgb : Filter.Tendsto g (nhdsWithin b (Set.Iio b)) (nhds lgb)) : ∃ c ∈ Set.Ioo a b, (lgb - lga) * deriv f c = (lfb - lfa) * deriv g c - exists_ratio_hasDerivAt_eq_ratio_slope' 📋 Mathlib.Analysis.Calculus.Deriv.MeanValue
(f f' : ℝ → ℝ) {a b : ℝ} (hab : a < b) (g g' : ℝ → ℝ) {lfa lga lfb lgb : ℝ} (hff' : ∀ x ∈ Set.Ioo a b, HasDerivAt f (f' x) x) (hgg' : ∀ x ∈ Set.Ioo a b, HasDerivAt g (g' x) x) (hfa : Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds lfa)) (hga : Filter.Tendsto g (nhdsWithin a (Set.Ioi a)) (nhds lga)) (hfb : Filter.Tendsto f (nhdsWithin b (Set.Iio b)) (nhds lfb)) (hgb : Filter.Tendsto g (nhdsWithin b (Set.Iio b)) (nhds lgb)) : ∃ c ∈ Set.Ioo a b, (lgb - lga) * f' c = (lfb - lfa) * g' c
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 a3d2529