name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda | Mathlib.CategoryTheory.Sites.Canonical | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.GrothendieckTopology.yoneda",
"CategoryTheory.Functor.category",
"ULift",
"CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda._proof_2",
"CategoryTheory.GrothendieckTopology.Subcanonic... | true |
isDenseInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | [
"IsDenseInducing.mk",
"isInducing_stoneCechUnit",
"CompletelyRegularSpace",
"IsDenseInducing",
"Topology.IsInducing",
"TopologicalSpace",
"denseRange_stoneCechUnit",
"stoneCechUnit",
"StoneCech",
"instTopologicalSpaceStoneCech"
] | true |
DFinsupp.comapDomain' | Mathlib.Data.DFinsupp.Defs | [
"Function.LeftInverse",
"Multiset.map",
"Trunc.map",
"Membership.mem",
"Multiset",
"DFinsupp.instDFunLike",
"Subtype",
"Subtype.mk",
"Multiset.instMembership",
"DFinsupp.comapDomain'._proof_1",
"DFinsupp.mk'",
"Zero.toOfNat0",
"DFinsupp",
"Or",
"DFinsupp.support'",
"OfNat.ofNat",
"Su... | true |
Std.DTreeMap.Internal.Impl.filter!_equiv_self_iff | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"congrArg",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.filter",
"Eq.mp",
"Std.DTreeMap.Internal.Impl.filter_equiv_self_iff",
"Std.DTreeMap.Internal.Impl.get",
"Std.DTreeMap.Internal.Impl.WF",
"Std.DTreeMap.Internal.Impl.WF.balanced",
"Bool.true",
"Iff",
"Std.DTreeMap.Internal.Impl.filt... | true |
MeasureTheory.SimpleFunc.lintegralₗ._proof_6 | Mathlib.MeasureTheory.Function.SimpleFunc | [
"MeasureTheory.SimpleFunc.lintegral",
"instHSMul",
"MeasureTheory.Measure",
"Semiring.toModule",
"ENNReal.instAddCommMonoid",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"RingHom",
"MeasureTheory.SimpleFunc",
"MeasureTheory.SimpleFunc.lintegralₗ._proo... | false |
Batteries.CodeAction.instanceStub | Batteries.CodeAction.Misc | [
"Lean.Elab.ElabInfo.stx",
"guard",
"Pure.pure",
"Option.isNone",
"Lean.FileMap.utf8RangeToLspRange",
"Lean.Server.RequestContext",
"Lean.Json",
"Lean.Server.Snapshots.Snapshot",
"instAlternativeOption",
"Lean.Syntax.Range.mk",
"Lean.Lsp.PartialResultParams.mk",
"Lean.Elab.TermInfo.runMetaM",
... | true |
Turing.ToPartrec.Cont.then.eq_def | Mathlib.Computability.TuringMachine.Config | [
"Eq.mpr",
"congrArg",
"Turing.ToPartrec.Cont.halt",
"Turing.ToPartrec.Cont.brecOn",
"_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Cont.eval.match_1.splitter",
"Turing.ToPartrec.Cont.below",
"Turing.ToPartrec.Cont.comp",
"Turing.ToPartrec.Cont.fix",
"id",
"Turing.ToPartrec... | true |
Lean.Elab.Command.Scope.casesOn | Lean.Elab.Command.Scope | [
"Lean.TSyntax",
"Lean.Elab.Command.Scope.rec",
"Lean.Elab.Command.Scope.mk",
"String",
"List.cons",
"Array",
"List",
"Lean.Elab.Command.Scope",
"Bool",
"Lean.Name",
"Lean.SyntaxNodeKind",
"Lean.Options",
"Lean.Name.mkStr4",
"Lean.OpenDecl",
"List.nil"
] | false |
ENNReal.continuous_zpow | Mathlib.Topology.Instances.ENNReal.Lemmas | [
"zpow_natCast",
"Eq.mpr",
"DivInvMonoid.toInv",
"Continuous",
"congrArg",
"CommSemiring.toSemiring",
"zpow_negSucc",
"DivInvMonoid.toZPow",
"ENNReal.instContinuousInv",
"cast",
"id",
"DivInvMonoid.toMonoid",
"ENNReal.continuous_pow",
"instOfNatNat",
"Int",
"ENNReal.instCommSemiring",
... | true |
Int.Linear.Poly.append._unsafe_rec | Init.Data.Int.Linear | [
"Int.Linear.Poly.append._unsafe_rec",
"Int.Linear.Poly.addConst",
"Int",
"Int.Linear.Var",
"Int.Linear.Poly.add",
"Int.Linear.Poly.denote.match_1",
"Int.Linear.Poly"
] | false |
LieModule.range_traceForm_le_span_weight | Mathlib.Algebra.Lie.TraceForm | [
"LieAlgebra.toModule",
"Set.mem_range_self",
"LieSubmodule.instSetLike",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"RingHomSurjective.ids",
"Algebra.to_smulCommClass",
"instHSMul",
"LieModule.Weight.instFunLike",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semirin... | true |
FreeCommRing.isSupported_mul | Mathlib.RingTheory.FreeCommRing | [
"FreeCommRing.IsSupported",
"HMul.hMul",
"FreeCommRing",
"CommSemiring.toSemiring",
"instCommRingFreeCommRing",
"FreeCommRing.of",
"CommRing.toNonAssocCommRing",
"instDistribOfSemiring",
"CommRing.toCommSemiring",
"Distrib.toMul",
"Set.image",
"Subring.mul_mem",
"Subring.closure",
"instHMu... | true |
_private.Init.Omega.IntList.0.List.mem_cons_self | Init.Omega.IntList | [
"Membership.mem",
"List.cons",
"List",
"List.instMembership",
"List.Mem.head"
] | true |
Lean.PrettyPrinter.Formatter.sepByNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | [
"Lean.PrettyPrinter.Formatter.instMonadTraverserFormatterM",
"Lean.PrettyPrinter.Formatter",
"Lean.Syntax.getArgs",
"Lean.Syntax",
"ReaderT.instMonad",
"Lean.PrettyPrinter.Formatter.State",
"IO.RealWorld",
"Nat.instMod",
"instDecidableEqBool",
"instHMod",
"instOfNatNat",
"instBEqOfDecidableEq"... | true |
Set.mk_preimage_prod_right_eq_if | Mathlib.Data.Set.Prod | [
"Set.instSProd",
"SProd.sprod",
"Membership.mem",
"Prod.mk",
"Set.preimage",
"DecidablePred",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Prod",
"Eq",
"Set.instMembership",
"_private.Mathlib.Data.Set.Prod.0.Set.mk_preimage_prod_right_eq_if._proof_1_1",
"ite",
"Set"
] | true |
LieSubmodule.nontrivial_iff._simp_1 | Mathlib.Algebra.Lie.Submodule | [
"Nontrivial",
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieSubmodule",
"AddCommGroup",
"LieRing",
"CommRing.toCommSemiring",
"LieRingModule",
"LieSubmodule.nontrivial_iff",
"propext",
"Module",
"Eq"
] | false |
UniformOnFun.congrLeft._proof_3 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | [
"UniformContinuous",
"UniformSpace",
"Equiv.instEquivLike",
"UniformOnFun.uniformSpace",
"Function.comp",
"Equiv",
"HasSubset.Subset",
"UniformOnFun.toFun",
"Set.preimage",
"UniformOnFun.precomp_uniformContinuous",
"UniformOnFun.ofFun",
"Set.image",
"UniformOnFun",
"DFunLike.coe",
"Equiv... | false |
CategoryTheory.yonedaAddMonObjIsoOfRepresentableBy._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | [
"CategoryTheory.Functor",
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"CategoryTheory.yonedaAddMonObj",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Hom.addMonoid",
"AddMonCat.hom_ext",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.Representabl... | false |
MonoidAlgebra.instNoZeroDivisorsOfUniqueProds | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | [
"Iff.mpr",
"Finsupp.mem_support_iff",
"Finsupp.instFunLike",
"Eq.mpr",
"UniqueMul",
"HMul.hMul",
"congrArg",
"Finset",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Mul",
"UniqueProds",
"Finsupp.support",
"UniqueProds.uniqueMul_of_nonempty",
"Membership.mem",
"Exists",
"Eq.rec",
"Mono... | true |
Std.Tactic.BVDecide.BVExpr.var._impl | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"UInt64",
"Std.Tactic.BVDecide.BVExpr._impl",
"Std.Tactic.BVDecide.BVExpr.var._impl",
"Nat"
] | false |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2.else_eq | Lean.Level | [
"Lean.Level.ctorIdx",
"Lean.Level.casesOn",
"Nat.shiftRight",
"Lean.Level.mvar",
"Lean.Level.param",
"Nat.hasNotBit",
"Lean.Level.imax",
"instOfNatNat",
"Lean.Level",
"Bool.true",
"Nat.land",
"_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2",
"absurd",
"Lean.Level.zero",
"Nat",
... | false |
CategoryTheory.Ind.colimitPresentationCompYoneda | Mathlib.CategoryTheory.Limits.Indization.Category | [
"CategoryTheory.Limits.IndObjectPresentation.I",
"CategoryTheory.Limits.IndObjectPresentation.ι",
"CategoryTheory.Functor",
"CategoryTheory.Limits.IndObjectPresentation.isColimit",
"Trans.trans",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"Opposite",
"Equiv.instEquivLike",
"CategoryTheo... | true |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.getKey!_eq_default._simp_1_1 | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.contains_iff_mem",
"Membership.mem",
"Std.DHashMap.instMembership",
"Bool.true",
"Std.DHashMap.contains",
"propext",
"Bool",
"Hashable",
"Eq.symm",
"BEq",
"Eq",
"Std.DHashMap"
] | false |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.HandleOverlapState.insertSurrounding.go | Lean.Server.FileWorker.SemanticHighlighting | [
"List.brecOn",
"Lean.Server.FileWorker.AbsoluteLspSemanticToken",
"List",
"_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.HandleOverlapState.insertSurrounding.go._f"
] | true |
CommRingCat.Colimits.Relation.below.add_2 | Mathlib.Algebra.Category.Ring.Colimits | [
"CategoryTheory.Functor",
"CommRingCat.Colimits.Relation.below.add_2",
"CommRingCat.Colimits.Relation.below",
"CommRingCat",
"CommRingCat.Colimits.Relation.add_2",
"CommRingCat.instCategory",
"CategoryTheory.SmallCategory",
"CommRingCat.Colimits.Relation",
"CommRingCat.Colimits.Prequotient.add",
"... | true |
NonUnitalStarAlgHom.range._proof_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | [
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"NonUnitalAlgHom.range",
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"Membership.mem",
"NonUnitalAlgHom.instFunLike_1",
"AddZeroClass.toAddZero",
"StarHomClass",
"StarHomClass.map_star",
"AddSubmonoid.toAddSubsemigroup",
"NonUnitalA... | false |
PadicInt.mahlerEquiv | Mathlib.NumberTheory.Padics.MahlerBasis | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Nat.Prime",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CompleteSpace",
"NormedRing.toRing",
"PadicInt.mahlerEquiv._proof_5",
"UniformContinuousConstSMul.to_continuousConstSMul",
"PadicInt",
"LinearEquiv.mk",
"PadicInt.... | true |
CategoryTheory.HasCodetector.mk | Mathlib.CategoryTheory.Generator.Basic | [
"CategoryTheory.HasCodetector.mk",
"Exists",
"CategoryTheory.HasCodetector",
"CategoryTheory.IsCodetector",
"CategoryTheory.Category"
] | true |
forall_lt_add_iff_lt_left | Mathlib.Algebra.Order.Monoid.Canonical.Basic | [
"_private.Mathlib.Algebra.Order.Monoid.Canonical.Basic.0.forall_lt_add_iff_lt_left._simp_1_1",
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"and_self",
"true_or",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"id",... | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_3 | Mathlib.Order.Filter.Basic | [
"Exists",
"exists_prop",
"And",
"propext",
"Eq"
] | false |
PolyEquivTensor.invFun | Mathlib.RingTheory.PolynomialAlgebra | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semiring.toModule",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"Algebra",
"Algebra.toModule",
"Algebra.id",
"Polynomial.eval₂",
"Algebra.TensorProduct.includeLeft",
"AddCommMonoidWithOne.toAddMonoidWithOne",... | true |
USize.toBitVec_ofNatTruncate_of_lt | Init.Data.UInt.Lemmas | [
"BitVec.ofNatLT",
"USize.toNat_ofNatTruncate_of_lt",
"congrArg",
"BitVec.eq_of_toNat_eq",
"USize.ofNatTruncate",
"BitVec",
"BitVec.toNat",
"System.Platform.numBits",
"USize.toBitVec",
"USize.toNat",
"Nat",
"LT.lt",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"USize.toNat_toBitVec",... | true |
SetLike.GradedBracket.rec | Mathlib.Algebra.Lie.Graded | [
"SetLike",
"SetLike.GradedBracket.mk",
"Bracket.bracket",
"Membership.mem",
"Bracket",
"instHAdd",
"HAdd.hAdd",
"SetLike.instMembership",
"Add",
"SetLike.GradedBracket"
] | false |
MeasureTheory.Measure.hausdorffMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Hausdorff | [
"Real",
"MeasureTheory.Measure",
"ENNReal.instPowReal",
"MeasureTheory.Measure.hausdorffMeasure",
"MeasureTheory.Measure.mkMetric",
"BorelSpace",
"EMetricSpace.toPseudoEMetricSpace",
"EMetricSpace",
"MeasurableSpace",
"HPow.hPow",
"PseudoEMetricSpace.toUniformSpace",
"ENNReal",
"Eq.refl",
... | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonBifunctorNatIso_inv | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesLimit",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.CartesianMonoidalCategory.prodComparisonBifunctorNatTrans",
"CategoryTheory.CartesianMonoidalCateg... | true |
CategoryTheory.EnrichedCat.rightUnitor | Mathlib.CategoryTheory.Enriched.EnrichedCat | [
"CategoryTheory.categoryForgetEnrichment",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.rightUnitor",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.EnrichedFunctor.category",
"CategoryTheory.Enri... | true |
isPrincipalIdealRing_prod_iff | Mathlib.RingTheory.PrincipalIdealDomain | [
"Prod.fst_surjective",
"RingHom.instRingHomClass",
"IsPrincipalIdealRing.of_surjective",
"RingHom",
"inferInstance",
"_private.Mathlib.RingTheory.PrincipalIdealDomain.0.isPrincipalIdealRing_prod_iff.match_1_1",
"Zero.instNonempty",
"Prod.instSemiring",
"RingHom.snd",
"And",
"Iff",
"RingHom.ins... | true |
Std.DHashMap.Equiv.congr_left | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.Equiv",
"Std.DHashMap.Equiv.symm",
"Iff",
"Iff.intro",
"Hashable",
"Std.DHashMap.Equiv.trans",
"BEq",
"Std.DHashMap"
] | true |
Complex.abs_arg_inv | Mathlib.Analysis.SpecialFunctions.Complex.Arg | [
"Eq.mpr",
"abs_neg",
"Real",
"Real.pi",
"Real.lattice",
"abs",
"congrArg",
"Complex.arg",
"id",
"Real.instAddGroup",
"if_pos",
"dite",
"Inv.inv",
"Complex.arg_inv",
"True",
"Real.instNeg",
"eq_self",
"of_eq_true",
"congrFun'",
"Complex",
"Real.decidableEq",
"Eq",
"if_neg"... | true |
Lean.ScopedEnvExtension.Entry.ctorIdx | Lean.ScopedEnvExtension | [
"Lean.ScopedEnvExtension.Entry",
"Lean.ScopedEnvExtension.Entry.casesOn",
"Nat",
"Lean.Name"
] | false |
MeasureTheory.Measure.instPartialOrder._proof_4 | Mathlib.MeasureTheory.Measure.MeasureSpace | [
"MeasureTheory.Measure",
"MeasurableSet",
"LE.le",
"MeasurableSpace",
"le_antisymm",
"ENNReal.instLE",
"ENNReal",
"ENNReal.instPartialOrder",
"Eq",
"DFunLike.coe",
"MeasureTheory.Measure.ext",
"MeasureTheory.Measure.instFunLike",
"Set"
] | false |
ContinuousLinearMap.flip._proof_1 | Mathlib.Analysis.Normed.Operator.Bilinear | [
"NormedCommRing.toSeminormedCommRing",
"SeminormedAddCommGroup",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContinuousLinearMap.topologicalSpace",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinea... | false |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.mk_eq_two_iff'._simp_1_2 | Mathlib.SetTheory.Cardinal.Basic | [
"Membership.mem",
"Insert.insert",
"Set.instInsert",
"propext",
"Or",
"Set.mem_insert_iff",
"Eq",
"Set.instMembership",
"Set"
] | false |
Std.Time.Modifier.A.injEq | Std.Time.Format.Basic | [
"Eq.propIntro",
"Std.Time.Modifier.A.inj",
"Std.Time.Number",
"Eq.ndrec",
"Std.Time.Modifier.A",
"Eq.refl",
"Std.Time.Modifier",
"Eq"
] | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instFinitenessRelation.match_1 | Init.Data.Range.Polymorphic.RangeIterator | [
"Std.IterStep",
"Std.IterStep.successor",
"Std.PRange.UpwardEnumerable",
"Std.Rxi.Iterator.mk",
"Std.Rxi.instIteratorIteratorIdOfUpwardEnumerable",
"Option.some",
"Std.IterM.IsPlausibleStep",
"Std.IterM.mk",
"Id",
"And.casesOn",
"Option.none",
"Std.IterM.IsPlausibleSuccessorOf",
"And",
"Ex... | false |
SymAlg.instNonAssocRingOfInvertibleOfNat._proof_3 | Mathlib.Algebra.Symmetrized | [
"SubNegMonoid.sub_eq_add_neg",
"AddMonoid.toAddSemigroup",
"LieRing.toAddCommGroup",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"SubNegMonoid.toSub",
"instHAdd",
"AddSemigroup.toAdd",
"instHSub",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"SubNegMonoid.toNeg",
"LieRing.ofAssociativeRing",
"SymAl... | false |
ContinuousMultilinearMap.bound | Mathlib.Analysis.Normed.Module.Multilinear.Basic | [
"Norm.norm",
"Real.instLE",
"Real",
"SeminormedAddCommGroup",
"HMul.hMul",
"Finset.univ",
"NormedSpace",
"Real.instZero",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Real.instLT",
"ContinuousMultilinearMap",
"MultilinearMap.exists_bound_of_c... | true |
IsSquare.one | Mathlib.Algebra.Group.Even | [
"MulOne.toOne",
"HMul.hMul",
"MulOne.toMul",
"MulOneClass.toMulOne",
"IsSquare",
"Exists.intro",
"One.toOfNat1",
"mul_one",
"MulOneClass",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"instHMul"
] | true |
ProbabilityTheory.hasDerivAt_iteratedDeriv_complexMGF | Mathlib.Probability.Moments.ComplexMGF | [
"iteratedDeriv_zero",
"instInnerProductSpaceRealComplex",
"IsModuleTopology.toContinuousSMul",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"iteratedDeriv_succ",
"Real",
"Nat.recAux",
"MeasureTheory.Measure",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",... | true |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.buildNormProof.convert._f | Lean.Meta.Tactic.AC.Main | [
"Lean.mkNatLit",
"Lean.Data.AC.Expr.var",
"Lean.Name.mkStr5",
"Lean.Data.AC.Expr",
"Lean.mkApp2",
"Lean.Expr",
"Lean.Level",
"Lean.mkConst",
"Lean.Data.AC.Expr.op",
"Lean.Data.AC.Expr.below",
"Nat",
"_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.buildNormProof.convert.match_3",
"Lean.Meta... | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.standardσ_simplicialInsert._proof_1_20 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | [
"_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.standardσ_simplicialInsert._proof_1_19",
"Lean.Grind.nestedProof",
"SimplexCategoryGenRel.standardσ_cons._proof_2",
"instOfNatNat",
"List.cons",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"inst... | false |
Turing.ToPartrec.Cont.then._unsafe_rec | Mathlib.Computability.TuringMachine.Config | [
"Turing.ToPartrec.Cont.then._unsafe_rec",
"Turing.ToPartrec.Cont.comp",
"Turing.ToPartrec.Cont.fix",
"Turing.ToPartrec.Cont",
"Turing.ToPartrec.Cont.cons₂",
"List",
"Unit",
"Nat",
"Turing.ToPartrec.Cont.eval.match_1",
"Turing.ToPartrec.Cont.cons₁",
"Turing.ToPartrec.Code"
] | false |
SimpleGraph.componentComplFunctor._proof_3 | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | [
"Set.ext",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"RelHom.instFunLike",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"Compl.compl",
"Finset",
"SimpleGraph.ConnectedComponent.map",
"SimpleGraph.Adj",
"SimpleGraph.ComponentCompl.hom_trans",
"RelHom",
"Parti... | false |
CategoryTheory.Square.unop_f₁₂ | Mathlib.CategoryTheory.Square | [
"CategoryTheory.Square.f₂₄",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.unop",
"CategoryTheory.Square.X₂",
"CategoryTheory.Square",
"CategoryTheory.Square.f₁₂",
"CategoryTheory.Square.unop",
"CategoryTheory.Square.X₄",
"CategoryTheory.Category.opposite",
"E... | true |
CategoryTheory.ShortComplex.RightHomologyData.mk.injEq | Mathlib.Algebra.Homology.ShortComplex.RightHomology | [
"CategoryTheory.ShortComplex.RightHomologyData.mk",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Limits.KernelFork.ofι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Eq.propIntro",
"CategoryTheory.ShortComplex.RightHomologyData",
"CategoryTheory.Limits.WalkingParallelPair",
... | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.MVarErrorInfo.logError.appendExtra | Lean.Elab.Term.TermElabM | [
"Lean.MessageData",
"Lean.MessageData.composePreservingKind",
"Unit",
"_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.MVarErrorInfo.logError.appendExtra.match_1",
"Option"
] | true |
Ideal.Quotient.mk_span_range | Mathlib.RingTheory.Ideal.Quotient.Basic | [
"Eq.mpr",
"Ideal.subset_span",
"Submodule.Quotient.instZeroQuotient",
"Semiring.toModule",
"congrArg",
"Ideal.Quotient.mk",
"RingHom",
"Membership.mem",
"id",
"Ideal.IsTwoSided",
"Ideal",
"Ideal.Quotient.eq_zero_iff_mem",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"HasQuotient.Quotient",... | true |
Lean.Meta.SynthInstance.Answer._sizeOf_inst | Lean.Meta.SynthInstance | [
"Lean.Meta.SynthInstance.Answer",
"Lean.Meta.SynthInstance.Answer._sizeOf_1",
"SizeOf.mk",
"SizeOf"
] | false |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.Pos.ofSliceTo_prev._simp_1 | Init.Data.String.Lemmas.FindPos | [
"String.Slice.Pos.ofSliceTo",
"String.Slice",
"String.Slice.Pos.ofSliceTo_inj",
"propext",
"String.Slice.Pos",
"Eq.symm",
"Eq",
"String.Slice.sliceTo"
] | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Specialize.0.Lean.Elab.Tactic.Do.ProofMode.mSpecializeImpStateful._sparseCasesOn_10 | Lean.Elab.Tactic.Do.ProofMode.Specialize | [
"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.Rxi.instIteratorIteratorIdOfUpwardEnumerable._proof_1 | Init.Data.Range.Polymorphic.RangeIterator | [
"Std.IterStep",
"Std.PRange.UpwardEnumerable",
"Std.Rxi.Iterator.Monadic.step",
"Id",
"Std.Rxi.Iterator",
"Std.IterM",
"Eq",
"rfl"
] | false |
_private.Init.Data.UInt.Bitwise.0.UInt32.ne_not_self._simp_1_1 | Init.Data.UInt.Bitwise | [
"UInt32.toBitVec",
"BitVec",
"instOfNatNat",
"UInt32.toBitVec_inj",
"Nat",
"propext",
"UInt32",
"OfNat.ofNat",
"Eq.symm",
"Eq"
] | false |
_private.Mathlib.Algebra.Lie.Weights.RootSystem.0.LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_lt._simp_1_12 | Mathlib.Algebra.Lie.Weights.RootSystem | [
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"SubNegMonoid",
"AddZeroClass.toAddZero",
"SubNegMonoid.toSub",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"SubNegMonoid.toNeg",
"AddZero.toAdd",
"SubNegMonoid.toAddMonoid",
"Eq.symm",
"Eq",
"Neg.neg"
] | false |
Set.infsep_empty | Mathlib.Topology.MetricSpace.Infsep | [
"Real",
"Real.instZero",
"Set.subsingleton_empty",
"Set.instEmptyCollection",
"Zero.toOfNat0",
"EmptyCollection.emptyCollection",
"EDist",
"Set.infsep",
"OfNat.ofNat",
"Eq",
"Set.Subsingleton.infsep_zero",
"Set"
] | true |
unitInterval.instConnectedSpaceElemReal | Mathlib.Topology.UnitInterval | [
"Iff.mpr",
"Real.partialOrder",
"Real",
"MulZeroClass.toMul",
"Real.instZero",
"Real.instZeroLEOneClass",
"PseudoMetricSpace.toUniformSpace",
"Preorder.toLE",
"Membership.mem",
"Set.nonempty_Icc",
"Real.semiring",
"Set.Elem",
"isPreconnected_Icc",
"LE.le",
"Subtype.connectedSpace",
"in... | true |
Array.pmap_append | Init.Data.Array.Attach | [
"Array.instAppend",
"Array.pmap",
"congrArg",
"Array.instMembership",
"Membership.mem",
"List.mem_append_left",
"Array.casesOn",
"List.append_toArray",
"List.pmap_append",
"List.toArray",
"List.attachWith_toArray._proof_1",
"Array",
"List.pmap",
"instHAppendOfAppend",
"List",
"Array.me... | true |
_private.Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators.0.SheafOfModules.LocalGeneratorsData.shrink._proof_3 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | [
"CategoryTheory.Over",
"SheafOfModules.LocalGeneratorsData.I",
"False",
"Exists.choose_spec",
"SheafOfModules.LocalGeneratorsData.X",
"Lean.Grind.nestedProof",
"eq_false",
"AddCommGrpCat.instCategory",
"AddMonoid.toAddZeroClass",
"Classical.byContradiction",
"RingCat.ring",
"_private.Mathlib.A... | false |
Algebra.IsCentral.recOn | Mathlib.Algebra.Central.Defs | [
"Algebra.IsCentral",
"Algebra.IsCentral.mk",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"Subalgebra.center",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Algebra.instCompleteLatticeSubalgebra",
"Algebra",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"Bot.bot",
"LE.le",
... | false |
Plausible.BoundedRandom.mk.noConfusion | Plausible.Random | [
"Plausible.RandGT",
"RandomGen",
"HEq.refl",
"Plausible.BoundedRandom",
"id",
"Subtype",
"LE.le",
"LE",
"And",
"heq_of_eq",
"Plausible.BoundedRandom.noConfusion",
"Eq.refl",
"HEq",
"Eq",
"Plausible.BoundedRandom.mk"
] | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.hasDerivAt_logTaylor._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | [
"False",
"eq_false",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"three_ne_zero",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
SimpleGraph.ConnectedComponent.Represents | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | [
"SimpleGraph.connectedComponentMk",
"SimpleGraph.ConnectedComponent",
"SimpleGraph",
"Set.BijOn",
"Set"
] | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.all_rotateL._simp_1_6 | Mathlib.Data.Ordmap.Invariants | [
"Ordnode",
"Ordnode.all_node4L",
"And",
"Ordnode.All",
"propext",
"Ordnode.node4L",
"Eq"
] | false |
Std.ExtDTreeMap.alter | Std.Data.ExtDTreeMap.Basic | [
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Ordering",
"Std.TransCmp",
"Std.ExtDTreeMap.alter._proof_1",
"Std.DTreeMap.alter",
"Std.LawfulEqCmp",
"Std.ExtDTreeMap",
"Std.ExtDTreeMap.lift",
"Option"
] | true |
CategoryTheory.RingObjCat.mk | Mathlib.CategoryTheory.Monoidal.Ring | [
"CategoryTheory.RingObjCat.mk",
"CategoryTheory.RingObj",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.RingObjCat",
"CategoryTheory.CartesianMonoidalCategory",
"CategoryTheory.BraidedCategory",
"CategoryTheory.Category",
"CategoryTheory.CartesianMonoidalCategory.t... | true |
Lean.Elab.Term.initFn._@.Lean.Elab.MutualDef.498884866._hygCtx._hyg.4 | Lean.Elab.MutualDef | [
"Lean.Option",
"Lean.Name.mkStr5",
"IO",
"Lean.Option.Decl.mk",
"Bool.true",
"Lean.KVMap.instValueBool",
"Lean.Option.register",
"Bool",
"Lean.Name.mkStr2"
] | false |
Monotone.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | [
"Monotone.mem_lowerBounds_image",
"lowerBounds",
"Monotone",
"Preorder.toLE",
"Membership.mem",
"HasSubset.Subset",
"And.casesOn",
"And",
"Exists.casesOn",
"Eq.ndrec",
"Set.image",
"Eq",
"Set.instMembership",
"Preorder",
"Set.instHasSubset",
"Set"
] | true |
SimpleGraph.deleteEdges_adj | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | [
"SimpleGraph.deleteEdges",
"SimpleGraph.Adj.ne",
"Sym2.mk",
"SimpleGraph.fromEdgeSet",
"SimpleGraph.Adj",
"and_iff_left",
"Membership.mem",
"Iff.not",
"Ne",
"and_congr_right",
"SimpleGraph",
"And",
"Iff",
"Set.instMembership",
"Sym2",
"Not",
"Sym2.ToRel",
"Set"
] | true |
Algebra.Presentation.differentials.comm₁₂ | Mathlib.Algebra.Module.Presentation.Differentials | [
"Algebra.Presentation.differentials.comm₁₂_single",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"LinearEquiv.symm",
"CommRing",
"Algebra.to_smulCommClass",
"Algebra.Extension.commRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Finsupp.module",
"Algebra.Exte... | true |
AddConjClasses.exists_rep | Mathlib.Algebra.Group.Conj | [
"AddConjClasses.mk",
"Exists",
"Quot.exists_rep",
"AddConjClasses",
"AddMonoid",
"Eq",
"IsAddConj.setoid",
"Setoid.r"
] | true |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure.match_1._arg_pusher | Mathlib.CategoryTheory.Filtered.Small | [
"Unit.unit",
"id",
"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure.match_1",
"instOfNatNat",
"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure.match_1... | false |
Lean.JsonRpc.Notification.ofMessage? | Lean.Data.JsonRpc | [
"Lean.Json",
"_private.Lean.Data.JsonRpc.0.Lean.JsonRpc.Notification.ofMessage?.match_1",
"String",
"Lean.JsonRpc.Notification.mk",
"Lean.JsonRpc.Notification",
"Option.some",
"Lean.ToJson.toJson",
"Lean.Json.Structured",
"Lean.Json.instToJsonStructured",
"Lean.JsonRpc.Message",
"Option.none",
... | true |
Height.AdmissibleAbsValues.mk | Mathlib.NumberTheory.Height.Basic | [
"Real.partialOrder",
"Real",
"HMul.hMul",
"Multiset.map",
"Multiset.prod",
"Height.AdmissibleAbsValues.mk",
"Membership.mem",
"Real.semiring",
"Multiset",
"Set.Elem",
"Height.AdmissibleAbsValues",
"Distrib.toAdd",
"Ne",
"Field.toSemifield",
"instDistribOfSemiring",
"Real.instOne",
"f... | true |
Filter.HasBasis.clusterPt_iff | Mathlib.Topology.ClusterPt | [
"Filter.HasBasis.inf_basis_neBot_iff",
"nhds",
"Set.instInter",
"Inter.inter",
"TopologicalSpace",
"ClusterPt",
"Filter.HasBasis",
"Iff",
"Set.Nonempty",
"Filter",
"Set"
] | true |
CategoryTheory.Discrete.sumEquiv_unitIso_hom_app | Mathlib.CategoryTheory.Discrete.SumsProducts | [
"CategoryTheory.Functor",
"CategoryTheory.Discrete.sumEquiv.match_1",
"CategoryTheory.Equivalence.unitIso",
"CategoryTheory.sum",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Discrete.functor",
"CategoryTh... | true |
CategoryTheory.ProjectiveResolution.extEquivCohomologyClass_symm_zero | Mathlib.CategoryTheory.Abelian.Projective.Ext | [
"CategoryTheory.Abelian.toPreadditive",
"HomologicalComplex.instCategory",
"Equiv.instEquivLike",
"AddEquiv.map_zero",
"CochainComplex.singleFunctor",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Abelian.Ext.instAddCommGroup",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"A... | true |
AddEquiv.mk'.congr_simp | Mathlib.Algebra.Category.Grp.ForgetCorepresentable | [
"Equiv.instEquivLike",
"Eq.rec",
"Equiv",
"instHAdd",
"HAdd.hAdd",
"Eq.ndrec",
"AddEquiv",
"Eq.refl",
"AddEquiv.mk'",
"Eq",
"DFunLike.coe",
"Add",
"EquivLike.toFunLike"
] | true |
Matrix.one_submatrix_mul | Mathlib.Data.Matrix.Mul | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Matrix.submatrix",
"Equiv.instEquivLike",
"HMul.hMul",
"Equiv.symm_comp_self",
"congrArg",
"Matrix",
"Matrix.instHMulOfFintypeOfMulOfAddCommMonoid",
"Finite",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Function.comp",
"id",
"Equiv",
... | true |
Subrepresentation.submoduleSubrepresentationOrderIso | Mathlib.RepresentationTheory.Subrepresentation | [
"MonoidAlgebra.semiring",
"Monoid",
"Submodule",
"RestrictScalars.module",
"RelIso.mk",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Subrepresentation.submoduleSubrepresentationOrderIso._proof_2",
"Equiv.mk",
"Algebra.id",
"OrderIso",
"Submodule.instPartialOrder",
... | true |
Mathlib.Meta.Positivity.Strictness.nonzero.sizeOf_spec | Mathlib.Tactic.Positivity.Core | [
"Mathlib.Meta.Positivity.Strictness",
"Lean.Expr.const",
"instSizeOfDefault",
"Mathlib.Meta.Positivity.Strictness._sizeOf_inst",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"Lean.Literal.natVal",
"instHAdd",
"Qq.Quoted",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Lean.Name.mk... | true |
Array._sizeOf_1 | Init.SizeOf | [
"Array.rec",
"instOfNatNat",
"Array",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List._sizeOf_inst",
"SizeOf.sizeOf",
"instAddNat",
"SizeOf",
"OfNat.ofNat"
] | false |
CategoryTheory.functorOfIsEmpty._proof_2 | Mathlib.CategoryTheory.PEmpty | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"isEmptyElim",
"IsEmpty",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Category"
] | false |
Std.DTreeMap.Internal.Impl.contains_minKey | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Std.Internal.List.containsKey_minKey",
"Std.DTreeMap.Internal.Impl.isEmpty_eq_isEmpty",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"Std.DTreeMap.Internal.Impl.contains_eq_containsKey",
"beqOfOrd",
"Std.DTreeMap.Internal.Impl.Ordered.distinctKeys",
"Std.TransOrd",
"Std.DTreeMap.Interna... | true |
Commute.geom_sum₂_Ico_mul | Mathlib.Algebra.Ring.GeomSum | [
"Eq.mpr",
"HMul.hMul",
"MulOpposite.op_injective",
"Ring.toNonAssocRing",
"Monoid.toMulOneClass",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Finset",
"MulOpposite",
"HSub.hSub",
"Commute.pow_pow",
"Commute",
"Nat.instLocallyFiniteOrder",
"Membership.mem",
"MulOpposite.instSub",
"id",
... | true |
SimplexCategoryGenRel.simplicialEvalσ._unsafe_rec | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | [
"HSub.hSub",
"instSubNat",
"instOfNatNat",
"List",
"Unit",
"instHSub",
"Nat",
"LT.lt",
"SimplexCategoryGenRel.simplicialInsert.match_1",
"Nat.decLt",
"instLTNat",
"OfNat.ofNat",
"SimplexCategoryGenRel.simplicialEvalσ._unsafe_rec",
"ite"
] | false |
Finite.divisionRing_to_field | Mathlib.RingTheory.LittleWedderburn | [
"littleWedderburn",
"Finite",
"DivisionRing",
"Field"
] | true |
CategoryTheory.Limits.cospanExt_hom_app_one | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.Iso",
"CategoryTheory.Limits.cospanExt",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.Limits.WalkingCospan.... | true |
AlgebraicGeometry.Scheme.IsQuasiAffine.isBasis_basicOpen | Mathlib.AlgebraicGeometry.QuasiAffine | [
"_private.Mathlib.AlgebraicGeometry.QuasiAffine.0.AlgebraicGeometry.Scheme.IsQuasiAffine.isBasis_basicOpen._simp_1_1",
"AlgebraicGeometry.Scheme.Hom.opensFunctor",
"Iff.mpr",
"AlgebraicGeometry.Scheme.IsQuasiAffine.toIsImmersion",
"Eq.mpr",
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.Scheme.Hom.toLRSHo... | true |
ClosureOperator.closure_inf_le | Mathlib.Order.Closure | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"ClosureOperator.instFunLike",
"SemilatticeInf.toMin",
"LE.le",
"ClosureOperator",
"SemilatticeInf",
"Monotone.map_inf_le",
"ClosureOperator.monotone",
"DFunLike.coe",
"Min.min"
] | true |
Std.HashMap.toList_filterMap | Std.Data.HashMap.Lemmas | [
"Std.HashMap.toList",
"Prod.mk",
"List.Perm",
"Std.HashMap",
"Prod.fst",
"Option.map",
"Std.HashMap.filterMap",
"Hashable",
"List.filterMap",
"Prod",
"Std.HashMap.inner",
"BEq",
"Prod.snd",
"Std.DHashMap.Const.toList_filterMap",
"Option"
] | true |
HasFDerivAt.const_smul | Mathlib.Analysis.Calculus.FDeriv.Add | [
"Pure.pure",
"HasFDerivAt",
"Monoid",
"instHSMul",
"NormedSpace",
"SProd.sprod",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"NormedField.toField",
"nhds... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.