Loogle!
Result
Found 169 declarations mentioning Antitone and Set. Of these, 61 match your pattern(s).
- Antitone.set_prod 📋 Mathlib.Data.Set.Prod
{α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : α → Set β} {g : α → Set γ} (hf : Antitone f) (hg : Antitone g) : Antitone fun x => f x ×ˢ g x - Antitone.iInter_nat_add 📋 Mathlib.Data.Set.Lattice
{α : Type u_1} {f : ℕ → Set α} (hf : Antitone f) (k : ℕ) : ⋂ n, f (n + k) = ⋂ n, f n - Set.iInter_union_of_antitone 📋 Mathlib.Data.Set.Lattice
{ι : Type u_12} {α : Type u_13} [Preorder ι] [IsDirected ι fun x1 x2 => x1 ≤ x2] {s t : ι → Set α} (hs : Antitone s) (ht : Antitone t) : ⋂ i, s i ∪ t i = (⋂ i, s i) ∪ ⋂ i, t i - Set.iUnion_inter_of_antitone 📋 Mathlib.Data.Set.Lattice
{ι : Type u_12} {α : Type u_13} [Preorder ι] [IsDirected ι (Function.swap fun x1 x2 => x1 ≤ x2)] {s t : ι → Set α} (hs : Antitone s) (ht : Antitone t) : ⋃ i, s i ∩ t i = (⋃ i, s i) ∩ ⋃ i, t i - Set.antitone_setOf 📋 Mathlib.Data.Set.Order
{α : Type u_1} {β : Type u_2} [Preorder α] {p : α → β → Prop} (hp : ∀ (b : β), Antitone fun a => p a b) : Antitone fun a => {b | p a b} - Antitone.inter 📋 Mathlib.Data.Set.Order
{α : Type u_1} {β : Type u_2} [Preorder β] {f g : β → Set α} (hf : Antitone f) (hg : Antitone g) : Antitone fun x => f x ∩ g x - Antitone.union 📋 Mathlib.Data.Set.Order
{α : Type u_1} {β : Type u_2} [Preorder β] {f g : β → Set α} (hf : Antitone f) (hg : Antitone g) : Antitone fun x => f x ∪ g x - ciSup_mem_iInter_Icc_of_antitone_Icc 📋 Mathlib.Order.ConditionallyCompleteLattice.Indexed
{α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] [SemilatticeSup β] {f g : β → α} (h : Antitone fun n => Set.Icc (f n) (g n)) (h' : ∀ (n : β), f n ≤ g n) : ⨆ n, f n ∈ ⋂ n, Set.Icc (f n) (g n) - Set.iInter_iUnion_of_antitone 📋 Mathlib.Data.Set.Finite.Lattice
{ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Finite ι] [Preorder ι'] [IsDirected ι' fun x1 x2 => x1 ≤ x2] [Nonempty ι'] {s : ι → ι' → Set α} (hs : ∀ (i : ι), Antitone (s i)) : ⋂ j, ⋃ i, s i j = ⋃ i, ⋂ j, s i j - Set.iUnion_iInter_of_antitone 📋 Mathlib.Data.Set.Finite.Lattice
{ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Finite ι] [Preorder ι'] [IsDirected ι' (Function.swap fun x1 x2 => x1 ≤ x2)] [Nonempty ι'] {s : ι → ι' → Set α} (hs : ∀ (i : ι), Antitone (s i)) : ⋃ j, ⋂ i, s i j = ⋂ i, ⋃ j, s i j - Filter.IsAntitoneBasis.antitone 📋 Mathlib.Order.Filter.Bases.Basic
{α : Type u_1} {ι'' : Type u_6} [Preorder ι''] {s'' : ι'' → Set α} (self : Filter.IsAntitoneBasis s'') : Antitone s'' - Filter.HasAntitoneBasis.antitone 📋 Mathlib.Order.Filter.Bases.Basic
{α : Type u_1} {ι'' : Type u_6} [Preorder ι''] {l : Filter α} {s : ι'' → Set α} (self : l.HasAntitoneBasis s) : Antitone s - Filter.IsAntitoneBasis.mk 📋 Mathlib.Order.Filter.Bases.Basic
{α : Type u_1} {ι'' : Type u_6} [Preorder ι''] {s'' : ι'' → Set α} (toIsBasis : Filter.IsBasis (fun x => True) s'') (antitone : Antitone s'') : Filter.IsAntitoneBasis s'' - Filter.HasAntitoneBasis.mk 📋 Mathlib.Order.Filter.Bases.Basic
{α : Type u_1} {ι'' : Type u_6} [Preorder ι''] {l : Filter α} {s : ι'' → Set α} (toHasBasis : l.HasBasis (fun x => True) s) (antitone : Antitone s) : l.HasAntitoneBasis s - Filter.HasAntitoneBasis.iInf_principal 📋 Mathlib.Order.Filter.Bases.Basic
{α : Type u_1} {ι : Type u_7} [Preorder ι] [Nonempty ι] [IsDirected ι fun x1 x2 => x1 ≤ x2] {s : ι → Set α} (hs : Antitone s) : (⨅ i, Filter.principal (s i)).HasAntitoneBasis s - Antitone.piecewise_eventually_eq_iInter 📋 Mathlib.Order.Filter.AtTopBot.Defs
{ι : Type u_1} {α : Type u_3} {β : α → Type u_6} [Preorder ι] {s : ι → Set α} [(i : ι) → DecidablePred fun x => x ∈ s i] [DecidablePred fun x => x ∈ ⋂ i, s i] (hs : Antitone s) (f g : (a : α) → β a) (a : α) : ∀ᶠ (i : ι) in Filter.atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a - Filter.antitone_seq_of_seq 📋 Mathlib.Order.Filter.CountablyGenerated
{α : Type u_1} (s : ℕ → Set α) : ∃ t, Antitone t ∧ ⨅ i, Filter.principal (s i) = ⨅ i, Filter.principal (t i) - Filter.exists_antitone_seq 📋 Mathlib.Order.Filter.CountablyGenerated
{α : Type u_1} (f : Filter α) [f.IsCountablyGenerated] : ∃ x, Antitone x ∧ ∀ {s : Set α}, s ∈ f ↔ ∃ i, x i ⊆ s - antitone_Ici 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} [Preorder α] : Antitone Set.Ici - antitone_Ioi 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} [Preorder α] : Antitone Set.Ioi - Antitone.Iic 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) : Antitone fun x => Set.Iic (f x) - Antitone.Iio 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) : Antitone fun x => Set.Iio (f x) - Monotone.Ici 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f) : Antitone fun x => Set.Ici (f x) - Monotone.Ioi 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f) : Antitone fun x => Set.Ioi (f x) - Monotone.Icc 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f g : α → β} (hf : Monotone f) (hg : Antitone g) : Antitone fun x => Set.Icc (f x) (g x) - Monotone.Ico 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f g : α → β} (hf : Monotone f) (hg : Antitone g) : Antitone fun x => Set.Ico (f x) (g x) - Monotone.Ioc 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f g : α → β} (hf : Monotone f) (hg : Antitone g) : Antitone fun x => Set.Ioc (f x) (g x) - Monotone.Ioo 📋 Mathlib.Order.Interval.Set.Monotone
{α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f g : α → β} (hf : Monotone f) (hg : Antitone g) : Antitone fun x => Set.Ioo (f x) (g x) - Antitone.iInter_comp_tendsto_atTop 📋 Mathlib.Order.Filter.AtTopBot.CompleteLattice
{α : Type u_3} {β : Type u_4} {γ : Type u_5} [Preorder β] {l : Filter α} [l.NeBot] {s : β → Set γ} (hs : Antitone s) {f : α → β} (hf : Filter.Tendsto f l Filter.atTop) : ⋂ a, s (f a) = ⋂ b, s b - Antitone.iUnion_comp_tendsto_atBot 📋 Mathlib.Order.Filter.AtTopBot.CompleteLattice
{α : Type u_3} {β : Type u_4} {γ : Type u_5} [Preorder β] {l : Filter α} [l.NeBot] {s : β → Set γ} (hs : Antitone s) {f : α → β} (hf : Filter.Tendsto f l Filter.atBot) : ⋃ a, s (f a) = ⋃ b, s b - MeasurableSet.iInter_of_antitone_of_frequently 📋 Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated
{α : Type u_1} [MeasurableSpace α] {ι : Type u_5} [Preorder ι] [Filter.atTop.IsCountablyGenerated] {s : ι → Set α} (hsm : Antitone s) (hs : ∃ᶠ (i : ι) in Filter.atTop, MeasurableSet (s i)) : MeasurableSet (⋂ i, s i) - MeasurableSet.iInter_of_antitone 📋 Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated
{α : Type u_1} [MeasurableSpace α] {ι : Type u_5} [Preorder ι] [IsDirected ι fun x1 x2 => x1 ≤ x2] [Filter.atTop.IsCountablyGenerated] {s : ι → Set α} (hsm : Antitone s) (hs : ∀ (i : ι), MeasurableSet (s i)) : MeasurableSet (⋂ i, s i) - MeasureTheory.tendsto_measure_iUnion_atBot 📋 Mathlib.MeasureTheory.Measure.MeasureSpace
{α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Preorder ι] [Filter.atBot.IsCountablyGenerated] {s : ι → Set α} (hm : Antitone s) : Filter.Tendsto (⇑μ ∘ s) Filter.atBot (nhds (μ (⋃ n, s n))) - Antitone.measure_iUnion 📋 Mathlib.MeasureTheory.Measure.MeasureSpace
{α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Preorder ι] [IsDirected ι fun x1 x2 => x1 ≥ x2] [Filter.atBot.IsCountablyGenerated] {s : ι → Set α} (hs : Antitone s) : μ (⋃ i, s i) = ⨆ i, μ (s i) - MeasureTheory.tendsto_measure_iInter_atTop 📋 Mathlib.MeasureTheory.Measure.MeasureSpace
{α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Preorder ι] [Filter.atTop.IsCountablyGenerated] {s : ι → Set α} (hs : ∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) (hm : Antitone s) (hf : ∃ i, μ (s i) ≠ ⊤) : Filter.Tendsto (⇑μ ∘ s) Filter.atTop (nhds (μ (⋂ n, s n))) - Antitone.measure_iInter 📋 Mathlib.MeasureTheory.Measure.MeasureSpace
{α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [Preorder ι] [IsDirected ι fun x1 x2 => x1 ≤ x2] [Filter.atTop.IsCountablyGenerated] {s : ι → Set α} (hs : Antitone s) (hsm : ∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) (hfin : ∃ i, μ (s i) ≠ ⊤) : μ (⋂ i, s i) = ⨅ i, μ (s i) - MeasureTheory.Egorov.notConvergentSeq_antitone 📋 Mathlib.MeasureTheory.Function.Egorov
{α : Type u_1} {β : Type u_2} {ι : Type u_3} [PseudoEMetricSpace β] {n : ℕ} {f : ι → α → β} {g : α → β} [Preorder ι] : Antitone (MeasureTheory.Egorov.notConvergentSeq f g n) - Antitone.indicator_eventuallyEq_iInter 📋 Mathlib.Order.Filter.IndicatorFunction
{α : Type u_1} {β : Type u_2} {ι : Type u_5} [Preorder ι] [Zero β] (s : ι → Set α) (hs : Antitone s) (f : α → β) (a : α) : (fun i => (s i).indicator f a) =ᶠ[Filter.atTop] fun x => (⋂ i, s i).indicator f a - Antitone.mulIndicator_eventuallyEq_iInter 📋 Mathlib.Order.Filter.IndicatorFunction
{α : Type u_1} {β : Type u_2} {ι : Type u_5} [Preorder ι] [One β] (s : ι → Set α) (hs : Antitone s) (f : α → β) (a : α) : (fun i => (s i).mulIndicator f a) =ᶠ[Filter.atTop] fun x => (⋂ i, s i).mulIndicator f a - Antitone.tendsto_indicator 📋 Mathlib.Order.Filter.IndicatorFunction
{α : Type u_1} {β : Type u_2} {ι : Type u_5} [Preorder ι] [Zero β] (s : ι → Set α) (hs : Antitone s) (f : α → β) (a : α) : Filter.Tendsto (fun i => (s i).indicator f a) Filter.atTop (pure ((⋂ i, s i).indicator f a)) - Antitone.tendsto_mulIndicator 📋 Mathlib.Order.Filter.IndicatorFunction
{α : Type u_1} {β : Type u_2} {ι : Type u_5} [Preorder ι] [One β] (s : ι → Set α) (hs : Antitone s) (f : α → β) (a : α) : Filter.Tendsto (fun i => (s i).mulIndicator f a) Filter.atTop (pure ((⋂ i, s i).mulIndicator f a)) - MeasureTheory.tendsto_setIntegral_of_antitone 📋 Mathlib.MeasureTheory.Integral.Bochner.Set
{X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : X → E} {μ : MeasureTheory.Measure X} {ι : Type u_5} [Preorder ι] [Filter.atTop.IsCountablyGenerated] {s : ι → Set X} (hsm : ∀ (i : ι), MeasurableSet (s i)) (h_anti : Antitone s) (hfi : ∃ i, MeasureTheory.IntegrableOn f (s i) μ) : Filter.Tendsto (fun i => ∫ (x : X) in s i, f x ∂μ) Filter.atTop (nhds (∫ (x : X) in ⋂ n, s n, f x ∂μ)) - fixedPoints_antitone 📋 Mathlib.GroupTheory.GroupAction.FixingSubgroup
(M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α] : Antitone fun P => MulAction.fixedPoints (↥P) α - fixedPoints_antitone_addSubmonoid 📋 Mathlib.GroupTheory.GroupAction.FixingSubgroup
(M : Type u_1) (α : Type u_2) [AddMonoid M] [AddAction M α] : Antitone fun P => AddAction.fixedPoints (↥P) α - fixedPoints_addSubgroup_antitone 📋 Mathlib.GroupTheory.GroupAction.FixingSubgroup
(M : Type u_1) (α : Type u_2) [AddGroup M] [AddAction M α] : Antitone fun P => AddAction.fixedPoints (↥P) α - fixedPoints_subgroup_antitone 📋 Mathlib.GroupTheory.GroupAction.FixingSubgroup
(M : Type u_1) (α : Type u_2) [Group M] [MulAction M α] : Antitone fun P => MulAction.fixedPoints (↥P) α - LinearMap.polar_antitone 📋 Mathlib.Analysis.LocallyConvex.Polar
{𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [NormedCommRing 𝕜] [AddCommMonoid E] [AddCommMonoid F] [Module 𝕜 E] [Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : Antitone B.polar - Antitone.tendsto_setIntegral 📋 Mathlib.MeasureTheory.Integral.DominatedConvergence
{α : Type u_1} {E : Type u_2} [MeasurableSpace α] {μ : MeasureTheory.Measure α} [NormedAddCommGroup E] [NormedSpace ℝ E] {s : ℕ → Set α} {f : α → E} (hsm : ∀ (i : ℕ), MeasurableSet (s i)) (h_anti : Antitone s) (hfi : MeasureTheory.IntegrableOn f (s 0) μ) : Filter.Tendsto (fun i => ∫ (a : α) in s i, f a ∂μ) Filter.atTop (nhds (∫ (a : α) in ⋂ n, s n, f a ∂μ)) - Dynamics.dynEntourage_antitone 📋 Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage
{X : Type u_1} (T : X → X) (U : Set (X × X)) : Antitone fun n => Dynamics.dynEntourage T U n - MeasureTheory.addContent_iUnion_eq_sum_of_tendsto_zero 📋 Mathlib.MeasureTheory.Measure.AddContent
{α : Type u_1} {C : Set (Set α)} (hC : MeasureTheory.IsSetRing C) (m : MeasureTheory.AddContent C) (hm_ne_top : ∀ s ∈ C, m s ≠ ⊤) (hm_tendsto : ∀ ⦃s : ℕ → Set α⦄, (∀ (n : ℕ), s n ∈ C) → Antitone s → ⋂ n, s n = ∅ → Filter.Tendsto (fun n => m (s n)) Filter.atTop (nhds 0)) ⦃f : ℕ → Set α⦄ (hf : ∀ (i : ℕ), f i ∈ C) (hUf : ⋃ i, f i ∈ C) (h_disj : Pairwise (Function.onFun Disjoint f)) : m (⋃ i, f i) = ∑' (i : ℕ), m (f i) - extentClosure_anti 📋 Mathlib.Order.Concept
{α : Type u_2} {β : Type u_3} (r : α → β → Prop) : Antitone (lowerPolar r) - intentClosure_anti 📋 Mathlib.Order.Concept
{α : Type u_2} {β : Type u_3} (r : α → β → Prop) : Antitone (upperPolar r) - lowerPolar_anti 📋 Mathlib.Order.Concept
{α : Type u_2} {β : Type u_3} (r : α → β → Prop) : Antitone (lowerPolar r) - upperPolar_anti 📋 Mathlib.Order.Concept
{α : Type u_2} {β : Type u_3} (r : α → β → Prop) : Antitone (upperPolar r) - ProbabilityTheory.Kernel.tendsto_densityProcess_atTop_of_antitone 📋 Mathlib.Probability.Kernel.Disintegration.Density
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β)) (ν : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ) (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅) (hseq_meas : ∀ (m : ℕ), MeasurableSet (seq m)) : Filter.Tendsto (fun m => κ.densityProcess ν n a x (seq m)) Filter.atTop (nhds 0) - ProbabilityTheory.Kernel.tendsto_densityProcess_atTop_empty_of_antitone 📋 Mathlib.Probability.Kernel.Disintegration.Density
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × β)) (ν : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ) (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅) (hseq_meas : ∀ (m : ℕ), MeasurableSet (seq m)) : Filter.Tendsto (fun m => κ.densityProcess ν n a x (seq m)) Filter.atTop (nhds (κ.densityProcess ν n a x ∅)) - ProbabilityTheory.Kernel.tendsto_density_atTop_ae_of_antitone 📋 Mathlib.Probability.Kernel.Disintegration.Density
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)} {ν : ProbabilityTheory.Kernel α γ} (hκν : κ.fst ≤ ν) [ProbabilityTheory.IsFiniteKernel ν] (a : α) (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅) (hseq_meas : ∀ (m : ℕ), MeasurableSet (seq m)) : ∀ᵐ (x : γ) ∂ν a, Filter.Tendsto (fun m => κ.density ν a x (seq m)) Filter.atTop (nhds 0) - ProbabilityTheory.Kernel.tendsto_integral_density_of_antitone 📋 Mathlib.Probability.Kernel.Disintegration.Density
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)} {ν : ProbabilityTheory.Kernel α γ} (hκν : κ.fst ≤ ν) [ProbabilityTheory.IsFiniteKernel ν] (a : α) (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅) (hseq_meas : ∀ (m : ℕ), MeasurableSet (seq m)) : Filter.Tendsto (fun m => ∫ (x : γ), κ.density ν a x (seq m) ∂ν a) Filter.atTop (nhds 0) - ProbabilityTheory.Kernel.trajContent_tendsto_zero 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {A : ℕ → Set ((n : ℕ) → X n)} (A_mem : ∀ (n : ℕ), A n ∈ MeasureTheory.measurableCylinders X) (A_anti : Antitone A) (A_inter : ⋂ n, A n = ∅) {p : ℕ} (x₀ : (i : { x // x ∈ Finset.Iic p }) → X ↑i) : Filter.Tendsto (fun n => (ProbabilityTheory.Kernel.trajContent κ x₀) (A n)) Filter.atTop (nhds 0) - MeasureTheory.piContent_tendsto_zero 📋 Mathlib.Probability.ProductMeasure
{ι : Type u_1} {X : ι → Type u_2} {mX : (i : ι) → MeasurableSpace (X i)} (μ : (i : ι) → MeasureTheory.Measure (X i)) [hμ : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] {A : ℕ → Set ((i : ι) → X i)} (A_mem : ∀ (n : ℕ), A n ∈ MeasureTheory.measurableCylinders X) (A_anti : Antitone A) (A_inter : ⋂ n, A n = ∅) : Filter.Tendsto (fun n => (MeasureTheory.piContent μ) (A n)) Filter.atTop (nhds 0) - preCantorSet_antitone 📋 Mathlib.Topology.Instances.CantorSet
: Antitone preCantorSet
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 ff04530
serving mathlib revision fc728c1