Loogle!
Result
Found 82 definitions mentioning HMul.hMul, tsum and Eq. Of these, 7 match your pattern(s).
- Summable.tsum_mul_left π Mathlib.Topology.Algebra.InfiniteSum.Ring
{ΞΉ : Type u_1} {Ξ± : Type u_3} [NonUnitalNonAssocSemiring Ξ±] [TopologicalSpace Ξ±] [TopologicalSemiring Ξ±] {f : ΞΉ β Ξ±} [T2Space Ξ±] (a : Ξ±) (hf : Summable f) : β' (i : ΞΉ), a * f i = a * β' (i : ΞΉ), f i - tsum_mul_left π Mathlib.Topology.Algebra.InfiniteSum.Ring
{ΞΉ : Type u_1} {Ξ± : Type u_3} [DivisionSemiring Ξ±] [TopologicalSpace Ξ±] [TopologicalSemiring Ξ±] {f : ΞΉ β Ξ±} {a : Ξ±} [T2Space Ξ±] : β' (x : ΞΉ), a * f x = a * β' (x : ΞΉ), f x - NNReal.tsum_mul_left π Mathlib.Topology.Instances.NNReal
{Ξ± : Type u_1} (a : NNReal) (f : Ξ± β NNReal) : β' (x : Ξ±), a * f x = a * β' (x : Ξ±), f x - ENNReal.tsum_mul_left π Mathlib.Topology.Instances.ENNReal
{Ξ± : Type u_1} {a : ENNReal} {f : Ξ± β ENNReal} : β' (i : Ξ±), a * f i = a * β' (i : Ξ±), f i - Real.tsum_exp_neg_mul_int_sq π Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation
{a : β} (ha : 0 < a) : β' (n : β€), Real.exp (-Real.pi * a * βn ^ 2) = 1 / a ^ (1 / 2) * β' (n : β€), Real.exp (-Real.pi / a * βn ^ 2) - Complex.tsum_exp_neg_mul_int_sq π Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation
{a : β} (ha : 0 < a.re) : β' (n : β€), Complex.exp (-βReal.pi * a * βn ^ 2) = 1 / a ^ (1 / 2) * β' (n : β€), Complex.exp (-βReal.pi / a * βn ^ 2) - Complex.tsum_exp_neg_quadratic π Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation
{a : β} (ha : 0 < a.re) (b : β) : β' (n : β€), Complex.exp (-βReal.pi * a * βn ^ 2 + 2 * βReal.pi * b * βn) = 1 / a ^ (1 / 2) * β' (n : β€), Complex.exp (-βReal.pi / a * (βn + Complex.I * b) ^ 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, _ * _, _ ^ _, |- _ < _ β _
woould 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 026c9d9
serving mathlib revision a608095