Loogle!
Result
Found 14 declarations mentioning Cardinal.mk and Function.Injective.
- Cardinal.mk_le_of_injective 📋 Mathlib.SetTheory.Cardinal.Order
{α β : Type u} {f : α → β} (hf : Function.Injective f) : Cardinal.mk α ≤ Cardinal.mk β - Cardinal.lift_mk_le_lift_mk_of_injective 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} {f : α → β} (hf : Function.Injective f) : Cardinal.lift.{v, u} (Cardinal.mk α) ≤ Cardinal.lift.{u, v} (Cardinal.mk β) - Cardinal.mk_range_eq 📋 Mathlib.SetTheory.Cardinal.Basic
{α β : Type u} (f : α → β) (h : Function.Injective f) : Cardinal.mk ↑(Set.range f) = Cardinal.mk α - Cardinal.mk_range_eq_lift 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} {f : α → β} (hf : Function.Injective f) : Cardinal.lift.{max u w, v} (Cardinal.mk ↑(Set.range f)) = Cardinal.lift.{max v w, u} (Cardinal.mk α) - Cardinal.mk_range_eq_of_injective 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} {f : α → β} (hf : Function.Injective f) : Cardinal.lift.{u, v} (Cardinal.mk ↑(Set.range f)) = Cardinal.lift.{v, u} (Cardinal.mk α) - Cardinal.mk_image_eq 📋 Mathlib.SetTheory.Cardinal.Basic
{α β : Type u} {f : α → β} {s : Set α} (hf : Function.Injective f) : Cardinal.mk ↑(f '' s) = Cardinal.mk ↑s - Cardinal.mk_preimage_of_injective 📋 Mathlib.SetTheory.Cardinal.Basic
{α β : Type u} (f : α → β) (s : Set β) (h : Function.Injective f) : Cardinal.mk ↑(f ⁻¹' s) ≤ Cardinal.mk ↑s - Cardinal.mk_image_eq_lift 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} (f : α → β) (s : Set α) (h : Function.Injective f) : Cardinal.lift.{u, v} (Cardinal.mk ↑(f '' s)) = Cardinal.lift.{v, u} (Cardinal.mk ↑s) - Cardinal.mk_preimage_of_injective_lift 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} (f : α → β) (s : Set β) (h : Function.Injective f) : Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s)) ≤ Cardinal.lift.{u, v} (Cardinal.mk ↑s) - Cardinal.mk_preimage_of_injective_of_subset_range 📋 Mathlib.SetTheory.Cardinal.Basic
{α β : Type u} (f : α → β) (s : Set β) (h : Function.Injective f) (h2 : s ⊆ Set.range f) : Cardinal.mk ↑(f ⁻¹' s) = Cardinal.mk ↑s - Cardinal.mk_preimage_of_injective_of_subset_range_lift 📋 Mathlib.SetTheory.Cardinal.Basic
{α : Type u} {β : Type v} (f : α → β) (s : Set β) (h : Function.Injective f) (h2 : s ⊆ Set.range f) : Cardinal.lift.{v, u} (Cardinal.mk ↑(f ⁻¹' s)) = Cardinal.lift.{u, v} (Cardinal.mk ↑s) - card_le_of_injective'' 📋 Mathlib.LinearAlgebra.Dimension.StrongRankCondition
{R : Type u} [Semiring R] [StrongRankCondition R] {α β : Type v} (f : (α →₀ R) →ₗ[R] β →₀ R) (i : Function.Injective ⇑f) : Cardinal.mk α ≤ Cardinal.mk β - Submodule.spanRank_span_range_of_linearIndependent 📋 Mathlib.Algebra.Module.SpanRank
{R : Type u_1} {M : Type u} [Semiring R] [AddCommMonoid M] [Module R M] [RankCondition R] {ι : Type u} {v : ι → M} (hv : Function.Injective v) (hs : LinearIndependent R v) : (Submodule.span R (Set.range v)).spanRank = Cardinal.mk ι - Monoid.CoprodI.lift_injective_of_ping_pong 📋 Mathlib.GroupTheory.CoprodI
{ι : Type u_1} {G : Type u_4} [Group G] {H : ι → Type u_5} [(i : ι) → Group (H i)] (f : (i : ι) → H i →* G) (hcard : 3 ≤ Cardinal.mk ι ∨ ∃ i, 3 ≤ Cardinal.mk (H i)) {α : Type u_6} [MulAction G α] (X : ι → Set α) (hXnonempty : ∀ (i : ι), (X i).Nonempty) (hXdisj : Pairwise (Function.onFun Disjoint X)) (hpp : Pairwise fun i j => ∀ (h : H i), h ≠ 1 → (f i) h • X j ⊆ X i) [Nontrivial ι] : Function.Injective ⇑(Monoid.CoprodI.lift 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