Loogle!
Result
Found 15013 declarations mentioning Int. Of these, 32 have a name containing "Divisors".
- Lean.Grind.no_int_zero_divisors 📋 Init.Grind.Ring.Basic
{α : Type u} [Lean.Grind.IntModule α] [Lean.Grind.NoNatZeroDivisors α] {k : ℤ} {a : α} : k ≠ 0 → k • a = 0 → a = 0 - Lean.Grind.instNoNatZeroDivisorsInt 📋 Init.GrindInstances.Ring.Int
: Lean.Grind.NoNatZeroDivisors ℤ - IsAddTorsionFree.to_noZeroSMulDivisors_int 📋 Mathlib.Algebra.NoZeroSMulDivisors.Defs
{G : Type u_3} [AddGroup G] [IsAddTorsionFree G] : NoZeroSMulDivisors ℤ G - IsAddTorsionFree.of_noZeroSMulDivisors_int 📋 Mathlib.Algebra.NoZeroSMulDivisors.Defs
{G : Type u_3} [AddCommGroup G] : NoZeroSMulDivisors ℤ G → IsAddTorsionFree G - noZeroSMulDivisors_int_iff_isAddTorsionFree 📋 Mathlib.Algebra.NoZeroSMulDivisors.Defs
{G : Type u_3} [AddCommGroup G] : NoZeroSMulDivisors ℤ G ↔ IsAddTorsionFree G - NoZeroSMulDivisors.int_of_charZero 📋 Mathlib.Algebra.NoZeroSMulDivisors.Basic
(R : Type u_3) (M : Type u_4) [Ring R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M] [CharZero R] : NoZeroSMulDivisors ℤ M - Int.divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
(z : ℤ) : Finset (ℤ × ℤ) - Int.divisorsAntidiag_zero 📋 Mathlib.NumberTheory.Divisors
: Int.divisorsAntidiag 0 = ∅ - Int.map_prodComm_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{z : ℤ} : Finset.map (Equiv.prodComm ℤ ℤ).toEmbedding z.divisorsAntidiag = z.divisorsAntidiag - Int.swap_mem_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{xy : ℤ × ℤ} {z : ℤ} : xy.swap ∈ z.divisorsAntidiag ↔ xy ∈ z.divisorsAntidiag - Int.prodMk_mem_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{x y z : ℤ} (hz : z ≠ 0) : (x, y) ∈ z.divisorsAntidiag ↔ x * y = z - Int.neg_mem_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{xy : ℤ × ℤ} {z : ℤ} : -xy ∈ z.divisorsAntidiag ↔ xy ∈ z.divisorsAntidiag - Int.mem_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{z : ℤ} {xy : ℤ × ℤ} : xy ∈ z.divisorsAntidiag ↔ xy.1 * xy.2 = z ∧ z ≠ 0 - Int.divisorsAntidiag_neg 📋 Mathlib.NumberTheory.Divisors
{z : ℤ} : (-z).divisorsAntidiag = Finset.map ((Function.Embedding.refl ℤ).prodMap (Equiv.toEmbedding (Equiv.neg ℤ))) z.divisorsAntidiag - Int.map_neg_divisorsAntidiag 📋 Mathlib.NumberTheory.Divisors
{z : ℤ} : Finset.map (Equiv.toEmbedding (Equiv.neg (ℤ × ℤ))) z.divisorsAntidiag = z.divisorsAntidiag - Int.divisorsAntidiagonal_one 📋 Mathlib.NumberTheory.Divisors
: Int.divisorsAntidiag 1 = {(1, 1), (-1, -1)} - Int.divisorsAntidiag.eq_1 📋 Mathlib.NumberTheory.Divisors
(n : ℕ) : (Int.ofNat n).divisorsAntidiag = (Finset.map (Nat.castEmbedding.prodMap Nat.castEmbedding) n.divisorsAntidiagonal).disjUnion (Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ)))) n.divisorsAntidiagonal) ⋯ - Int.divisorsAntidiag_natCast 📋 Mathlib.NumberTheory.Divisors
(n : ℕ) : (↑n).divisorsAntidiag = (Finset.map (Nat.castEmbedding.prodMap Nat.castEmbedding) n.divisorsAntidiagonal).disjUnion (Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ)))) n.divisorsAntidiagonal) ⋯ - Int.divisorsAntidiag_ofNat 📋 Mathlib.NumberTheory.Divisors
(n : ℕ) : (OfNat.ofNat n).divisorsAntidiag = (Finset.map (Nat.castEmbedding.prodMap Nat.castEmbedding) n.divisorsAntidiagonal).disjUnion (Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ)))) n.divisorsAntidiagonal) ⋯ - Int.divisorsAntidiag_neg_natCast 📋 Mathlib.NumberTheory.Divisors
(n : ℕ) : (-↑n).divisorsAntidiag = (Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ)))) n.divisorsAntidiagonal).disjUnion (Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding) n.divisorsAntidiagonal) ⋯ - Int.divisorsAntidiagonal_three 📋 Mathlib.NumberTheory.Divisors
: Int.divisorsAntidiag 3 = {(1, 3), (3, 1), (-1, -3), (-3, -1)} - Int.divisorsAntidiagonal_two 📋 Mathlib.NumberTheory.Divisors
: Int.divisorsAntidiag 2 = {(1, 2), (2, 1), (-1, -2), (-2, -1)} - Int.divisorsAntidiag.eq_2 📋 Mathlib.NumberTheory.Divisors
(n : ℕ) : (Int.negSucc n).divisorsAntidiag = (Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ)))) (n + 1).divisorsAntidiagonal).disjUnion (Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding) (n + 1).divisorsAntidiagonal) ⋯ - Int.divisorsAntidiagonal_four 📋 Mathlib.NumberTheory.Divisors
: Int.divisorsAntidiag 4 = {(1, 4), (2, 2), (4, 1), (-1, -4), (-2, -2), (-4, -1)} - NumberField.RingOfIntegers.instIsLocalizationAlgebraMapSubmonoidIntNonZeroDivisors 📋 Mathlib.NumberTheory.NumberField.Basic
(K : Type u_1) [Field K] [NumberField K] : IsLocalization (Algebra.algebraMapSubmonoid (NumberField.RingOfIntegers K) (nonZeroDivisors ℤ)) K - IsDedekindDomain.HeightOneSpectrum.instNoZeroSMulDivisorsSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers 📋 Mathlib.RingTheory.DedekindDomain.AdicValuation
(R : Type u_1) [CommRing R] [IsDedekindDomain R] (K : Type u_2) [Field K] [Algebra R K] [IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) : NoZeroSMulDivisors R ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v) - Ideal.absNorm_ne_zero_iff_mem_nonZeroDivisors 📋 Mathlib.RingTheory.Ideal.Norm.AbsNorm
{S : Type u_1} [CommRing S] [Nontrivial S] [IsDedekindDomain S] [Module.Free ℤ S] [Module.Finite ℤ S] {I : Ideal S} : Ideal.absNorm I ≠ 0 ↔ I ∈ nonZeroDivisors (Ideal S) - Ideal.absNorm_pos_iff_mem_nonZeroDivisors 📋 Mathlib.RingTheory.Ideal.Norm.AbsNorm
{S : Type u_1} [CommRing S] [Nontrivial S] [IsDedekindDomain S] [Module.Free ℤ S] [Module.Finite ℤ S] {I : Ideal S} : 0 < Ideal.absNorm I ↔ I ∈ nonZeroDivisors (Ideal S) - Ideal.absNorm_ne_zero_of_nonZeroDivisors 📋 Mathlib.RingTheory.Ideal.Norm.AbsNorm
{S : Type u_1} [CommRing S] [Nontrivial S] [IsDedekindDomain S] [Module.Free ℤ S] [Module.Finite ℤ S] (I : ↥(nonZeroDivisors (Ideal S))) : Ideal.absNorm ↑I ≠ 0 - Ideal.absNorm_pos_of_nonZeroDivisors 📋 Mathlib.RingTheory.Ideal.Norm.AbsNorm
{S : Type u_1} [CommRing S] [Nontrivial S] [IsDedekindDomain S] [Module.Free ℤ S] [Module.Finite ℤ S] (I : ↥(nonZeroDivisors (Ideal S))) : 0 < Ideal.absNorm ↑I - NumberField.instIsLocalizedModuleIntSubtypeMemSubmoduleRingOfIntegersCoeToSubmoduleValFractionalIdealNonZeroDivisorsRestrictScalarsSubtype 📋 Mathlib.NumberTheory.NumberField.FractionalIdeal
(K : Type u_1) [Field K] [NumberField K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ) : IsLocalizedModule (nonZeroDivisors ℤ) (↑ℤ (↑↑I).subtype) - Zsqrtd.instNoZeroDivisorsCastInt 📋 Mathlib.NumberTheory.Zsqrtd.Basic
{d : ℕ} [dnsq : Zsqrtd.Nonsquare d] : NoZeroDivisors (ℤ√↑d)
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 6ff4759 serving mathlib revision abad10c