name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicGeometry.IsSchemeTheoreticallyDominant.pullbackFst | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | [
"AlgebraicGeometry.Flat",
"CategoryTheory.Limits.pullback",
"AlgebraicGeometry.Scheme",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.pullback.snd",
"AlgebraicGeometry.IsSchemeTheoreticallyDominant",
"CategoryTheory.IsPullback.flip",
"AlgebraicGeometry.QuasiCompact",... | true |
Convexity.IsAffineMap.map_sConvexComb | Mathlib.Geometry.Convex.ConvexSpace.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Convexity.ConvexSpace",
"PartialOrder.toPreorder",
"IsStrictOrderedRing",
"Preorder.toLE",
"PartialOrder",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddMonoidWithOne.toOne",
"Convexity.ConvexSpace.sConvexCom... | true |
_private.Lean.Meta.Sym.IsClass.0.Lean.Meta.Sym.isClass?.go.match_1 | Lean.Meta.Sym.IsClass | [
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.Expr.forallE",
"Lean.Expr.casesOn",
"List",
"Lean.MData",
"Lean.Expr.lam",
... | false |
SheafOfModules.Presentation.ctorIdx | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | [
"AddCommGrpCat.instCategory",
"SheafOfModules.Presentation",
"AddMonoid.toAddZeroClass",
"RingCat.ring",
"AddCommGroup.toAddGroup",
"RingHom",
"AddCommGrpCat.instConcreteCategoryAddMonoidHomCarrier",
"AddZeroClass.toAddZero",
"RingCat.instConcreteCategoryRingHomCarrier",
"AddCommGrpCat.carrier",
... | false |
CategoryTheory.Limits.ConeMorphism.hom | Mathlib.CategoryTheory.Limits.Cones | [
"CategoryTheory.Limits.ConeMorphism",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.Cone.pt",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"
] | true |
Rat.toDyadic_eq_ofIntWithPrec | Init.Data.Dyadic.Basic | [
"Eq.mpr",
"Int.instDiv",
"Rat.num",
"instHDiv",
"Rat.toDyadic",
"Rat.toDyadic_mkRat",
"Dyadic.ofIntWithPrec",
"congrArg",
"Int.instHShiftLeftNat",
"Rat",
"HShiftLeft.hShiftLeft",
"Rat.den",
"Eq.rec",
"Dyadic",
"id",
"HDiv.hDiv",
"Int.instNegInt",
"Int",
"Rat.mkRat_self",
"Nat.c... | true |
CategoryTheory.ReflQuiv.forget.Faithful | Mathlib.CategoryTheory.Category.ReflQuiv | [
"CategoryTheory.ReflQuiv.forget",
"CategoryTheory.ReflQuiv",
"CategoryTheory.Cat.category",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Cat",
"CategoryTheory.Functor.Faithful.mk",
"CategoryTheory.Functor.map",
"CategoryTheory.ReflQuiv.category",
"CategoryTheory.ReflQuiv... | true |
Std.Time.Week.Ordinal.ofInt | Std.Time.Date.Unit.Week | [
"Std.Time.Week.Ordinal",
"Std.Time.Internal.Bounded.LE.mk",
"Int",
"LE.le",
"And",
"instOfNat",
"OfNat.ofNat",
"Int.instLEInt"
] | true |
CategoryTheory.Bicategory.Adj.Bicategory.rightUnitor_hom_τl | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | [
"CategoryTheory.Bicategory.Adj.Bicategory.rightUnitor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Bicategory.Adj.Hom.l",
"Quiver.Hom",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory.A... | true |
partialSups._proof_1 | Mathlib.Order.PartialSups | [
"Iff.mpr",
"Finset",
"Preorder.toLE",
"LocallyFiniteOrderBot",
"HasSubset.Subset",
"LE.le",
"Finset.Iic_subset_Iic",
"Finset.Nonempty",
"Finset.instHasSubset",
"Finset.Iic",
"Finset.Nonempty.mono",
"Preorder",
"Finset.nonempty_Iic"
] | false |
CategoryTheory.GrothendieckTopology.liftToPlusObjLimitObj_fac | Mathlib.CategoryTheory.Sites.LeftExact | [
"CategoryTheory.GrothendieckTopology.liftToPlusObjLimitObj._proof_10",
"CategoryTheory.GrothendieckTopology.liftToPlusObjLimitObj._proof_5",
"CategoryTheory.Limits.limit.π",
"CategoryTheory.Limits.multiequalizer",
"CategoryTheory.Limits.HasLimit.isoOfNatIso",
"Eq.mpr",
"CategoryTheory.Category.assoc",
... | true |
sub_pos | Mathlib.Algebra.Order.Group.Unbundled.Basic | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"AddRightStrictMono",
"HSub.hSub",
"AddZeroClass.toAddZero",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"zero_add",
"SubNegMonoid.toSub",
"... | true |
LieModuleHom.coe_zsmul | Mathlib.Algebra.Lie.Basic | [
"CommRing",
"instHSMul",
"LieModuleHom",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Int",
"LieRing",
"CommRing.toCommSemiring",
"AddGroup.toSubNegMonoid",
"Pi.subNegMonoid",
"LieRingModule",
"HSMul.hSMul",
"Module",
"Eq",
"D... | true |
Path.symm.eq_1 | Mathlib.Topology.Homotopy.Path | [
"Real",
"Path.symm",
"ContinuousMap.mk",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"Membership.mem",
"Set.Elem",
"Path.symm._proof_1",
"TopologicalSpace",
"Path.symm._proof_3",
"Path.mk",
"Path.instFunLike",
"Path",
"Eq.refl",
"Real.pseudoMetricSpace",
"instTopologicalSpaceS... | true |
analyticWithinAt_rexp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | [
"Real",
"Real.denselyNormedField",
"analyticAt_rexp",
"AnalyticWithinAt",
"Real.normedAddCommGroup",
"Real.exp",
"AnalyticAt.analyticWithinAt",
"NontriviallyNormedField.toNormedField",
"DenselyNormedField.toNontriviallyNormedField",
"NormedField.toNormedSpace",
"Set"
] | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.ctorElimType | Std.Sync.Channel | [
"cond",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer",
"Nat.ble",
"PULift",
"Std.Internal.IO.Async.Waiter",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.select",
"Nat",
"IO.Promise",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.normal",
"Option"
] | false |
OpenPartialHomeomorph.MDifferentiable.mfderiv | Mathlib.Geometry.Manifold.MFDeriv.Atlas | [
"mfderiv",
"ContinuousLinearEquiv.mk",
"NormedSpace",
"LinearEquiv.mk",
"AddCommGroup.toAddCommMonoid",
"instAddCommGroupTangentSpace",
"ContinuousLinearMap.funLike",
"OpenPartialHomeomorph.MDifferentiable.mfderiv._proof_2",
"Membership.mem",
"NormedField.toField",
"instModuleTangentSpace",
"C... | true |
Lean.Diff.Action.insert.elim | Lean.Util.Diff | [
"PULift.up",
"Lean.Diff.Action.insert",
"Lean.Diff.Action",
"Lean.Diff.Action.ctorIdx",
"Nat",
"Eq.symm",
"Eq",
"Lean.Diff.Action.ctorElim"
] | false |
CategoryTheory.Functor.sheafPushforwardCocontinuousCompSheafToPresheafIso_inv | Mathlib.CategoryTheory.Sites.CoverLifting | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Functor.ran",
"CategoryTheory.Functor.IsCocontinuous",
... | true |
ContinuousMultilinearMap.toMultilinearMapLinear | Mathlib.Topology.Algebra.Module.Multilinear.Basic | [
"ContinuousMultilinearMap.toMultilinearMap_add",
"DistribMulAction.toDistribSMul",
"MultilinearMap.addCommMonoid",
"AddMonoid.toAddZeroClass",
"ContinuousMultilinearMap.addCommMonoid",
"ContinuousMultilinearMap.instModule",
"ContinuousMultilinearMap",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZer... | true |
BoundedContinuousFunction.C._proof_7 | Mathlib.Topology.ContinuousMap.Bounded.Normed | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"NormedRing.toRing",
"BoundedContinuousFunction.ext",
"Algebra.algebraMap",
"Ring.toNonAssocRing",
"IsTopologicalRing.toIsTopologicalSemiring",
"BoundedContinuousFunction.C._proof_3",
"CommSemiring.toSemiring",
"IsTopologicalSemiring.toContinuousMul",
"Is... | false |
_private.Mathlib.GroupTheory.Goursat.0.AddSubgroup.goursat_surjective.match_1_1 | Mathlib.GroupTheory.Goursat | [
"Subtype.casesOn",
"Membership.mem",
"Subtype",
"Subtype.mk",
"AddSubgroup",
"AddGroup",
"AddSubgroup.instSetLike",
"Prod",
"SetLike.instMembership",
"Prod.instAddGroup"
] | false |
finprod_mem_eq_prod_filter | Mathlib.Algebra.BigOperators.Finprod | [
"Set.ext",
"MulOne.toOne",
"Function.mem_mulSupport._simp_2",
"Finset.coe_filter",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"setOf",
"Membership.mem",
"iff_and_self._simp_1",
"_private.Mathlib.Algebra.BigOperators.Finprod.0.finprod_mem_eq_prod_filter._simp_1_1",
"Ne",
"Set.instInter",
... | true |
SSet.stdSimplex.monotone_apply | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | [
"Opposite",
"Equiv.instEquivLike",
"OrderHom.monotone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Monotone",
"Equiv",
"instOfNatNat",
"SSet",
"SSet.stdSimplex",
"instHAdd",
"Fin.instPartialOrder",
"HAdd.hAdd",
... | true |
HomologicalComplex.id_f | Mathlib.Algebra.Homology.HomologicalComplex | [
"CategoryTheory.Limits.HasZeroMorphisms",
"HomologicalComplex.instCategory",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HomologicalComplex",
"CategoryTheory.CategoryStruct.id",
"ComplexShape",
"CategoryTheory.Category.toCategoryStruct",
"HomologicalComplex... | true |
Lean.Parser.Tactic.MCasesPat.alts.injEq | Std.Tactic.Do.Syntax | [
"Eq.propIntro",
"Lean.Parser.Tactic.MCasesPat.alts",
"Lean.Parser.Tactic.MCasesPat.alts.inj",
"List",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Parser.Tactic.MCasesPat"
] | true |
IsCompact.finite_compact_cover | Mathlib.Topology.Separation.Basic | [
"Eq.mpr",
"False",
"Finset.set_biUnion_insert_update",
"Function.update",
"R1Space",
"Iff.of_eq",
"congrArg",
"Finset",
"Classical.propDecidable",
"Membership.mem",
"Exists",
"Set.instUnion",
"Eq.mp",
"id",
"Finset.induction",
"Insert.insert",
"HasSubset.Subset",
"Ne",
"Finset.in... | true |
_private.Mathlib.Algebra.Homology.ShortComplex.Preadditive.0.CategoryTheory.ShortComplex.Homotopy.unop._abel_1 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | [
"Mathlib.Tactic.Abel.const_add_termg",
"Mathlib.Tactic.Abel.term_atomg",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.opposite",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"CategoryTheory.ShortComplex",
"Ad... | false |
CategoryTheory.ShortComplex.Homotopy.h₀_f | Mathlib.Algebra.Homology.ShortComplex.Preadditive | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.ShortComplex.Homotopy",
"CategoryTheory.ShortComplex.instCategory",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"CategoryTheory.Preadditive",
"CategoryTheory.Sh... | true |
LowerSemicontinuousOn.inf | Mathlib.Topology.Semicontinuity.Basic | [
"LowerSemicontinuousOn",
"LinearOrder",
"PartialOrder.toPreorder",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"SemilatticeInf.toMin",
"LowerSemicontinuousWithinAt.inf",
"TopologicalSpace",
"Set.instMembership",
"instDistribLatticeOfLinearOrder",
"Min.min",
... | true |
Std.MinEqOr.recOn | Init.Data.Order.Classes | [
"Min",
"Std.MinEqOr",
"Std.MinEqOr.mk",
"Std.MinEqOr.rec",
"Or",
"Eq",
"Min.min"
] | false |
Set.addCentralizer_prod | Mathlib.Algebra.Group.Center | [
"Set.instSProd",
"Set.ext",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"Prod.instAdd",
"Set.addCentralizer",
"_private.Mathlib.Algebra.Group.Center.0.Set.addCentralizer_prod._proof_1_4",
"Membership.mem",
"id",
"Prod.mk",
"Prod.fst",
"instHAdd",
"Set.mem_prod",
"And",
"Iff",
"Set.Nonempty"... | true |
RootPairing.corootSpan_ne_bot | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | [
"Submodule",
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Nat.instAtLeastTwoHAddOfNat",
"RootPairing.flip",
"AddGroupWithOne.toAddMonoidWithOne",
"AddCommGroup",
"AddMonoidWithOne.toNatCast",
"Ne",
"instOfNatNat",
"Bot.bot",
"Submodule.instBot",
"CommRing.toCommS... | true |
Mathlib.Tactic.Translate.instBEqRelevantArg.beq | Mathlib.Tactic.Translate.Core | [
"instBEqOfDecidableEq",
"Bool.true",
"BEq.beq",
"Unit",
"Nat",
"_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.instBEqRelevantArg.beq.match_1",
"Mathlib.Tactic.Translate.RelevantArg",
"Bool",
"instDecidableEqNat",
"Bool.false"
] | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_4 | Mathlib.Order.Interval.Finset.Nat | [
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"HMul.hMul",
"Int.Linear.norm_le",
"Lean.Grind.not_and",
"Int.Linear.Expr.eq_of_norm_eq",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Int.Linear.le_neg",
"Int.Lin... | false |
MulAction.smul_orbit | Mathlib.GroupTheory.GroupAction.Basic | [
"DivInvMonoid.toInv",
"instHSMul",
"Trans.trans",
"DivInvOneMonoid.toInvOneClass",
"Set.image_mono",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"DivInvMonoid.toMonoid",
"MulAction.smul_orbit_subset",
"HasSubset.Subset",
"smul_inv_smul",
"Set.instAntisymmSubset",
... | true |
Finset.Ioc_diff_Ioo_self | Mathlib.Order.Interval.Finset.Basic | [
"Set.Ioc",
"Preorder.toLT",
"Finset.coe_singleton",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Finset.coe_sdiff",
"Finset.instSDiff",
"PartialOrder",
"Set.instSingletonSet",
"_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ioc_diff_Ioo_self._simp_1_1",
"Finset.coe_Ioc",
"Finset.... | true |
_private.Mathlib.Data.Fintype.EquivFin.0.Fintype.card_eq_one_iff_nonempty_unique.match_1_3 | Mathlib.Data.Fintype.EquivFin | [
"Unique",
"Nonempty.intro",
"Nonempty.casesOn",
"Nonempty"
] | false |
Ordinal.lt_iSup_iff | Mathlib.SetTheory.Ordinal.Family | [
"Preorder.toLT",
"Ordinal.partialOrder",
"iSup",
"PartialOrder.toPreorder",
"Exists",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"Ordinal.instConditionallyCompleteLinearOrderBot",
"Ordinal.bddAbove_of_small",
"Iff",
"LT.lt",
"ConditionallyCompleteLinearOrderBot.toConditio... | true |
_private.Lean.Meta.Tactic.Apply.0.Lean.Meta.synthAppInstances.step.match_1 | Lean.Meta.Tactic.Apply | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"_private.Lean.Meta.Tactic.Apply.0.Lean.Meta.synthAppInstances.step._sparseCasesOn_1",
"Option"
] | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSemilinearSet.sInter._simp_1_2 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | [
"forall_eq_or_imp",
"And",
"propext",
"Or",
"Eq"
] | false |
FloatSpec.noConfusionType | Init.Data.Float | [
"FloatSpec.casesOn",
"DecidableRel",
"FloatSpec",
"HEq",
"Eq"
] | false |
Std.DTreeMap.mk.noConfusion | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"HEq.refl",
"Ord.mk",
"Ordering",
"id",
"Std.DTreeMap.Internal.Impl.WF",
"autoParam",
"Std.DTreeMap._auto_1",
"Std.DTreeMap.noConfusion",
"Std.DTreeMap.mk",
"heq_of_eq",
"Eq.refl",
"HEq",
"Eq",
"Std.DTreeMap.Internal.Impl"
] | false |
Std.Internal.Parsec.ByteArray.Parser | Std.Internal.Parsec.ByteArray | [
"ByteArray.Iterator",
"Std.Internal.Parsec"
] | true |
_aux_Mathlib_Tactic_GuardGoalNums___elabRules_guardGoalNums_1 | Mathlib.Tactic.GuardGoalNums | [
"guard",
"Lean.TSyntax",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.Elab.Tactic.instOrElseTacticM",
"String",
"Lean.Meta.State",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMonad",
"Lean.Syntax... | false |
WithVal.instAlgebra | Mathlib.Topology.Algebra.Valued.WithVal | [
"WithVal.instSMul_1",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"MulOne.toOne",
"CommRing",
"RingHom.mk",
"WithVal.instAlgebra._proof_5",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"OneHom.mk",
"Algebra",
"RingHom",
"Algebra.toSMul",
"WithVal.instAlgebra._proo... | true |
Batteries.RBNode.zoom.eq_1 | Batteries.Data.RBMap.Lemmas | [
"Batteries.RBNode",
"Batteries.RBNode.Path",
"Ordering",
"Batteries.RBNode.zoom",
"Prod.mk",
"Batteries.RBNode.nil",
"Eq.refl",
"Prod",
"Eq"
] | true |
smul_zero | Mathlib.Algebra.GroupWithZero.Action.Defs | [
"instHSMul",
"SMulZeroClass",
"Zero.toOfNat0",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"OfNat.ofNat",
"SMulZeroClass.smul_zero",
"Eq",
"Zero"
] | true |
Finset.prod_dite_of_false | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | [
"of_eq_false",
"Finset.univ",
"eq_false",
"congrArg",
"Finset",
"Membership.mem",
"SetLike.coe_mem._simp_1",
"Subtype",
"dite",
"Finset.prod",
"Subtype.mk",
"Finset.instSetLike",
"DecidablePred",
"Finset.prod_bij'",
"Subtype.coe_eta",
"True",
"Finset.attach",
"eq_self",
"Finset.S... | true |
UInt32.not_zero | Init.Data.UInt.Bitwise | [
"instComplementUInt32",
"instNegUInt32",
"Complement.complement",
"UInt32",
"OfNat.ofNat",
"Eq",
"UInt32.instOfNat",
"Neg.neg",
"rfl"
] | true |
Array.array_toSubarray | Init.Data.Slice.Array.Lemmas | [
"Subarray",
"congrArg",
"Nat.min_le_right",
"Std.Slice.internalRepresentation",
"Array.toSubarray",
"Std.Slice.Internal.SubarrayData.mk",
"Array",
"Array.toSubarray_eq_min",
"Std.Slice.mk",
"Std.Slice.Internal.SubarrayData",
"Nat",
"True",
"eq_self",
"Std.Slice.Internal.SubarrayData.array"... | true |
Aesop.LocalRuleSetMember.casesOn | Aesop.RuleSet.Member | [
"Aesop.LocalRuleSetMember.global",
"Aesop.LocalRuleSetMember",
"Aesop.LocalRuleSetMember.localNormSimpRule",
"Aesop.LocalRuleSetMember.rec",
"Aesop.GlobalRuleSetMember",
"Aesop.LocalNormSimpRule"
] | false |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.map._proof_1 | Std.Data.ExtDHashMap.Basic | [
"Std.DHashMap.Equiv",
"Std.ExtDHashMap.mk",
"Std.ExtDHashMap",
"Hashable",
"Std.DHashMap.map",
"Std.ExtDHashMap.sound",
"Std.DHashMap.Equiv.map",
"BEq",
"Eq",
"Std.DHashMap"
] | false |
Lean.Lsp.LogConfig.allowedMethods? | Lean.Data.Lsp.InitShutdown | [
"String",
"Std.HashSet",
"instHashableString",
"instBEqOfDecidableEq",
"instDecidableEqString",
"Lean.Lsp.LogConfig",
"Option"
] | true |
Lean.Meta.PProdN.projs | Lean.Meta.PProdN | [
"Array.ofFn",
"Lean.Expr",
"Lean.Meta.PProdN.proj",
"Fin.val",
"Array",
"Nat",
"Fin"
] | true |
ValuativeRel.ofValuation._proof_6 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | [
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"CommRing",
"Lattice.toSemilatticeSup",
"PartialOrder.toPreorder",
"LinearOrderedCommMonoidWithZero.toLinearOrder",
"Preorder.toLE",
"ValuationClass.map_add_le_max",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"Distri... | false |
CategoryTheory.Discrete.monoidal._proof_3 | Mathlib.CategoryTheory.Monoidal.Discrete | [
"Monoid",
"Eq.mpr",
"HMul.hMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Monoid.toMulOneClass",
"congrArg",
"id",
"MulOne.toMul",
"CategoryTheory.Discrete.mk",
"MulOneClass.toMulOne",
"CategoryTheory.Discrete.as",
"CategoryTheory.discreteCategory",
"CategoryTheory.Discrete... | false |
Mathlib.instToExprBinderInfo_mathlib | Mathlib.Tactic.ToExpr | [
"Lean.Expr.const",
"Lean.Level",
"Lean.Name.mkStr2",
"Lean.ToExpr.mk",
"Lean.BinderInfo",
"Lean.ToExpr",
"Mathlib.instToExprBinderInfo_mathlib.toExpr",
"List.nil"
] | true |
String.Slice.dropEndWhile_string_eq_dropEndWhile_toSlice | Init.Data.String.Lemmas.Pattern.String.ForwardPattern | [
"String.toSlice",
"String.Slice.Pattern.BackwardSliceSearcher.instBackwardPattern",
"congrArg",
"String",
"String.Slice",
"String.Slice.dropEndWhile",
"id",
"String.Slice.Pattern.BackwardSliceSearcher.instBackwardPattern_1",
"String.Slice.skipSuffixWhile_string_eq_skipSuffixWhile_toSlice",
"String... | true |
TypeName.ctorIdx | Init.Dynamic | [
"TypeName",
"Nat"
] | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.discr_of_degree_eq_one._proof_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | [
"Int.Linear.eq_of_core",
"Int.Linear.not_eq_norm_expr",
"Lean.RArray.leaf",
"False",
"CommRing",
"HMul.hMul",
"Int.Linear.norm_le",
"Nat.instOne",
"Int.Linear.Expr.eq_of_norm_eq",
"congrArg",
"CommSemiring.toSemiring",
"Lean.Grind.Semiring.mul_one",
"Int.Linear.le_unsat",
"Int.Linear.le_ne... | false |
CategoryTheory.SmallObject.attachCellsιFunctorObj_g₂ | Mathlib.CategoryTheory.SmallObject.Construction | [
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory.SmallObject.FunctorObjIndex",
"CategoryTheory.Limits.HasColimitsOfShape",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.SmallObject.functorObj",
"CategoryTheory.SmallObject.functorObjTop",
"CategoryTheory... | true |
Meromorphic.sum | Mathlib.Analysis.Meromorphic.Basic | [
"Pi.addCommMonoid",
"Meromorphic",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"Finset",
"MeromorphicAt.sum",
"Membership.mem",
"Finset.instSetLike",
"NontriviallyNormedField",
"NormedAddCommGroup.toAddCommGroup",
"NontriviallyNormedField.toNormedField",
"NormedAddCommGroup.toSeminormedAddC... | true |
Std.DTreeMap.getKeyD_filter_key | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Option.getD",
"Ord.mk",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.getKey?",
"Std.DTreeMap.Internal.Impl.getKeyD_filter_key",
"Option.filter",
"Std.DTreeMap.wf",
"Bool",
"Eq",
"Std.DTreeMap.filter",
"Std.DTreeMap.getKeyD"
] | true |
Std.HashMap.Raw.getKeyD_insertMany_list_of_mem | Std.Data.HashMap.RawLemmas | [
"List.Pairwise",
"Std.HashMap.Raw.WF.out",
"instForInOfForIn'",
"List.map",
"Membership.mem",
"inferInstance",
"Std.HashMap.Raw.WF",
"Id",
"Membership",
"LawfulHashable",
"Prod.fst",
"Std.HashMap.Raw",
"Bool.true",
"Std.HashMap.Raw.getKeyD",
"List",
"BEq.beq",
"EquivBEq",
"List.ins... | true |
Finset.div_subset_div_left | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"instHDiv",
"Finset",
"HDiv.hDiv",
"Div",
"HasSubset.Subset",
"Finset.instHasSubset",
"Finset.div",
"Finset.image₂_subset_left",
"DecidableEq"
] | true |
Lean.Lsp.LeanILeanHeaderSetupInfoParams.casesOn | Lean.Data.Lsp.Internal | [
"Lean.Lsp.LeanILeanHeaderSetupInfoParams",
"Lean.Lsp.LeanILeanHeaderSetupInfoParams.rec",
"Lean.Lsp.ImportInfo",
"Array",
"Nat",
"Bool",
"Lean.Lsp.LeanILeanHeaderSetupInfoParams.mk"
] | false |
MulOpposite.instNonUnitalSeminormedRing | Mathlib.Analysis.Normed.Ring.Basic | [
"MulOpposite.instNonUnitalRing",
"NonUnitalSeminormedRing",
"SeminormedAddCommGroup",
"MulOpposite",
"SeminormedAddCommGroup.toNorm",
"NonUnitalSeminormedRing.mk",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"NonUnitalSeminormedRing.toSeminormedAddCommGroup",
"MulOpposite.instSeminormedAddCommGrou... | true |
Subgroup.HasDetOne.det_eq | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | [
"CommRing",
"Subgroup.HasDetOne",
"MonoidHom.instFunLike",
"MonoidHom",
"CommSemiring.toSemiring",
"Matrix",
"Membership.mem",
"Units",
"Subgroup",
"Units.instGroup",
"Units.instOne",
"MulOneClass.toMulOne",
"CommRing.toCommSemiring",
"Fintype",
"Semiring.toMonoid",
"One.toOfNat1",
"... | true |
omegaLimit.«_aux_Mathlib_Dynamics_OmegaLimit___macroRules_omegaLimit_termω⁺_1» | Mathlib.Dynamics.OmegaLimit | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.instMonad",
"Lean.TSyntax.... | false |
Lean.Meta.Hint.Suggestion.mk | Lean.Meta.Hint | [
"Lean.Meta.Hint.DiffGranularity",
"Lean.Syntax",
"Lean.Meta.Hint.Suggestion",
"Lean.Meta.Tactic.TryThis.Suggestion",
"Lean.Meta.Hint.Suggestion.mk",
"Option"
] | true |
Std.TreeMap.mem_of_mem_filterMap | Std.Data.TreeMap.Lemmas | [
"Std.DTreeMap.mem_of_mem_filterMap",
"Std.TreeMap.inner",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.TreeMap.filterMap",
"Std.TreeMap.instMembership",
"Std.TreeMap",
"Option"
] | true |
SimpleGraph.Walk.cons'.congr_simp | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | [
"SimpleGraph.Adj",
"SimpleGraph.Walk",
"Eq.rec",
"SimpleGraph.Walk.cons'",
"SimpleGraph",
"Eq.refl",
"Eq"
] | true |
_private.Mathlib.Algebra.Lie.Submodule.0.LieSubmodule.inclusion_injective._simp_1_1 | Mathlib.Algebra.Lie.Submodule | [
"imp_self",
"True",
"propext",
"Eq"
] | false |
Stream'.Seq.drop.eq_1 | Mathlib.Data.Seq.Basic | [
"Stream'.Seq",
"Stream'.Seq.drop",
"instOfNatNat",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Eq"
] | true |
PiTensorProduct.module' | Mathlib.LinearAlgebra.PiTensorProduct | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instSMulOfMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"Module.mk",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"PiTensorProduct.instAddCommMonoid",... | true |
Module.Dual.instLieRingModule._proof_4 | Mathlib.Algebra.Lie.Basic | [
"AddHom.mk.congr_simp",
"NegZeroClass.toNeg",
"CommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",... | false |
Set.iUnion_iInter_ge_nat_add | Mathlib.Data.Set.Lattice | [
"Set.iInter",
"GE.ge",
"instLENat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"CompleteBooleanAlgebra.toCompleteLattice",
"instAddNat",
"iSup_iInf_ge_nat_add",
"Eq",
"Set.iUnion",
"CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra",
"Set.instCompleteAtomicBooleanAlgebra",
"Set"
] | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.getFnType._sunfold | Lean.Meta.Sym.Simp.App | [
"Pure.pure",
"_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.getFnType",
"Lean.Meta.Sym.instInhabitedSymM",
"Lean.Meta.Sym.Context",
"panicWithPosWithDecl",
"ReaderT.instMonad",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.getFnType.ma... | false |
CategoryTheory.Pseudofunctor.isoMapOfCommSq_horiz_id | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | [
"Eq.mpr",
"CategoryTheory.Pseudofunctor.mapId",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Bicategory.whiskerLeftIso",
"CategoryTheory.Pseudofunctor.mapComp'_comp_id",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryTheory.CategoryStruct.id",
"CategoryThe... | true |
Lean.Meta.Simp.ConfigCtx.contextual._default | Init.MetaTypes | [
"id",
"Bool.true",
"Bool"
] | false |
Std.DTreeMap.Internal.Impl.View.v | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.View.k",
"Std.DTreeMap.Internal.Impl.View",
"Nat"
] | true |
NumberField.mixedEmbedding.normAtPlace_polarCoord_symm_of_isReal | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | [
"Norm.norm",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Real.lattice",
"Pi.topologicalSpace",
"abs",
"congrArg",
"NumberField.mixedEmbedding.normAtPlace_apply_of_isReal",
"NumberField.InfinitePlace.IsComplex",
"Complex.instNormedField",
"PseudoMetricSpace.toUniformSpace",
"MonoidWithZeroH... | true |
Std.DTreeMap.Internal.Impl.Const.getKey?_filterMap | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Option.pfilter",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"Std.DTreeMap.Internal.Impl.contains_eq_containsKey",
"beqOfOrd",
"Std.DTreeMap.Internal.Impl.Ordered.distinctKeys",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.WF.filterMap",
"Std.DTreeMap.Internal.Impl.toListModel_filterMap... | true |
CategoryTheory.Limits.reflectsFiniteLimits_of_reflectsIsomorphisms | Mathlib.CategoryTheory.Limits.Preserves.Finite | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesFiniteLimits",
"CategoryTheory.Limits.reflectsLimitsOfShape_of_reflectsIsomorphisms",
"CategoryTheory.Limits.HasFiniteLimits",
"CategoryTheory.Limits.ReflectsFiniteLimits",
"CategoryTheory.Limits.PreservesFiniteLimits.preservesFiniteLimits",
"Cat... | true |
lt_add_of_neg_add_lt | Mathlib.Algebra.Order.Group.Unbundled.Basic | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"neg_add_lt_iff_lt_add",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"instHAdd",
"AddGroup",
"AddLeftStrictMono",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
... | true |
_private.Lean.Meta.Tactic.Grind.Order.0.Lean.Meta.Grind.Order.initFn._@.Lean.Meta.Tactic.Grind.Order.3999496204._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Order | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Bool.true",
"Unit",
"Nat",
"OfNat.ofNat",
"Lean.Name.mkStr4"
] | false |
Polynomial.evalEval_finsetSum | Mathlib.Algebra.Polynomial.Bivariate | [
"Polynomial.C",
"Polynomial.eval",
"congrArg",
"Finset",
"RingHom",
"Membership.mem",
"Polynomial.eval_finsetSum",
"Polynomial",
"Polynomial.evalEval",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"RingHom.instFunLike",
"Finset.instSetLike",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
... | true |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Basic.0.IsUniformGroup.cauchy_map_iff_tendsto._simp_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | [
"UniformSpace",
"Cauchy",
"SProd.sprod",
"Filter.map",
"Filter.NeBot",
"cauchy_map_iff",
"uniformity",
"Prod.mk",
"Prod.fst",
"And",
"Filter.Tendsto",
"propext",
"Prod",
"Filter.instSProd",
"Eq",
"Prod.snd",
"Filter"
] | false |
Lean.Elab.Term.hasElabWithoutExpectedType | Lean.Elab.App | [
"Lean.Elab.Term.elabWithoutExpectedTypeAttr",
"Lean.TagAttribute.hasTag",
"Bool",
"Lean.Name",
"Lean.Environment"
] | true |
ArchimedeanOrder.instPreorder._proof_1 | Mathlib.Algebra.Order.Archimedean.Class | [
"instHSMul",
"Equiv.instEquivLike",
"instReflLe",
"abs",
"congrArg",
"LinearOrder",
"Std.le_refl",
"PartialOrder.toPreorder",
"AddMonoid.toNSMul",
"ArchimedeanOrder.val",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddCommGroup",
"DistribLattice.toLattic... | false |
_private.Mathlib.Algebra.Group.Even.0.even_subset_image_even.match_1_1 | Mathlib.Algebra.Group.Even | [
"setOf",
"Membership.mem",
"AddZeroClass.toAddZero",
"instHAdd",
"AddZeroClass",
"Exists.casesOn",
"HAdd.hAdd",
"Even",
"Exists.intro",
"AddZero.toAdd",
"Eq",
"Set.instMembership",
"Set"
] | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_35 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"congrArg",
"Std.Tactic.BVDecide.BVExpr.var",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Std.Tactic.BVDecide.BVExpr",
"Eq",
"Eq.trans"
] | false |
ENNReal.toNNReal_sSup | Mathlib.Data.ENNReal.Operations | [
"congrArg",
"iSup",
"setOf",
"Membership.mem",
"ENNReal.toNNReal_iSup",
"Eq.mp",
"Subtype",
"NNReal",
"Ne",
"ENNReal.toNNReal",
"Subtype.range_coe_subtype",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"NNReal.instConditionallyCompleteLinearOrderBot",
"CompleteLinearO... | true |
Array.min?_singleton_append' | Init.Data.Array.MinMax | [
"Array.min?_toList._cbv_eval_1",
"Array.instAppend",
"List.min?",
"congrArg",
"Option.some",
"Array.min?",
"Array.toList_append",
"instOfNatNat",
"List.foldl",
"Array.toList",
"List.toArray",
"Min",
"Array.foldl",
"List.cons",
"Array",
"Option.none",
"instHAppendOfAppend",
"List",
... | true |
Vector.foldl_attach | Init.Data.Vector.Attach | [
"Vector.instMembership",
"Eq.mpr",
"Array.unattach_attachWith",
"Vector.attach",
"Vector.foldl",
"Vector",
"congrArg",
"Array.instMembership",
"Vector.casesOn",
"Membership.mem",
"Array.size_attachWith",
"Eq.rec",
"Subtype",
"instOfNatNat",
"Array.foldl_subtype'",
"Array.foldl",
"Sub... | true |
CategoryTheory.LaxFunctor.mk.inj | Mathlib.CategoryTheory.Bicategory.Functor.Lax | [
"CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Bicategory.whiskerRight",
"CategoryTheory.PrelaxFunctorStruct.map₂",
"CategoryTheory.Bicategory.... | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.size_insertUnit._proof_1_2 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | [
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment",
"Prod.mk.inj",
"False",
"bne",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment",
"eq_false",
"Array.push",
"congrArg",
"Classical.byContradiction",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned",
"Std.Tactic.BVD... | false |
TrivSqZeroExt.lift_def | Mathlib.Algebra.TrivSqZeroExt.Basic | [
"TrivSqZeroExt.snd",
"instHSMul",
"TrivSqZeroExt",
"HMul.hMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"TrivSqZeroExt.lift",
"AlgHom",
"IsScalarTower",
"AlgHom.funLike",
"AddMonoid.toAddZeroClass",
"MulOpposite",
"LinearMap.instFunLike",
"TrivSqZeroExt.algebra'",
"A... | true |
Lean.PersistentHashSet.ctorIdx | Lean.Data.PersistentHashSet | [
"Nat",
"Hashable",
"Lean.PersistentHashSet",
"BEq"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.