Loogle!

Result

Found 212 declarations mentioning Finset and Set.iUnion. Of these, 14 match your pattern(s).

• Set.iUnion_eq_iUnion_finset 📋 Mathlib.Order.CompleteLattice.Finset
  {α : Type u_2} {ι : Type u_5} (s : ι → Set α) : ⋃ i, s i = ⋃ t, ⋃ i ∈ t, s i
• Set.iUnion_finset_eq_set 📋 Mathlib.Order.CompleteLattice.Finset
  {ι : Type u_5} (s : Set ι) : ⋃ s', Subtype.val '' ↑s' = s
• Set.iUnion_eq_iUnion_finset' 📋 Mathlib.Order.CompleteLattice.Finset
  {α : Type u_2} {ι' : Sort u_7} (s : ι' → Set α) : ⋃ i, s i = ⋃ t, ⋃ i ∈ t, s i.down
• Filter.iInf_sets_eq_finite 📋 Mathlib.Order.Filter.Finite
  {α : Type u} {ι : Type u_2} (f : ι → Filter α) : (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i).sets
• Filter.iInf_sets_eq_finite' 📋 Mathlib.Order.Filter.Finite
  {α : Type u} {ι : Sort x} (f : ι → Filter α) : (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i.down).sets
• convexHull_eq_union_convexHull_finite_subsets 📋 Mathlib.Analysis.Convex.Combination
  {R : Type u_1} {E : Type u_3} [Field R] [AddCommGroup E] [Module R E] [LinearOrder R] [IsStrictOrderedRing R] (s : Set E) : (convexHull R) s = ⋃ t, ⋃ (_ : ↑t ⊆ s), (convexHull R) ↑t
• SeminormFamily.basisSets.eq_1 📋 Mathlib.Analysis.LocallyConvex.WithSeminorms
  {R : Type u_1} {E : Type u_6} {ι : Type u_9} [SeminormedRing R] [AddCommGroup E] [Module R E] (p : SeminormFamily R E ι) : p.basisSets = ⋃ s, ⋃ r, ⋃ (_ : 0 < r), {(s.sup p).ball 0 r}
• convexHull_eq_union 📋 Mathlib.Analysis.Convex.Caratheodory
  {𝕜 : Type u_1} {E : Type u} [Field 𝕜] [LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [AddCommGroup E] [Module 𝕜 E] {s : Set E} : (convexHull 𝕜) s = ⋃ t, ⋃ (_ : ↑t ⊆ s), ⋃ (_ : AffineIndependent 𝕜 Subtype.val), (convexHull 𝕜) ↑t
• Geometry.SimplicialComplex.vertices_eq 📋 Mathlib.Analysis.Convex.SimplicialComplex.Basic
  {𝕜 : Type u_1} {E : Type u_2} [Ring 𝕜] [PartialOrder 𝕜] [AddCommGroup E] [Module 𝕜 E] {K : Geometry.SimplicialComplex 𝕜 E} : K.vertices = ⋃ k ∈ K.faces, ↑k
• Geometry.SimplicialComplex.space.eq_1 📋 Mathlib.Analysis.Convex.SimplicialComplex.Basic
  {𝕜 : Type u_1} {E : Type u_2} [Ring 𝕜] [PartialOrder 𝕜] [AddCommGroup E] [Module 𝕜 E] (K : Geometry.SimplicialComplex 𝕜 E) : K.space = ⋃ s ∈ K.faces, (convexHull 𝕜) ↑s
• FirstOrder.Language.distinctConstantsTheory_eq_iUnion 📋 Mathlib.ModelTheory.Syntax
  {L : FirstOrder.Language} {α : Type u'} (s : Set α) : L.distinctConstantsTheory s = ⋃ t, L.distinctConstantsTheory ↑(Finset.map (Function.Embedding.subtype fun x => x ∈ s) t)
• MeasureTheory.squareCylinders_eq_iUnion_image 📋 Mathlib.MeasureTheory.Constructions.Cylinders
  {ι : Type u_2} {α : ι → Type u_1} (C : (i : ι) → Set (Set (α i))) : MeasureTheory.squareCylinders C = ⋃ s, (fun t => (↑s).pi t) '' Set.univ.pi C
• MeasureTheory.measurableCylinders.eq_1 📋 Mathlib.MeasureTheory.Constructions.Cylinders
  {ι : Type u_2} (α : ι → Type u_1) [(i : ι) → MeasurableSpace (α i)] : MeasureTheory.measurableCylinders α = ⋃ s, ⋃ S, ⋃ (_ : MeasurableSet S), {MeasureTheory.cylinder s S}
• MeasureTheory.closedCompactCylinders.eq_1 📋 Mathlib.MeasureTheory.Constructions.ClosedCompactCylinders
  {ι : Type u_1} (X : ι → Type u_2) [(i : ι) → TopologicalSpace (X i)] : MeasureTheory.closedCompactCylinders X = ⋃ s, ⋃ S, ⋃ (_ : IsClosed S), ⋃ (_ : IsCompact S), {MeasureTheory.cylinder s S}

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 519f454