Loogle!
Result
Found 2167 declarations mentioning Rat. Of these, only the first 200 are shown.
- Rat π Init.Data.Rat.Basic
: Type - instDecidableEqRat π Init.Data.Rat.Basic
: DecidableEq β - instHashableRat π Init.Data.Rat.Basic
: Hashable β - instInhabitedRat π Init.Data.Rat.Basic
: Inhabited β - instReprRat π Init.Data.Rat.Basic
: Repr β - instToStringRat π Init.Data.Rat.Basic
: ToString β - Rat.ceil π Init.Data.Rat.Basic
(a : β) : β€ - Rat.den π Init.Data.Rat.Basic
(self : β) : β - Rat.floor π Init.Data.Rat.Basic
(a : β) : β€ - Rat.instAdd π Init.Data.Rat.Basic
: Add β - Rat.instDiv π Init.Data.Rat.Basic
: Div β - Rat.instIntCast π Init.Data.Rat.Basic
: IntCast β - Rat.instInv π Init.Data.Rat.Basic
: Inv β - Rat.instLE π Init.Data.Rat.Basic
: LE β - Rat.instLT π Init.Data.Rat.Basic
: LT β - Rat.instMax π Init.Data.Rat.Basic
: Max β - Rat.instMin π Init.Data.Rat.Basic
: Min β - Rat.instMul π Init.Data.Rat.Basic
: Mul β - Rat.instNatCast π Init.Data.Rat.Basic
: NatCast β - Rat.instNeg π Init.Data.Rat.Basic
: Neg β - Rat.instOfScientific π Init.Data.Rat.Basic
: OfScientific β - Rat.instSub π Init.Data.Rat.Basic
: Sub β - Rat.inv π Init.Data.Rat.Basic
(a : β) : β - Rat.isInt π Init.Data.Rat.Basic
(a : β) : Bool - Rat.neg π Init.Data.Rat.Basic
(a : β) : β - Rat.num π Init.Data.Rat.Basic
(self : β) : β€ - Rat.ofInt π Init.Data.Rat.Basic
(num : β€) : β - instHashableRat.hash π Init.Data.Rat.Basic
: β β UInt64 - mkRat π Init.Data.Rat.Basic
(num : β€) (den : β) : β - Rat.add π Init.Data.Rat.Basic
(a b : β) : β - Rat.blt π Init.Data.Rat.Basic
(a b : β) : Bool - Rat.div π Init.Data.Rat.Basic
: β β β β β - Rat.divInt π Init.Data.Rat.Basic
: β€ β β€ β β - Rat.instPowInt π Init.Data.Rat.Basic
: Pow β β€ - Rat.instPowNat π Init.Data.Rat.Basic
: Pow β β - Rat.mul π Init.Data.Rat.Basic
(a b : β) : β - Rat.pow π Init.Data.Rat.Basic
(q : β) (n : β) : β - Rat.sub π Init.Data.Rat.Basic
(a b : β) : β - Rat.zpow π Init.Data.Rat.Basic
(q : β) (i : β€) : β - Rat.instOfNat π Init.Data.Rat.Basic
{n : β} : OfNat β n - Rat.ofScientific π Init.Data.Rat.Basic
(m : β) (s : Bool) (e : β) : β - Rat.reduced π Init.Data.Rat.Basic
(self : β) : self.num.natAbs.Coprime self.den - instDecidableEqRat.decEq π Init.Data.Rat.Basic
(xβ xβΒΉ : β) : Decidable (xβ = xβΒΉ) - Rat.instDecidableLe π Init.Data.Rat.Basic
(a b : β) : Decidable (a β€ b) - Rat.instDecidableLt π Init.Data.Rat.Basic
(a b : β) : Decidable (a < b) - Rat.den_nz π Init.Data.Rat.Basic
(self : β) : self.den β 0 - Rat.den_pos π Init.Data.Rat.Basic
(self : β) : 0 < self.den - Rat.mk' π Init.Data.Rat.Basic
(num : β€) (den : β) (den_nz : den β 0 := by decide) (reduced : num.natAbs.Coprime den := by decide) : β - Rat.normalize π Init.Data.Rat.Basic
(num : β€) (den : β := 1) (den_nz : den β 0 := by decide) : β - Rat.maybeNormalize π Init.Data.Rat.Basic
(num : β€) (den g : β) (dvd_num : βg β£ num) (dvd_den : g β£ den) (den_nz : den / g β 0) (reduced : (num / βg).natAbs.Coprime (den / g)) : β - Rat.mk'.injEq π Init.Data.Rat.Basic
(num : β€) (den : β) (den_nz : den β 0 := by decide) (reduced : num.natAbs.Coprime den := by decide) (numβ : β€) (denβ : β) (den_nzβ : denβ β 0 := by decide) (reducedβ : numβ.natAbs.Coprime denβ := by decide) : ({ num := num, den := den, den_nz := den_nz, reduced := reduced } = { num := numβ, den := denβ, den_nz := den_nzβ, reduced := reducedβ }) = (num = numβ β§ den = denβ) - Rat.mk'.sizeOf_spec π Init.Data.Rat.Basic
(num : β€) (den : β) (den_nz : den β 0 := by decide) (reduced : num.natAbs.Coprime den := by decide) : sizeOf { num := num, den := den, den_nz := den_nz, reduced := reduced } = 1 + sizeOf num + sizeOf den + sizeOf reduced - Rat.add.aux π Init.Data.Rat.Basic
(a b : β) {g ad bd : β} (hg : g = a.den.gcd b.den) (had : ad = a.den / g) (hbd : bd = b.den / g) : have den := ad * b.den; have num := a.num * βbd + b.num * βad; num.natAbs.gcd g = num.natAbs.gcd den - Rat.sub.aux π Init.Data.Rat.Basic
(a b : β) {g ad bd : β} (hg : g = a.den.gcd b.den) (had : ad = a.den / g) (hbd : bd = b.den / g) : have den := ad * b.den; have num := a.num * βbd - b.num * βad; num.natAbs.gcd g = num.natAbs.gcd den - Rat.le_refl π Init.Data.Rat.Lemmas
{a : β} : a β€ a - Rat.lt_irrefl π Init.Data.Rat.Lemmas
{a : β} : Β¬a < a - Rat.ceil_intCast π Init.Data.Rat.Lemmas
(a : β€) : (βa).ceil = a - Rat.floor_intCast π Init.Data.Rat.Lemmas
(a : β€) : (βa).floor = a - Rat.intCast_num π Init.Data.Rat.Lemmas
(a : β€) : (βa).num = a - Rat.mkRat_self π Init.Data.Rat.Lemmas
(a : β) : mkRat a.num a.den = a - Rat.num_intCast π Init.Data.Rat.Lemmas
(a : β€) : (βa).num = a - Rat.floor_le π Init.Data.Rat.Lemmas
(a : β) : βa.floor β€ a - Rat.neg_den π Init.Data.Rat.Lemmas
(a : β) : (-a).den = a.den - Rat.inv_inv π Init.Data.Rat.Lemmas
(a : β) : aβ»ΒΉβ»ΒΉ = a - Rat.ne_of_gt π Init.Data.Rat.Lemmas
{a b : β} (ha : a < b) : b β a - Rat.ne_of_lt π Init.Data.Rat.Lemmas
{a b : β} (ha : a < b) : a β b - Rat.normalize_self π Init.Data.Rat.Lemmas
(r : β) : Rat.normalize r.num r.den β― = r - Rat.divInt_self π Init.Data.Rat.Lemmas
(a : β) : Rat.divInt a.num βa.den = a - Rat.le_of_lt π Init.Data.Rat.Lemmas
{a b : β} (ha : a < b) : a β€ b - Rat.num_divInt_den π Init.Data.Rat.Lemmas
(a : β) : Rat.divInt a.num βa.den = a - Rat.num_natCast π Init.Data.Rat.Lemmas
(n : β) : (βn).num = βn - Rat.ceil_eq_neg_floor_neg π Init.Data.Rat.Lemmas
(a : β) : a.ceil = -(-a).floor - Rat.den_intCast π Init.Data.Rat.Lemmas
(a : β€) : (βa).den = 1 - Rat.den_natCast π Init.Data.Rat.Lemmas
(n : β) : (βn).den = 1 - Rat.divInt_ofNat π Init.Data.Rat.Lemmas
(num : β€) (den : β) : Rat.divInt num βden = mkRat num den - Rat.intCast_den π Init.Data.Rat.Lemmas
(a : β€) : (βa).den = 1 - Rat.inv_divInt π Init.Data.Rat.Lemmas
(n d : β€) : (Rat.divInt n d)β»ΒΉ = Rat.divInt d n - Rat.le_total π Init.Data.Rat.Lemmas
{a b : β} : a β€ b β¨ b β€ a - Rat.natCast_nonneg π Init.Data.Rat.Lemmas
{a : β} : 0 β€ βa - Rat.neg_num π Init.Data.Rat.Lemmas
(a : β) : (-a).num = -a.num - Rat.one_den π Init.Data.Rat.Lemmas
: Rat.den 1 = 1 - Rat.one_num π Init.Data.Rat.Lemmas
: Rat.num 1 = 1 - Rat.zero_den π Init.Data.Rat.Lemmas
: Rat.den 0 = 1 - Rat.zero_num π Init.Data.Rat.Lemmas
: Rat.num 0 = 0 - Rat.divInt.eq_1 π Init.Data.Rat.Lemmas
(xβ : β€) (d : β) : Rat.divInt xβ (Int.ofNat d) = inline (mkRat xβ d) - Rat.floor_monotone π Init.Data.Rat.Lemmas
{a b : β} (h : a β€ b) : a.floor β€ b.floor - Rat.intCast_natCast π Init.Data.Rat.Lemmas
(n : β) : ββn = βn - Rat.not_le π Init.Data.Rat.Lemmas
{a b : β} : Β¬a β€ b β b < a - Rat.not_lt π Init.Data.Rat.Lemmas
{a b : β} : Β¬a < b β b β€ a - Rat.ofInt_ofNat π Init.Data.Rat.Lemmas
{n : β} : Rat.ofInt (OfNat.ofNat n) = OfNat.ofNat n - Rat.instLE.eq_1 π Init.Data.Rat.Lemmas
: Rat.instLE = { le := fun a b => b.blt a = false } - Rat.den_ofNat π Init.Data.Rat.Lemmas
{n : β} : (OfNat.ofNat n).den = 1 - Rat.num_ofNat π Init.Data.Rat.Lemmas
{n : β} : (OfNat.ofNat n).num = OfNat.ofNat n - Rat.ofNat_den π Init.Data.Rat.Lemmas
{n : β} : (OfNat.ofNat n).den = 1 - Rat.ofNat_num π Init.Data.Rat.Lemmas
{n : β} : (OfNat.ofNat n).num = OfNat.ofNat n - Rat.divInt_zero π Init.Data.Rat.Lemmas
(n : β€) : Rat.divInt n 0 = 0 - Rat.intCast_one π Init.Data.Rat.Lemmas
: β1 = 1 - Rat.intCast_zero π Init.Data.Rat.Lemmas
: β0 = 0 - Rat.inv_def π Init.Data.Rat.Lemmas
(a : β) : aβ»ΒΉ = Rat.divInt (βa.den) a.num - Rat.inv_zero π Init.Data.Rat.Lemmas
: 0β»ΒΉ = 0 - Rat.mkRat_zero π Init.Data.Rat.Lemmas
(n : β€) : mkRat n 0 = 0 - Rat.zero_divInt π Init.Data.Rat.Lemmas
(n : β€) : Rat.divInt 0 n = 0 - Rat.zero_mkRat π Init.Data.Rat.Lemmas
(n : β) : mkRat 0 n = 0 - Rat.divInt_neg' π Init.Data.Rat.Lemmas
(num den : β€) : Rat.divInt num (-den) = Rat.divInt (-num) den - Rat.le_antisymm π Init.Data.Rat.Lemmas
{a b : β} (hab : a β€ b) (hba : b β€ a) : a = b - Rat.lt_of_le_of_ne π Init.Data.Rat.Lemmas
{a b : β} (ha : a β€ b) (hb : a β b) : a < b - Rat.neg_divInt π Init.Data.Rat.Lemmas
(n d : β€) : -Rat.divInt n d = Rat.divInt (-n) d - Rat.neg_divInt_neg π Init.Data.Rat.Lemmas
(num den : β€) : Rat.divInt (-num) (-den) = Rat.divInt num den - Rat.neg_mkRat π Init.Data.Rat.Lemmas
(n : β€) (d : β) : -mkRat n d = mkRat (-n) d - Rat.intCast_ofNat π Init.Data.Rat.Lemmas
{a : β} : β(OfNat.ofNat a) = OfNat.ofNat a - Rat.natCast_ofNat π Init.Data.Rat.Lemmas
{a : β} : β(OfNat.ofNat a) = OfNat.ofNat a - Rat.add_zero π Init.Data.Rat.Lemmas
(a : β) : a + 0 = a - Rat.floor_lt_iff π Init.Data.Rat.Lemmas
{a : β} {x : β€} : a.floor < x β a < βx - Rat.intCast_inj π Init.Data.Rat.Lemmas
{a b : β€} : βa = βb β a = b - Rat.intCast_neg π Init.Data.Rat.Lemmas
(a : β€) : β(-a) = -βa - Rat.le_floor_iff π Init.Data.Rat.Lemmas
{x : β€} {a : β} : x β€ a.floor β βx β€ a - Rat.mul_one π Init.Data.Rat.Lemmas
(a : β) : a * 1 = a - Rat.natCast_inj π Init.Data.Rat.Lemmas
{a b : β} : βa = βb β a = b - Rat.one_mul π Init.Data.Rat.Lemmas
(a : β) : 1 * a = a - Rat.zero_add π Init.Data.Rat.Lemmas
(a : β) : 0 + a = a - Rat.divInt.eq_2 π Init.Data.Rat.Lemmas
(xβ : β€) (d : β) : Rat.divInt xβ (Int.negSucc d) = Rat.normalize (-xβ) d.succ β― - Rat.ext π Init.Data.Rat.Lemmas
{p q : β} : p.num = q.num β p.den = q.den β p = q - Rat.le_trans π Init.Data.Rat.Lemmas
{a b c : β} (hab : a β€ b) (hbc : b β€ c) : a β€ c - Rat.mk_den_one π Init.Data.Rat.Lemmas
{r : β€} : { num := r, den_nz := Nat.one_ne_zero, reduced := β― } = βr - Rat.pow_one π Init.Data.Rat.Lemmas
(q : β) : q ^ 1 = q - Rat.zpow_one π Init.Data.Rat.Lemmas
(q : β) : q ^ 1 = q - Rat.divInt_self' π Init.Data.Rat.Lemmas
{n : β€} (hn : n β 0) : Rat.divInt n n = 1 - Rat.floor_def π Init.Data.Rat.Lemmas
(a : β) : a.floor = a.num / βa.den - Rat.intCast_le_intCast π Init.Data.Rat.Lemmas
{a b : β€} : βa β€ βb β a β€ b - Rat.intCast_lt_intCast π Init.Data.Rat.Lemmas
{a b : β€} : βa < βb β a < b - Rat.natCast_le_natCast π Init.Data.Rat.Lemmas
{a b : β} : βa β€ βb β a β€ b - Rat.natCast_lt_natCast π Init.Data.Rat.Lemmas
{a b : β} : βa < βb β a < b - Rat.num_eq_zero π Init.Data.Rat.Lemmas
{q : β} : q.num = 0 β q = 0 - Rat.add_neg_cancel π Init.Data.Rat.Lemmas
(a : β) : a + -a = 0 - Rat.neg_add_cancel π Init.Data.Rat.Lemmas
(a : β) : -a + a = 0 - Rat.ofNat_eq_ofNat π Init.Data.Rat.Lemmas
{a b : β} : OfNat.ofNat a = OfNat.ofNat b β a = b - Rat.intCast_eq_zero_iff π Init.Data.Rat.Lemmas
{a : β€} : βa = 0 β a = 0 - Rat.mul_zero π Init.Data.Rat.Lemmas
(a : β) : a * 0 = 0 - Rat.natCast_eq_zero_iff π Init.Data.Rat.Lemmas
{a : β} : βa = 0 β a = 0 - Rat.num_nonneg π Init.Data.Rat.Lemmas
{q : β} : 0 β€ q.num β 0 β€ q - Rat.zero_mul π Init.Data.Rat.Lemmas
(a : β) : 0 * a = 0 - Rat.add_comm π Init.Data.Rat.Lemmas
(a b : β) : a + b = b + a - Rat.divInt_eq_div π Init.Data.Rat.Lemmas
(a b : β€) : Rat.divInt a b = βa / βb - Rat.lt_floor_add_one π Init.Data.Rat.Lemmas
(a : β) : a < β(a.floor + 1) - Rat.mkRat_eq_div π Init.Data.Rat.Lemmas
(a : β€) (b : β) : mkRat a b = βa / βb - Rat.mul_comm π Init.Data.Rat.Lemmas
(a b : β) : a * b = b * a - Rat.numDenCasesOn' π Init.Data.Rat.Lemmas
{C : β β Sort u} (a : β) (H : (n : β€) β (d : β) β d β 0 β C (Rat.divInt n βd)) : C a - Rat.pow_zero π Init.Data.Rat.Lemmas
(q : β) : q ^ 0 = 1 - Rat.zpow_zero π Init.Data.Rat.Lemmas
(q : β) : q ^ 0 = 1 - Rat.intCast_neg_iff π Init.Data.Rat.Lemmas
{a : β€} : βa < 0 β a < 0 - Rat.intCast_nonneg π Init.Data.Rat.Lemmas
{a : β€} : 0 β€ βa β 0 β€ a - Rat.intCast_nonpos π Init.Data.Rat.Lemmas
{a : β€} : βa β€ 0 β a β€ 0 - Rat.intCast_pos π Init.Data.Rat.Lemmas
{a : β€} : 0 < βa β 0 < a - Rat.inv_pos π Init.Data.Rat.Lemmas
{a : β} : 0 < aβ»ΒΉ β 0 < a - Rat.natCast_pos π Init.Data.Rat.Lemmas
{a : β} : 0 < βa β 0 < a - Rat.nonneg_total π Init.Data.Rat.Lemmas
(a : β) : 0 β€ a β¨ 0 β€ -a - Rat.num_inv π Init.Data.Rat.Lemmas
(a : β) : aβ»ΒΉ.num = a.num.sign * βa.den - Rat.mk_eq_mkRat π Init.Data.Rat.Lemmas
(num : β€) (den : β) (nz : den β 0) (c : num.natAbs.Coprime den) : { num := num, den := den, den_nz := nz, reduced := c } = mkRat num den - Rat.ofScientific_ofNat_ofNat π Init.Data.Rat.Lemmas
{m : β} {s : Bool} {e : β} : Rat.ofScientific (OfNat.ofNat m) s (OfNat.ofNat e) = OfScientific.ofScientific m s e - Rat.div_def π Init.Data.Rat.Lemmas
(a b : β) : a / b = a * bβ»ΒΉ - Rat.inv_eq_of_mul_eq_one π Init.Data.Rat.Lemmas
{a b : β} (h : a * b = 1) : aβ»ΒΉ = b - Rat.le_iff_sub_nonneg π Init.Data.Rat.Lemmas
(a b : β) : a β€ b β 0 β€ b - a - Rat.lt_iff_sub_pos π Init.Data.Rat.Lemmas
(a b : β) : a < b β 0 < b - a - Rat.neg_sub π Init.Data.Rat.Lemmas
(a b : β) : -(a - b) = b - a - Rat.normalize_eq_mkRat π Init.Data.Rat.Lemmas
{num : β€} {den : β} (den_nz : den β 0) : Rat.normalize num den den_nz = mkRat num den - Rat.numDenCasesOn'' π Init.Data.Rat.Lemmas
{C : β β Sort u} (a : β) (H : (n : β€) β (d : β) β (nz : d β 0) β (red : n.natAbs.Coprime d) β C { num := n, den := d, den_nz := nz, reduced := red }) : C a - Rat.sub_eq_add_neg π Init.Data.Rat.Lemmas
(a b : β) : a - b = a + -b - Rat.add_right_cancel π Init.Data.Rat.Lemmas
{a b : β} (c : β) (h : a + c = b + c) : a = b - Rat.mk'_eq_divInt π Init.Data.Rat.Lemmas
{n : β€} {d : β} {h : d β 0} {c : n.natAbs.Coprime d} : { num := n, den := d, den_nz := h, reduced := c } = Rat.divInt n βd - Rat.mk_eq_divInt π Init.Data.Rat.Lemmas
(num : β€) (den : β) (nz : den β 0) (c : num.natAbs.Coprime den) : { num := num, den := den, den_nz := nz, reduced := c } = Rat.divInt num βden - Rat.zpow_natCast π Init.Data.Rat.Lemmas
(q : β) (n : β) : q ^ βn = q ^ n - Rat.numDenCasesOn π Init.Data.Rat.Lemmas
{C : β β Sort u} (a : β) : ((n : β€) β (d : β) β 0 < d β n.natAbs.Coprime d β C (Rat.divInt n βd)) β C a - Rat.den_pow π Init.Data.Rat.Lemmas
(q : β) (n : β) : (q ^ n).den = q.den ^ n - Rat.inv_mul_cancel π Init.Data.Rat.Lemmas
(a : β) (h : a β 0) : aβ»ΒΉ * a = 1 - Rat.mul_inv_cancel π Init.Data.Rat.Lemmas
(a : β) : a β 0 β a * aβ»ΒΉ = 1 - Rat.mul_neg π Init.Data.Rat.Lemmas
(a b : β) : a * -b = -(a * b) - Rat.neg_mul π Init.Data.Rat.Lemmas
(a b : β) : -a * b = -(a * b) - Rat.num_pow π Init.Data.Rat.Lemmas
(q : β) (n : β) : (q ^ n).num = q.num ^ n - Rat.mkRat_eq_zero π Init.Data.Rat.Lemmas
{d : β} {n : β€} (d0 : d β 0) : mkRat n d = 0 β n = 0 - Rat.mkRat_ne_zero π Init.Data.Rat.Lemmas
{d : β} {n : β€} (d0 : d β 0) : mkRat n d β 0 β n β 0 - Rat.ofScientific_true_def π Init.Data.Rat.Lemmas
{m e : β} : Rat.ofScientific m true e = mkRat (βm) (10 ^ e) - Rat.pow_nonneg π Init.Data.Rat.Lemmas
{a : β} {n : β} (h : 0 β€ a) : 0 β€ a ^ n - Rat.pow_pos π Init.Data.Rat.Lemmas
{a : β} {n : β} (h : 0 < a) : 0 < a ^ n - Rat.zpow_nonneg π Init.Data.Rat.Lemmas
{a : β} {n : β€} (h : 0 β€ a) : 0 β€ a ^ n - Rat.zpow_pos π Init.Data.Rat.Lemmas
{a : β} {n : β€} (h : 0 < a) : 0 < a ^ n - Rat.add_le_add_left π Init.Data.Rat.Lemmas
{a b c : β} : c + a β€ c + b β a β€ b - Rat.add_le_add_right π Init.Data.Rat.Lemmas
{a b c : β} : a + c β€ b + c β a β€ b - Rat.div_mul_cancel π Init.Data.Rat.Lemmas
{a b : β} (hb : b β 0) : a / b * b = a - Rat.mul_div_cancel π Init.Data.Rat.Lemmas
{a b : β} (hb : b β 0) : a * b / b = a - Rat.nonneg_antisymm π Init.Data.Rat.Lemmas
{q : β} : 0 β€ q β 0 β€ -q β q = 0 - Rat.normalize_eq_zero π Init.Data.Rat.Lemmas
{d : β} {n : β€} (d0 : d β 0) : Rat.normalize n d d0 = 0 β n = 0 - Rat.normalize_zero π Init.Data.Rat.Lemmas
{d : β} (nz : d β 0) : Rat.normalize 0 d nz = 0 - Rat.zpow_neg π Init.Data.Rat.Lemmas
(q : β) (n : β€) : q ^ (-n) = (q ^ n)β»ΒΉ - Rat.divInt_nonneg π Init.Data.Rat.Lemmas
{a b : β€} (ha : 0 β€ a) (hb : 0 β€ b) : 0 β€ Rat.divInt a b - Rat.intCast_add π Init.Data.Rat.Lemmas
(a b : β€) : β(a + b) = βa + βb - Rat.intCast_mul π Init.Data.Rat.Lemmas
(a b : β€) : β(a * b) = βa * βb - Rat.intCast_sub π Init.Data.Rat.Lemmas
(a b : β€) : β(a - b) = βa - βb - Rat.inv_mul_rev π Init.Data.Rat.Lemmas
(a b : β) : (a * b)β»ΒΉ = bβ»ΒΉ * aβ»ΒΉ - Rat.mk_eq_normalize π Init.Data.Rat.Lemmas
(num : β€) (den : β) (nz : den β 0) (c : num.natAbs.Coprime den) : { num := num, den := den, den_nz := nz, reduced := c } = Rat.normalize num den nz - Rat.natCast_add π Init.Data.Rat.Lemmas
(a b : β) : β(a + b) = βa + βb
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 0902274
serving mathlib revision 3540854