name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
Int32.toInt_ofInt_of_le
|
Init.Data.SInt.Lemmas
|
∀ {n : ℤ}, -2 ^ 31 ≤ n → n < 2 ^ 31 → (Int32.ofInt n).toInt = n
|
List.ext_getElem
|
Init.Data.List.Lemmas
|
∀ {α : Type u_1} {l₁ l₂ : List α},
l₁.length = l₂.length → (∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), l₁[i] = l₂[i]) → l₁ = l₂
|
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.InductiveView.withTypeRef.match_1
|
Lean.Elab.MutualInductive
|
(motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((type : Lean.Syntax) → motive (some type)) → (Unit → motive none) → motive x
|
Std.HashMap.Raw.getElem!_union
|
Std.Data.HashMap.RawLemmas
|
∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂)[k]! = m₂.getD k m₁[k]!
|
RelEmbedding.isIrrefl
|
Mathlib.Order.RelIso.Basic
|
∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [IsIrrefl β s], IsIrrefl α r
|
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.congr_eq_4
|
Init.Grind.Ring.CommSolver
|
∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_5 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_6 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b)) (h_7 : (a : Lean.Grind.CommRing.Expr) → motive a.neg)
(h_8 : (a b : Lean.Grind.CommRing.Expr) → motive (a.sub b))
(h_9 : (a : Lean.Grind.CommRing.Expr) → (k : ℕ) → motive (a.pow k)) (x_1 : Lean.Grind.CommRing.Var),
x = Lean.Grind.CommRing.Expr.var x_1 →
(match x with
| Lean.Grind.CommRing.Expr.num k => h_1 k
| Lean.Grind.CommRing.Expr.natCast k => h_2 k
| Lean.Grind.CommRing.Expr.intCast k => h_3 k
| Lean.Grind.CommRing.Expr.var x => h_4 x
| a.add b => h_5 a b
| a.mul b => h_6 a b
| a.neg => h_7 a
| a.sub b => h_8 a b
| a.pow k => h_9 a k) ≍
h_4 x_1
|
isSimpleAddGroup_of_prime_card
|
Mathlib.GroupTheory.SpecificGroups.Cyclic
|
∀ {α : Type u_1} [inst : AddGroup α] {p : ℕ} [hp : Fact (Nat.Prime p)], Nat.card α = p → IsSimpleAddGroup α
|
Distributions.«_aux_Mathlib_Analysis_Distribution_Distribution___macroRules_Distributions_term𝓓'^{_}(_,_)_1»
|
Mathlib.Analysis.Distribution.Distribution
|
Lean.Macro
|
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData._proof_3
|
Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_3} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X Y : C} {p : X ⟶ Y}
(f : F.obj ⊥ ⟶ X) (g : c.pt ⟶ Y) [inst_3 : SuccOrder J] (j : J)
(sq' : (CategoryTheory.HasLiftingProperty.transfiniteComposition.sqFunctor c p f g).obj (Opposite.op j))
(this :
∀
(sq :
CategoryTheory.CommSq sq'.f' (F.map (CategoryTheory.homOfLE ⋯)) p
(CategoryTheory.CategoryStruct.comp (c.ι.app (Order.succ j)) g)),
sq.HasLift),
CategoryTheory.CategoryStruct.comp ⋯.lift p = CategoryTheory.CategoryStruct.comp (c.ι.app (Order.succ j)) g
|
_private.Mathlib.Data.List.Basic.0.List.getLastI.match_1.eq_1
|
Mathlib.Data.List.Basic
|
∀ {α : Type u_1} (motive : List α → Sort u_2) (h_1 : Unit → motive []) (h_2 : (a : α) → motive [a])
(h_3 : (head b : α) → motive [head, b]) (h_4 : (head head_1 : α) → (l : List α) → motive (head :: head_1 :: l)),
(match [] with
| [] => h_1 ()
| [a] => h_2 a
| [head, b] => h_3 head b
| head :: head_1 :: l => h_4 head head_1 l) =
h_1 ()
|
Hyperreal.infinitePos_add_not_infiniteNeg
|
Mathlib.Analysis.Real.Hyperreal
|
∀ {x y : ℝ*}, x.InfinitePos → ¬y.InfiniteNeg → (x + y).InfinitePos
|
CategoryTheory.Limits.PreservesFiniteLimits.preservesFiniteLimits
|
Mathlib.CategoryTheory.Limits.Preserves.Finite
|
∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} [self : CategoryTheory.Limits.PreservesFiniteLimits F] (J : Type)
[inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J],
CategoryTheory.Limits.PreservesLimitsOfShape J F
|
_private.Mathlib.Data.Finset.Prod.0.Finset.diag_insert._proof_1_1
|
Mathlib.Data.Finset.Prod
|
∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (a : α), (insert a s).diag = insert (a, a) s.diag
|
FirstOrder.Language.BoundedFormula.restrictFreeVar.eq_def
|
Mathlib.ModelTheory.Semantics
|
∀ {L : FirstOrder.Language} {α : Type u'} {β : Type v'} [inst : DecidableEq α] (x : ℕ) (x_1 : L.BoundedFormula α x)
(x_2 : ↥x_1.freeVarFinset → β),
x_1.restrictFreeVar x_2 =
match x, x_1, x_2 with
| _n, FirstOrder.Language.BoundedFormula.falsum, _f => FirstOrder.Language.BoundedFormula.falsum
| _n, FirstOrder.Language.BoundedFormula.equal t₁ t₂, f =>
FirstOrder.Language.BoundedFormula.equal (t₁.restrictVarLeft (f ∘ Set.inclusion ⋯))
(t₂.restrictVarLeft (f ∘ Set.inclusion ⋯))
| _n, FirstOrder.Language.BoundedFormula.rel R ts, f =>
FirstOrder.Language.BoundedFormula.rel R fun i => (ts i).restrictVarLeft (f ∘ Set.inclusion ⋯)
| _n, φ₁.imp φ₂, f => (φ₁.restrictFreeVar (f ∘ Set.inclusion ⋯)).imp (φ₂.restrictFreeVar (f ∘ Set.inclusion ⋯))
| _n, φ.all, f => (φ.restrictFreeVar f).all
|
PresheafOfModules.Hom
|
Mathlib.Algebra.Category.ModuleCat.Presheaf
|
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → PresheafOfModules R → PresheafOfModules R → Type (max u₁ v)
|
SSet.Truncated.Path.arrow._proof_1
|
Mathlib.AlgebraicTopology.SimplicialSet.Path
|
∀ {n : ℕ}, 1 ≤ n + 1
|
AddMonCat.adjoinZero.eq_1
|
Mathlib.Algebra.Category.MonCat.Adjunctions
|
AddMonCat.adjoinZero =
{ obj := fun S => AddMonCat.of (WithZero ↑S),
map := fun {X Y} f => AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom f)),
map_id := AddMonCat.adjoinZero._proof_1, map_comp := @AddMonCat.adjoinZero._proof_2 }
|
Module.AEval.mapSubmodule._proof_2
|
Mathlib.Algebra.Polynomial.Module.AEval
|
∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M
|
_private.Mathlib.Logic.Equiv.PartialEquiv.0.PartialEquiv.IsImage.iff_preimage_eq._simp_1_5
|
Mathlib.Logic.Equiv.PartialEquiv
|
∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c))
|
IsSelfAdjoint.commute_cfcₙHom
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Commute
|
∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A]
[inst_3 : Module 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A] [inst_6 : TopologicalSpace A]
[inst_7 : NonUnitalContinuousFunctionalCalculus 𝕜 A p] [IsTopologicalRing A] [T2Space A] {a b : A} (ha : p a),
IsSelfAdjoint a → Commute a b → ∀ (f : ContinuousMapZero (↑(quasispectrum 𝕜 a)) 𝕜), Commute ((cfcₙHom ha) f) b
|
_private.Lean.Compiler.IR.Basic.0.Lean.IR.IRType.isObj._sparseCasesOn_1
|
Lean.Compiler.IR.Basic
|
{motive_1 : Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
motive_1 Lean.IR.IRType.object →
motive_1 Lean.IR.IRType.tagged →
motive_1 Lean.IR.IRType.tobject →
motive_1 Lean.IR.IRType.void → (Nat.hasNotBit 12672 t.ctorIdx → motive_1 t) → motive_1 t
|
Algebra.TensorProduct.map_ker
|
Mathlib.LinearAlgebra.TensorProduct.RightExactness
|
∀ {R : Type u_4} [inst : CommRing R] {A : Type u_5} {B : Type u_6} {C : Type u_7} {D : Type u_8} [inst_1 : Ring A]
[inst_2 : Ring B] [inst_3 : Ring C] [inst_4 : Ring D] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra R C] [inst_8 : Algebra R D] (f : A →ₐ[R] B) (g : C →ₐ[R] D),
Function.Surjective ⇑f →
Function.Surjective ⇑g →
RingHom.ker (Algebra.TensorProduct.map f g) =
Ideal.map Algebra.TensorProduct.includeLeft (RingHom.ker f) ⊔
Ideal.map Algebra.TensorProduct.includeRight (RingHom.ker g)
|
Lean.Parser.Tactic.simpAllTraceArgsRest
|
Init.Tactics
|
Lean.ParserDescr
|
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_pos_getElem._proof_1_2
|
Batteries.Data.List.Lemmas
|
∀ {i : ℕ} {α : Type u_1} {xs : List α}, i < xs.length → i < xs.length
|
CategoryTheory.WideSubcategory.ctorIdx
|
Mathlib.CategoryTheory.Widesubcategory
|
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{_P : CategoryTheory.MorphismProperty C} → {inst_1 : _P.IsMultiplicative} → CategoryTheory.WideSubcategory _P → ℕ
|
SMulPosReflectLT.mk._flat_ctor
|
Mathlib.Algebra.Order.Module.Defs
|
∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β] [inst_3 : Zero β],
(∀ ⦃b : β⦄, 0 ≤ b → ∀ ⦃a₁ a₂ : α⦄, a₁ • b < a₂ • b → a₁ < a₂) → SMulPosReflectLT α β
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isSome_minKey?_modify._simp_1_2
|
Std.Data.DTreeMap.Internal.Lemmas
|
∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false)
|
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.forall_mem_keysArray_iff_forall_mem_getKey._simp_1_1
|
Std.Data.DHashMap.RawLemmas
|
∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true)
|
Mathlib.Tactic.BicategoryLike.MkMor₂.recOn
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
{m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t
|
Lean.Elab.Tactic.Do.State.mk.noConfusion
|
Lean.Elab.Tactic.Do.VCGen.Basic
|
{P : Sort u} →
{fuel : Lean.Elab.Tactic.Do.Fuel} →
{simpState : Lean.Meta.Simp.State} →
{invariants vcs : Array Lean.MVarId} →
{fuel' : Lean.Elab.Tactic.Do.Fuel} →
{simpState' : Lean.Meta.Simp.State} →
{invariants' vcs' : Array Lean.MVarId} →
{ fuel := fuel, simpState := simpState, invariants := invariants, vcs := vcs } =
{ fuel := fuel', simpState := simpState', invariants := invariants', vcs := vcs' } →
(fuel = fuel' → simpState = simpState' → invariants = invariants' → vcs = vcs' → P) → P
|
CategoryTheory.Functor.CoconeTypes.precomp._proof_2
|
Mathlib.CategoryTheory.Limits.Types.ColimitType
|
∀ {J : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} J] {F : CategoryTheory.Functor J (Type u_3)}
(c : F.CoconeTypes) {J' : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J'] (G : CategoryTheory.Functor J' J)
{j j' : J'} (f : j ⟶ j'), c.ι (G.obj j') ∘ F.map (G.map f) = c.ι (G.obj j)
|
MvPolynomial.pUnitAlgEquiv._proof_2
|
Mathlib.Algebra.MvPolynomial.Equiv
|
∀ (R : Type u_1) [inst : CommSemiring R] (a : R),
MvPolynomial.eval₂ Polynomial.C (fun x => Polynomial.X)
(Polynomial.eval₂ MvPolynomial.C (MvPolynomial.X PUnit.unit) (Polynomial.C a)) =
Polynomial.C a
|
OreLocalization.instDivisionRingNonZeroDivisors._proof_6
|
Mathlib.RingTheory.OreLocalization.Ring
|
∀ {R : Type u_1} [inst : Ring R] [inst_1 : Nontrivial R] [inst_2 : NoZeroDivisors R]
[inst_3 : OreLocalization.OreSet (nonZeroDivisors R)] (n : ℕ) (a : OreLocalization (nonZeroDivisors R) R),
DivInvMonoid.zpow (Int.negSucc n) a = (DivInvMonoid.zpow (↑n.succ) a)⁻¹
|
LinearMap.toMatrix_basis_equiv
|
Mathlib.LinearAlgebra.Matrix.ToLin
|
∀ {R : Type u_1} [inst : CommSemiring R] {l : Type u_2} {M₁ : Type u_5} {M₂ : Type u_6} [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] [inst_5 : Fintype l]
[inst_6 : DecidableEq l] (b : Module.Basis l R M₁) (b' : Module.Basis l R M₂),
(LinearMap.toMatrix b' b) ↑(b'.equiv b (Equiv.refl l)) = 1
|
CategoryTheory.GrothendieckTopology.sheafification
|
Mathlib.CategoryTheory.Sites.ConcreteSheafification
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type w) →
[inst_1 : CategoryTheory.Category.{w', w} D] →
[∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X),
CategoryTheory.Limits.HasMultiequalizer (S.index P)] →
[∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D] →
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ D) (CategoryTheory.Functor Cᵒᵖ D)
|
_private.Mathlib.Algebra.Homology.TotalComplex.0.HomologicalComplex₂.hasTotal_of_iso.match_1_1
|
Mathlib.Algebra.Homology.TotalComplex
|
{I₁ : Type u_1} →
{I₂ : Type u_2} → (motive : I₁ × I₂ → Sort u_3) → (x : I₁ × I₂) → ((i₁ : I₁) → (i₂ : I₂) → motive (i₁, i₂)) → motive x
|
Std.Time.instInhabitedOffsetX.default
|
Std.Time.Format.Basic
|
Std.Time.OffsetX
|
Array.SatisfiesM_foldlM._proof_2
|
Batteries.Data.Array.Monadic
|
∀ {α : Type u_1} {as : Array α} (i : Fin as.size), ↑i < as.size
|
CategoryTheory.expComparison
|
Mathlib.CategoryTheory.Monoidal.Closed.Functor
|
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v, u'} D] →
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
[inst_4 : CategoryTheory.CartesianClosed C] →
[inst_5 : CategoryTheory.CartesianClosed D] →
[CategoryTheory.Limits.PreservesLimitsOfShape
(CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] →
(A : C) → CategoryTheory.TwoSquare (CategoryTheory.exp A) F F (CategoryTheory.exp (F.obj A))
|
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_14
|
Mathlib.GroupTheory.Perm.Fin
|
∀ {n : ℕ} {i j k : Fin n}, i ≤ k → k ≤ j → ¬k = j → ↑k - ↑i + 1 < n - ↑i
|
AddMonoidHom.compLeft._proof_2
|
Mathlib.Algebra.Group.Pi.Lemmas
|
∀ {α : Type u_3} {β : Type u_2} [inst : AddZeroClass α] [inst_1 : AddZeroClass β] (f : α →+ β) (I : Type u_1)
(x x_1 : I → α), ⇑f ∘ (x + x_1) = ⇑f ∘ x + ⇑f ∘ x_1
|
CategoryTheory.ObjectProperty.subtypeOpEquiv._proof_3
|
Mathlib.CategoryTheory.ObjectProperty.Opposite
|
∀ {C : Type u_2} [inst : CategoryTheory.CategoryStruct.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
(x : Subtype P.op), P.op ↑x
|
MeasureTheory.addEquivAddHaarChar_smul_eq_comap
|
Mathlib.MeasureTheory.Measure.Haar.MulEquivHaarChar
|
∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G] [inst_3 : BorelSpace G]
[inst_4 : IsTopologicalAddGroup G] [inst_5 : LocallyCompactSpace G] (μ : MeasureTheory.Measure G) [μ.IsAddHaarMeasure]
[μ.Regular] (φ : G ≃ₜ+ G), MeasureTheory.addEquivAddHaarChar φ • μ = MeasureTheory.Measure.comap (⇑φ) μ
|
Int.cast_neg_natCast._simp_1
|
Mathlib.Data.Int.Cast.Field
|
∀ {R : Type u_2} [inst : DivisionRing R] (n : ℕ), -↑n = ↑(-↑n)
|
antitone_iff_apply₂
|
Mathlib.Order.Monotone.Defs
|
∀ {ι : Type u_1} {α : Type u} {β : ι → Type u_4} [inst : (i : ι) → Preorder (β i)] [inst_1 : Preorder α]
{f : α → (i : ι) → β i}, Antitone f ↔ ∀ (i : ι), Antitone fun x => f x i
|
CategoryTheory.Iso.toCoalgEquiv_trans
|
Mathlib.Algebra.Category.CoalgCat.Basic
|
∀ {R : Type u} [inst : CommRing R] {X Y Z : CoalgCat R} (e : X ≅ Y) (f : Y ≅ Z),
(e ≪≫ f).toCoalgEquiv = e.toCoalgEquiv.trans f.toCoalgEquiv
|
Lean.DataValue.noConfusion
|
Lean.Data.KVMap
|
{P : Sort u} → {t t' : Lean.DataValue} → t = t' → Lean.DataValue.noConfusionType P t t'
|
Sum.instLocallyFiniteOrder._proof_2
|
Mathlib.Data.Sum.Interval
|
∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a a_1 x : α ⊕ β),
(x ∈
match a, a_1 with
| Sum.inl a, Sum.inl b => Finset.map Function.Embedding.inl (Finset.Ico a b)
| Sum.inl val, Sum.inr val_1 => ∅
| Sum.inr val, Sum.inl val_1 => ∅
| Sum.inr a, Sum.inr b => Finset.map Function.Embedding.inr (Finset.Ico a b)) ↔
a ≤ x ∧ x < a_1
|
StableUnderGeneralization.image
|
Mathlib.Topology.Inseparable
|
∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
GeneralizingMap f → ∀ {s : Set X}, StableUnderGeneralization s → StableUnderGeneralization (f '' s)
|
lTensor.inverse_of_rightInverse._proof_9
|
Mathlib.LinearAlgebra.TensorProduct.RightExactness
|
∀ {R : Type u_3} {M : Type u_4} {N : Type u_1} {P : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_2) [inst_7 : AddCommGroup Q] [inst_8 : Module R Q] {h : P → N},
Function.Exact ⇑f ⇑g →
Function.RightInverse h ⇑g →
∀ (p p' : P),
(LinearMap.range (LinearMap.lTensor Q f)).mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h (p + p')) =
(LinearMap.range (LinearMap.lTensor Q f)).mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h p) +
(LinearMap.range (LinearMap.lTensor Q f)).mkQ ∘ₗ (TensorProduct.mk R Q N).flip (h p')
|
SubmoduleClass.module'._proof_3
|
Mathlib.Algebra.Module.Submodule.Defs
|
∀ {S : Type u_3} {R : Type u_4} {M : Type u_1} {T : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Semiring S] [inst_3 : Module R M] [inst_4 : SMul S R] [inst_5 : Module S M] [inst_6 : IsScalarTower S R M]
[inst_7 : SetLike T M] [inst_8 : SMulMemClass T R M] (t : T) (x : ↥t), 1 • x = x
|
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_12
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict
|
∀ {S : Type u_1} [inst : Field S] [inst_1 : TopologicalSpace S] [IsTopologicalRing S], ContinuousAdd S
|
CochainComplex.mkHom
|
Mathlib.Algebra.Homology.HomologicalComplex
|
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
(P Q : CochainComplex V ℕ) →
(zero : P.X 0 ⟶ Q.X 0) →
(one : P.X 1 ⟶ Q.X 1) →
CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one →
((n : ℕ) →
(p :
(f : P.X n ⟶ Q.X n) ×'
(f' : P.X (n + 1) ⟶ Q.X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) =
CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') →
(f'' : P.X (n + 2) ⟶ Q.X (n + 2)) ×'
CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) =
CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') →
(P ⟶ Q)
|
Tropical.instMulOneClassTropical._proof_2
|
Mathlib.Algebra.Tropical.Basic
|
∀ {R : Type u_1} [inst : AddZeroClass R] (x : Tropical R), x * 1 = x
|
FractionalIdeal.quotientEquiv._proof_2
|
Mathlib.RingTheory.DedekindDomain.Factorization
|
∀ {R : Type u_2} [inst : CommRing R] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra R K]
(I : FractionalIdeal (nonZeroDivisors R) K), SemilinearMapClass (↥↑I →ₗ[R] K) (RingHom.id R) (↥↑I) K
|
Lean.Elab.Do.MonadInstanceCache.recOn
|
Lean.Elab.Do.Basic
|
{motive : Lean.Elab.Do.MonadInstanceCache → Sort u} →
(t : Lean.Elab.Do.MonadInstanceCache) →
((instPure instBind cachedPure cachedBind : Option Lean.Expr) →
motive { instPure := instPure, instBind := instBind, cachedPure := cachedPure, cachedBind := cachedBind }) →
motive t
|
Lean.Parser.Command.open._regBuiltin.Lean.Parser.Command.openScoped.parenthesizer_59
|
Lean.Parser.Command
|
IO Unit
|
SummableUniformly.summable
|
Mathlib.Topology.Algebra.InfiniteSum.UniformOn
|
∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {x : β}
[inst_1 : UniformSpace α], SummableUniformly f → Summable fun x_1 => f x_1 x
|
_private.Init.Data.List.Lemmas.0.GetElem?.match_1.splitter
|
Init.Data.List.Lemmas
|
(elem : outParam (Type u_1)) →
(motive : Option elem → Sort u_2) →
(x : Option elem) → ((e : elem) → motive (some e)) → (Unit → motive none) → motive x
|
Lean.Elab.Tactic.evalSubst._regBuiltin.Lean.Elab.Tactic.evalSubst.declRange_3
|
Lean.Elab.Tactic.BuiltinTactic
|
IO Unit
|
CategoryTheory.MonoidalClosed.curry'_comp
|
Mathlib.CategoryTheory.Monoidal.Closed.Basic
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.Closed X] [inst_3 : CategoryTheory.Closed Y] (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.MonoidalClosed.curry' (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalClosed.curry' f)
(CategoryTheory.MonoidalClosed.curry' g))
(CategoryTheory.MonoidalClosed.comp X Y Z))
|
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.uniqueBaseOn_inter_ground_eq._simp_1_2
|
Mathlib.Combinatorics.Matroid.Constructions
|
∀ {α : Type u_1} (M M' : Matroid α) (X : Set α), (M.restrict X = M'.restrict X) = ∀ I ⊆ X, M.Indep I ↔ M'.Indep I
|
MeasureTheory.unifTight_iff_ennreal
|
Mathlib.MeasureTheory.Function.UnifTight
|
∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ ⦃ε : ENNReal⦄, 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ε
|
TensorProduct.rightComm._proof_2
|
Mathlib.LinearAlgebra.TensorProduct.Associator
|
∀ (R : Type u_4) [inst : CommSemiring R] (M : Type u_1) (N : Type u_2) (P : Type u_3) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P],
TensorProduct.lift
(TensorProduct.lift
(↑LinearMap.lflip ∘ₗ (TensorProduct.mk R M N).compr₂ (TensorProduct.mk R (TensorProduct R M N) P))) ∘ₗ
TensorProduct.lift
(TensorProduct.lift
(↑LinearMap.lflip ∘ₗ (TensorProduct.mk R M P).compr₂ (TensorProduct.mk R (TensorProduct R M P) N))) =
LinearMap.id
|
OrderHom.gfp_le_map
|
Mathlib.Order.FixedPoints
|
∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {a : α}, OrderHom.gfp f ≤ a → OrderHom.gfp f ≤ f a
|
Std.DTreeMap.Internal.Impl.Equiv.getEntryLE_eq._proof_1
|
Std.Data.DTreeMap.Internal.Lemmas
|
∀ {α : Type u_1} {β : α → Type u_2} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF →
t₂.WF → t₁.Equiv t₂ → ∀ {k : α} {he : ∃ a ∈ t₁, (compare a k).isLE = true}, ∃ a ∈ t₂, (compare a k).isLE = true
|
BddLat.dualEquiv._proof_1
|
Mathlib.Order.Category.BddLat
|
∀ {X Y : BddLat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id BddLat).map f)
(BddLat.Iso.mk (OrderIso.dualDual ↑Y.toLat)).hom =
CategoryTheory.CategoryStruct.comp (BddLat.Iso.mk (OrderIso.dualDual ↑X.toLat)).hom
((BddLat.dual.comp BddLat.dual).map f)
|
Lean.instInhabitedLevel
|
Lean.Level
|
Inhabited Lean.Level
|
self_le_mul_right
|
Mathlib.Algebra.Order.Monoid.Canonical.Defs
|
∀ {α : Type u} [inst : Mul α] [inst_1 : LE α] [CanonicallyOrderedMul α] (a b : α), a ≤ a * b
|
MulAction.fixedBy_one_eq_univ
|
Mathlib.GroupTheory.GroupAction.FixedPoints
|
∀ (α : Type u_1) (M : Type u_3) [inst : Monoid M] [inst_1 : MulAction M α], MulAction.fixedBy α 1 = Set.univ
|
_private.Init.Data.Nat.Div.Lemmas.0.Nat.add_div_of_dvd_add_add_one._proof_1_1
|
Init.Data.Nat.Div.Lemmas
|
∀ {c : ℕ} {a b : ℕ}, c ≠ 0 → ¬0 < c → False
|
LipschitzWith.uniformEquicontinuous
|
Mathlib.Topology.MetricSpace.UniformConvergence
|
∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace γ] [inst_1 : PseudoEMetricSpace β]
(f : α → γ → β) (K : NNReal), (∀ (c : α), LipschitzWith K (f c)) → UniformEquicontinuous f
|
WithZero.instSemiring._proof_14
|
Mathlib.Algebra.Ring.WithZero
|
∀ {α : Type u_1} [inst : Semiring α] (n : ℕ), ↑(n + 1) = ↑n + 1
|
CategoryTheory.MonoidalCategory.DayConvolution.hexagon_reverse
|
Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C]
[inst_4 : CategoryTheory.MonoidalCategory V] [inst_5 : CategoryTheory.BraidedCategory V]
(F G : CategoryTheory.Functor C V)
[inst_6 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorLeft v)]
[inst_7 :
∀ (v : V) (d : C),
CategoryTheory.Limits.PreservesColimitsOfShape
(CategoryTheory.CostructuredArrow (CategoryTheory.MonoidalCategory.tensor C) d)
(CategoryTheory.MonoidalCategory.tensorRight v)]
(H : CategoryTheory.Functor C V) [inst_8 : CategoryTheory.MonoidalCategory.DayConvolution F G]
[inst_9 : CategoryTheory.MonoidalCategory.DayConvolution G H]
[inst_10 :
CategoryTheory.MonoidalCategory.DayConvolution F (CategoryTheory.MonoidalCategory.DayConvolution.convolution G H)]
[inst_11 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution F G) H]
[inst_12 :
CategoryTheory.MonoidalCategory.DayConvolution H (CategoryTheory.MonoidalCategory.DayConvolution.convolution F G)]
[inst_13 : CategoryTheory.MonoidalCategory.DayConvolution H F]
[inst_14 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution H F) G]
[inst_15 : CategoryTheory.MonoidalCategory.DayConvolution H G]
[inst_16 :
CategoryTheory.MonoidalCategory.DayConvolution F (CategoryTheory.MonoidalCategory.DayConvolution.convolution H G)]
[inst_17 : CategoryTheory.MonoidalCategory.DayConvolution F H]
[inst_18 :
CategoryTheory.MonoidalCategory.DayConvolution (CategoryTheory.MonoidalCategory.DayConvolution.convolution F H) G],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.associator F G H).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.DayConvolution.braiding
(CategoryTheory.MonoidalCategory.DayConvolution.convolution F G) H).hom
(CategoryTheory.MonoidalCategory.DayConvolution.associator H F G).inv) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.DayConvolution.map (CategoryTheory.CategoryStruct.id F)
(CategoryTheory.MonoidalCategory.DayConvolution.braiding G H).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.associator F H G).inv
(CategoryTheory.MonoidalCategory.DayConvolution.map
(CategoryTheory.MonoidalCategory.DayConvolution.braiding F H).hom (CategoryTheory.CategoryStruct.id G)))
|
Matrix.transposeRingEquiv._proof_2
|
Mathlib.Data.Matrix.Basic
|
∀ (m : Type u_1) (α : Type u_2) [inst : AddCommMonoid α] [inst_1 : CommSemigroup α] [inst_2 : Fintype m]
(M N : Matrix m m α), MulOpposite.op (M * N).transpose = MulOpposite.op M.transpose * MulOpposite.op N.transpose
|
RingCat.Colimits.instRingColimitType._proof_8
|
Mathlib.Algebra.Category.Ring.Colimits
|
∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(x y z : RingCat.Colimits.ColimitType F), (x + y) * z = x * z + y * z
|
Batteries.Tactic.GeneralizeProofs.AContext.depth
|
Batteries.Tactic.GeneralizeProofs
|
Batteries.Tactic.GeneralizeProofs.AContext → ℕ
|
_private.Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2.0.MeasureTheory.inner_condExpL2_eq_inner_fun._simp_1_2
|
Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2
|
∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection] (v : E), ↑(U.orthogonalProjection v) = U.starProjection v
|
CategoryTheory.MonoidalCategory.tensorIso_def
|
Mathlib.CategoryTheory.Monoidal.Category
|
∀ {C : Type u} [𝒞 : CategoryTheory.Category.{v, u} C] [inst : CategoryTheory.MonoidalCategory C] {X Y X' Y' : C}
(f : X ≅ Y) (g : X' ≅ Y'),
CategoryTheory.MonoidalCategory.tensorIso f g =
CategoryTheory.MonoidalCategory.whiskerRightIso f X' ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso Y g
|
Mathlib.Tactic.ITauto.Proof.intro
|
Mathlib.Tactic.ITauto
|
Lean.Name → Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof
|
ENNReal.logOrderIso_symm
|
Mathlib.Analysis.SpecialFunctions.Log.ENNRealLogExp
|
ENNReal.logOrderIso.symm = EReal.expOrderIso
|
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_left_ne._simp_1_4
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic
|
∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b)
|
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.expr
|
Lean.Elab.Tactic.Induction
|
Lean.Elab.Tactic.ElimTargetInfo✝ → Lean.Expr
|
_private.Mathlib.NumberTheory.Harmonic.Bounds.0.harmonic_le_one_add_log._simp_1_3
|
Mathlib.NumberTheory.Harmonic.Bounds
|
∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True
|
Mathlib.Tactic.FieldSimp.DenomCondition.none.sizeOf_spec
|
Mathlib.Tactic.FieldSimp
|
∀ {v : Lean.Level} {M : Q(Type v)} {iM : Q(GroupWithZero «$M»)}, sizeOf Mathlib.Tactic.FieldSimp.DenomCondition.none = 1
|
CategoryTheory.Functor.Monoidal.ε_η._autoParam
|
Mathlib.CategoryTheory.Monoidal.Functor
|
Lean.Syntax
|
Array.count_pos_iff
|
Init.Data.Array.Count
|
∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, 0 < Array.count a xs ↔ a ∈ xs
|
CategoryTheory.Limits.Pi.ι_π_eq_id
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{β : Type w} [inst_2 : DecidableEq β] (f : β → C) [inst_3 : CategoryTheory.Limits.HasProduct f] (b : β),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.ι f b) (CategoryTheory.Limits.Pi.π f b) =
CategoryTheory.CategoryStruct.id (f b)
|
Lean.Parser.ParserExtension.Entry.parser.sizeOf_spec
|
Lean.Parser.Extension
|
∀ (catName declName : Lean.Name) (leading : Bool) (p : Lean.Parser.Parser) (prio : ℕ),
sizeOf (Lean.Parser.ParserExtension.Entry.parser catName declName leading p prio) =
1 + sizeOf catName + sizeOf declName + sizeOf leading + sizeOf p + sizeOf prio
|
continuous_sup
|
Mathlib.Topology.Order.Lattice
|
∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Max L] [ContinuousSup L], Continuous fun p => p.1 ⊔ p.2
|
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.induct_roo_left._proof_1_1
|
Init.Data.Range.Polymorphic.NatLemmas
|
∀ (a b : ℕ), b - a - 1 = 0 → ¬b ≤ a + 1 → False
|
Lean.Meta.Grind.Clean.State.rec
|
Lean.Meta.Tactic.Grind.Types
|
{motive : Lean.Meta.Grind.Clean.State → Sort u} →
((used : Lean.PHashSet Lean.Name) → (next : Lean.PHashMap Lean.Name ℕ) → motive { used := used, next := next }) →
(t : Lean.Meta.Grind.Clean.State) → motive t
|
IsLocalization.Away.algebraMap_pow_isUnit
|
Mathlib.RingTheory.Localization.Away.Basic
|
∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x : R)
[IsLocalization.Away x S] (n : ℕ), IsUnit ((algebraMap R S) x ^ n)
|
Filter.mem_prod_top
|
Mathlib.Order.Filter.Prod
|
∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {s : Set (α × β)}, s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f
|
CategoryTheory.Mon.instSymmetricCategory._proof_7
|
Mathlib.CategoryTheory.Monoidal.Mon_
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (X_1 Y Z : CategoryTheory.Mon C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X_1 Y Z).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Mon.mkIso' (β_ X_1.X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z).X)).hom
(CategoryTheory.MonoidalCategoryStruct.associator Y Z X_1).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Mon.mkIso' (β_ X_1.X Y.X)).hom Z)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Y X_1 Z).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y (CategoryTheory.Mon.mkIso' (β_ X_1.X Z.X)).hom))
|
uniformity_hasBasis_closed
|
Mathlib.Topology.UniformSpace.Basic
|
∀ {α : Type ua} [inst : UniformSpace α], (uniformity α).HasBasis (fun V => V ∈ uniformity α ∧ IsClosed V) id
|
_private.Mathlib.SetTheory.Cardinal.Finite.0.ENat.card_pos._simp_1_2
|
Mathlib.SetTheory.Cardinal.Finite
|
∀ (α : Type u_3), (ENat.card α ≠ 0) = Nonempty α
|
instInhabitedRingInvo
|
Mathlib.RingTheory.RingInvo
|
(R : Type u_2) → [inst : CommRing R] → Inhabited (RingInvo R)
|
Mathlib.Tactic.BicategoryCoherence.liftHom₂AssociatorHom
|
Mathlib.Tactic.CategoryTheory.BicategoryCoherence
|
{B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
[inst_3 : Mathlib.Tactic.BicategoryCoherence.LiftHom h] →
Mathlib.Tactic.BicategoryCoherence.LiftHom₂ (CategoryTheory.Bicategory.associator f g h).hom
|
List.replace_of_not_mem
|
Init.Data.List.Lemmas
|
∀ {α : Type u_1} [inst : BEq α] {a b : α} [LawfulBEq α] {l : List α}, a ∉ l → l.replace a b = l
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.