Loogle!
Result
Found 21 declarations mentioning Fintype.card and Nat.card.
- Fintype.card_eq_nat_card 📋 Mathlib.SetTheory.Cardinal.Finite
{α : Type u_1} {x✝ : Fintype α} : Fintype.card α = Nat.card α - Nat.card_eq_fintype_card 📋 Mathlib.SetTheory.Cardinal.Finite
{α : Type u_1} [Fintype α] : Nat.card α = Fintype.card α - Nat.card_eq 📋 Mathlib.Data.Finite.Card
(α : Type u_4) : Nat.card α = if x : Finite α then Fintype.card α else 0 - tendsto_card_div_pow_atTop_volume 📋 Mathlib.Analysis.BoxIntegral.UnitPartition
{ι : Type u_1} [Fintype ι] (s : Set (ι → ℝ)) (hs₁ : Bornology.IsBounded s) (hs₂ : MeasurableSet s) (hs₃ : MeasureTheory.volume (frontier s) = 0) : Filter.Tendsto (fun n => ↑(Nat.card ↑(s ∩ (↑n)⁻¹ • ↑(Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))) / ↑n ^ Fintype.card ι) Filter.atTop (nhds (MeasureTheory.volume.real s)) - tendsto_card_div_pow_atTop_volume' 📋 Mathlib.Analysis.BoxIntegral.UnitPartition
{ι : Type u_1} [Fintype ι] (s : Set (ι → ℝ)) (hs₁ : Bornology.IsBounded s) (hs₂ : MeasurableSet s) (hs₃ : MeasureTheory.volume (frontier s) = 0) (hs₄ : ∀ ⦃x y : ℝ⦄, 0 < x → x ≤ y → x • s ⊆ y • s) : Filter.Tendsto (fun x => ↑(Nat.card ↑(s ∩ x⁻¹ • ↑(Submodule.span ℤ (Set.range ⇑(Pi.basisFun ℝ ι))))) / x ^ Fintype.card ι) Filter.atTop (nhds (MeasureTheory.volume.real s)) - ZLattice.covolume.tendsto_card_div_pow 📋 Mathlib.Algebra.Module.ZLattice.Covolume
{ι : Type u_1} [Fintype ι] (L : Submodule ℤ (ι → ℝ)) [DiscreteTopology ↥L] [IsZLattice ℝ L] (b : Basis ι ℤ ↥L) {s : Set (ι → ℝ)} (hs₁ : Bornology.IsBounded s) (hs₂ : MeasurableSet s) (hs₃ : MeasureTheory.volume (frontier s) = 0) : Filter.Tendsto (fun n => ↑(Nat.card ↑(s ∩ (↑n)⁻¹ • ↑L)) / ↑n ^ Fintype.card ι) Filter.atTop (nhds (MeasureTheory.volume.real s / ZLattice.covolume L MeasureTheory.volume)) - ZLattice.covolume.tendsto_card_le_div 📋 Mathlib.Algebra.Module.ZLattice.Covolume
{ι : Type u_1} [Fintype ι] (L : Submodule ℤ (ι → ℝ)) [DiscreteTopology ↥L] [IsZLattice ℝ L] {X : Set (ι → ℝ)} (hX : ∀ ⦃x : ι → ℝ⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • x ∈ X) {F : (ι → ℝ) → ℝ} (h₁ : ∀ (x : ι → ℝ) ⦃r : ℝ⦄, 0 ≤ r → F (r • x) = r ^ Fintype.card ι * F x) (h₂ : Bornology.IsBounded {x | x ∈ X ∧ F x ≤ 1}) (h₃ : MeasurableSet {x | x ∈ X ∧ F x ≤ 1}) (h₄ : MeasureTheory.volume (frontier {x | x ∈ X ∧ F x ≤ 1}) = 0) [Nonempty ι] : Filter.Tendsto (fun c => ↑(Nat.card ↑({x | x ∈ X ∧ F x ≤ c} ∩ ↑L)) / c) Filter.atTop (nhds (MeasureTheory.volume.real {x | x ∈ X ∧ F x ≤ 1} / ZLattice.covolume L MeasureTheory.volume)) - ZLattice.covolume.tendsto_card_div_pow'' 📋 Mathlib.Algebra.Module.ZLattice.Covolume
{E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {L : Submodule ℤ E} [DiscreteTopology ↥L] [IsZLattice ℝ L] {ι : Type u_2} [Fintype ι] (b : Basis ι ℤ ↥L) [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {s : Set E} (hs₁ : Bornology.IsBounded s) (hs₂ : MeasurableSet s) (hs₃ : MeasureTheory.volume (frontier (⇑(Basis.ofZLatticeBasis ℝ L b).equivFun '' s)) = 0) : Filter.Tendsto (fun n => ↑(Nat.card ↑(s ∩ (↑n)⁻¹ • ↑L)) / ↑n ^ Fintype.card ι) Filter.atTop (nhds (MeasureTheory.volume.real (⇑(Basis.ofZLatticeBasis ℝ L b).equivFun '' s))) - ZLattice.covolume.tendsto_card_le_div'' 📋 Mathlib.Algebra.Module.ZLattice.Covolume
{E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] {L : Submodule ℤ E} [DiscreteTopology ↥L] [IsZLattice ℝ L] {ι : Type u_2} [Fintype ι] (b : Basis ι ℤ ↥L) [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] [Nonempty ι] {X : Set E} (hX : ∀ ⦃x : E⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • x ∈ X) {F : E → ℝ} (h₁ : ∀ (x : E) ⦃r : ℝ⦄, 0 ≤ r → F (r • x) = r ^ Fintype.card ι * F x) (h₂ : Bornology.IsBounded {x | x ∈ X ∧ F x ≤ 1}) (h₃ : MeasurableSet {x | x ∈ X ∧ F x ≤ 1}) (h₄ : MeasureTheory.volume (frontier (⇑(Basis.ofZLatticeBasis ℝ L b).equivFun '' {x | x ∈ X ∧ F x ≤ 1})) = 0) : Filter.Tendsto (fun c => ↑(Nat.card ↑({x | x ∈ X ∧ F x ≤ c} ∩ ↑L)) / c) Filter.atTop (nhds (MeasureTheory.volume.real (⇑(Basis.ofZLatticeBasis ℝ L b).equivFun '' {x | x ∈ X ∧ F x ≤ 1}))) - SubAddAction.ofFixingAddSubgroup.append_left 📋 Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup
{M : Type u_1} {α : Type u_2} [AddGroup M] [AddAction M α] {n : ℕ} {s : Set α} [Finite ↑s] (x : Fin n ↪ ↥(SubAddAction.ofFixingAddSubgroup M s)) (i : Fin s.ncard) : let Hs := ⋯; (SubAddAction.ofFixingAddSubgroup.append x) (Fin.castAdd n i) = ↑((Classical.choice Hs) i) - SubMulAction.ofFixingSubgroup.append_left 📋 Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup
{M : Type u_1} {α : Type u_2} [Group M] [MulAction M α] {n : ℕ} {s : Set α} [Finite ↑s] (x : Fin n ↪ ↥(SubMulAction.ofFixingSubgroup M s)) (i : Fin s.ncard) : let Hs := ⋯; (SubMulAction.ofFixingSubgroup.append x) (Fin.castAdd n i) = ↑((Classical.choice Hs) i) - Equiv.Perm.card_isConj_eq 📋 Mathlib.GroupTheory.Perm.Centralizer
{α : Type u_1} [DecidableEq α] [Fintype α] (g : Equiv.Perm α) : Nat.card ↑{h | IsConj g h} = (Fintype.card α).factorial / ((Fintype.card α - g.cycleType.sum).factorial * g.cycleType.prod * ∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial) - Equiv.Perm.card_isConj_mul_eq 📋 Mathlib.GroupTheory.Perm.Centralizer
{α : Type u_1} [DecidableEq α] [Fintype α] (g : Equiv.Perm α) : Nat.card ↑{h | IsConj g h} * ((Fintype.card α - g.cycleType.sum).factorial * g.cycleType.prod * ∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial) = (Fintype.card α).factorial - Equiv.Perm.nat_card_centralizer 📋 Mathlib.GroupTheory.Perm.Centralizer
{α : Type u_1} [DecidableEq α] [Fintype α] (g : Equiv.Perm α) : Nat.card ↥(Subgroup.centralizer {g}) = (Fintype.card α - g.cycleType.sum).factorial * g.cycleType.prod * ∏ n ∈ g.cycleType.toFinset, (Multiset.count n g.cycleType).factorial - Basis.SmithNormalForm.toAddSubgroup_index_eq_pow_mul_prod 📋 Mathlib.LinearAlgebra.FreeModule.Int
{ι : Type u_1} {R : Type u_2} {M : Type u_3} {n : ℕ} [CommRing R] [AddCommGroup M] [Fintype ι] [Module R M] {N : Submodule R M} (snf : Basis.SmithNormalForm N ι n) : N.toAddSubgroup.index = Nat.card R ^ (Fintype.card ι - n) * ∏ i, (Submodule.toAddSubgroup (Ideal.span {snf.a i})).index - Matrix.card_GL_field 📋 Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card
{𝔽 : Type u_1} [Field 𝔽] [Fintype 𝔽] (n : ℕ) : Nat.card (GL (Fin n) 𝔽) = ∏ i, (Fintype.card 𝔽 ^ n - Fintype.card 𝔽 ^ ↑i) - card_linearIndependent 📋 Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card
{K : Type u_1} {V : Type u_2} [DivisionRing K] [AddCommGroup V] [Module K V] [Fintype K] [Finite V] {k : ℕ} (hk : k ≤ Module.finrank K V) : Nat.card { s // LinearIndependent K s } = ∏ i, (Fintype.card K ^ Module.finrank K V - Fintype.card K ^ ↑i) - CyclotomicCharacter.toZModPow_toFun 📋 Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter
{L : Type u} [CommRing L] [IsDomain L] (p : ℕ) [Fact (Nat.Prime p)] (g : L ≃+* L) [∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)] (n : ℕ) : (PadicInt.toZModPow n) (cyclotomicCharacter.toFun p g) = ↑((modularCyclotomicCharacter L ⋯) g) - cyclotomicCharacter.toZModPow_toFun 📋 Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter
{L : Type u} [CommRing L] [IsDomain L] (p : ℕ) [Fact (Nat.Prime p)] (g : L ≃+* L) [∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)] (n : ℕ) : (PadicInt.toZModPow n) (cyclotomicCharacter.toFun p g) = ↑((modularCyclotomicCharacter L ⋯) g) - CyclotomicCharacter.toZModPow 📋 Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter
{L : Type u} [CommRing L] [IsDomain L] (p : ℕ) [Fact (Nat.Prime p)] {n : ℕ} [∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)] (g : L ≃+* L) : (PadicInt.toZModPow n) ↑((cyclotomicCharacter L p) g) = ↑((modularCyclotomicCharacter L ⋯) g) - cyclotomicCharacter.toZModPow 📋 Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter
{L : Type u} [CommRing L] [IsDomain L] (p : ℕ) [Fact (Nat.Prime p)] {n : ℕ} [∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)] (g : L ≃+* L) : (PadicInt.toZModPow n) ↑((cyclotomicCharacter L p) g) = ↑((modularCyclotomicCharacter L ⋯) g)
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 07d4605
serving mathlib revision 2e2176e