Loogle!
Result
Found 595 declarations mentioning Subtype and Fintype. Of these, only the first 200 are shown.
- Fintype.subtype 📋 Mathlib.Data.Fintype.Defs
{α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x) : Fintype { x // p x } - Finset.subtype_univ 📋 Mathlib.Data.Finset.BooleanAlgebra
{α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }] : Finset.subtype p Finset.univ = Finset.univ - Finset.univ_map_subtype 📋 Mathlib.Data.Finset.BooleanAlgebra
{α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }] : Finset.map (Function.Embedding.subtype p) Finset.univ = Finset.filter p Finset.univ - Finset.subtype_eq_univ 📋 Mathlib.Data.Finset.BooleanAlgebra
{α : Type u_1} {s : Finset α} {p : α → Prop} [DecidablePred p] [Fintype { a // p a }] : Finset.subtype p s = Finset.univ ↔ ∀ ⦃a : α⦄, p a → a ∈ s - Finset.univ_val_map_subtype_val 📋 Mathlib.Data.Finset.BooleanAlgebra
{α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] [Fintype { a // p a }] : Multiset.map Subtype.val Finset.univ.val = (Finset.filter p Finset.univ).val - Finset.univ_val_map_subtype_restrict 📋 Mathlib.Data.Finset.BooleanAlgebra
{α : Type u_1} {β : Type u_2} [Fintype α] (f : α → β) (p : α → Prop) [DecidablePred p] [Fintype { a // p a }] : Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val - Subtype.fintype 📋 Mathlib.Data.Fintype.Sets
{α : Type u_1} (p : α → Prop) [DecidablePred p] [Fintype α] : Fintype { x // p x } - Finset.fintypeCoeSort 📋 Mathlib.Data.Fintype.Sets
{α : Type u} (s : Finset α) : Fintype { x // x ∈ s } - Finset.Subtype.fintype 📋 Mathlib.Data.Fintype.Sets
{α : Type u_1} (s : Finset α) : Fintype { x // x ∈ s } - List.Subtype.fintype 📋 Mathlib.Data.Fintype.Sets
{α : Type u_1} [DecidableEq α] (l : List α) : Fintype { x // x ∈ l } - Multiset.Subtype.fintype 📋 Mathlib.Data.Fintype.Sets
{α : Type u_1} [DecidableEq α] (s : Multiset α) : Fintype { x // x ∈ s } - Set.toFinset.eq_1 📋 Mathlib.Data.Fintype.Sets
{α : Type u_1} (s : Set α) [Fintype ↑s] : s.toFinset = Finset.map (Function.Embedding.subtype fun x => x ∈ s) Finset.univ - Finset.prod_attach_univ 📋 Mathlib.Algebra.BigOperators.Group.Finset.Defs
{ι : Type u_1} {α : Type u_3} [CommMonoid α] [Fintype ι] (f : { i // i ∈ Finset.univ } → α) : ∏ i ∈ Finset.univ.attach, f i = ∏ i, f ⟨i, ⋯⟩ - Finset.sum_attach_univ 📋 Mathlib.Algebra.BigOperators.Group.Finset.Defs
{ι : Type u_1} {α : Type u_3} [AddCommMonoid α] [Fintype ι] (f : { i // i ∈ Finset.univ } → α) : ∑ i ∈ Finset.univ.attach, f i = ∑ i, f ⟨i, ⋯⟩ - Finset.prod_subtype 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{ι : Type u_1} {M : Type u_4} [CommMonoid M] {p : ι → Prop} {F : Fintype (Subtype p)} (s : Finset ι) (h : ∀ (x : ι), x ∈ s ↔ p x) (f : ι → M) : ∏ a ∈ s, f a = ∏ a, f ↑a - Finset.sum_subtype 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{ι : Type u_1} {M : Type u_4} [AddCommMonoid M] {p : ι → Prop} {F : Fintype (Subtype p)} (s : Finset ι) (h : ∀ (x : ι), x ∈ s ↔ p x) (f : ι → M) : ∑ a ∈ s, f a = ∑ a, f ↑a - Fintype.prod_fiberwise' 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {κ : Type u_6} {ι : Type u_7} [Fintype ι] [Fintype κ] [CommMonoid M] [DecidableEq κ] (g : ι → κ) (f : κ → M) : ∏ j, ∏ _i, f j = ∏ i, f (g i) - Fintype.sum_fiberwise' 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {κ : Type u_6} {ι : Type u_7} [Fintype ι] [Fintype κ] [AddCommMonoid M] [DecidableEq κ] (g : ι → κ) (f : κ → M) : ∑ j, ∑ _i, f j = ∑ i, f (g i) - Fintype.prod_fiberwise 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {κ : Type u_6} {ι : Type u_7} [Fintype ι] [Fintype κ] [CommMonoid M] [DecidableEq κ] (g : ι → κ) (f : ι → M) : ∏ j, ∏ i, f ↑i = ∏ i, f i - Fintype.sum_fiberwise 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {κ : Type u_6} {ι : Type u_7} [Fintype ι] [Fintype κ] [AddCommMonoid M] [DecidableEq κ] (g : ι → κ) (f : ι → M) : ∑ j, ∑ i, f ↑i = ∑ i, f i - Fintype.prod_subtype_mul_prod_subtype 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {ι : Type u_7} [Fintype ι] [CommMonoid M] (p : ι → Prop) (f : ι → M) [DecidablePred p] : (∏ i, f ↑i) * ∏ i, f ↑i = ∏ i, f i - Fintype.sum_subtype_add_sum_subtype 📋 Mathlib.Algebra.BigOperators.Group.Finset.Basic
{M : Type u_4} {ι : Type u_7} [Fintype ι] [AddCommMonoid M] (p : ι → Prop) (f : ι → M) [DecidablePred p] : ∑ i, f ↑i + ∑ i, f ↑i = ∑ i, f i - Fintype.subtypeEq 📋 Mathlib.Data.Fintype.Basic
{α : Type u_1} (y : α) : Fintype { x // x = y } - Fintype.subtypeEq' 📋 Mathlib.Data.Fintype.Basic
{α : Type u_1} (y : α) : Fintype { x // y = x } - Fintype.card_subtype_true 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Fintype α] {h : Fintype { _a // True }} : Fintype.card { _a // True } = Fintype.card α - Fintype.card_subtype_le 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Fintype α] (p : α → Prop) [Fintype { a // p a }] : Fintype.card { x // p x } ≤ Fintype.card α - Fintype.card_subtype_eq 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} (y : α) [Fintype { x // x = y }] : Fintype.card { x // x = y } = 1 - Fintype.card_subtype_eq' 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} (y : α) [Fintype { x // y = x }] : Fintype.card { x // y = x } = 1 - Fintype.card_subtype_lt 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Fintype α] {p : α → Prop} [Fintype { a // p a }] {x : α} (hx : ¬p x) : Fintype.card { x // p x } < Fintype.card α - Fintype.card_coe 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} (s : Finset α) [Fintype { x // x ∈ s }] : Fintype.card { x // x ∈ s } = s.card - Fintype.card_subtype 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Fintype α] (p : α → Prop) [Fintype { a // p a }] [DecidablePred p] : Fintype.card { x // p x } = {x | p x}.card - Fintype.card_of_subtype 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x) [Fintype { x // p x }] : Fintype.card { x // p x } = s.card - Fintype.card_subtype_compl 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Fintype α] (p : α → Prop) [Fintype { x // p x }] [Fintype { x // ¬p x }] : Fintype.card { x // ¬p x } = Fintype.card α - Fintype.card { x // p x } - Fintype.card_subtype_mono 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} (p q : α → Prop) (h : p ≤ q) [Fintype { x // p x }] [Fintype { x // q x }] : Fintype.card { x // p x } ≤ Fintype.card { x // q x } - Fintype.card_compl_eq_card_compl 📋 Mathlib.Data.Fintype.Card
{α : Type u_1} [Finite α] (p q : α → Prop) [Fintype { x // p x }] [Fintype { x // ¬p x }] [Fintype { x // q x }] [Fintype { x // ¬q x }] (h : Fintype.card { x // p x } = Fintype.card { x // q x }) : Fintype.card { x // ¬p x } = Fintype.card { x // ¬q x } - Fintype.truncFinBijection 📋 Mathlib.Data.Fintype.EquivFin
(α : Type u_4) [Fintype α] : Trunc { f // Function.Bijective f } - Finset.card_eq_of_equiv_fintype 📋 Mathlib.Data.Fintype.EquivFin
{α : Type u_1} {β : Type u_2} {s : Finset α} [Fintype β] (i : { x // x ∈ s } ≃ β) : s.card = Fintype.card β - AddSubmonoid.fintypeMultiples 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {a : M} [Fintype M] : Fintype ↥(AddSubmonoid.multiples a) - Submonoid.fintypePowers 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {a : M} [Fintype M] : Fintype ↥(Submonoid.powers a) - AddSubmonoid.card_bot 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {x✝ : Fintype ↥⊥} : Fintype.card ↥⊥ = 1 - Submonoid.card_bot 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {x✝ : Fintype ↥⊥} : Fintype.card ↥⊥ = 1 - AddSubmonoid.eq_bot_of_card_eq 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] (h : Fintype.card ↥S = 1) : S = ⊥ - Submonoid.eq_bot_of_card_eq 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] (h : Fintype.card ↥S = 1) : S = ⊥ - AddSubmonoid.eq_bot_iff_card 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] : S = ⊥ ↔ Fintype.card ↥S = 1 - AddSubmonoid.eq_bot_of_card_le 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] (h : Fintype.card ↥S ≤ 1) : S = ⊥ - Submonoid.eq_bot_iff_card 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] : S = ⊥ ↔ Fintype.card ↥S = 1 - Submonoid.eq_bot_of_card_le 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] (h : Fintype.card ↥S ≤ 1) : S = ⊥ - AddSubmonoid.card_le_one_iff_eq_bot 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {S : AddSubmonoid M} [Fintype ↥S] : Fintype.card ↥S ≤ 1 ↔ S = ⊥ - Submonoid.card_le_one_iff_eq_bot 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {S : Submonoid M} [Fintype ↥S] : Fintype.card ↥S ≤ 1 ↔ S = ⊥ - AddSubmonoid.fintypeMultiples.eq_1 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [AddMonoid M] {a : M} [Fintype M] : AddSubmonoid.fintypeMultiples = inferInstanceAs (Fintype ↥(AddSubmonoid.multiples a)) - Submonoid.fintypePowers.eq_1 📋 Mathlib.Algebra.Group.Submonoid.Membership
{M : Type u_1} [Monoid M] {a : M} [Fintype M] : Submonoid.fintypePowers = inferInstanceAs (Fintype ↥(Submonoid.powers a)) - RingHom.fintypeRangeS 📋 Mathlib.Algebra.Ring.Subsemiring.Basic
{R : Type u} {S : Type v} [NonAssocSemiring R] [NonAssocSemiring S] [Fintype R] [DecidableEq S] (f : R →+* S) : Fintype ↥f.rangeS - Subring.instFintypeSubtypeMemTop 📋 Mathlib.Algebra.Ring.Subring.Basic
{R : Type u_1} [Ring R] [Fintype R] : Fintype ↥⊤ - Subring.card_top 📋 Mathlib.Algebra.Ring.Subring.Basic
(R : Type u_1) [Ring R] [Fintype R] : Fintype.card ↥⊤ = Fintype.card R - RingHom.fintypeRange 📋 Mathlib.Algebra.Ring.Subring.Basic
{R : Type u} {S : Type v} [Ring R] [Ring S] [Fintype R] [DecidableEq S] (f : R →+* S) : Fintype ↥f.range - LinearMap.fintypeRange 📋 Mathlib.Algebra.Module.Submodule.Range
{R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R₂ M₂] {τ₁₂ : R →+* R₂} [Fintype M] [DecidableEq M₂] [RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂) : Fintype ↥(LinearMap.range f) - NonUnitalRingHom.fintypeRange 📋 Mathlib.RingTheory.NonUnitalSubring.Basic
{R : Type u} {S : Type v} [NonUnitalNonAssocRing R] [NonUnitalNonAssocRing S] [Fintype R] [DecidableEq S] (f : R →ₙ+* S) : Fintype ↥f.range - NonUnitalAlgHom.fintypeRange 📋 Mathlib.Algebra.Algebra.NonUnitalSubalgebra
{F : Type v'} {R : Type u} {A : Type v} {B : Type w} [CommSemiring R] [NonUnitalNonAssocSemiring A] [Module R A] [NonUnitalNonAssocSemiring B] [Module R B] [FunLike F A B] [NonUnitalAlgHomClass F R A B] [Fintype A] [DecidableEq B] (φ : F) : Fintype ↥(NonUnitalAlgHom.range φ) - Finset.prod_attach_eq_prod_dite 📋 Mathlib.Algebra.BigOperators.Group.Finset.Piecewise
{α : Type u_3} {β : Type u_4} [CommMonoid β] [Fintype α] (s : Finset α) (f : { x // x ∈ s } → β) [DecidablePred fun x => x ∈ s] : ∏ i ∈ s.attach, f i = ∏ i, if h : i ∈ s then f ⟨i, h⟩ else 1 - Finset.sum_attach_eq_sum_dite 📋 Mathlib.Algebra.BigOperators.Group.Finset.Piecewise
{α : Type u_3} {β : Type u_4} [AddCommMonoid β] [Fintype α] (s : Finset α) (f : { x // x ∈ s } → β) [DecidablePred fun x => x ∈ s] : ∑ i ∈ s.attach, f i = ∑ i, if h : i ∈ s then f ⟨i, h⟩ else 0 - Fintype.card_finset_len 📋 Mathlib.Data.Fintype.Powerset
{α : Type u_1} [Fintype α] (k : ℕ) : Fintype.card { s // s.card = k } = (Fintype.card α).choose k - AlgHom.fintypeRange 📋 Mathlib.Algebra.Algebra.Subalgebra.Basic
{R : Type u} {A : Type v} {B : Type w} [CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B] [Fintype A] [DecidableEq B] (φ : A →ₐ[R] B) : Fintype ↥φ.range - fintypeOfFintypeNe 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} (a : α) : Fintype { b // b ≠ a } → Fintype α - Fintype.card_subtype_or 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} (p q : α → Prop) [Fintype { x // p x }] [Fintype { x // q x }] [Fintype { x // p x ∨ q x }] : Fintype.card { x // p x ∨ q x } ≤ Fintype.card { x // p x } + Fintype.card { x // q x } - Fintype.card_subtype_or_disjoint 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} (p q : α → Prop) (h : Disjoint p q) [Fintype { x // p x }] [Fintype { x // q x }] [Fintype { x // p x ∨ q x }] : Fintype.card { x // p x ∨ q x } = Fintype.card { x // p x } + Fintype.card { x // q x } - image_subtype_ne_univ_eq_image_erase 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (k : β) (b : α → β) : Finset.image (fun i => b ↑i) Finset.univ = (Finset.image b Finset.univ).erase k - image_subtype_univ_ssubset_image_univ 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] (k : β) (b : α → β) (hk : k ∈ Finset.image b Finset.univ) (p : β → Prop) [DecidablePred p] (hp : ¬p k) : Finset.image (fun i => b ↑i) Finset.univ ⊂ Finset.image b Finset.univ - Set.MapsTo.exists_equiv_extend_of_card_eq 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} {β : Type u_2} [Fintype α] {t : Finset β} (hαt : Fintype.card α = t.card) {s : Set α} {f : α → β} (hfst : Set.MapsTo f s ↑t) (hfs : Set.InjOn f s) : ∃ g, ∀ i ∈ s, ↑(g i) = f i - Finset.exists_equiv_extend_of_card_eq 📋 Mathlib.Data.Fintype.Sum
{α : Type u_1} {β : Type u_2} [Fintype α] [DecidableEq β] {t : Finset β} (hαt : Fintype.card α = t.card) {s : Finset α} {f : α → β} (hfst : Finset.image f s ⊆ t) (hfs : Set.InjOn f ↑s) : ∃ g, ∀ i ∈ s, ↑(g i) = f i - Finset.prod_toFinset_eq_subtype 📋 Mathlib.Data.Fintype.BigOperators
{α : Type u_1} {M : Type u_4} [CommMonoid M] [Fintype α] (p : α → Prop) [DecidablePred p] (f : α → M) : ∏ a ∈ {x | p x}.toFinset, f a = ∏ a, f ↑a - Finset.sum_toFinset_eq_subtype 📋 Mathlib.Data.Fintype.BigOperators
{α : Type u_1} {M : Type u_4} [AddCommMonoid M] [Fintype α] (p : α → Prop) [DecidablePred p] (f : α → M) : ∑ a ∈ {x | p x}.toFinset, f a = ∑ a, f ↑a - Fintype.prod_eq_mul_prod_subtype_ne 📋 Mathlib.Data.Fintype.BigOperators
{α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] [DecidableEq α] (f : α → M) (a : α) : ∏ i, f i = f a * ∏ i, f ↑i - Fintype.sum_eq_add_sum_subtype_ne 📋 Mathlib.Data.Fintype.BigOperators
{α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] [DecidableEq α] (f : α → M) (a : α) : ∑ i, f i = f a + ∑ i, f ↑i - Fintype.prod_dite 📋 Mathlib.Data.Fintype.BigOperators
{α : Type u_1} {β : Type u_2} [Fintype α] {p : α → Prop} [DecidablePred p] [CommMonoid β] (f : (a : α) → p a → β) (g : (a : α) → ¬p a → β) : ∏ a, dite (p a) (f a) (g a) = (∏ a, f ↑a ⋯) * ∏ a, g ↑a ⋯ - Ideal.finsuppTotal_apply_eq_of_fintype 📋 Mathlib.RingTheory.Ideal.Operations
{ι : Type u_1} {M : Type u_2} [AddCommGroup M] {R : Type u_3} [CommRing R] [Module R M] (I : Ideal R) {v : ι → M} [Fintype ι] (f : ι →₀ ↥I) : (Ideal.finsuppTotal ι M I v) f = ∑ i, ↑(f i) • v i - Basis.reindexFinsetRange 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] : Basis { x // x ∈ Finset.image (⇑b) Finset.univ } R M - Basis.reindexFinsetRange.eq_1 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] : b.reindexFinsetRange = b.reindexRange.reindex ((Equiv.refl M).subtypeEquiv ⋯) - Basis.reindexFinsetRange_apply 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] (x : { x // x ∈ Finset.image (⇑b) Finset.univ }) : b.reindexFinsetRange x = ↑x - Basis.reindexFinsetRange_self 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] (i : ι) (h : b i ∈ Finset.image (⇑b) Finset.univ := ⋯) : b.reindexFinsetRange ⟨b i, h⟩ = b i - Basis.reindexFinsetRange_repr_self 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] (i : ι) : b.reindexFinsetRange.repr (b i) = fun₀ | ⟨b i, ⋯⟩ => 1 - Basis.reindexFinsetRange_repr 📋 Mathlib.LinearAlgebra.Basis.Defs
{ι : Type u_10} {R : Type u_11} {M : Type u_12} [Semiring R] [AddCommMonoid M] [Module R M] (b : Basis ι R M) [Fintype ι] [DecidableEq M] (x : M) (i : ι) (h : b i ∈ Finset.image (⇑b) Finset.univ := ⋯) : (b.reindexFinsetRange.repr x) ⟨b i, h⟩ = (b.repr x) i - DFinsupp.equivFunOnFintype.eq_1 📋 Mathlib.Algebra.DirectSum.Basic
{ι : Type u} {β : ι → Type v} [(i : ι) → Zero (β i)] [Fintype ι] : DFinsupp.equivFunOnFintype = { toFun := DFunLike.coe, invFun := fun f => { toFun := f, support' := Trunc.mk ⟨Finset.univ.val, ⋯⟩ }, left_inv := ⋯, right_inv := ⋯ } - Basis.mem_submodule_iff' 📋 Mathlib.LinearAlgebra.Basis.Submodule
{ι : Type u_1} {R : Type u_3} {M : Type u_5} [Semiring R] [AddCommMonoid M] [Module R M] [Fintype ι] {P : Submodule R M} (b : Basis ι R ↥P) {x : M} : x ∈ P ↔ ∃ c, x = ∑ i, c i • ↑(b i) - AddSubgroup.fintypeBot 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] : Fintype ↥⊥ - Subgroup.fintypeBot 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] : Fintype ↥⊥ - AddSubgroup.instFintypeSubtypeMemOfDecidablePred 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] (K : AddSubgroup G) [DecidablePred fun x => x ∈ K] [Fintype G] : Fintype ↥K - Subgroup.instFintypeSubtypeMemOfDecidablePred 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] (K : Subgroup G) [DecidablePred fun x => x ∈ K] [Fintype G] : Fintype ↥K - AddMonoidHom.fintypeRange 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] {N : Type u_3} [AddGroup N] [Fintype G] [DecidableEq N] (f : G →+ N) : Fintype ↥f.range - MonoidHom.fintypeRange 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] {N : Type u_3} [Group N] [Fintype G] [DecidableEq N] (f : G →* N) : Fintype ↥f.range - AddMonoidHom.fintypeMrange 📋 Mathlib.Algebra.Group.Subgroup.Finite
{M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] [Fintype M] [DecidableEq N] (f : M →+ N) : Fintype ↥(AddMonoidHom.mrange f) - MonoidHom.fintypeMrange 📋 Mathlib.Algebra.Group.Subgroup.Finite
{M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] [Fintype M] [DecidableEq N] (f : M →* N) : Fintype ↥(MonoidHom.mrange f) - AddSubgroup.instFintypeSubtypeMemOfDecidablePred.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] (K : AddSubgroup G) [DecidablePred fun x => x ∈ K] [Fintype G] : K.instFintypeSubtypeMemOfDecidablePred = inferInstance - Subgroup.instFintypeSubtypeMemOfDecidablePred.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] (K : Subgroup G) [DecidablePred fun x => x ∈ K] [Fintype G] : K.instFintypeSubtypeMemOfDecidablePred = inferInstance - Fintype.card_coeSort_range 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] {N : Type u_3} [Group N] [Fintype G] [DecidableEq N] {f : G →* N} (hf : Function.Injective ⇑f) : Fintype.card ↥f.range = Fintype.card G - AddMonoidHom.fintypeRange.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] {N : Type u_3} [AddGroup N] [Fintype G] [DecidableEq N] (f : G →+ N) : f.fintypeRange = Set.fintypeRange ⇑f - MonoidHom.fintypeRange.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] {N : Type u_3} [Group N] [Fintype G] [DecidableEq N] (f : G →* N) : f.fintypeRange = Set.fintypeRange ⇑f - Fintype.card_coeSort_mrange 📋 Mathlib.Algebra.Group.Subgroup.Finite
{M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] [Fintype M] [DecidableEq N] {f : M →* N} (hf : Function.Injective ⇑f) : Fintype.card ↥(MonoidHom.mrange f) = Fintype.card M - AddMonoidHom.fintypeMrange.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] [Fintype M] [DecidableEq N] (f : M →+ N) : f.fintypeMrange = Set.fintypeRange ⇑f - MonoidHom.fintypeMrange.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] [Fintype M] [DecidableEq N] (f : M →* N) : f.fintypeMrange = Set.fintypeRange ⇑f - AddSubgroup.fintypeBot.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [AddGroup G] : AddSubgroup.fintypeBot = { elems := {0}, complete := ⋯ } - Subgroup.fintypeBot.eq_1 📋 Mathlib.Algebra.Group.Subgroup.Finite
{G : Type u_1} [Group G] : Subgroup.fintypeBot = { elems := {1}, complete := ⋯ } - AddGroup.fintypeOfKerOfCodom 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{G H : Type u} [AddGroup G] [AddGroup H] [Fintype H] (g : G →+ H) [Fintype ↥g.ker] : Fintype G - Group.fintypeOfKerOfCodom 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{G H : Type u} [Group G] [Group H] [Fintype H] (g : G →* H) [Fintype ↥g.ker] : Fintype G - AddGroup.fintypeOfKerOfCodom.eq_1 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{G H : Type u} [AddGroup G] [AddGroup H] [Fintype H] (g : G →+ H) [Fintype ↥g.ker] : AddGroup.fintypeOfKerOfCodom g = AddGroup.fintypeOfKerLeRange (AddSubgroup.topEquiv.toAddMonoidHom.comp (AddSubgroup.inclusion ⋯)) g ⋯ - Group.fintypeOfKerOfCodom.eq_1 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{G H : Type u} [Group G] [Group H] [Fintype H] (g : G →* H) [Fintype ↥g.ker] : Group.fintypeOfKerOfCodom g = Group.fintypeOfKerLeRange (Subgroup.topEquiv.toMonoidHom.comp (Subgroup.inclusion ⋯)) g ⋯ - AddGroup.fintypeOfKerLeRange.eq_1 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{F G H : Type u} [AddGroup F] [AddGroup G] [AddGroup H] [Fintype F] [Fintype H] (f : F →+ G) (g : G →+ H) (h : g.ker ≤ f.range) : AddGroup.fintypeOfKerLeRange f g h = Fintype.ofEquiv ((G ⧸ g.ker) × ↥g.ker) AddSubgroup.addGroupEquivQuotientProdAddSubgroup.symm - Group.fintypeOfKerLeRange.eq_1 📋 Mathlib.GroupTheory.QuotientGroup.Finite
{F G H : Type u} [Group F] [Group G] [Group H] [Fintype F] [Fintype H] (f : F →* G) (g : G →* H) (h : g.ker ≤ f.range) : Group.fintypeOfKerLeRange f g h = Fintype.ofEquiv ((G ⧸ g.ker) × ↥g.ker) Subgroup.groupEquivQuotientProdSubgroup.symm - Basis.card_le_card_of_submodule 📋 Mathlib.LinearAlgebra.Dimension.StrongRankCondition
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] {ι : Type w} {ι' : Type w'} [StrongRankCondition R] (N : Submodule R M) [Fintype ι] (b : Basis ι R M) [Fintype ι'] (b' : Basis ι' R ↥N) : Fintype.card ι' ≤ Fintype.card ι - Module.instFintypeElemExtendOfFiniteSubtypeMemSubmoduleSpan 📋 Mathlib.LinearAlgebra.Dimension.StrongRankCondition
{R : Type u_1} {M : Type u_2} [DivisionRing R] [AddCommGroup M] [Module R M] {s t : Set M} [Module.Finite R ↥(Submodule.span R t)] (hs : LinearIndepOn R id s) (hst : s ⊆ t) : Fintype ↑(hs.extend hst) - Basis.card_le_card_of_le 📋 Mathlib.LinearAlgebra.Dimension.StrongRankCondition
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] {ι : Type w} {ι' : Type w'} [StrongRankCondition R] {N O : Submodule R M} (hNO : N ≤ O) [Fintype ι] (b : Basis ι R ↥O) [Fintype ι'] (b' : Basis ι' R ↥N) : Fintype.card ι' ≤ Fintype.card ι - Ideal.rank_eq 📋 Mathlib.LinearAlgebra.Dimension.StrongRankCondition
{R : Type u_1} {S : Type u_2} [CommRing R] [StrongRankCondition R] [Ring S] [IsDomain S] [Algebra R S] {n : Type u_3} {m : Type u_4} [Fintype n] [Fintype m] (b : Basis n R S) {I : Ideal S} (hI : I ≠ ⊥) (c : Basis m R ↥I) : Fintype.card m = Fintype.card n - Sym.equivNatSumOfFintype 📋 Mathlib.Data.Finsupp.Multiset
(α : Type u_1) [DecidableEq α] (n : ℕ) [Fintype α] : Sym α n ≃ { P // ∑ i, P i = n } - Sym.coe_equivNatSumOfFintype_apply_apply 📋 Mathlib.Data.Finsupp.Multiset
(α : Type u_1) [DecidableEq α] (n : ℕ) [Fintype α] (s : Sym α n) (a : α) : ↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s - Sym.coe_equivNatSumOfFintype_symm_apply 📋 Mathlib.Data.Finsupp.Multiset
(α : Type u_1) [DecidableEq α] (n : ℕ) [Fintype α] (P : { P // ∑ i, P i = n }) : ↑((Sym.equivNatSumOfFintype α n).symm P) = ∑ a, ↑P a • {a} - finrank_span_le_card 📋 Mathlib.LinearAlgebra.Dimension.Constructions
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] [StrongRankCondition R] (s : Set M) [Fintype ↑s] : Module.finrank R ↥(Submodule.span R s) ≤ s.toFinset.card - finrank_span_set_eq_card 📋 Mathlib.LinearAlgebra.Dimension.Constructions
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] [StrongRankCondition R] {s : Set M} [Fintype ↑s] (hs : LinearIndepOn R id s) : Module.finrank R ↥(Submodule.span R s) = s.toFinset.card - finrank_span_eq_card 📋 Mathlib.LinearAlgebra.Dimension.Constructions
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] [StrongRankCondition R] [Nontrivial R] {ι : Type u_2} [Fintype ι] {b : ι → M} (hb : LinearIndependent R b) : Module.finrank R ↥(Submodule.span R (Set.range b)) = Fintype.card ι - span_lt_of_subset_of_card_lt_finrank 📋 Mathlib.LinearAlgebra.Dimension.Constructions
{R : Type u} {M : Type v} [Semiring R] [AddCommMonoid M] [Module R M] [StrongRankCondition R] {s : Set M} [Fintype ↑s] {t : Submodule R M} (subset : s ⊆ ↑t) (card_lt : s.toFinset.card < Module.finrank R ↥t) : Submodule.span R s < t - iSupIndep.fintypeNeBotOfFiniteDimensional 📋 Mathlib.LinearAlgebra.Dimension.Finite
{R : Type u} {M : Type v} {ι : Type w} [Ring R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M] [Module.Finite R M] [StrongRankCondition R] {p : ι → Submodule R M} (hp : iSupIndep p) : Fintype { i // p i ≠ ⊥ } - iSupIndep.subtype_ne_bot_le_finrank 📋 Mathlib.LinearAlgebra.Dimension.Finite
{R : Type u} {M : Type v} {ι : Type w} [Ring R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M] [Module.Finite R M] [StrongRankCondition R] {p : ι → Submodule R M} (hp : iSupIndep p) [Fintype { i // p i ≠ ⊥ }] : Fintype.card { i // p i ≠ ⊥ } ≤ Module.finrank R M - fintypeNodupList 📋 Mathlib.Data.Fintype.List
{α : Type u_1} [Fintype α] : Fintype { l // l.Nodup } - Cycle.fintypeNodupCycle 📋 Mathlib.Data.List.Cycle
{α : Type u_1} [DecidableEq α] [Fintype α] : Fintype { s // s.Nodup } - Cycle.fintypeNodupNontrivialCycle 📋 Mathlib.Data.List.Cycle
{α : Type u_1} [DecidableEq α] [Fintype α] : Fintype { s // s.Nodup ∧ s.Nontrivial } - AddAction.card_orbit_mul_card_stabilizer_eq_card_addGroup 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) {β : Type v} [AddGroup α] [AddAction α β] (b : β) [Fintype α] [Fintype ↑(AddAction.orbit α b)] [Fintype ↥(AddAction.stabilizer α b)] : Fintype.card ↑(AddAction.orbit α b) * Fintype.card ↥(AddAction.stabilizer α b) = Fintype.card α - MulAction.card_orbit_mul_card_stabilizer_eq_card_group 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) {β : Type v} [Group α] [MulAction α β] (b : β) [Fintype α] [Fintype ↑(MulAction.orbit α b)] [Fintype ↥(MulAction.stabilizer α b)] : Fintype.card ↑(MulAction.orbit α b) * Fintype.card ↥(MulAction.stabilizer α b) = Fintype.card α - AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) (β : Type v) [AddGroup α] [AddAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (AddAction.orbitRel α β))] [(b : β) → Fintype ↥(AddAction.stabilizer α b)] : Fintype.card β = ∑ ω, Fintype.card α / Fintype.card ↥(AddAction.stabilizer α ω.out) - MulAction.card_eq_sum_card_group_div_card_stabilizer 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) (β : Type v) [Group α] [MulAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (MulAction.orbitRel α β))] [(b : β) → Fintype ↥(MulAction.stabilizer α b)] : Fintype.card β = ∑ ω, Fintype.card α / Fintype.card ↥(MulAction.stabilizer α ω.out) - AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer' 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) (β : Type v) [AddGroup α] [AddAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (AddAction.orbitRel α β))] [(b : β) → Fintype ↥(AddAction.stabilizer α b)] {φ : Quotient (AddAction.orbitRel α β) → β} (hφ : Function.LeftInverse Quotient.mk'' φ) : Fintype.card β = ∑ ω, Fintype.card α / Fintype.card ↥(AddAction.stabilizer α (φ ω)) - MulAction.card_eq_sum_card_group_div_card_stabilizer' 📋 Mathlib.GroupTheory.GroupAction.Quotient
(α : Type u) (β : Type v) [Group α] [MulAction α β] [Fintype α] [Fintype β] [Fintype (Quotient (MulAction.orbitRel α β))] [(b : β) → Fintype ↥(MulAction.stabilizer α b)] {φ : Quotient (MulAction.orbitRel α β) → β} (hφ : Function.LeftInverse Quotient.mk'' φ) : Fintype.card β = ∑ ω, Fintype.card α / Fintype.card ↥(MulAction.stabilizer α (φ ω)) - ConjClasses.card_carrier 📋 Mathlib.GroupTheory.GroupAction.Quotient
{G : Type u_1} [Group G] [Fintype G] (g : G) [Fintype ↑(ConjClasses.mk g).carrier] [Fintype ↥(MulAction.stabilizer (ConjAct G) g)] : Fintype.card ↑(ConjClasses.mk g).carrier = Fintype.card G / Fintype.card ↥(MulAction.stabilizer (ConjAct G) g) - Fintype.card_zmultiples 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [AddGroup G] [Fintype G] {x : G} : Fintype.card ↥(AddSubgroup.zmultiples x) = addOrderOf x - Fintype.card_zpowers 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [Group G] [Fintype G] {x : G} : Fintype.card ↥(Subgroup.zpowers x) = orderOf x - addOrderOf_eq_card_multiples 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [AddLeftCancelMonoid G] [Fintype G] {x : G} : addOrderOf x = Fintype.card ↥(AddSubmonoid.multiples x) - orderOf_eq_card_powers 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [LeftCancelMonoid G] [Fintype G] {x : G} : orderOf x = Fintype.card ↥(Submonoid.powers x) - card_zmultiples_le 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [AddGroup G] [Fintype G] (a : G) {k : ℕ} (k_pos : k ≠ 0) (ha : k • a = 0) : Fintype.card ↥(AddSubgroup.zmultiples a) ≤ k - card_zpowers_le 📋 Mathlib.GroupTheory.OrderOfElement
{G : Type u_1} [Group G] [Fintype G] (a : G) {k : ℕ} (k_pos : k ≠ 0) (ha : a ^ k = 1) : Fintype.card ↥(Subgroup.zpowers a) ≤ k - RingHom.fintypeFieldRange 📋 Mathlib.Algebra.Field.Subfield.Basic
{K : Type u} {L : Type v} [DivisionRing K] [DivisionRing L] [Fintype K] [DecidableEq L] (f : K →+* L) : Fintype ↥f.fieldRange - Matrix.toBlock_mul_eq_mul 📋 Mathlib.Data.Matrix.Block
{R : Type u_10} [CommRing R] {m : Type u_14} {n : Type u_15} {k : Type u_16} [Fintype n] (p : m → Prop) (q : k → Prop) (A : Matrix m n R) (B : Matrix n k R) : (A * B).toBlock p q = A.toBlock p ⊤ * B.toBlock ⊤ q - Matrix.toBlock_mul_eq_add 📋 Mathlib.Data.Matrix.Block
{R : Type u_10} [CommRing R] {m : Type u_14} {n : Type u_15} {k : Type u_16} [Fintype n] (p : m → Prop) (q : n → Prop) [DecidablePred q] (r : k → Prop) (A : Matrix m n R) (B : Matrix n k R) : (A * B).toBlock p r = A.toBlock p q * B.toBlock q r + (A.toBlock p fun i => ¬q i) * B.toBlock (fun i => ¬q i) r - Equiv.Perm.card_support_extend_domain 📋 Mathlib.GroupTheory.Perm.Support
{α : Type u_1} [DecidableEq α] [Fintype α] {β : Type u_2} [DecidableEq β] [Fintype β] {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) {g : Equiv.Perm α} : (g.extendDomain f).support.card = g.support.card - Equiv.Perm.support_extend_domain 📋 Mathlib.GroupTheory.Perm.Support
{α : Type u_1} [DecidableEq α] [Fintype α] {β : Type u_2} [DecidableEq β] [Fintype β] {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) {g : Equiv.Perm α} : (g.extendDomain f).support = Finset.map f.asEmbedding g.support - Equiv.Perm.support_ofSubtype 📋 Mathlib.GroupTheory.Perm.Support
{α : Type u_1} [DecidableEq α] [Fintype α] {p : α → Prop} [DecidablePred p] (u : Equiv.Perm (Subtype p)) : (Equiv.Perm.ofSubtype u).support = Finset.map (Function.Embedding.subtype p) u.support - Equiv.Perm.ofSubtype_eq_iff 📋 Mathlib.GroupTheory.Perm.Support
{α : Type u_1} [DecidableEq α] [Fintype α] {g c : Equiv.Perm α} {s : Finset α} (hg : ∀ (x : α), x ∈ s ↔ g x ∈ s) : Equiv.Perm.ofSubtype (g.subtypePerm hg) = c ↔ c.support ≤ s ∧ ∀ (hc' : ∀ (x : α), x ∈ s ↔ c x ∈ s), c.subtypePerm hc' = g.subtypePerm hg - Fintype.chooseX 📋 Mathlib.Data.Fintype.Inv
{α : Type u_1} [Fintype α] (p : α → Prop) [DecidablePred p] (hp : ∃! a, p a) : { a // p a } - Fintype.choose_subtype_eq 📋 Mathlib.Data.Fintype.Inv
{α : Type u_4} (p : α → Prop) [Fintype { a // p a }] [DecidableEq α] (x : { a // p a }) (h : ∃! a, ↑a = ↑x := ⋯) : Fintype.choose (fun y => ↑y = ↑x) h = x - Equiv.Perm.ofSubtype_support_disjoint 📋 Mathlib.GroupTheory.Perm.Finite
{α : Type u} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (x : Equiv.Perm ↑(Function.fixedPoints ⇑σ)) : Disjoint (Equiv.Perm.ofSubtype x).support σ.support - Equiv.Perm.isConj_of_support_equiv 📋 Mathlib.GroupTheory.Perm.Finite
{α : Type u} [DecidableEq α] [Fintype α] {σ τ : Equiv.Perm α} (f : { x // x ∈ ↑σ.support } ≃ { x // x ∈ ↑τ.support }) (hf : ∀ (x : α) (hx : x ∈ ↑σ.support), ↑(f ⟨σ x, ⋯⟩) = τ ↑(f ⟨x, hx⟩)) : IsConj σ τ - Equiv.Perm.truncSwapFactors 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) : Trunc { l // l.prod = f ∧ ∀ g ∈ l, g.IsSwap } - Equiv.Perm.swapFactors 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] [Fintype α] [LinearOrder α] (f : Equiv.Perm α) : { l // l.prod = f ∧ ∀ g ∈ l, g.IsSwap } - Equiv.Perm.sign_extendDomain 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] {β : Type v} [Fintype α] [DecidableEq β] [Fintype β] (e : Equiv.Perm α) {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) : Equiv.Perm.sign (e.extendDomain f) = Equiv.Perm.sign e - Equiv.Perm.sign_subtypePerm 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) {p : α → Prop} [DecidablePred p] (h₁ : ∀ (x : α), p x ↔ p (f x)) (h₂ : ∀ (x : α), f x ≠ x → p x) : Equiv.Perm.sign (f.subtypePerm h₁) = Equiv.Perm.sign f - Equiv.Perm.sign_ofSubtype 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] [Fintype α] {p : α → Prop} [DecidablePred p] (f : Equiv.Perm (Subtype p)) : Equiv.Perm.sign (Equiv.Perm.ofSubtype f) = Equiv.Perm.sign f - Equiv.Perm.sign_subtypeCongr 📋 Mathlib.GroupTheory.Perm.Sign
{α : Type u} [DecidableEq α] [Fintype α] {p : α → Prop} [DecidablePred p] (ep : Equiv.Perm { a // p a }) (en : Equiv.Perm { a // ¬p a }) : Equiv.Perm.sign (ep.subtypeCongr en) = Equiv.Perm.sign ep * Equiv.Perm.sign en - Equiv.Perm.subtypePermOfSupport 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] (c : Equiv.Perm α) : Equiv.Perm { x // x ∈ c.support } - Equiv.Perm.subtypePerm_of_support_le 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] (c : Equiv.Perm α) {s : Finset α} (hcs : c.support ⊆ s) : Equiv.Perm { x // x ∈ s } - Equiv.Perm.subtypePermOfSupport.eq_1 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] (c : Equiv.Perm α) : c.subtypePermOfSupport = c.subtypePerm ⋯ - Equiv.Perm.IsCycle.zpowersEquivSupport 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle) : ↥(Subgroup.zpowers σ) ≃ { x // x ∈ σ.support } - Equiv.Perm.IsCycle.commute_iff' 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] {g c : Equiv.Perm α} (hc : c.IsCycle) : Commute g c ↔ ∃ (hc' : ∀ (x : α), x ∈ c.support ↔ g x ∈ c.support), g.subtypePerm hc' ∈ Subgroup.zpowers c.subtypePermOfSupport - Equiv.Perm.IsCycle.commute_iff 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] {g c : Equiv.Perm α} (hc : c.IsCycle) : Commute g c ↔ ∃ (hc' : ∀ (x : α), x ∈ c.support ↔ g x ∈ c.support), Equiv.Perm.ofSubtype (g.subtypePerm hc') ∈ Subgroup.zpowers c - Equiv.Perm.zpow_eq_ofSubtype_subtypePerm_iff 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [Fintype α] [DecidableEq α] {g c : Equiv.Perm α} {s : Finset α} (hg : ∀ (x : α), x ∈ s ↔ g x ∈ s) (hc : c.support ⊆ s) (n : ℤ) : c ^ n = Equiv.Perm.ofSubtype (g.subtypePerm hg) ↔ c.subtypePerm ⋯ ^ n = g.subtypePerm hg - Equiv.Perm.IsCycle.zpowersEquivSupport_apply 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle) {n : ℕ} : hσ.zpowersEquivSupport ⟨σ ^ n, ⋯⟩ = ⟨(σ ^ n) (Classical.choose hσ), ⋯⟩ - Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply 📋 Mathlib.GroupTheory.Perm.Cycle.Basic
{α : Type u_2} [DecidableEq α] [Fintype α] {σ : Equiv.Perm α} (hσ : σ.IsCycle) (n : ℕ) : hσ.zpowersEquivSupport.symm ⟨(σ ^ n) (Classical.choose hσ), ⋯⟩ = ⟨σ ^ n, ⋯⟩ - AddMonoidHom.noncommPiCoprodEquiv 📋 Mathlib.GroupTheory.NoncommPiCoprod
{M : Type u_1} [AddMonoid M] {ι : Type u_2} [Fintype ι] {N : ι → Type u_3} [(i : ι) → AddMonoid (N i)] [DecidableEq ι] : { ϕ // Pairwise fun i j => ∀ (x : N i) (y : N j), AddCommute ((ϕ i) x) ((ϕ j) y) } ≃ (((i : ι) → N i) →+ M) - AddSubgroup.independent_of_coprime_order 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y) [Finite ι] [(i : ι) → Fintype ↥(H i)] (hcoprime : Pairwise fun i j => (Fintype.card ↥(H i)).Coprime (Fintype.card ↥(H j))) : iSupIndep H - MonoidHom.noncommPiCoprodEquiv 📋 Mathlib.GroupTheory.NoncommPiCoprod
{M : Type u_1} [Monoid M] {ι : Type u_2} [Fintype ι] {N : ι → Type u_3} [(i : ι) → Monoid (N i)] [DecidableEq ι] : { ϕ // Pairwise fun i j => ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y) } ≃ (((i : ι) → N i) →* M) - Subgroup.independent_of_coprime_order 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y) [Finite ι] [(i : ι) → Fintype ↥(H i)] (hcoprime : Pairwise fun i j => (Fintype.card ↥(H i)).Coprime (Fintype.card ↥(H j))) : iSupIndep H - AddSubgroup.noncommPiCoprod_range 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y} : (AddSubgroup.noncommPiCoprod hcomm).range = ⨆ i, H i - Subgroup.noncommPiCoprod_range 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y} : (Subgroup.noncommPiCoprod hcomm).range = ⨆ i, H i - AddSubgroup.noncommPiCoprod 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y) : ((i : ι) → ↥(H i)) →+ G - Subgroup.noncommPiCoprod 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y) : ((i : ι) → ↥(H i)) →* G - AddSubgroup.noncommPiCoprod.eq_1 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y) : AddSubgroup.noncommPiCoprod hcomm = AddMonoidHom.noncommPiCoprod (fun i => (H i).subtype) ⋯ - Subgroup.noncommPiCoprod.eq_1 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] (hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y) : Subgroup.noncommPiCoprod hcomm = MonoidHom.noncommPiCoprod (fun i => (H i).subtype) ⋯ - AddSubgroup.injective_noncommPiCoprod_of_iSupIndep 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y} (hind : iSupIndep H) : Function.Injective ⇑(AddSubgroup.noncommPiCoprod hcomm) - Subgroup.injective_noncommPiCoprod_of_iSupIndep 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y} (hind : iSupIndep H) : Function.Injective ⇑(Subgroup.noncommPiCoprod hcomm) - AddSubgroup.noncommPiCoprod_single 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] [DecidableEq ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y} (i : ι) (y : ↥(H i)) : (AddSubgroup.noncommPiCoprod hcomm) (Pi.single i y) = ↑y - Subgroup.noncommPiCoprod_mulSingle 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] [DecidableEq ι] {hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y} (i : ι) (y : ↥(H i)) : (Subgroup.noncommPiCoprod hcomm) (Pi.mulSingle i y) = ↑y - AddSubgroup.noncommPiCoprod_apply 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [AddGroup G] {ι : Type u_2} {H : ι → AddSubgroup G} [Fintype ι] (comm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → AddCommute x y) (u : (i : ι) → ↥(H i)) : (AddSubgroup.noncommPiCoprod comm) u = Finset.univ.noncommSum (fun i => ↑(u i)) ⋯ - Subgroup.noncommPiCoprod_apply 📋 Mathlib.GroupTheory.NoncommPiCoprod
{G : Type u_1} [Group G] {ι : Type u_2} {H : ι → Subgroup G} [Fintype ι] (comm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y) (u : (i : ι) → ↥(H i)) : (Subgroup.noncommPiCoprod comm) u = Finset.univ.noncommProd (fun i => ↑(u i)) ⋯ - AddMonoidHom.noncommPiCoprodEquiv.eq_1 📋 Mathlib.GroupTheory.NoncommPiCoprod
{M : Type u_1} [AddMonoid M] {ι : Type u_2} [Fintype ι] {N : ι → Type u_3} [(i : ι) → AddMonoid (N i)] [DecidableEq ι] : AddMonoidHom.noncommPiCoprodEquiv = { toFun := fun ϕ => AddMonoidHom.noncommPiCoprod ↑ϕ ⋯, invFun := fun f => ⟨fun i => f.comp (AddMonoidHom.single N i), ⋯⟩, left_inv := ⋯, right_inv := ⋯ } - MonoidHom.noncommPiCoprodEquiv.eq_1 📋 Mathlib.GroupTheory.NoncommPiCoprod
{M : Type u_1} [Monoid M] {ι : Type u_2} [Fintype ι] {N : ι → Type u_3} [(i : ι) → Monoid (N i)] [DecidableEq ι] : MonoidHom.noncommPiCoprodEquiv = { toFun := fun ϕ => MonoidHom.noncommPiCoprod ↑ϕ ⋯, invFun := fun f => ⟨fun i => f.comp (MonoidHom.mulSingle N i), ⋯⟩, left_inv := ⋯, right_inv := ⋯ } - Equiv.Perm.cycleFactors 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [Fintype α] [LinearOrder α] (f : Equiv.Perm α) : { l // l.prod = f ∧ (∀ g ∈ l, g.IsCycle) ∧ List.Pairwise Equiv.Perm.Disjoint l } - Equiv.Perm.truncCycleFactors 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) : Trunc { l // l.prod = f ∧ (∀ g ∈ l, g.IsCycle) ∧ List.Pairwise Equiv.Perm.Disjoint l } - Equiv.Perm.subtypePerm_on_cycleFactorsFinset 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] {g c : Equiv.Perm α} (hc : c ∈ g.cycleFactorsFinset) : g.subtypePerm ⋯ = c.subtypePermOfSupport - Equiv.Perm.cycleFactorsAux 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (l : List α) (f : Equiv.Perm α) (h : ∀ {x : α}, f x ≠ x → x ∈ l) : { pl // pl.prod = f ∧ (∀ g ∈ pl, g.IsCycle) ∧ List.Pairwise Equiv.Perm.Disjoint pl } - Equiv.Perm.cycleFactorsAux.go 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) (l : List α) (g : Equiv.Perm α) (hg : ∀ {x : α}, g x ≠ x → x ∈ l) (hfg : ∀ {x : α}, g x ≠ x → f.cycleOf x = g.cycleOf x) : { pl // pl.prod = g ∧ (∀ g' ∈ pl, g'.IsCycle) ∧ List.Pairwise Equiv.Perm.Disjoint pl } - Equiv.Perm.zpow_apply_mem_support_of_mem_cycleFactorsFinset_iff 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] {g : Equiv.Perm α} {x : α} {m : ℤ} {c : { x // x ∈ g.cycleFactorsFinset }} : (g ^ m) x ∈ (↑c).support ↔ x ∈ (↑c).support - Equiv.Perm.support_zpowers_of_mem_cycleFactorsFinset_le 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] {g : Equiv.Perm α} {c : { x // x ∈ g.cycleFactorsFinset }} (v : ↥(Subgroup.zpowers ↑c)) : (↑v).support ≤ g.support - Equiv.Perm.pairwise_disjoint_of_mem_zpowers 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) : Pairwise fun i j => ∀ (x y : Equiv.Perm α), x ∈ Subgroup.zpowers ↑i → y ∈ Subgroup.zpowers ↑j → x.Disjoint y - Equiv.Perm.cycleFactorsFinset.eq_1 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) : f.cycleFactorsFinset = Trunc.lift (fun l => (↑l).toFinset) ⋯ f.truncCycleFactors - Equiv.Perm.pairwise_commute_of_mem_zpowers 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) : Pairwise fun i j => ∀ (x y : Equiv.Perm α), x ∈ Subgroup.zpowers ↑i → y ∈ Subgroup.zpowers ↑j → Commute x y - Equiv.Perm.commute_iff_of_mem_cycleFactorsFinset 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] {g k c : Equiv.Perm α} (hc : c ∈ g.cycleFactorsFinset) : Commute k c ↔ ∃ (hc' : ∀ (x : α), x ∈ c.support ↔ k x ∈ c.support), k.subtypePerm hc' ∈ Subgroup.zpowers (g.subtypePerm ⋯) - Equiv.Perm.IsCycle.forall_commute_iff 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (g z : Equiv.Perm α) : (∀ c ∈ g.cycleFactorsFinset, Commute z c) ↔ ∀ c ∈ g.cycleFactorsFinset, ∃ (hc : ∀ (x : α), x ∈ c.support ↔ z x ∈ c.support), Equiv.Perm.ofSubtype (z.subtypePerm hc) ∈ Subgroup.zpowers c - Equiv.Perm.disjoint_ofSubtype_noncommPiCoprod 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) (u : Equiv.Perm ↑(Function.fixedPoints ⇑f)) (v : (c : { x // x ∈ f.cycleFactorsFinset }) → ↥(Subgroup.zpowers ↑c)) : (Equiv.Perm.ofSubtype u).Disjoint ((Subgroup.noncommPiCoprod ⋯) v) - Equiv.Perm.commute_ofSubtype_noncommPiCoprod 📋 Mathlib.GroupTheory.Perm.Cycle.Factors
{α : Type u_2} [DecidableEq α] [Fintype α] (f : Equiv.Perm α) (u : Equiv.Perm ↑(Function.fixedPoints ⇑f)) (v : (c : { x // x ∈ f.cycleFactorsFinset }) → ↥(Subgroup.zpowers ↑c)) : Commute (Equiv.Perm.ofSubtype u) ((Subgroup.noncommPiCoprod ⋯) v) - Equiv.Perm.cycleType_extendDomain 📋 Mathlib.GroupTheory.Perm.Cycle.Type
{α : Type u_1} [Fintype α] [DecidableEq α] {β : Type u_2} [Fintype β] [DecidableEq β] {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) {g : Equiv.Perm α} : (g.extendDomain f).cycleType = g.cycleType - Equiv.Perm.cycleType_ofSubtype 📋 Mathlib.GroupTheory.Perm.Cycle.Type
{α : Type u_1} [Fintype α] [DecidableEq α] {p : α → Prop} [DecidablePred p] {g : Equiv.Perm (Subtype p)} : (Equiv.Perm.ofSubtype g).cycleType = g.cycleType - Equiv.Perm.subgroup_eq_top_of_swap_mem 📋 Mathlib.GroupTheory.Perm.Cycle.Type
{α : Type u_1} [Fintype α] [DecidableEq α] {H : Subgroup (Equiv.Perm α)} [d : DecidablePred fun x => x ∈ H] {τ : Equiv.Perm α} (h0 : Nat.Prime (Fintype.card α)) (h1 : Fintype.card α ∣ Fintype.card ↥H) (h2 : τ ∈ H) (h3 : τ.IsSwap) : H = ⊤ - Equiv.Perm.CycleType.count_def 📋 Mathlib.GroupTheory.Perm.Cycle.Type
{α : Type u_1} [Fintype α] [DecidableEq α] {σ : Equiv.Perm α} (n : ℕ) : Multiset.count n σ.cycleType = Fintype.card { c // (↑c).support.card = n } - setBasisOfTopLeSpanOfCardEqFinrank_repr_apply 📋 Mathlib.LinearAlgebra.Dimension.DivisionRing
{K : Type u} {V : Type v} [DivisionRing K] [AddCommGroup V] [Module K V] {s : Set V} [Fintype ↑s] (le_span : ⊤ ≤ Submodule.span K s) (card_eq : s.toFinset.card = Module.finrank K V) (a✝ : V) : (setBasisOfTopLeSpanOfCardEqFinrank le_span card_eq).repr a✝ = ⋯.repr ((LinearMap.codRestrict (Submodule.span K (Set.range Subtype.val)) LinearMap.id ⋯) a✝) - setBasisOfLinearIndependentOfCardEqFinrank 📋 Mathlib.LinearAlgebra.FiniteDimensional.Lemmas
{K : Type u} {V : Type v} [DivisionRing K] [AddCommGroup V] [Module K V] {s : Set V} [Nonempty ↑s] [Fintype ↑s] (lin_ind : LinearIndependent K Subtype.val) (card_eq : s.toFinset.card = Module.finrank K V) : Basis (↑s) K V
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 19971e9
serving mathlib revision e0654b0