name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicClosure.instGroupWithZero._proof_8 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | [
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"AlgebraicClosure.maxIdeal.isMaximal",
"AddMonoidAlgebra.commRing",
"CommSemiring.toSemiring",
"Finsupp.instAddMonoid",
"Nat.instAddMonoid",
"DivisionSemiring.zpow_zero'",
"Int",
"Ideal",
"autoParam",
"Field.toSemifield",
"Finsupp.instAddC... | false |
TensorProduct.quotientTensorQuotientEquiv._proof_9 | Mathlib.LinearAlgebra.TensorProduct.Quotient | [
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"IsScalarTower",
"TensorProduct.addCommGroup",
"AddCommGroup",
"CommRing.toCommSemiring",
"Monoid.toSemigroup",
"Monoid.toMulAction",
"TensorProduct",
"Module.toDistribMulAction",
"SemigroupAction.toSMul",
"AddCommMonoid.... | false |
CategoryTheory.Functor.whiskeringLeft₃ObjObjMap_app | Mathlib.CategoryTheory.Whiskering | [
"CategoryTheory.Functor.whiskeringLeft₃ObjObjMap",
"CategoryTheory.Functor",
"CategoryTheory.Functor.whiskeringLeft₃ObjObjObj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.whiskerLeft",
"CategoryThe... | true |
PolynomialLaw.instZero._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | [
"AlgHom.toLinearMap",
"SemilinearMapClass.distribMulActionSemiHomClass",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"TensorProduct.addCommMonoid",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"Algebra",
"RingHom",
"Function.comp",
"AddZeroClass.toAddZero",
"map_zero",
"Algebr... | false |
FirstOrder.Language.isFraisse_finite_linear_order | Mathlib.ModelTheory.Order | [
"instNoBotOrderOfNoMinOrder",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"MulZeroClass.toMul",
"instNoMaxOrderOfNontrivial",
"Finite",
"Rat.nontrivial",
"Rat",
"setOf",
"Rat.linearOrder",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"FirstOrder.Language.ord... | true |
TestFunction.monoCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | [
"TopologicalSpace.Opens.instPartialOrder",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"TopologicalSpace.Opens",
"Preorder.toLE",
"HasSubset.Subset.trans",
"Set.instIsTransSubset",
"HasSubset.Subset",
"LE.le",
"TopologicalSpace.Opens.instSetLike",
"instLEENat",
"And",
"Sem... | false |
CategoryTheory.Cat.freeMapIdIso | Mathlib.CategoryTheory.Category.Quiv | [
"CategoryTheory.Functor",
"Prefunctor.id",
"CategoryTheory.Paths.categoryPaths",
"CategoryTheory.Paths",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.id",
"CategoryTheory.Iso.refl",
"CategoryTheory.Iso",
"CategoryTheory.Cat.freeMapIdIso._proof_2",
"CategoryTheory.Cat.freeMap",
"Qui... | true |
ULift.addGroup._proof_4 | Mathlib.Algebra.Group.ULift | [
"Equiv.instEquivLike",
"ULift",
"HSub.hSub",
"ULift.sub",
"Equiv.ulift",
"Equiv",
"SubNegMonoid.toSub",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike"
] | false |
CategoryTheory.Limits.Types.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"Equiv.instEquivLike",
"CategoryTheory.Functor.ColimitType",
"Equiv",
"CategoryTheory.Functor.coconeTypesEquiv",
"CategoryTheory.Functor.CoconeTypes",
"CategoryTheory.types",
"CategoryTheory.Functor.CoconeTypes.postcomp",
"Shrink",
"Categ... | true |
Nat.recOnPrimePow._proof_2 | Mathlib.Data.Nat.Factorization.Induction | [
"Nat.Prime",
"Nat.minFac",
"instOfNatNat",
"Nat.succ_succ_ne_one",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Nat.minFac_prime"
] | false |
Lean.Meta.instInhabitedCaseArraySizesSubgoal.default | Lean.Meta.Match.CaseArraySizes | [
"Inhabited.default",
"Lean.Meta.CaseArraySizesSubgoal.mk",
"Lean.MVarId",
"Lean.instInhabitedMVarId",
"Lean.FVarId",
"Array",
"Lean.Meta.instInhabitedFVarSubst",
"Array.instInhabited",
"Lean.Meta.FVarSubst",
"Lean.Meta.CaseArraySizesSubgoal"
] | true |
FiniteField.instFieldExtension._proof_68 | Mathlib.FieldTheory.Finite.Extension | [
"Ring.mk",
"FiniteField.instFieldExtension._aux_34",
"instFieldGaloisField._proof_68",
"FiniteField.instFieldExtension._aux_66",
"FiniteField.instFieldExtension._proof_27",
"Mul.mk",
"Nat.Prime",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"FiniteField.instFieldExtension._proof_46",
"One.mk",... | false |
CategoryTheory.Limits.SequentialProduct.functorObj_eq_neg | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | [
"dif_neg",
"dite",
"Nat",
"LT.lt",
"Nat.decLt",
"instLTNat",
"Eq",
"Not"
] | true |
AddAction.vadd_mem_fixedBy_iff_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | [
"Eq.mpr",
"AddMonoid.toAddSemigroup",
"congrArg",
"Iff.rfl",
"AddAction.fixedBy",
"Membership.mem",
"id",
"HVAdd.hVAdd",
"AddAction",
"AddAction.toAddSemigroupAction",
"AddGroup",
"Iff",
"AddSemigroupAction.toVAdd",
"AddAction.mem_fixedBy",
"AddGroup.toSubNegMonoid",
"propext",
"inst... | true |
instCompleteLinearOrderWithBotENat._proof_12 | Mathlib.Data.ENat.Lattice | [
"instCompleteLatticeWithBot",
"WithBot",
"Lattice.toSemilatticeSup",
"instCompleteLinearOrderENat",
"CompleteLattice.toLattice",
"CompletelyDistribLattice.toCompleteLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"WithBot.WithTop.completeLinearOrder._proof_7... | false |
Lean.Parser.Term.binrel._regBuiltin.Lean.Parser.Term.binrel_1 | Lean.Parser.Term | [
"IO",
"Unit",
"Lean.Parser.Term.binrel",
"Lean.Parser.addBuiltinLeadingParser",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | false |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_apply_zero_of_even._simp_1_2 | Mathlib.NumberTheory.LSeries.ZMod | [
"Finset.mem_univ",
"Finset.univ",
"Finset",
"Membership.mem",
"Fintype",
"Finset.instSetLike",
"True",
"eq_true",
"Eq",
"SetLike.instMembership"
] | false |
_private.Plausible.Gen.0.Plausible.Gen.runUntil.repeatGen.match_1 | Plausible.Gen | [
"Unit.unit",
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"instOfNatNat",
"dite",
"_private.Plausible.Gen.0.Plausible.Gen.runUntil.repeatGen._sparseCasesOn_1",
"Unit",
"Nat",
"Eq.ndrec_symm",
"instDecidableEqNat",
"OfNat.ofNat",
"Eq",
"Not",
"Option"
] | false |
LieModule.Weight.mk | Mathlib.Algebra.Lie.Weights.Basic | [
"CommRing",
"LieSubmodule.instBot",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieRing.IsNilpotent",
"LieSubmodule",
"AddCommGroup",
"Ne",
"Bot.bot",
"LieModule.Weight.mk",
"LieRing",
"CommRing.toCommSemiring",
"LieRingModule",
"LieAlgebra",
"LieModule.genWeightSpace",
... | true |
MeasureTheory.FiniteMeasure.restrict_apply | Mathlib.MeasureTheory.Measure.FiniteMeasure | [
"MeasureTheory.FiniteMeasure",
"MeasureTheory.Measure",
"MeasurableSet",
"MeasureTheory.Measure.restrict_apply",
"NNReal",
"ENNReal.toNNReal",
"Set.instInter",
"MeasureTheory.FiniteMeasure.instFunLike",
"Inter.inter",
"congr_arg",
"MeasurableSpace",
"ENNReal",
"MeasureTheory.FiniteMeasure.to... | true |
Rep.FiniteCyclicGroup.groupCohomologyIsoEven._proof_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.FiniteCyclic | [
"Nat.instMulZeroClass",
"Nat.recAux",
"Nat.instOne",
"congrArg",
"False.elim",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.instAddCancelCommMonoid",
"ComplexShape.prev",
"instOfNatNat",
"CochainComplex.prev_nat_succ",
"instHAdd",
"AddSemigroup.toA... | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Countable.0.CategoryTheory.Limits.IsFiltered.sequentialFunctor_final._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Countable | [
"List.isChain_singleton",
"List.IsChain",
"List.cons",
"True",
"eq_true",
"Eq",
"List.nil"
] | false |
NumberField.mixedEmbedding.negAt_apply_isComplex | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | [
"instInnerProductSpaceRealComplex",
"Pi.Function.module",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Pi.addCommMonoid",
"Complex.instNormedAddCommGroup",
"NumberField.mixedEmbedding.negAt",
"Pi.topologicalSpace",
"Real.instRCLike",
"NormedSpace.toModule",
... | true |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_sigma0_eq_sum_div._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | [
"Lean.RArray.leaf",
"False",
"Nat.instMulZeroClass",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"instHDiv",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Finset",
"Classical.byContradiction",
"Lean.Grind.Nat.lt_eq",
"Preorder.... | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go._unsafe_rec | Lean.Meta.Tactic.Grind.Types | [
"Pure.pure",
"_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go.match_1",
"Lean.Meta.Grind.Goal",
"_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go._unsafe_rec",
"Array.push",
"Monad.toApplicative",
"Lean.Meta.Sym.isSameExpr",
"Lean.Meta.Grind.Goal.getNext?",... | false |
LocalSubring.instPartialOrder._proof_2 | Mathlib.RingTheory.LocalRing.LocalSubring | [
"CommRing",
"Subring.instSetLike",
"Subring.instSubringClass",
"CommRing.toNonAssocCommRing",
"Subring",
"SubringClass",
"NonAssocCommRing.toNonAssocRing"
] | false |
Lean.Compiler.LCNF.MonadFVarSubstState.recOn | Lean.Compiler.LCNF.CompilerM | [
"Lean.Compiler.LCNF.MonadFVarSubstState.mk",
"Lean.Compiler.LCNF.Purity",
"Unit",
"Lean.Compiler.LCNF.MonadFVarSubstState",
"Lean.Compiler.LCNF.MonadFVarSubstState.rec",
"Lean.Compiler.LCNF.FVarSubst"
] | false |
PadicComplex.instRankOneNNRealV._proof_6 | Mathlib.NumberTheory.Padics.Complex | [
"Nat.Prime",
"PadicAlgCl.valued",
"Field.toDivisionRing",
"Fact",
"NNReal",
"DivisionRing.toRing",
"CompletableTopField",
"instFieldPadic",
"Valued.toUniformSpace",
"NNReal.instLinearOrderedCommGroupWithZero",
"Nat",
"AlgebraicClosure.instField",
"Padic",
"Valued.completable",
"PadicAlgC... | false |
_private.Mathlib.Data.Finset.Image.0.Finset.coe_map_subset_range._proof_1_1 | Mathlib.Data.Finset.Image | [
"of_eq_false",
"False",
"Set.mem_range",
"forall_not_of_not_exists",
"eq_false",
"Lean.Grind.iff_eq",
"Set.subset_def",
"Finset",
"Classical.byContradiction",
"Finset.map",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"HasSubset.Subset",
"Lean.Grind.eq_false_of_imp_eq_false",
"Function... | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.G2_slash_action._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | [
"Membership.mem",
"Set.instSingletonSet",
"Set.mem_singleton_iff",
"propext",
"Singleton.singleton",
"Eq",
"Set.instMembership",
"Set"
] | false |
List.Vector.ofFn | Mathlib.Data.Vector.Defs | [
"Fin.succ",
"List.Vector",
"List.Vector.ofFn._proof_1",
"Nat.brecOn",
"Fin.instOfNat",
"instOfNatNat",
"Nat.below",
"List.Vector.ofFn.match_1",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"List.Vector.nil",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"List.Vector.cons"
] | true |
_private.Mathlib.SetTheory.Cardinal.Pigeonhole.0.Cardinal.le_range_of_union_finset_eq_univ._simp_1_1 | Mathlib.SetTheory.Cardinal.Pigeonhole | [
"not_le",
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"LT.lt",
"propext",
"LinearOrder.toPartialOrder",
"Eq",
"Not"
] | false |
Localization.mkHom_surjective | Mathlib.GroupTheory.MonoidLocalization.Basic | [
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Quot.ind",
"Prod.instMulOneClass",
"Membership.mem",
"Exists",
"Subtype",
"Localization",
"Submonoid.toMulOneClass",
"Prod.mk",
"MulOneClass.toMulOne",
"OreLocalization.oreSetComm",
"CommMonoid.toMonoid",
"Localization.mkHom"... | true |
MonoidHom.toAdditive._proof_5 | Mathlib.Algebra.Group.TypeTags.Hom | [
"AddMonoidHom.map_zero",
"Additive",
"AddZeroClass.toAddZero",
"Additive.addZeroClass",
"AddZero.toZero",
"Zero.toOfNat0",
"AddMonoidHom",
"MulOneClass",
"AddMonoidHom.instFunLike",
"OfNat.ofNat",
"Eq",
"DFunLike.coe"
] | false |
AddGroupSeminormClass.toSeminormedAddGroup.congr_simp | Mathlib.Analysis.Normed.Order.Hom.Ultra | [
"Real.partialOrder",
"Real",
"AddGroupSeminormClass",
"SeminormedAddGroup",
"Eq.rec",
"AddGroupSeminormClass.toSeminormedAddGroup",
"AddGroup",
"Real.instAddCommMonoid",
"Eq.refl",
"Eq",
"FunLike"
] | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_completedSinZeta._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | [
"Int.cast",
"Int.cast_abs",
"AddGroupWithOne.toAddGroup",
"abs",
"LinearOrder",
"IsStrictOrderedRing",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Int",
"AddGroupWithOne.toIntCast",
"instLatticeInt",
"Int.instAddGroup",
"Eq.symm",
"Ring.toSemiring",
"Eq",
"Ring",
"R... | false |
instFinitePresentation | Mathlib.Algebra.Module.FinitePresentation | [
"Semiring.toModule",
"Ring.toNonAssocRing",
"AddCommGroup.toAddCommMonoid",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"NonAssocRing.toNonUnitalNonAssocRing",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Module.Finite.self",
"Module.Projective.of_free",
"Ring.toAddCommGroup",
"Module.Fi... | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | [
"Lean.Expr",
"Lean.Meta.Simp.Arith.Int.ToLinear.State.casesOn",
"Array",
"Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusionType",
"Nat",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Meta.KExprMap",
"Lean.Meta.Simp.Arith.Int.ToLinear.State"
] | false |
Std.TreeSet.get?_eq_some_iff | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Option.some",
"Membership.mem",
"Exists",
"Ordering",
"Std.TreeSet.inner",
"Std.TransCmp",
"Std.TreeMap.getKey?_eq_some_iff",
"Unit",
"Iff",
"Std.TreeSet.get?",
"Eq",
"Std.TreeSet.instMembership",
"Std.TreeSet.get",
"Option"
] | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | [
"NonUnitalNonAssocRing",
"HMul.hMul",
"NonUnitalNonAssocRing.toAddCommGroup",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"SubNegMonoid.toSub",
"sub_mul",
"instHSub",
"AddGroup.toSubNegMonoid",
"Distrib.toMul",
"NonUnitalNonAssocSemiring.toDistr... | false |
FirstOrder.Language.LHom.realize_onBoundedFormula | Mathlib.ModelTheory.Semantics | [
"FirstOrder.Language.BoundedFormula.imp",
"Eq.mpr",
"FirstOrder.Language.LHom.onRelation",
"congrArg",
"Iff.rfl",
"FirstOrder.Language.Relations.boundedFormula",
"FirstOrder.Language.LHom.onTerm",
"FirstOrder.Language.Term.bdEqual",
"Function.comp",
"FirstOrder.Language.Term",
"Fin.snoc",
"Sum... | true |
Submodule.singleton_smul | Mathlib.Algebra.Algebra.Operations | [
"Eq.mpr",
"Submodule",
"Submodule.instAddCommMonoidWithOne",
"SetSemiring.down",
"RingHomSurjective.ids",
"Algebra.to_smulCommClass",
"instHSMul",
"Equiv.instEquivLike",
"HMul.hMul",
"IsScalarTower.right",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"SetSemirin... | true |
intervalIntegral.intervalIntegrable_log'._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | [
"Real",
"IntervalIntegrable",
"PseudoMetricSpace.toUniformSpace",
"Real.measureSpace",
"Real.normedAddCommGroup",
"NormedAddGroup.toENormedAddMonoid",
"Real.log",
"MeasureTheory.MeasureSpace.volume",
"NormedAddCommGroup.toNormedAddGroup",
"True",
"eq_true",
"Real.pseudoMetricSpace",
"Uniform... | false |
Lean.Server.FileWorker.SemanticTokensState.recOn | Lean.Server.FileWorker.SemanticHighlighting | [
"Lean.Server.FileWorker.SemanticTokensState.mk",
"Lean.Server.FileWorker.SemanticTokensState",
"Lean.Server.FileWorker.SemanticTokensState.rec"
] | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | [
"CategoryTheory.ShortComplex.Exact.gIsCokernel",
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.Limits.Fork.ofι",
"CategoryTheory.Limits.KernelFork.ofι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.Wa... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne.match_1.congr_eq_1._sparseCasesOn_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.rec",
"List.cons",
"Nat.land",
"List",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"List.ctorIdx",
"List.nil"
] | false |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | [
"HSub.hSub",
"Nat.instMod",
"instHMod",
"instSubNat",
"HMod.hMod",
"_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_3",
"instHSub",
"Std.Sat.AIG",
"Nat",
"LT.lt",
"Decidable.byContradiction",
... | false |
Algebra.TensorProduct.basis_apply | Mathlib.RingTheory.TensorProduct.Free | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"CommSemiring.toSemiring",
"TensorProduct.addCommMonoid",
"Algebra",
"Algebra.toModule",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Module.Basis.instFunLike",
"AddCommMonoid",
"CommSemiring",
"NonUnita... | true |
Finset.surjOn_of_injOn_of_card_le | Mathlib.Data.Finset.Card | [
"subset_refl._simp_1",
"Eq.mpr",
"SetLike.mem_coe._simp_1",
"LE.le.trans_eq",
"congrArg",
"Finset",
"Finset.mem_image._simp_1",
"Set.SurjOn",
"Classical.propDecidable",
"Membership.mem",
"Exists",
"Finset.coe_image",
"id",
"_private.Mathlib.Data.Finset.Card.0.Finset.surjOn_of_injOn_of_card... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.not_cliqueFree_of_isTuranMaximal._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | [
"Exists",
"exists_prop",
"And",
"propext",
"Eq"
] | false |
Std.ExtDTreeMap.getKey!_erase_self | Std.Data.ExtDTreeMap.Lemmas | [
"Inhabited.default",
"Std.DTreeMap",
"Std.ExtDTreeMap.erase",
"Ordering",
"Std.DTreeMap.getKey!_erase_self",
"Std.TransCmp",
"Std.ExtDTreeMap.getKey!",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Inhabited",
"Eq"
] | true |
CategoryTheory.Bicategory.Adj.Hom₂.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | [
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Bicategory.Adj.Hom.l",
"Quiver.Hom",
"Equiv",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory.Adj.obj",
"autoParam",
"CategoryTheory.Bicategory.Adj.Hom₂",
"CategoryTheory.Bicategory",
"And",... | true |
CategoryTheory.OplaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | [
"CategoryTheory.OplaxFunctor._sizeOf_1",
"CategoryTheory.Bicategory",
"SizeOf.mk",
"CategoryTheory.OplaxFunctor",
"SizeOf"
] | false |
List.foldl_nil | Init.Data.List.Basic | [
"List.foldl",
"Eq",
"rfl",
"List.nil"
] | true |
DomMulAct.smul_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | [
"DomMulAct",
"instHSMul",
"MeasureTheory.Measure",
"SMul",
"MeasureTheory.AEEqFun",
"DomMulAct.instSMulAEEqFun",
"MeasurableSpace",
"TopologicalSpace",
"HSMul.hSMul",
"MeasurableConstSMul",
"Eq",
"MeasureTheory.SMulInvariantMeasure",
"rfl",
"MeasureTheory.AEEqFun.const"
] | true |
ListSlice.toArray_toList | Init.Data.Slice.List.Lemmas | [
"Std.Slice.toList",
"Std.Iter.toArray_toList",
"Std.Iterators.Types.Take.instIterator",
"Std.Slice.Internal.ListSliceData",
"ListSlice.instToIterator",
"Std.Iterators.Types.ListIterator.instFinite",
"Std.Iterators.Types.ListIterator",
"Std.Slice.toArray",
"congrArg",
"Monad.toApplicative",
"Std.... | true |
CategoryTheory.Abelian.SpectralObject.E._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_projective.match_1_1 | Mathlib.Algebra.Module.FinitePresentation | [
"LinearMap.id",
"Pi.Function.module",
"Semiring.toModule",
"Pi.addCommMonoid",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"Exists",
"AddCommGroup",
"LinearMap",
"And.casesOn",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"LinearMap.comp",
"And",
"Exists.casesOn",
"NonAssocS... | false |
CategoryTheory.Bicategory.toNatTrans_conjugateEquiv | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"Equiv.trans",
"CategoryTheory.Functor.category",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryTh... | true |
SheafOfModules.Presentation.mapRelations._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | [
"CategoryTheory.Limits.PreservesColimitsOfSize",
"CategoryTheory.Functor",
"AddCommGrpCat.instCategory",
"SheafOfModules.Presentation",
"CategoryTheory.HasSheafify",
"AddMonoid.toAddZeroClass",
"RingCat.ring",
"AddCommGroup.toAddGroup",
"RingHom",
"AddCommGrpCat.instConcreteCategoryAddMonoidHomCar... | false |
Con.subgroup._proof_3 | Mathlib.GroupTheory.QuotientGroup.Defs | [
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"Con.refl",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"One.toOfNat1",
"Con",
"OfNat.ofNat",
... | false |
Std.Internal.List.getKey?_minKeyD | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Ord",
"congrArg",
"Std.TransOrd",
"Option.some",
"Eq.mp",
"Std.Internal.List.minKey_eq_minKeyD",
"Std.Internal.List.minKeyD",
"List",
"List.isEmpty",
"congr",
"Std.Internal.List.getKey?_minKey",
"Bool",
"Std.LawfulBEqOrd",
"Std.Internal.List.minKey",
... | true |
Subgroup.instMulActionLeftTransversal | Mathlib.GroupTheory.Complement | [
"instHSMul",
"Subgroup.instMulActionLeftTransversal._proof_3",
"MulAction.QuotientAction",
"Group",
"DivInvMonoid.toMonoid",
"Subgroup",
"SMul.mk",
"SemigroupAction.mk",
"Subtype.mk",
"Group.toDivInvMonoid",
"Subgroup.LeftTransversal",
"SetLike.coe",
"Subgroup.instMulActionLeftTransversal._p... | true |
Lean.Lsp.CancelParams.mk._flat_ctor | Lean.Data.Lsp.CancelParams | [
"Lean.Lsp.CancelParams.mk",
"Lean.JsonRpc.RequestID",
"Lean.Lsp.CancelParams"
] | false |
AddHom.srangeRestrict.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | [
"AddSubsemigroup.instSetLike",
"AddHom",
"AddHom.srangeRestrict._proof_1",
"Membership.mem",
"AddSubsemigroup.instAddMemClass",
"AddHom.srange",
"Subtype",
"AddMemClass.add",
"AddSubsemigroup",
"Eq.refl",
"AddHom.codRestrict",
"AddHom.srangeRestrict",
"Eq",
"SetLike.instMembership",
"Add... | true |
Lean.Grind.AC.Context.noConfusionType | Init.Grind.AC | [
"Lean.Grind.AC.Context",
"PLift",
"Lean.RArray",
"Lean.Grind.AC.Context.casesOn",
"HEq"
] | false |
Decidable.and_iff_not_not_or_not | Init.PropLemmas | [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"Decidable",
"id",
"Decidable.not_and_iff_not_or_not",
"And",
"Iff",
"propext",
"Decidable.not_not",
"Or",
"instDecidableAnd",
"Eq.symm",
"Eq",
"Not"
] | true |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | [
"String.Slice",
"String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher",
"Nat"
] | false |
Set.piecewise | Mathlib.Logic.Function.Basic | [
"Decidable",
"Membership.mem",
"Set.instMembership",
"ite",
"Set"
] | true |
Lean.Elab.Term.Do.Code._sizeOf_5_eq | Lean.Elab.Do.Legacy | [
"Lean.Elab.Term.Do.AltExpr._sizeOf_inst",
"congrArg",
"Lean.Elab.Term.Do.Code._sizeOf_inst",
"Lean.Elab.Term.Do.Code._sizeOf_5",
"instOfNatNat",
"List.rec",
"List.cons",
"List",
"instHAdd",
"List.cons.sizeOf_spec",
"HAdd.hAdd",
"Lean.Elab.Term.Do.AltExpr",
"Nat",
"List._sizeOf_inst",
"Si... | false |
ArithmeticFunction.instCommRing._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | [
"ArithmeticFunction.instAddGroup",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"ArithmeticFunction.instSemiring",
"CommRing.toNonUnitalCommRing",
"ArithmeticFunction.instNeg",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGroup",
"CommSemiring.toSemiring",
"HSub.hSub",
"NonU... | false |
Std.ExtHashMap.mem_map | Std.Data.ExtHashMap.Lemmas | [
"Std.ExtHashMap.contains",
"Std.ExtHashMap.contains_map",
"congrArg",
"Membership.mem",
"LawfulHashable",
"Std.ExtHashMap",
"iff_self",
"Bool.true",
"Iff",
"EquivBEq",
"congr",
"True",
"Bool",
"of_eq_true",
"congrFun'",
"Hashable",
"_private.Std.Data.ExtHashMap.Lemmas.0.Std.ExtHashMa... | true |
ULift.algebra._proof_4 | Mathlib.Algebra.Algebra.Basic | [
"RingHom.map_add'",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"ULift",
"ULift.nonAssocSemiring",
"Algebra",
"algebraMap",
"AddZeroClass.toAddZero",
"ULift.add",
"Distrib.toAdd",
"NonAssocSemiring.toMulZeroOneClass",
"A... | false |
CategoryTheory.Functor.ReflectsMonomorphisms | Mathlib.CategoryTheory.Functor.EpiMono | [
"CategoryTheory.Functor.ReflectsMonomorphisms.mk",
"CategoryTheory.Functor",
"CategoryTheory.Category"
] | true |
_private.Init.Data.Array.Attach.0.Array.attachWithImpl | Init.Data.Array.Attach | [
"Array.instMembership",
"Membership.mem",
"Subtype",
"Array",
"unsafeCast"
] | true |
Valuation.RankOne.mk | Mathlib.RingTheory.Valuation.RankOne | [
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Valuation.RankOne.mk",
"Valuation.RankOne",
"LinearOrderedCommGroupWithZero",
"Valuation.IsNontrivial",
"Valuation.RankLeOne",
"Ring",
"Valuation"
] | true |
Lean.Compiler.LCNF.Closure.State.mk.injEq | Lean.Compiler.LCNF.Closure | [
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Compiler.LCNF.Closure.State.mk",
"Lean.Compiler.LCNF.Purity.pure",
"Array",
"And",
"Lean.Compiler.LCNF.CodeDecl",
"Lean.Compiler.LCNF.Closure.State",
"Eq.ndrec",
"Lean.Compiler.LCNF.Closure.State.mk.inj",
"Eq.refl",
"Lean.Compiler.LCNF.Param",
"Eq",... | true |
ZeroAtInftyContinuousMap.instNonUnitalCommSemiring._proof_6 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | [
"ZeroAtInftyContinuousMap.instNonUnitalCommSemiring._proof_2",
"HMul.hMul",
"MulZeroClass.toMul",
"IsTopologicalSemiring",
"IsTopologicalSemiring.toContinuousMul",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"ZeroAtInftyContinuousMap.instFunLike",
"ZeroAtInftyContinuousMap.instMul",
"NonUnitalSemiri... | false |
IsCompactOpenCovered.empty | Mathlib.Topology.Sets.CompactOpenCovered | [
"Set.finite_empty",
"False",
"Set.mem_empty_iff_false._simp_1",
"Iff.of_eq",
"congrArg",
"TopologicalSpace.Opens",
"Set.Finite",
"Membership.mem",
"Exists",
"IsCompactOpenCovered",
"TopologicalSpace.Opens.instSetLike",
"TopologicalSpace.Opens.carrier",
"TopologicalSpace",
"funext",
"Set.... | true |
Real.cauchy_intCast | Mathlib.Data.Real.Basic | [
"Int.cast",
"Real",
"Real.cauchy",
"abs",
"IsAbsoluteValue.abs_isAbsoluteValue",
"Rat",
"CauSeq.Completion.Cauchy",
"Rat.linearOrder",
"Rat.instLattice",
"Rat.instDivisionRing",
"DivisionRing.toRing",
"Int",
"Rat.instField",
"Real.instIntCast",
"Rat.instIsStrictOrderedRing",
"Rat.addGr... | true |
map_inv₀ | Mathlib.Algebra.GroupWithZero.Units.Lemmas | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"DivInvMonoid.toInv",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"eq_inv_of_mul_eq_one_left",
"DivInvOneMonoid.toInvOneClass",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"c... | true |
IsLocalization.Away.mapₐ.congr_simp | Mathlib.RingTheory.ZariskisMainTheorem | [
"CommSemiring.toSemiring",
"AlgHom",
"IsScalarTower",
"AlgHom.funLike",
"IsLocalization.Away",
"Algebra",
"Algebra.toSMul",
"Eq.rec",
"IsLocalization.Away.mapₐ",
"CommSemiring",
"Eq.ndrec",
"Eq.refl",
"Eq",
"DFunLike.coe"
] | true |
Int16.sub_right_inj._simp_1 | Init.Data.SInt.Lemmas | [
"Int16",
"HSub.hSub",
"instHSub",
"propext",
"instSubInt16",
"Int16.sub_right_inj",
"Eq"
] | false |
RootPairing.rootSpan_eq_top_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | [
"Eq.mpr",
"RootPairing.finrank_corootSpan_eq'",
"Submodule",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"Module.IsReflexive",
"RootPairing.flip",
"RootPairing.isPerfPair_toLinearMap",
"Mem... | true |
Lean.Meta.FunInd.Collector.saveFunInd | Lean.Meta.Tactic.FunIndCollect | [
"Lean.Meta.FunIndInfo",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"MonadState.get",
"IO",
"StateRefT'.instMonadStateOfOfMonadLiftTST",
"ReaderT.instMonad",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"liftM",
... | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_37 | Mathlib.GroupTheory.Perm.Cycle.Type | [
"Lean.Grind.Nat.lt_eq",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List.filter",
"LT.lt",
"Eq.substr",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"Decidable.decide",
"Eq",
"List.length",
"List.nil",
"DecidableEq"
] | false |
CharP.subsemiring | Mathlib.Algebra.CharP.Subring | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"Dvd.dvd",
"Subsemiring.instSetLike",
"outParam",
"Subsemiring.subtype",
"congrArg",
"AddMonoid.toAddZeroClass",
"Subsemiring.toNonAssocSemiring",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"RingHom",
"Membersh... | true |
_private.Mathlib.RingTheory.ChainOfDivisors.0.pow_image_of_prime_by_factor_orderIso_dvd._simp_1_1 | Mathlib.RingTheory.ChainOfDivisors | [
"Monoid",
"Associates.bot_eq_one",
"Bot.bot",
"Associates",
"Associates.instBot",
"One.toOfNat1",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Associates.instOne"
] | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_316 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.finsetCongr_piAntidiag_eq_antidiag._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Pi | [
"Equiv.instEquivLike",
"Equiv",
"propext",
"Equiv.symm",
"Eq.symm",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike",
"Equiv.eq_symm_apply"
] | false |
Std.HashMap.getElem!_alter_self | Std.Data.HashMap.Lemmas | [
"Std.HashMap.alter",
"Membership.mem",
"Option.get!",
"Std.HashMap",
"LawfulHashable",
"EquivBEq",
"Inhabited",
"Hashable",
"GetElem?.getElem?",
"Std.HashMap.instGetElem?Mem",
"Std.HashMap.inner",
"BEq",
"Eq",
"GetElem?.getElem!",
"Std.DHashMap.Const.get!_alter_self",
"Std.HashMap.inst... | true |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | [
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.Functor.PushoutObjObj",
"CategoryTheory.Functor.category",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.PushoutObjObj.ι",
"CategoryTheory.Functor.id",
"CategoryTheory.Comma.hom",
"CategoryTheory.Iso",
"CategoryTheory.I... | true |
_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.rec | Lean.Meta.MethodSpecs | [
"_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecTheorem",
"Array",
"_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo",
"Bool",
"Lean.Name",
"Prod",
"_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.mk"
] | false |
Pi.nonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.Ring.Pi | [
"Pi.addCommMonoid",
"AddMonoid.toAddSemigroup",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"AddCommMonoid.add_comm",
"AddCommMonoid.toAddMonoid",
"NonUnitalNonAssocSemiring",
"Eq"
] | false |
CategoryTheory.Limits.Multiequalizer.lift_ι_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"CategoryTheory.Limits.multiequalizer",
"CategoryTheory.Limits.MulticospanShape.snd",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.MulticospanShape.L",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryThe... | true |
Array.ne_push_self._simp_1 | Init.Data.Array.Lemmas | [
"False",
"eq_false",
"Array.push",
"Array",
"Array.ne_push_self",
"Eq"
] | false |
Set.add_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"trivial",
"add_neg_cancel_left",
"Set.univ",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"_private.Mathlib.Algebra.Group.Point... | true |
ContinuousMap.compAddMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | [
"ContinuousMap",
"ContinuousMap.comp",
"AddZeroClass.toAddZero",
"TopologicalSpace",
"AddZero.toZero",
"AddZeroClass",
"ContinuousMap.instZero",
"Zero.toOfNat0",
"ContinuousMap.zero_comp",
"OfNat.ofNat",
"Eq"
] | false |
Mathlib.Tactic.Bound._aux_Mathlib_Tactic_Bound_Attribute___macroRules_Mathlib_Tactic_Bound_attrBound_forward_1 | Mathlib.Tactic.Bound.Attribute | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.... | false |
Lean.Doc.Block.dl | Lean.DocString.Types | [
"Lean.Doc.Block",
"Lean.Doc.DescItem",
"Lean.Doc.Block.dl",
"Array",
"Lean.Doc.Inline"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.