Loogle!
Result
Found 36 declarations mentioning LE.le, OfNat.ofNat and Real.sin. Of these, 20 match your pattern(s).
- Real.sin_le_one π Mathlib.Data.Complex.Trigonometric
(x : β) : Real.sin x β€ 1 - Real.neg_one_le_sin π Mathlib.Data.Complex.Trigonometric
(x : β) : -1 β€ Real.sin x - Real.abs_sin_le_one π Mathlib.Data.Complex.Trigonometric
(x : β) : |Real.sin x| β€ 1 - Real.sin_sq_le_one π Mathlib.Data.Complex.Trigonometric
(x : β) : Real.sin x ^ 2 β€ 1 - Real.sin_pos_of_pos_of_le_one π Mathlib.Data.Complex.Trigonometric
{x : β} (hx0 : 0 < x) (hx : x β€ 1) : 0 < Real.sin x - Real.sin_bound π Mathlib.Data.Complex.Trigonometric
{x : β} (hx : |x| β€ 1) : |Real.sin x - (x - x ^ 3 / 6)| β€ |x| ^ 4 * (5 / 96) - Real.sin_eq_sqrt_one_sub_cos_sq π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
{x : β} (hl : 0 β€ x) (hu : x β€ Real.pi) : Real.sin x = β(1 - Real.cos x ^ 2) - Real.cos_eq_sqrt_one_sub_sin_sq π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
{x : β} (hl : -(Real.pi / 2) β€ x) (hu : x β€ Real.pi / 2) : Real.cos x = β(1 - Real.sin x ^ 2) - Real.sin_half_eq_sqrt π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
{x : β} (hl : 0 β€ x) (hr : x β€ 2 * Real.pi) : Real.sin (x / 2) = β((1 - Real.cos x) / 2) - Real.sin_half_eq_neg_sqrt π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
{x : β} (hl : -(2 * Real.pi) β€ x) (hr : x β€ 0) : Real.sin (x / 2) = -β((1 - Real.cos x) / 2) - Real.coe_sinOrderIso_apply π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
(x : β(Set.Icc (-(Real.pi / 2)) (Real.pi / 2))) : β(Real.sinOrderIso x) = Real.sin βx - Real.sinOrderIso_apply π Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
(x : β(Set.Icc (-(Real.pi / 2)) (Real.pi / 2))) : Real.sinOrderIso x = β¨Real.sin βx, β―β© - Real.sin_arcsin π Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
{x : β} (hxβ : -1 β€ x) (hxβ : x β€ 1) : Real.sin (Real.arcsin x) = x - Real.arcsin_le_iff_le_sin π Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
{x y : β} (hx : x β Set.Icc (-1) 1) (hy : y β Set.Icc (-(Real.pi / 2)) (Real.pi / 2)) : Real.arcsin x β€ y β x β€ Real.sin y - Real.le_arcsin_iff_sin_le π Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
{x y : β} (hx : x β Set.Icc (-(Real.pi / 2)) (Real.pi / 2)) (hy : y β Set.Icc (-1) 1) : x β€ Real.arcsin y β Real.sin x β€ y - Real.le_sin_mul π Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds
{x : β} (hx : 0 β€ x) (hx' : x β€ 1) : x β€ Real.sin (Real.pi / 2 * x) - Real.sin_gt_sub_cube π Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds
{x : β} (h : 0 < x) (h' : x β€ 1) : x - x ^ 3 / 4 < Real.sin x - integral_sin_pow_succ_le π Mathlib.Analysis.SpecialFunctions.Integrals
(n : β) : β« (x : β) in 0 ..Real.pi, Real.sin x ^ (n + 1) β€ β« (x : β) in 0 ..Real.pi, Real.sin x ^ n - EulerSine.integral_cos_mul_cos_pow_aux π Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd
{z : β} {n : β} (hn : 2 β€ n) (hz : z β 0) : β« (x : β) in 0 ..Real.pi / 2, Complex.cos (2 * z * βx) * β(Real.cos x) ^ n = βn / (2 * z) * β« (x : β) in 0 ..Real.pi / 2, Complex.sin (2 * z * βx) * β(Real.sin x) * β(Real.cos x) ^ (n - 1) - EulerSine.integral_sin_mul_sin_mul_cos_pow_eq π Mathlib.Analysis.SpecialFunctions.Trigonometric.EulerSineProd
{z : β} {n : β} (hn : 2 β€ n) (hz : z β 0) : β« (x : β) in 0 ..Real.pi / 2, Complex.sin (2 * z * βx) * β(Real.sin x) * β(Real.cos x) ^ (n - 1) = (βn / (2 * z) * β« (x : β) in 0 ..Real.pi / 2, Complex.cos (2 * z * βx) * β(Real.cos x) ^ n) - (βn - 1) / (2 * z) * β« (x : β) in 0 ..Real.pi / 2, Complex.cos (2 * z * βx) * β(Real.cos x) ^ (n - 2)
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