Loogle!

Result

Found 12278 declarations mentioning Finset. Of these, 27 have a name containing "strong".

• Finset.strongInduction 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (s : Finset α) : p s
• Finset.strongInductionOn 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (s : Finset α) : ((s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) → p s
• Finset.strongDownwardInduction 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} {n : ℕ} (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) (s : Finset α) : s.card ≤ n → p s
• Finset.strongDownwardInductionOn 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {n : ℕ} {p : Finset α → Sort u_4} (s : Finset α) (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) : s.card ≤ n → p s
• Finset.strongInduction_eq 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (s : Finset α) : Finset.strongInduction H s = H s fun t x => Finset.strongInduction H t
• Finset.case_strong_induction_on 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} [DecidableEq α] {p : Finset α → Prop} (s : Finset α) (h₀ : p ∅) (h₁ : ∀ (a : α) (s : Finset α), a ∉ s → (∀ t ⊆ s, p t) → p (insert a s)) : p s
• Finset.strongInductionOn_eq 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (s : Finset α) (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) : s.strongInductionOn H = H s fun t x => t.strongInductionOn H
• Finset.Nonempty.strong_induction 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : (s : Finset α) → s.Nonempty → Prop} (h₀ : ∀ (a : α), p {a} ⋯) (h₁ : ∀ ⦃s : Finset α⦄ (hs : s.Nontrivial), (∀ (t : Finset α) (ht : t.Nonempty), t ⊂ s → p t ht) → p s ⋯) ⦃s : Finset α⦄ (hs : s.Nonempty) : p s hs
• Finset.strongInduction.eq_1 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (x✝ : Finset α) : Finset.strongInduction H x✝ = H x✝ fun t h => have this := ⋯; Finset.strongInduction H t
• Finset.strongInduction.eq_def 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} (H : (s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) (x✝ : Finset α) : Finset.strongInduction H x✝ = have s := x✝; H s fun t h => have this := ⋯; Finset.strongInduction H t
• Finset.strongDownwardInduction_eq 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {n : ℕ} {p : Finset α → Sort u_4} (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) (s : Finset α) : Finset.strongDownwardInduction H s = H s fun {t} ht x => Finset.strongDownwardInduction H t ht
• Finset.strongDownwardInductionOn_eq 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {n : ℕ} {p : Finset α → Sort u_4} (s : Finset α) (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) : (fun a => s.strongDownwardInductionOn H a) = H s fun {t} ht x => t.strongDownwardInductionOn H ht
• Finset.strongDownwardInduction.eq_1 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} {n : ℕ} (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) (x✝ : Finset α) : Finset.strongDownwardInduction H x✝ = H x✝ fun {t} ht h => have this := ⋯; have this := ⋯; Finset.strongDownwardInduction H t ht
• Finset.strongDownwardInduction.eq_def 📋 Mathlib.Data.Finset.Card
  {α : Type u_1} {p : Finset α → Sort u_4} {n : ℕ} (H : (t₁ : Finset α) → ({t₂ : Finset α} → t₂.card ≤ n → t₁ ⊂ t₂ → p t₂) → t₁.card ≤ n → p t₁) (x✝ : Finset α) : Finset.strongDownwardInduction H x✝ = let s := x✝; H s fun {t} ht h => have this := ⋯; have this := ⋯; Finset.strongDownwardInduction H t ht
