Loogle!
Result
Found 13 declarations mentioning LE.le and ProbabilityTheory.iIndep. Of these, 13 match your pattern(s).
- ProbabilityTheory.iIndep_of_iIndep_of_le 📋 Mathlib.Probability.Independence.Basic
{Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {m₁ m₂ : ι → MeasurableSpace Ω} (h_indep : ProbabilityTheory.iIndep m₂ μ) (h_le : ∀ (i : ι), m₁ i ≤ m₂ i) : ProbabilityTheory.iIndep m₁ μ - ProbabilityTheory.iIndepSets.iIndep 📋 Mathlib.Probability.Independence.Basic
{Ω : Type u_1} {ι : Type u_2} {m : ι → MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h_le : ∀ (i : ι), m i ≤ _mΩ) (π : ι → Set (Set Ω)) (h_pi : ∀ (n : ι), IsPiSystem (π n)) (h_generate : ∀ (i : ι), m i = MeasurableSpace.generateFrom (π i)) (h_ind : ProbabilityTheory.iIndepSets π μ) : ProbabilityTheory.iIndep m μ - ProbabilityTheory.indep_iSup_of_disjoint 📋 Mathlib.Probability.Independence.Basic
{Ω : Type u_1} {ι : Type u_2} {m : ι → MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h_le : ∀ (i : ι), m i ≤ _mΩ) (h_indep : ProbabilityTheory.iIndep m μ) {S T : Set ι} (hST : Disjoint S T) : ProbabilityTheory.Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) μ - ProbabilityTheory.indep_limsup_atBot_self 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [SemilatticeInf ι] [NoMinOrder ι] [Nonempty ι] (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) : ProbabilityTheory.Indep (Filter.limsup s Filter.atBot) (Filter.limsup s Filter.atBot) μ - ProbabilityTheory.indep_limsup_atTop_self 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [SemilatticeSup ι] [NoMaxOrder ι] [Nonempty ι] (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) : ProbabilityTheory.Indep (Filter.limsup s Filter.atTop) (Filter.limsup s Filter.atTop) μ - ProbabilityTheory.measure_zero_or_one_of_measurableSet_limsup_atBot 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [SemilatticeInf ι] [NoMinOrder ι] [Nonempty ι] (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) {t : Set Ω} (ht_tail : MeasurableSet t) : μ t = 0 ∨ μ t = 1 - ProbabilityTheory.measure_zero_or_one_of_measurableSet_limsup_atTop 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [SemilatticeSup ι] [NoMaxOrder ι] [Nonempty ι] (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) {t : Set Ω} (ht_tail : MeasurableSet t) : μ t = 0 ∨ μ t = 1 - ProbabilityTheory.indep_limsup_self 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (hf : ∀ (t : Set ι), p t → tᶜ ∈ f) (hns : Directed (fun x1 x2 => x1 ≤ x2) ns) (hnsp : ∀ (a : β), p (ns a)) (hns_univ : ∀ (n : ι), ∃ a, n ∈ ns a) : ProbabilityTheory.Indep (Filter.limsup s f) (Filter.limsup s f) μ - ProbabilityTheory.indep_biSup_limsup 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {p : Set ι → Prop} {f : Filter ι} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (hf : ∀ (t : Set ι), p t → tᶜ ∈ f) {t : Set ι} (ht : p t) : ProbabilityTheory.Indep (⨆ n ∈ t, s n) (Filter.limsup s f) μ - ProbabilityTheory.indep_iSup_limsup 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (hf : ∀ (t : Set ι), p t → tᶜ ∈ f) (hns : Directed (fun x1 x2 => x1 ≤ x2) ns) (hnsp : ∀ (a : β), p (ns a)) (hns_univ : ∀ (n : ι), ∃ a, n ∈ ns a) : ProbabilityTheory.Indep (⨆ n, s n) (Filter.limsup s f) μ - ProbabilityTheory.indep_biSup_compl 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (t : Set ι) : ProbabilityTheory.Indep (⨆ n ∈ t, s n) (⨆ n ∈ tᶜ, s n) μ - ProbabilityTheory.measure_zero_or_one_of_measurableSet_limsup 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (hf : ∀ (t : Set ι), p t → tᶜ ∈ f) (hns : Directed (fun x1 x2 => x1 ≤ x2) ns) (hnsp : ∀ (a : β), p (ns a)) (hns_univ : ∀ (n : ι), ∃ a, n ∈ ns a) {t : Set Ω} (ht_tail : MeasurableSet t) : μ t = 0 ∨ μ t = 1 - ProbabilityTheory.indep_iSup_directed_limsup 📋 Mathlib.Probability.Independence.ZeroOne
{Ω : Type u_2} {ι : Type u_3} {s : ι → MeasurableSpace Ω} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_4} {p : Set ι → Prop} {f : Filter ι} {ns : β → Set ι} (h_le : ∀ (n : ι), s n ≤ m0) (h_indep : ProbabilityTheory.iIndep s μ) (hf : ∀ (t : Set ι), p t → tᶜ ∈ f) (hns : Directed (fun x1 x2 => x1 ≤ x2) ns) (hnsp : ∀ (a : β), p (ns a)) : ProbabilityTheory.Indep (⨆ a, ⨆ n ∈ ns a, s n) (Filter.limsup s 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 a3d2529