name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
FiniteArchimedeanClass.toAddSubgroup_ball | Mathlib.Algebra.Order.Module.Archimedean | [
"FiniteArchimedeanClass.ballAddSubgroup",
"Ring.toNonAssocRing",
"IsOrderedRing",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddZeroClass.toAd... | true |
PhragmenLindelof.eq_zero_on_quadrant_III | Mathlib.Analysis.Complex.PhragmenLindelof | [
"Iff.mpr",
"DiffContOnCl",
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real.instPow",
"Real.instLE",
"Real",
"HMul.hMul",
"Complex.instNormedAddCommGroup",
"PseudoMetricSpace.toBornology",
"NormedSpace",
"Real.inst... | true |
Lean.Expr.prod? | Lean.Util.Recognizers | [
"Lean.Expr",
"Lean.Expr.app2?",
"Prod",
"Lean.Name.mkStr1",
"Option"
] | true |
FiberBundleCore.localTriv_apply | Mathlib.Topology.FiberBundle.Basic | [
"FiberBundleCore.indexAt",
"Bundle.Trivialization.toFun'",
"FiberBundleCore.Fiber",
"FiberBundleCore.toTopologicalSpace",
"FiberBundleCore.TotalSpace",
"Prod.mk",
"FiberBundleCore.proj",
"FiberBundleCore.localTriv",
"TopologicalSpace",
"Bundle.TotalSpace.proj",
"FiberBundleCore.coordChange",
"... | true |
RootPairing.IsG2.pairingIn_mem_zero_one_three | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | [
"Mathlib.Tactic.Push.not_forall_eq",
"Eq.mpr",
"instDecidableNot",
"RootPairing.IsReduced",
"NegZeroClass.toNeg",
"IsDomain",
"CommRing",
"HMul.hMul",
"_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.IsG2.pairingIn_mem_zero_one_three._proof_1_5",
"congrArg",
"CommSemiring.toSem... | true |
smulAddHom_apply | Mathlib.Algebra.Module.End | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddMonoidHom.instAddCommMonoid",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"AddCommMonoid",
"AddZero.toZero",
"Semiring... | true |
Units.mul_inv_of_eq | Mathlib.Algebra.Group.Units.Defs | [
"Monoid",
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Units",
"id",
"MulOne.toMul",
"Units.mul_inv",
"MulOneClass.toMulOne",
"Inv.inv",
"One.toOfNat1",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Units.instInv",
"instHMul"
] | true |
OpenPartialHomeomorph.toHomeomorphSourceTarget | Mathlib.Topology.OpenPartialHomeomorph.Basic | [
"PartialEquiv.target",
"OpenPartialHomeomorph.homeomorphOfImageSubsetSource",
"Membership.mem",
"Set.Elem",
"OpenPartialHomeomorph.image_source_eq_target",
"TopologicalSpace",
"OpenPartialHomeomorph.toHomeomorphSourceTarget._proof_1",
"Homeomorph",
"PartialEquiv.source",
"instTopologicalSpaceSubty... | true |
MDifferentiableWithinAt.congr_of_eventuallyEq_insert | Mathlib.Geometry.Manifold.MFDeriv.Basic | [
"NormedSpace",
"nhdsWithin",
"Filter.EventuallyEq",
"MDifferentiableWithinAt.of_insert",
"MDifferentiableWithinAt.insert",
"Insert.insert",
"TopologicalSpace",
"ModelWithCorners",
"Set.instInsert",
"MDifferentiableWithinAt.congr_of_eventuallyEq_of_mem",
"NontriviallyNormedField",
"Set.mem_inse... | true |
Denumerable.lower.match_1 | Mathlib.Logic.Equiv.Multiset | [
"List.cons",
"List",
"Nat",
"List.casesOn",
"List.nil"
] | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go._unary.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | [
"Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst._proof_6",
"Std.Sat.AIG.RefVec.get",
"Eq.mpr",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst._proof_4",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go._unary._proof_1",
"Std.Sat.AIG.RefVec.push",
"congrArg",
"have... | false |
Affine.Simplex.point_mem_closedInterior | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | [
"Affine.Simplex.affineCombination_mem_closedInterior_iff",
"Finset.mem_univ",
"Eq.mpr",
"Pi.Function.module",
"Affine.Simplex.points",
"False",
"Semiring.toModule",
"AffineMap.instFunLike",
"Finset.univ",
"eq_false",
"Ring.toNonAssocRing",
"instReflLe",
"congrArg",
"and_self",
"AddCommGr... | true |
Finset.truncatedInf_of_notMem | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | [
"UpperSet",
"Finset.inf'",
"Finset.truncatedInf",
"Finset",
"UpperSet.instSetLike",
"OrderBot.toBot",
"upperClosure",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"id",
"Bot.bot",
"LE.le",
"dif_neg",
"DecidableLE",
"SemilatticeInf",
... | true |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._proof_1_29 | Mathlib.Algebra.Lie.CartanExists | [
"AddSubmonoidClass.toAddMemClass",
"LieRing.toAddCommGroup",
"LieSubalgebra.instSetLike",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"Field.toCommRing",
"AddSubgroupClass.toAddSubmonoidClass",
"LieRing",
"AddGroup.toSubNegMonoid",
"AddMemClass",
"AddZero.t... | false |
CategoryTheory.Pseudofunctor.mapComp'₀₂₃_inv_app | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | [
"CategoryTheory.Cat.associator_hom_app",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Pseudofunctor.mapComp'₀₂₃_hom_comp_mapComp'_hom_whiskerRight._proof_4",
"CategoryTheory.Functor.comp",
"CategoryTheory.Cat.str",
"CategoryTheory.CategoryStruct.id",
"Mathlib.T... | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.getCaseGoals.notFound | Lean.Elab.Tactic.BuiltinTactic | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MessageData",
"Lean.MonadError.mk",
"instDecidableNot",
"Lean.instMonadExceptOfExceptionCoreM",
"Std.instToFormatString",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.getCaseGoals.getUserName",
"Lean... | true |
AbsoluteValue.isEquiv_iff_lt_one_iff | Mathlib.Analysis.AbsoluteValue.Equivalence | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"False",
"Preorder.toLT",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"eq_false",
"MulZeroClass.toMul",
"IsStrictOrderedRing.toMulPosStrictMono",
"congrA... | true |
AlgebraicTopology.DoldKan.MorphComponents.id.eq_1 | Mathlib.AlgebraicTopology.DoldKan.Decomposition | [
"Opposite",
"Nat.instOne",
"HomologicalComplex.Hom.f",
"AlgebraicTopology.DoldKan.MorphComponents",
"AlgebraicTopology.DoldKan.MorphComponents.φ._proof_1",
"AlgebraicTopology.DoldKan.MorphComponents.mk",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.instAdd... | true |
instPartialOrderAntisymmetrization._proof_5 | Mathlib.Order.Antisymmetrization | [
"AntisymmRel.setoid",
"Preorder.toLT",
"instPartialOrderAntisymmetrization._proof_2",
"lt_iff_le_not_ge",
"Preorder.toLE",
"Quotient.lift₂",
"LE.le",
"Quotient.inductionOn₂'",
"Antisymmetrization",
"And",
"Iff",
"And.right",
"And.left",
"HasEquiv.Equiv",
"LT.lt.trans_le",
"instIsPreord... | false |
CategoryTheory.Functor.IsRightAdjoint.rec | Mathlib.CategoryTheory.Adjunction.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.IsRightAdjoint",
"Exists",
"Nonempty",
"CategoryTheory.Functor.IsRightAdjoint.mk",
"CategoryTheory.Adjunction",
"CategoryTheory.Category"
] | false |
Std.Http.Response.Builder._sizeOf_inst | Std.Internal.Http.Data.Response | [
"Std.Http.Response.Builder._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"Std.Http.Response.Builder"
] | false |
IsFiltration.mk_int | Mathlib.RingTheory.FilteredAlgebra.Basic | [
"IsFiltration.mk",
"Preorder.toLT",
"Int.instNeZeroOfNatOfNat",
"Int.instLinearOrder",
"instIsLeftCancelAddOfAddLeftReflectLE",
"PartialOrder.toPreorder",
"Monotone",
"HSub.hSub",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Distrib.toAdd",
"AddGroup.addLeftReflectLE_of_addLeftMono",
"... | true |
BddLat.Hom.Simps.hom | Mathlib.Order.Category.BddLat | [
"BddLat.toLat",
"Lat.carrier",
"BoundedLatticeHom",
"BddLat",
"BddLat.Hom.hom",
"Lat.str",
"BddLat.Hom",
"BddLat.isBoundedOrder"
] | true |
Lean.ToJson.rec | Lean.Data.Json.FromToJson.Basic | [
"Lean.Json",
"Lean.ToJson.mk",
"Lean.ToJson"
] | false |
CategoryTheory.Limits.Trident.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.WalkingParallelFamily",
"CategoryTheory.Limits.Trident",
"CategoryTheory.Limits.Trident.condition",
"CategoryTheory.Functor.category",
"Eq.mp",
"i... | true |
CategoryTheory.PrelaxFunctor.instInhabited | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | [
"CategoryTheory.PrelaxFunctor.id",
"CategoryTheory.Bicategory",
"Inhabited",
"CategoryTheory.PrelaxFunctor",
"Inhabited.mk"
] | true |
ExteriorAlgebra.GradedAlgebra.liftι._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | [
"Submodule",
"Submodule.addSubmonoidClass",
"CommRing",
"Semiring.toModule",
"QuadraticMap.instZero",
"Ring.toNonAssocRing",
"ExteriorAlgebra",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"instAlgebraCliffordAlgebra",
"AddMonoid.toAddZeroClass",
"QuadraticForm",
"AddSubmonoidC... | false |
CategoryTheory.Functor.LaxMonoidal.prod'._proof_7 | Mathlib.CategoryTheory.Monoidal.Functor | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.diag",
"CategoryTheory.Functor.LaxMonoidal.associativity._autoParam",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.prod",
"Cate... | false |
MulEquiv.toContinuousMulEquiv_symm_apply | Mathlib.Topology.Algebra.ContinuousMonoidHom | [
"MulEquiv.toContinuousMulEquiv",
"MulEquiv.instEquivLike",
"ContinuousMulEquiv.instEquivLike",
"Mul",
"TopologicalSpace",
"Iff",
"Set.preimage",
"ContinuousMulEquiv.symm",
"MulEquiv",
"Eq.refl",
"IsOpen",
"ContinuousMulEquiv",
"MulEquiv.symm",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike... | true |
CpltSepUniformSpace.α | Mathlib.Topology.Category.UniformSpace | [
"CpltSepUniformSpace"
] | true |
PowerSeries.rescale | Mathlib.RingTheory.PowerSeries.Basic | [
"MulOne.toOne",
"PowerSeries.rescale._proof_4",
"RingHom.mk",
"Semiring.toModule",
"HMul.hMul",
"CommSemiring.toSemiring",
"PowerSeries.rescale._proof_1",
"OneHom.mk",
"LinearMap.instFunLike",
"RingHom",
"PowerSeries.rescale._proof_5",
"MonoidHom.mk",
"PowerSeries.coeff",
"NonAssocSemiring... | true |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.ofNat | Std.Tactic.BVDecide.LRAT.Internal.Assignment | [
"cond",
"Nat.ble",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.neg",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos",
"Nat",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.both"
] | true |
Function.Injective.involutiveNeg._proof_2 | Mathlib.Algebra.Group.InjSurj | [
"Neg",
"InvolutiveNeg",
"Function.Injective",
"InvolutiveNeg.toNeg",
"Function.Injective.involutiveNeg._proof_1",
"Eq",
"Neg.neg"
] | false |
add_zero_eq_id | Mathlib.Algebra.Group.Basic | [
"AddZeroClass.toAddZero",
"id",
"AddZero.toZero",
"funext",
"instHAdd",
"AddZeroClass",
"HAdd.hAdd",
"AddZero.toAdd",
"Zero.toOfNat0",
"add_zero",
"OfNat.ofNat",
"Eq"
] | true |
CategoryTheory.ShiftedHom.map_naturality | Mathlib.CategoryTheory.Shift.ShiftedHom | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.ShiftedHom.map.eq_1",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShiftedHom.comp_mk₀._proof_1",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.category",
"CategoryTh... | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.tendsto_pow_exp_of_isLittleO_sub_add_div._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | [
"False",
"eq_false",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"Nat.cast_add_one_ne_zero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"On... | false |
ISize.toInt_not | Init.Data.SInt.Bitwise | [
"instPowNat",
"of_decide_eq_true",
"congrArg",
"HSub.hSub",
"id",
"ISize.toInt_sub",
"Int.instNegInt",
"Int.bmod_sub_bmod",
"instOfNatNat",
"Int",
"instComplementISize",
"instNatPowNat",
"System.Platform.numBits",
"Bool.true",
"instHSub",
"HPow.hPow",
"instOfNat",
"Int.bmod",
"IS... | true |
Aesop.EqualUpToIds.GoalContext.equalFVarIds | Aesop.Util.EqualUpToIds | [
"Lean.instBEqFVarId",
"Lean.FVarId",
"Std.HashMap",
"Aesop.EqualUpToIds.GoalContext",
"Lean.instHashableFVarId"
] | true |
Std.IterM.find?_eq_findM? | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Pure.pure",
"Monad.toApplicative",
"Std.IterM.find?",
"ULift",
"Std.IteratorLoop",
"Std.Iterators.Finite",
"Applicative.toPure",
"Std.Iterator",
"Std.IterM.findM?",
"Bool",
"Std.IterM",
"ULift.up",
"Monad",
"Eq",
"rfl",
"Option"
] | true |
WithZero.instSemigroupWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.WithZero | [
"Semigroup",
"Semigroup.toMul",
"HMul.hMul",
"mul_assoc",
"Option.map₂_assoc",
"WithZero",
"Eq",
"Option.map₂",
"instHMul",
"Option"
] | false |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.trySolveCore.match_3 | Mathlib.Lean.Meta.CongrTheorems | [
"Lean.MVarId",
"Lean.FVarId",
"Prod.mk",
"Array",
"Prod",
"Prod.casesOn"
] | false |
ProbabilityTheory.Kernel.instIsMarkovKernelCondKernelReal | Mathlib.Probability.Kernel.Disintegration.StandardBorel | [
"Eq.mpr",
"Real",
"ProbabilityTheory.IsFiniteKernel",
"ProbabilityTheory.Kernel.condKernelCDF",
"ProbabilityTheory.Kernel.isCondKernelCDF_condKernelCDF",
"congrArg",
"ProbabilityTheory.Kernel.condKernelReal",
"inferInstance",
"id",
"MeasurableSpace",
"Real.measurableSpace",
"ProbabilityTheory.... | true |
IsLUB.div | Mathlib.Algebra.Order.Group.Pointwise.Bounds | [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Preorder.toLE",
"Group.toDivisionMonoid",
"MulLeftMono",
"id",
"MulOne.toMul",
"HDiv.hDiv",
"IsLUB.mul",
"DivInvMonoid.toMonoid",
"MulRightMono",
"div_eq_mul_inv",
"DivisionMonoid... | true |
Filter.exists_eventually_atBot | Mathlib.Order.Filter.AtTopBot.Basic | [
"OrderDual.instNonempty",
"IsCodirectedOrder",
"Filter.exists_eventually_atTop",
"Filter.Eventually",
"OrderDual.isDirected_le",
"Preorder.toLE",
"Exists",
"LE.le",
"Iff",
"Nonempty",
"Filter.atBot",
"OrderDual",
"OrderDual.instPreorder",
"Preorder"
] | true |
CategoryTheory.Functor.prod'CompFst_inv_app | Mathlib.CategoryTheory.Products.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Functor.prod'",
"CategoryTheory.Functor.prod'CompFst",
"CategoryTheory.prod'",
"Eq.refl",
"Categ... | true |
Lean.Elab.Term.Quotation.HeadCheck.ctorElimType | Lean.Elab.Quotation | [
"cond",
"Lean.Elab.Term.Quotation.HeadCheck.slice",
"Nat.ble",
"Lean.Syntax",
"Lean.Elab.Term.Quotation.HeadCheck.other",
"Lean.Elab.Term.Quotation.HeadCheck",
"Lean.Elab.Term.Quotation.HeadCheck.shape",
"PULift",
"List",
"Lean.Elab.Term.Quotation.HeadCheck.unconditional",
"Nat",
"Lean.SyntaxN... | false |
Num.add_one | Mathlib.Data.Num.Lemmas | [
"PosNum.casesOn",
"PosNum.bit1",
"Num.succ",
"instOneNum",
"PosNum.bit0",
"instHAdd",
"Num",
"Unit",
"HAdd.hAdd",
"instZeroNum",
"Num.pos",
"Eq.ndrec",
"One.toOfNat1",
"Zero.toOfNat0",
"Eq.refl",
"PosNum",
"_private.Mathlib.Data.Num.Lemmas.0.Num.add_one.match_1_1",
"OfNat.ofNat",
... | true |
Sum.discreteTopology | Mathlib.Topology.Constructions | [
"coinduced_bot",
"Iff.mpr",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"and_self",
"DiscreteTopology",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLattice",
"TopologicalSpace.instCompleteLattice",
"Semilattic... | true |
Lean.Grind.not_eq_prop | Init.Grind.Norm | [
"False",
"eq_false",
"iff_false",
"congrArg",
"iff_true",
"eq_iff_iff._simp_1",
"Classical.propDecidable",
"not_true_eq_false",
"dite",
"Iff",
"congr",
"True",
"eq_self",
"eq_true",
"of_eq_true",
"not_false_eq_true",
"Eq",
"Not",
"Eq.trans"
] | true |
TypeVec.ofRepeat.match_1 | Mathlib.Data.TypeVec | [
"HEq.refl",
"Fin2.fz",
"Fin2.casesOn",
"instOfNatNat",
"Fin2.fs",
"instHAdd",
"HAdd.hAdd",
"Nat",
"eq_of_heq",
"Eq.ndrec",
"instAddNat",
"Eq.refl",
"HEq",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Fin2"
] | false |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'._simp_1_10 | Mathlib.Algebra.Star.UnitaryStarAlgAut | [
"Set.mem_range",
"Membership.mem",
"Exists",
"propext",
"Set.range",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Mathlib.AlgebraicGeometry.ZariskisMainTheorem.0.AlgebraicGeometry.Scheme.Hom.quasiFiniteLocus_comp._simp_1_1 | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | [
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CommRingCat",
"TopCat.instCategory",
"ContinuousMap",
"AlgebraicGeometry.Scheme.Hom.quasiFiniteAt_comp_iff_of_isOpenImmersion",
"... | false |
_private.Init.Control.Lawful.MonadAttach.Instances.0.instWeaklyLawfulMonadAttachExceptTOfLawfulMonad.match_4 | Init.Control.Lawful.MonadAttach.Instances | [
"Except.ok",
"Subtype.casesOn",
"Except.error",
"Subtype",
"ExceptT",
"Subtype.mk",
"MonadAttach",
"Except.casesOn",
"Except",
"MonadAttach.CanReturn"
] | false |
Std.ExtDTreeMap.maxKey_erase_le_maxKey | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.maxKey._proof_1",
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Std.ExtDTreeMap.erase",
"Std.ExtDTreeMap.maxKey",
"Quot.pliftOn._proof_2",
"Ordering",
"Ne",
"Std.DTreeMap.maxKey",
"Std.ExtDTreeMap.instEmptyCollection",
"Std.TransCmp",
"Bool.true",
"Std.DTreeMap.isSetoid",
"Std.Ex... | true |
_private.Mathlib.Logic.Basic.0.xor_not_not._proof_1_1 | Mathlib.Logic.Basic | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"False.elim",
"Classical.byContradiction",
"Xor",
"Lean.Grind.and_eq_of_eq_true_left",
"Lean.Grind.and_eq_of_eq_... | false |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.IsTopologicalBasis.mem_nhds_iff.match_1_3 | Mathlib.Topology.Bases | [
"Membership.mem",
"Exists",
"HasSubset.Subset",
"Set.instInter",
"Inter.inter",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Set.instMembership",
"Set.instHasSubset",
"Set"
] | false |
Std.TreeMap.isEmpty_filterMap_iff | Std.Data.TreeMap.Lemmas | [
"GetElem?.toGetElem",
"Std.TreeMap.getKey",
"Std.TreeMap.inner",
"Membership.mem",
"Ordering",
"Std.DTreeMap.Const.isEmpty_filterMap_iff",
"Std.TransCmp",
"Std.TreeMap.isEmpty",
"GetElem.getElem",
"Bool.true",
"Option.none",
"Iff",
"Std.TreeMap.filterMap",
"Std.TreeMap.instMembership",
"... | true |
GeneralizedBooleanAlgebra.toBooleanAlgebra._proof_3 | Mathlib.Order.BooleanAlgebra.Basic | [
"SemilatticeSup.mk",
"SemilatticeSup.le_sup_left",
"LT.mk",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Preorder.mk",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"Preorder.le_refl",
"DistribLattice.toLattice",
"LE.le",
"Preorder.le... | false |
Semigrp.instConcreteCategoryMulHomCarrier._proof_1 | Mathlib.Algebra.Category.Semigrp.Basic | [
"MulHom",
"Semigroup.toMul",
"_private.Mathlib.Algebra.Category.Semigrp.Basic.0.Semigrp.Hom.mk",
"id",
"Semigrp.Hom.hom'",
"Semigrp.str",
"Semigrp",
"Eq.refl",
"Semigrp.carrier",
"Eq"
] | false |
Aesop.ForwardRulePriority.rec | Aesop.Rule.Forward | [
"Int",
"Aesop.ForwardRulePriority",
"Aesop.ForwardRulePriority.normSafe",
"Aesop.Percent",
"Aesop.ForwardRulePriority.unsafe"
] | false |
Int.modEq_sub_modulus_iff | Mathlib.Data.Int.ModEq | [
"Eq.mpr",
"Int.modEq_add_modulus_iff",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddZeroClass.toAddZero",
"id",
"Int",
"SubNegMonoid.toSub",
"instHAdd",
"Iff",
"instHSub",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"Int.ModEq",
"propext",
"Int.instAdd",
"Int.i... | true |
Lean.Grind.CommRing.Poly.mulMon.go.eq_2 | Init.Grind.Ring.CommSolver | [
"Lean.Grind.CommRing.Poly.mulMon.go",
"Lean.Grind.CommRing.Poly",
"HMul.hMul",
"Lean.Grind.CommRing.Poly.add",
"Int",
"Int.instMul",
"Lean.Grind.CommRing.Mon.mul",
"Eq.refl",
"Eq",
"Lean.Grind.CommRing.Mon",
"instHMul"
] | true |
Matrix.instAddCommGroupWithOne._proof_1 | Mathlib.Data.Matrix.Diagonal | [
"AddMonoidWithOne.natCast_zero",
"AddCommGroupWithOne",
"Matrix",
"AddMonoid.toZero",
"AddGroupWithOne.toAddMonoidWithOne",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"NatCast.natCast",
"Nat",
"Zero.toOfNat0",
"AddMonoidWithOne.toAddMonoid",
"Matrix.instAddGroupWithOne",
"OfNat.ofNat",
... | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.applyPartition.go.match_3.splitter | Std.Data.DTreeMap.Internal.Model | [
"Ord",
"Ordering",
"Std.DTreeMap.Internal.Impl.inner",
"Std.DTreeMap.Internal.Impl.applyPartition.go.match_3",
"Bool.true",
"Std.DTreeMap.Internal.Impl.contains'",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Bool",
"Eq",
"Std.DTreeMap.Internal.Impl"
] | true |
List.Ico.succ_top | Mathlib.Data.List.Intervals | [
"Eq.mpr",
"congrArg",
"id",
"Nat.le_succ",
"instOfNatNat",
"LE.le",
"instLENat",
"List.Ico.succ_singleton",
"List.cons",
"instHAppendOfAppend",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"List.Ico.append_consecutive",
"List.Ico",
"List.instAppend",
"OfNat.... | true |
Algebra.QuasiFiniteAt.of_quasiFiniteAt_residueField | Mathlib.RingTheory.ZariskisMainTheorem | [
"RingHom.instRingHomClass",
"CommRing",
"Algebra.to_smulCommClass",
"OreLocalization.instAlgebra",
"CommSemiring.toSemiring",
"Algebra.TensorProduct.instCommRing",
"Localization.AtPrime",
"Algebra.QuasiFiniteAt",
"IsLocalRing.ResidueField.algebra",
"Algebra",
"Algebra.QuasiFiniteAt.of_weaklyQuas... | true |
LieAlgebra.IsSemisimple.instBooleanAlgebra | Mathlib.Algebra.Lie.Semisimple.Basic | [
"LieAlgebra.toModule",
"BooleanAlgebra",
"CommRing",
"LieAlgebra.IsSemisimple",
"LieAlgebra.IsSemisimple.booleanGenerators",
"LieRing.toAddCommGroup",
"PartialOrder.toPreorder",
"setOf",
"LieSubmodule.instPartialOrder",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"LieAlgebra.IsSemisimpl... | true |
Std.PRange.UpwardEnumerable.eq_of_succ_eq | Init.Data.Range.Polymorphic.UpwardEnumerable | [
"Std.PRange.UpwardEnumerable",
"Std.PRange.UpwardEnumerable.succ_inj",
"Std.PRange.LinearlyUpwardEnumerable",
"Std.PRange.InfinitelyUpwardEnumerable",
"Iff.mp",
"Eq",
"Std.PRange.UpwardEnumerable.succ"
] | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabProj.match_1 | Lean.PrettyPrinter.Delaborator.Builtins | [
"_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabProj._sparseCasesOn_1",
"Lean.Expr",
"Nat.hasNotBit",
"Nat",
"Lean.Name",
"Lean.Expr.ctorIdx",
"Lean.Expr.proj"
] | false |
_private.Mathlib.GroupTheory.FreeGroup.Orbit.0.FreeGroup.startsWith.disjoint_iff_ne._simp_1_2 | Mathlib.GroupTheory.FreeGroup.Orbit | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Set.instInter",
"Set.instDistribLattice",
"Set.disjoint_iff_inter_eq_empty",
"Inter.inter",
"Set.instBoundedOrder",
"BoundedOrder.toOrderBot",
"propext",
"Set.instEmptyCollec... | false |
Lean.Parser.Term.letI.formatter | Lean.Parser.Term | [
"Lean.PrettyPrinter.Formatter",
"Lean.Parser.withCache.formatter",
"Lean.Parser.Term.optSemicolon.formatter",
"Lean.Parser.leadingNode.formatter",
"instOfNatNat",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Lean.Parser.symbol.formatter",
"Lean.Parser.Term.letConfig.formatter",
"Bool.true... | true |
Lean.Parser.Attr.export._regBuiltin.Lean.Parser.Attr.export.formatter_7 | Lean.Parser.Attr | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.Parser.Attr.export.formatter",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
Lean.Meta.RecursorUnivLevelPos.motive | Lean.Meta.RecursorInfo | [
"Lean.Meta.RecursorUnivLevelPos.motive",
"Lean.Meta.RecursorUnivLevelPos"
] | true |
TensorProduct.liftAddHom_tmul | Mathlib.LinearAlgebra.TensorProduct.Basic | [
"instHSMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddMonoidHom.instAddCommMonoid",
"AddCommMonoid",
"CommSemiring",
"AddZero.toZero",
"TensorProduct.liftAddHom",
"Semiring.toMonoid",
... | true |
Std.DHashMap.Internal.Raw₀.insertMany_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | [
"Eq.mpr",
"congrArg",
"instForInOfForIn'",
"inferInstance",
"id",
"instOfNatNat",
"Id",
"Membership",
"Std.DHashMap.Internal.Raw₀.emptyWithCapacity",
"List.cons",
"List",
"Std.DHashMap.Internal.Raw₀.insert",
"List.instMembership",
"Nat",
"Std.DHashMap.Internal.Raw₀.insertMany",
"Std.DH... | true |
FinBoolAlg.Iso.mk._proof_14 | Mathlib.Order.Category.FinBoolAlg | [
"FinBoolAlg",
"BoolAlg.carrier",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"BooleanAlgebra.toBoundedOrder",
"OrderIso",
"Bot.bot",
"BiheytingAlgebra.toCoheytingAlgebra",
"OrderIso.instEquivLike",
"OrderIso.instOrderIsoClass",
"OrderIso.sym... | false |
Ordinal.card_nat | Mathlib.SetTheory.Ordinal.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"Nat.recAux",
"Cardinal.instOne",
"Ordinal.card_one",
"AddMonoid.toAddSemigroup",
"Ordinal.card_zero",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"Cardinal.commSemiring",
"AddZeroClass.toAddZero",... | true |
Batteries.RBNode.WF.casesOn | Batteries.Data.RBMap.Basic | [
"Batteries.RBNode.WF",
"Batteries.RBNode",
"Batteries.RBNode.WF.insert",
"Batteries.RBNode.WF.mk",
"Ordering",
"Batteries.RBNode.WF.erase",
"Batteries.RBNode.erase",
"Batteries.RBNode.insert",
"Batteries.RBColor",
"Nat",
"Batteries.RBNode.Ordered",
"Batteries.RBNode.Balanced",
"Batteries.RBN... | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabMatchAltViews.updateFirst.match_1 | Lean.Elab.Match | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Lean.Elab.Term.SavedState",
"Option.none",
"Unit",
"Prod",
"Lean.Exception",
"Option"
] | false |
Unitary.two_mul_one_sub_cos_norm_argSelfAdjoint | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | [
"Norm.norm",
"Eq.mpr",
"CStarAlgebra.toNonUnitalCStarAlgebra",
"Real",
"selfAdjoint.norm_sq_expUnitary_sub_one",
"NonUnitalCStarAlgebra.toNonUnitalNormedRing",
"NormedRing.toRing",
"HMul.hMul",
"selfAdjoint.expUnitary",
"Ring.toNonAssocRing",
"Real.cos",
"Monoid.toMulOneClass",
"AddGroupWith... | true |
Lean.Widget.instFromJsonGetWidgetSourceParams.fromJson | Lean.Widget.UserWidget | [
"Pure.pure",
"Lean.Json",
"UInt64",
"Monad.toApplicative",
"String",
"Lean.Lsp.instFromJsonPosition",
"Lean.Name.mkStr3",
"Lean.Json.getObjValAs?",
"Applicative.toPure",
"ToString.toString",
"Except.instMonad",
"instAppendString",
"Except.mapError",
"instHAppendOfAppend",
"Lean.Name.inst... | true |
String.Legacy.Iterator.ValidFor.pos | Batteries.Data.String.Lemmas | [
"String.Legacy.Iterator.mk",
"List.reverseAux",
"String.utf8Len",
"_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.ValidFor.pos.match_1_1",
"String.Pos.Raw",
"List",
"Unit",
"String.Pos.Raw.mk",
"String.Legacy.Iterator",
"Char",
"String.Legacy.Iterator.ValidFor",
"Eq",
"String... | true |
Homeomorph.piFinTwo._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | [
"Continuous",
"Pi.topologicalSpace",
"instTopologicalSpaceProd",
"Fin.instOfNat",
"instOfNatNat",
"Equiv.toFun",
"TopologicalSpace",
"Nat.instNeZeroSucc",
"Nat",
"continuous_apply",
"Prod",
"piFinTwoEquiv._proof_2",
"OfNat.ofNat",
"Fin",
"piFinTwoEquiv",
"Continuous.prodMk"
] | false |
Batteries.RBMap.val_toList | Batteries.Data.RBMap.Lemmas | [
"Batteries.RBNode.WF",
"Batteries.RBNode",
"Batteries.RBNode.toList",
"Ordering.byKey",
"Batteries.RBMap",
"Ordering",
"Prod.fst",
"List",
"Prod",
"Subtype.val",
"Eq",
"rfl",
"Batteries.RBMap.toList"
] | true |
ComplexShape._sizeOf_inst | Mathlib.Algebra.Homology.ComplexShape | [
"ComplexShape",
"ComplexShape._sizeOf_1",
"SizeOf.mk",
"SizeOf"
] | false |
tprod_eq_mulSingle | Mathlib.Topology.Algebra.InfiniteSum.Basic | [
"Eq.mpr",
"MulOne.toOne",
"Finset.prod_singleton",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"SummationFilter",
"Membership.mem",
"Eq.mp",
"id",
"Ne",
"Finset.mem_singleton._simp_1",
"Finset.prod",
"TopologicalSpace",
"MulOneClass.toMulOne",
"Finset.instSetLike",
"CommMonoid.toMo... | true |
USize.ofNat_toNat | Init.Data.UInt.Lemmas | [
"instPowNat",
"congrArg",
"USize.toNat_lt_size",
"USize.ofNat",
"Nat.instMod",
"instHMod",
"instOfNatNat",
"Nat.mod_eq_of_lt",
"USize.toNat_ofNat'",
"instNatPowNat",
"System.Platform.numBits",
"HMod.hMod",
"HPow.hPow",
"USize.toNat",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congr... | true |
Lean.IR.Sorry.State.mk.sizeOf_spec | Lean.Compiler.IR.Sorry | [
"Lean.NameMap",
"instSizeOfDefault",
"instOfNatNat",
"Lean.IR.Sorry.State",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Bool",
"instAddNat",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool._sizeOf_inst",
"Eq",
"Lean.IR.Sorry.State.mk",
"Lean.IR.Sorry.State._sizeOf_inst"
] | true |
List.min_eq_head | Init.Data.List.MinMax | [
"List.head?",
"List.head",
"Eq.mpr",
"List.head?_eq_some_head",
"List.min?",
"List.Pairwise",
"congrArg",
"List.min",
"Option.some",
"id",
"Option.some.inj",
"Ne",
"Min",
"List",
"List.min?_eq_some_min",
"Eq.symm",
"List.min?_eq_head?",
"Eq",
"Min.min",
"List.nil",
"Option"
] | true |
AddSubmonoid.one_eq_mrange | Mathlib.Algebra.Ring.Submonoid.Pointwise | [
"Nat.castAddMonoidHom",
"AddMonoidHom.instAddMonoidHomClass",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"AddMonoidHom.mrange",
"AddSubmonoid",
"Nat",
"AddSubmonoid.one",
"One.toOfNat1",
"AddMonoidWithOne.toAddMonoid",
"AddMonoidHom",
"AddMonoidHom.instFunLike... | true |
Real.tanh_eq_sinh_div_cosh | Mathlib.Analysis.Complex.Trigonometric | [
"Real",
"Complex.sinh",
"instHDiv",
"Real.tanh",
"Complex.ofReal_tanh",
"congrArg",
"Real.instDivInvMonoid",
"Complex.instDivInvMonoid",
"Real.sinh",
"HDiv.hDiv",
"Complex.ofReal",
"congr",
"True",
"Complex.ofReal_sinh",
"eq_self",
"Iff.mp",
"DivInvMonoid.toDiv",
"Complex.ofReal_di... | true |
bddBelow_Ioo._simp_1 | Mathlib.Order.Bounds.Basic | [
"Preorder.toLE",
"True",
"bddBelow_Ioo",
"BddBelow",
"eq_true",
"Eq",
"Set.Ioo",
"Preorder"
] | false |
Std.DTreeMap.keys_filter_key | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Internal.Impl.keys_filter_key",
"Ord.mk",
"Ordering",
"Std.DTreeMap.inner",
"List",
"List.filter",
"Std.DTreeMap.wf",
"Bool",
"Std.DTreeMap.keys",
"Eq",
"Std.DTreeMap.filter"
] | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_12 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | [
"CategoryTheory.Over.map",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.Over.mk",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.SemiCartesianMonoidalCategory... | false |
Aesop.Frontend.elabAdditionalForwardRules | Aesop.Frontend.Saturate | [
"Pure.pure",
"Aesop.Frontend.elabForwardRule",
"Lean.TSyntax",
"Lean.instMonadExceptOfExceptionCoreM",
"instForInOfForIn'",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"Lean.Meta.State",
"Lean.Syntax.isOfKind",
"_private.Aesop.Frontend.Saturate.0.Aesop.Frontend.elabAdditionalForwardRules.match... | true |
Lean.instInhabitedLocalContext | Lean.LocalContext | [
"Inhabited",
"Lean.LocalContext",
"Lean.instInhabitedLocalContext.default",
"Inhabited.mk"
] | true |
Batteries.RBNode.Path.RootOrdered.eq_2 | Batteries.Data.RBMap.Alter | [
"Batteries.RBNode",
"Batteries.RBNode.Path",
"Ordering",
"Batteries.RBNode.cmpLT",
"Batteries.RBNode.Path.RootOrdered",
"And",
"Batteries.RBColor",
"Eq.refl",
"Eq",
"Batteries.RBNode.Path.left"
] | true |
_private.Mathlib.AlgebraicTopology.ModelCategory.Over.0.HomotopicalAlgebra.weakEquivalences_over_iff._simp_1_2 | Mathlib.AlgebraicTopology.ModelCategory.Over | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.instCategoryOver",
"CategoryTheory.Over.left",
"CategoryTheory.MorphismProperty.over_iff",
"propext",
"CategoryTheory.Category.toCategor... | false |
Cycle.Chain._proof_4 | Mathlib.Data.List.Cycle | [
"Eq.mpr",
"List.rotate_singleton",
"Nat.recAux",
"List.append_assoc",
"congrArg",
"List.IsRotated.setoid",
"False.elim",
"Iff.rfl",
"List.isChain_cons_cons._simp_1",
"List.rotate_cons_succ",
"List.isRotated_nil_iff'",
"noConfusion_of_Nat",
"List.rotate_rotate",
"Eq.mp",
"id",
"List.IsC... | false |
Computation.memRecOn._proof_2 | Mathlib.Data.Seq.Computation | [
"Computation.thinkN",
"congrArg",
"Membership.mem",
"id",
"Computation",
"Computation.get_eq_of_mem",
"Computation.length",
"Computation.pure",
"Computation.terminates_of_mem",
"Computation.instMembership",
"Computation.get",
"Eq"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.