• Finset.stronglyMeasurable_fun_prod 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {M : Type u_5} [CommMonoid M] [TopologicalSpace M] [ContinuousMul M] {m : MeasurableSpace α} {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable (f i)) : MeasureTheory.StronglyMeasurable fun a => ∏ i ∈ s, f i a
• Finset.stronglyMeasurable_fun_sum 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {M : Type u_5} [AddCommMonoid M] [TopologicalSpace M] [ContinuousAdd M] {m : MeasurableSpace α} {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable (f i)) : MeasureTheory.StronglyMeasurable fun a => ∑ i ∈ s, f i a
• Finset.stronglyMeasurable_prod 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {M : Type u_5} [CommMonoid M] [TopologicalSpace M] [ContinuousMul M] {m : MeasurableSpace α} {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable (f i)) : MeasureTheory.StronglyMeasurable (∏ i ∈ s, f i)
• Finset.stronglyMeasurable_sum 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {M : Type u_5} [AddCommMonoid M] [TopologicalSpace M] [ContinuousAdd M] {m : MeasurableSpace α} {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable (f i)) : MeasureTheory.StronglyMeasurable (∑ i ∈ s, f i)
• MeasureTheory.StronglyMeasurable.Finset.stronglyMeasurable_prod_apply 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {β : Type u_2} {M : Type u_5} [CommMonoid M] [TopologicalSpace M] [ContinuousMul M] {m : MeasurableSpace α} {n : MeasurableSpace β} {ι : Type u_6} {f : ι → α → β → M} {g : α → β} {s : Finset ι} (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable ↿(f i)) (hg : Measurable g) : MeasureTheory.StronglyMeasurable fun a => (∏ i ∈ s, f i a) (g a)
• MeasureTheory.StronglyMeasurable.Finset.stronglyMeasurable_sum_apply 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
  {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] [TopologicalSpace M] [ContinuousAdd M] {m : MeasurableSpace α} {n : MeasurableSpace β} {ι : Type u_6} {f : ι → α → β → M} {g : α → β} {s : Finset ι} (hf : ∀ i ∈ s, MeasureTheory.StronglyMeasurable ↿(f i)) (hg : Measurable g) : MeasureTheory.StronglyMeasurable fun a => (∑ i ∈ s, f i a) (g a)
• Finset.aestronglyMeasurable_fun_prod 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
  {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {M : Type u_5} [CommMonoid M] [TopologicalSpace M] [ContinuousMul M] {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (f i) μ) : MeasureTheory.AEStronglyMeasurable (fun a => ∏ i ∈ s, f i a) μ
• Finset.aestronglyMeasurable_fun_sum 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
  {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {M : Type u_5} [AddCommMonoid M] [TopologicalSpace M] [ContinuousAdd M] {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (f i) μ) : MeasureTheory.AEStronglyMeasurable (fun a => ∑ i ∈ s, f i a) μ
• Finset.aestronglyMeasurable_prod 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
  {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {M : Type u_5} [CommMonoid M] [TopologicalSpace M] [ContinuousMul M] {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (f i) μ) : MeasureTheory.AEStronglyMeasurable (∏ i ∈ s, f i) μ
• Finset.aestronglyMeasurable_sum 📋 Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable
  {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {M : Type u_5} [AddCommMonoid M] [TopologicalSpace M] [ContinuousAdd M] {ι : Type u_6} {f : ι → α → M} (s : Finset ι) (hf : ∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (f i) μ) : MeasureTheory.AEStronglyMeasurable (∑ i ∈ s, f i) μ
• MeasureTheory.StronglyMeasurable.dependsOn_of_piFinset 📋 Mathlib.MeasureTheory.Function.FactorsThrough
  {Z : Type u_3} {ι : Type u_4} {X : ι → Type u_5} [(i : ι) → MeasurableSpace (X i)] {f : ((i : ι) → X i) → Z} {s : Finset ι} [TopologicalSpace Z] [TopologicalSpace.PseudoMetrizableSpace Z] [T1Space Z] (hf : MeasureTheory.StronglyMeasurable f) : DependsOn f ↑s
• ProbabilityTheory.aestronglyMeasurable_exp_mul_sum 📋 Mathlib.Probability.Moments.Basic
  {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ} {X : ι → Ω → ℝ} {s : Finset ι} (h_int : ∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * X i ω)) μ) : MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * (∑ i ∈ s, X i) ω)) μ
• ProbabilityTheory.Kernel.aestronglyMeasurable_traj 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
  {X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {E : Type u_2} [NormedAddCommGroup E] {a b : ℕ} (hab : a ≤ b) {f : ((n : ℕ) → X n) → E} {x₀ : (i : ↥(Finset.Iic a)) → X ↑i} (hf : MeasureTheory.AEStronglyMeasurable f ((ProbabilityTheory.Kernel.traj κ a) x₀)) : ∀ᵐ (x : (i : ↥(Finset.Iic b)) → X ↑i) ∂(ProbabilityTheory.Kernel.partialTraj κ a b) x₀, MeasureTheory.AEStronglyMeasurable f ((ProbabilityTheory.Kernel.traj κ b) x)

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:

1. By constant:
   🔍 Real.sin
   finds all lemmas whose statement somehow mentions the sine function.

2. By lemma name substring:
   🔍 "differ"
   finds all lemmas that have "differ" somewhere in their lemma name.

3. 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

4. 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 find tsum_lt_tsum even though the hypothesis f 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 6ff4759 serving mathlib revision 76f94b4