name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.MonoCoprod.mono_map'_of_injective | Mathlib.CategoryTheory.Limits.MonoCoprod | [
"Eq.mpr",
"CategoryTheory.Functor",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"HEq.refl",
"Compl.compl",
"CategoryTheory.Limits.MonoCoprod.mono_of_injective'",
"CategoryTheory.Functor.category",
"CategoryTheory.Discrete.functor",
"Function.comp"... | true |
instPowInt32Nat | Init.Data.SInt.Basic | [
"Pow",
"Pow.mk",
"Nat",
"Int32",
"Int32.pow"
] | true |
FunLike.coeAddMonoidHom | Mathlib.Data.FunLike.Group | [
"IsZeroApply",
"AddZeroClass.toAddZero",
"AddMonoidHom.mk",
"FunLike.coeAddMonoidHom._proof_2",
"ZeroHom.mk",
"AddZero.toZero",
"AddZero",
"AddZeroClass",
"Pi.addZeroClass",
"AddZero.toAdd",
"IsAddApply",
"FunLike.coeAddMonoidHom._proof_1",
"AddMonoidHom",
"DFunLike.coe",
"FunLike"
] | true |
Finset.image_eq_iff_eq_preimage | Mathlib.Data.Finset.Preimage | [
"Eq.mpr",
"Finset.image_inj",
"congrArg",
"Finset.image_preimage_of_bijective",
"Function.Injective.injOn",
"Finset",
"Iff.rfl",
"id",
"Function.Bijective.injective",
"Iff",
"SetLike.coe",
"Set.preimage",
"Finset.instSetLike",
"Finset.preimage",
"propext",
"Function.Bijective",
"Eq.s... | true |
continuous_ofDual | Mathlib.Topology.Constructions | [
"Continuous",
"Equiv.instEquivLike",
"OrderDual.ofDual",
"Equiv",
"TopologicalSpace",
"continuous_id",
"OrderDual.instTopologicalSpace",
"OrderDual",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Std.Http.Status.tooManyRequests.elim | Std.Internal.Http.Data.Status | [
"PULift.up",
"Std.Http.Status.ctorIdx",
"Std.Http.Status.tooManyRequests",
"Std.Http.Status",
"Std.Http.Status.ctorElim",
"Nat",
"Eq.symm",
"Eq"
] | false |
Lean.Lsp.LeanFileProgressProcessingInfo.ctorIdx | Lean.Data.Lsp.Extra | [
"Lean.Lsp.LeanFileProgressProcessingInfo",
"Nat"
] | false |
CategoryTheory.Regular.hasCoequalizer_of_isKernelPair | Mathlib.CategoryTheory.RegularCategory.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.HasCoequalizer",
"CategoryTheory.IsKernelPair",
"CategoryTheory.Regular",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"
] | true |
NumberField.InfinitePlace.mkReal._proof_2 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | [
"NumberField.ComplexEmbedding.IsReal",
"RingHom",
"Exists",
"Subtype",
"NumberField.InfinitePlace.mk",
"Field.toSemifield",
"And",
"Semifield.toDivisionSemiring",
"Subtype.prop",
"And.intro",
"Exists.intro",
"DivisionSemiring.toSemiring",
"NumberField.InfinitePlace",
"Complex",
"Subtype.... | false |
Poly.instAddCommGroup._proof_4 | Mathlib.NumberTheory.Dioph | [
"Poly.instAdd",
"Poly.ext",
"Poly",
"congrArg",
"AddMonoid.toAddZeroClass",
"Poly.instFunLike",
"id",
"Int",
"Int.instAddMonoid",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"Nat",
"True",
"eq_self",
"of_eq_true",
"Int.instAdd",
"Zero.toOfNat0",
"congrFun'",
"add_zero",
"OfNat.ofNa... | false |
Lean.Doc.Parser.instInhabitedInlineCtxt.default | Lean.DocString.Parser | [
"Inhabited.default",
"Lean.Doc.Parser.InlineCtxt",
"instInhabitedBool",
"instInhabitedNat",
"instInhabitedOption",
"Nat",
"Lean.Doc.Parser.InlineCtxt.mk",
"Bool",
"Option"
] | true |
Lean.Meta.Sym.AlphaShareCommon.State.mk.injEq | Lean.Meta.Sym.AlphaShareCommon | [
"Eq.propIntro",
"Lean.Meta.Sym.instBEqAlphaKey",
"Lean.PHashSet",
"Lean.Meta.Sym.AlphaShareCommon.State.mk.inj",
"Lean.Meta.Sym.AlphaKey",
"Lean.Meta.Sym.AlphaShareCommon.State.mk",
"Eq.ndrec",
"Eq.refl",
"Lean.Meta.Sym.instHashableAlphaKey",
"Eq",
"Lean.Meta.Sym.AlphaShareCommon.State"
] | true |
List.decidableBEx._proof_2 | Init.Data.List.Basic | [
"Membership.mem",
"Exists",
"List.cons",
"List",
"And",
"List.instMembership",
"And.intro",
"Exists.intro",
"List.Mem.head"
] | false |
Lean.Meta.ExtractLets.LocalDecl'.mk.inj | Lean.Meta.Tactic.Lets | [
"Lean.Meta.ExtractLets.LocalDecl'.mk",
"Lean.Meta.ExtractLets.LocalDecl'.mk.noConfusion",
"And",
"And.intro",
"Lean.Meta.ExtractLets.LocalDecl'",
"Bool",
"Lean.LocalDecl",
"Eq"
] | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.JoinPoints.3948291228._hygCtx._hyg.2 | Lean.Compiler.LCNF.JoinPoints | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Bool.true",
"Unit",
"Nat",
"Lean.Name.mkStr2",
"OfNat.ofNat"
] | false |
CategoryTheory.Limits.hasCokernel_comp_iso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.IsIso",
"CategoryTheory.Limits.cokernel.desc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"CategoryTheory.Limits.CokernelCofork... | true |
Polynomial.toFinsupp_mul | Mathlib.Algebra.Polynomial.Basic | [
"Polynomial.toFinsupp",
"HMul.hMul",
"Polynomial",
"AddMonoidAlgebra.instMul",
"Nat",
"Semiring",
"instAddNat",
"Polynomial.instMul",
"AddMonoidAlgebra",
"Eq",
"rfl",
"instHMul"
] | true |
codisjoint_top_right._simp_1 | Mathlib.Order.Disjoint | [
"Codisjoint",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"OrderTop",
"OrderTop.toTop",
"codisjoint_top_right",
"True",
"eq_true",
"Top.top",
"Eq"
] | false |
Std.DTreeMap.Internal.Impl.entryAtIdxD.eq_2 | Std.Data.DTreeMap.Internal.Model | [
"HSub.hSub",
"Ordering",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"instSubNat",
"instOfNatNat",
"Ord.compare",
"Unit",
"instHSub",
"Nat",
"Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1",
"Eq.refl",
"Sigma.mk",
"instOrdNat",
"OfNat.ofNat",
"Std.DTreeMap.In... | true |
Subgroup.instMulDistribMulActionSubtypeMemNormalizerCoe._proof_4 | Mathlib.GroupTheory.Subgroup.Centralizer | [
"Subtype.mk.congr_simp",
"Semigroup.toMul",
"conj_mul",
"instHSMul",
"Subgroup.instSubgroupClass",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"SubgroupClass.toGroup._proof_6",
"Group",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivI... | false |
TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace._proof_3 | Mathlib.Topology.Connected.TotallyDisconnected | [
"ConnectedSpace.toPreconnectedSpace",
"ContinuousMap.mk",
"ContinuousMap",
"TotallyDisconnectedSpace",
"TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace._proof_1",
"TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace._proof_2",
"ConnectedSpace.toNonempty",
"TopologicalSpace",
"Con... | false |
Lean.Server.Watchdog.LogMsg.ctorIdx | Lean.Server.Watchdog | [
"Lean.Server.Watchdog.LogMsg.casesOn",
"String",
"Lean.JsonRpc.Message",
"Nat",
"Lean.Server.Watchdog.LogMsg",
"Lean.JsonRpc.MessageDirection"
] | false |
Std.HashMap.getKey?_eq_some_getKeyD | Std.Data.HashMap.Lemmas | [
"Std.DHashMap.getKey?_eq_some_getKeyD",
"Option.some",
"Membership.mem",
"Std.HashMap",
"LawfulHashable",
"EquivBEq",
"Std.HashMap.getKeyD",
"Std.HashMap.getKey?",
"Hashable",
"Std.HashMap.inner",
"BEq",
"Eq",
"Std.HashMap.instMembership",
"Option"
] | true |
_private.Lean.Parser.Module.0.Lean.Parser.Module.updateTokens.match_1 | Lean.Parser.Module | [
"Except.ok",
"String",
"Except.error",
"Lean.Parser.TokenTable",
"Except.casesOn",
"Except"
] | false |
Std.Irrefl.recOn | Init.Core | [
"Std.Irrefl",
"Std.Irrefl.mk",
"Not",
"Std.Irrefl.rec"
] | false |
SemiNormedGrp.Hom.neg | Mathlib.Analysis.Normed.Group.SemiNormedGrp | [
"SemiNormedGrp.ofHom",
"NormedAddGroupHom",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Neg.mk",
"NormedAddGroupHom.neg",
"SemiNormedGrp.Hom.hom",
"SemiNormedGrp.carrier",
"Neg",
"SemiNormedGrp.instLargeCategory",
"CategoryTheory.Category.toCategoryStruct",
"SemiNormedGrp.str",
... | true |
CategoryTheory.MorphismProperty.instFaithfulArrowArrowForget | Mathlib.CategoryTheory.MorphismProperty.Comma | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.MorphismProperty.Comma.instCategory",
"CategoryTheory.Functor.id",
"CategoryTheory.instCategoryArrow",
"CategoryTheory.MorphismProperty.Arrow.forget",
"_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instFaithfulAr... | true |
CategoryTheory.Functor.coconeTypesEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Colimits | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"TypeCat.instFunLikeFun",
"Function.comp",
"CategoryTheory.Functor.map",
"funext",
"CategoryTheory.Limits.Co... | false |
CategoryTheory.Limits.isLimitConeOfCoconeUnop_lift | Mathlib.CategoryTheory.Limits.Opposites | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Limits.Cone",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"CategoryTheory.Limits.coneOfCoconeUnop",
"CategoryTheory.Limits.IsColimit",
"CategoryTheory.Limits.isLi... | true |
IsDedekindDomain.HeightOneSpectrum._sizeOf_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | [
"IsDedekindDomain.HeightOneSpectrum.rec",
"CommRing",
"Submodule._sizeOf_inst",
"Semiring.toModule",
"CommSemiring.toSemiring",
"IsDedekindDomain.HeightOneSpectrum",
"instSizeOfDefault",
"Ne",
"instOfNatNat",
"Bot.bot",
"Ideal",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Submodule.instBot... | false |
Finsupp.instAddMonoid._proof_1 | Mathlib.Algebra.Group.Finsupp | [
"Finsupp.instFunLike",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"Function.Injective.addSemigroup._proof_2",
"AddZeroClass.toAddZero",
"AddZero.toZero",
"Finsupp.coe_add",
"instHAdd",
"Finsupp.instAdd",
"HAdd.hAdd",
"DFunLike.coe_injective",
"AddMonoid",
"Pi.addMonoid",
"Eq",... | false |
CategoryTheory.regularTopology.mapToEqualizer._proof_4 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | [
"CategoryTheory.Functor",
"_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.mapToEqualizer._simp_1",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"Quiver.Hom.op"... | false |
CategoryTheory.evaluationAdjunctionLeft_unit_app_app | Mathlib.CategoryTheory.Adjunction.Evaluation | [
"CategoryTheory.Functor",
"CategoryTheory.evaluationRightAdjoint._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.evaluationRightAdjoint",
"CategoryTheo... | true |
Language.leftQuotient_append | Mathlib.Computability.MyhillNerode | [
"List.append_assoc",
"congrArg",
"setOf",
"Membership.mem",
"Language.leftQuotient",
"funext",
"instHAppendOfAppend",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Language.instMembershipList",
"List.instAppend",
"Language",
"Eq",
"HAppend.hAppend",
"Eq.trans",
"Set"
] | true |
ContinuousMap.Homotopic.comp | Mathlib.Topology.Homotopy.Basic | [
"ContinuousMap",
"Nonempty.map2",
"ContinuousMap.comp",
"ContinuousMap.Homotopy.comp",
"TopologicalSpace",
"ContinuousMap.Homotopy",
"ContinuousMap.Homotopic"
] | true |
exteriorPower.map_injective | Mathlib.LinearAlgebra.ExteriorPower.Basic | [
"LinearMap.id",
"Eq.mpr",
"Submodule",
"CommRing",
"Semiring.toModule",
"QuadraticMap.instZero",
"Ring.toNonAssocRing",
"ExteriorAlgebra",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LinearMap.id_coe",
"Submodule.addCommMonoid",
"instAlgebraCliffordAlgebra",
"... | true |
Ordinal.isEquivalent.match_3 | Mathlib.SetTheory.Ordinal.Basic | [
"WellOrder.r",
"WellOrder.α",
"IsWellOrder",
"Nonempty.intro",
"RelIso",
"Nonempty.casesOn",
"WellOrder",
"Nonempty",
"Ordinal.isEquivalent.match_1"
] | false |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_pos_iff._simp_1_1 | Mathlib.Data.EReal.Operations | [
"and_comm",
"And",
"propext",
"Eq"
] | false |
ConvexCone.coe_iInf._simp_1 | Mathlib.Geometry.Convex.Cone.Basic | [
"iInf",
"Set.iInter",
"SMul",
"ConvexCone.instSetLike",
"PartialOrder",
"AddCommMonoid",
"SetLike.coe",
"ConvexCone",
"ConvexCone.instInfSet",
"Semiring",
"ConvexCone.coe_iInf",
"Eq.symm",
"Eq",
"Set"
] | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rev._proof_1_3 | Init.Data.BitVec.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_congr",
"Lean.Om... | false |
PiTensorProduct.mapL_pow | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | [
"PiTensorProduct.instModule",
"PiTensorProduct.instSeminormedAddCommGroup",
"SeminormedAddCommGroup",
"ContinuousLinearMap.semiring",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"NormedField.toField",
"PiTe... | true |
CategoryTheory.ShortComplex.RightHomologyMapData.id_φH | Mathlib.Algebra.Homology.ShortComplex.RightHomology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ShortComplex.RightHomologyMapData.φH",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex.RightHomologyData",
"CategoryTheory.ShortComplex.RightHomologyMapData.id",
"CategoryTheory.ShortComplex",
"CategoryTheor... | true |
Lean.PrettyPrinter.Delaborator.delabApp | Lean.PrettyPrinter.Delaborator.Builtins | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Bool.not",
"Lean.PrettyPrinter.Delaborator.getPPOption",
"Lean.PrettyPrinter.Delaborator.withMDatasOptions",
"Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM",
"Lean.SourceInfo",
"Lean.PrettyPrinter.Delaborator.Context",
"Lean.Meta.State"... | true |
Std.ExtDTreeMap.Const.insertMany_cons | Std.Data.ExtDTreeMap.Lemmas | [
"Pure.pure",
"Eq.mpr",
"List.foldl_hom",
"congrArg",
"instForInOfForIn'",
"Monad.toApplicative",
"Std.ExtDTreeMap.insert",
"Ordering",
"inferInstance",
"LawfulMonad.bind_pure_comp",
"id",
"Subtype",
"Prod.mk",
"ForIn.forIn",
"List.foldl",
"Id.run",
"Std.TransCmp",
"Id",
"Applicat... | true |
Aesop.GoalState.provenByNormalization | Aesop.Tree.Data | [
"Aesop.GoalState",
"Aesop.GoalState.provenByNormalization"
] | true |
sq_le_sq₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | [
"MulZeroClass.toMul",
"LinearOrder",
"PartialOrder.toPreorder",
"Zero.ofOfNat0",
"Preorder.toLE",
"pow_le_pow_iff_left₀",
"instOfNatNat",
"LE.le",
"Monoid.toPow",
"MulPosMono",
"two_ne_zero",
"Iff",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat.instNeZeroSucc"... | true |
ProbabilityTheory.Kernel.iIndepFun_zero_right | Mathlib.Probability.Independence.Kernel.IndepFun | [
"MeasureTheory.Measure",
"MeasurableSpace.comap",
"ProbabilityTheory.Kernel.iIndep",
"MeasureTheory.Measure.instZero",
"MeasurableSpace",
"of_eq_true",
"ProbabilityTheory.Kernel.iIndepFun",
"Zero.toOfNat0",
"OfNat.ofNat",
"ProbabilityTheory.Kernel.iIndep_zero_right._simp_1",
"ProbabilityTheory.K... | true |
Turing.TM0to1.trCfg | Mathlib.Computability.TuringMachine.PostTuringMachine | [
"cond",
"Unit.unit",
"Turing.Tape",
"Option.some",
"Turing.TM1.Cfg",
"Turing.TM1.Cfg.mk",
"Turing.TM0.Machine",
"Turing.Tape.head",
"Option.none",
"Unit",
"Turing.TM0to1.Λ'",
"Inhabited",
"Prod",
"Option.isSome",
"Turing.TM0to1.Λ'.normal",
"Turing.TM0.Cfg.map.match_1",
"Turing.TM0.St... | true |
Set.piecewise_insert_self | Mathlib.Data.Set.Piecewise | [
"congrArg",
"true_or",
"Decidable",
"Membership.mem",
"Insert.insert",
"ite_cond_eq_true",
"Set.instInsert",
"Set.mem_insert_iff._simp_1",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Or",
"Set.piecewise",
"Eq",
"Set.instMembership",
"Eq.trans",
"Set"
] | true |
FundamentalGroupoidFunctor.piToPiTop_map | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | [
"Pi.topologicalSpace",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopCat.instCategory",
"FundamentalGroupoid.fundamentalGroupoidFunctor",
"Path.Homotopic.pi",
"CategoryTheory.Groupoid",
"Path.Homotopic.Quotient",
"CategoryTheory.pi",
"CategoryTheory.Functor.map",
"CategoryTheory.Gr... | true |
Lean.Meta.instDecidableEqProjReductionKind._proof_2 | Lean.Meta.Basic | [
"False",
"Lean.Meta.ProjReductionKind",
"absurd",
"Nat",
"Eq.ndrec",
"Eq.refl",
"Lean.Meta.ProjReductionKind.ctorIdx",
"Eq",
"Not"
] | false |
Real.coshOpenPartialHomeomorph._proof_7 | Mathlib.Analysis.SpecialFunctions.Arcosh | [
"Real",
"Set.Ioi",
"Set.Ici",
"Set.Ioi_subset_Ici_self",
"PseudoMetricSpace.toUniformSpace",
"Real.arcosh",
"Real.instOne",
"One.toOfNat1",
"ContinuousOn.mono",
"ContinuousOn",
"Real.pseudoMetricSpace",
"OfNat.ofNat",
"Real.continuousOn_arcosh",
"UniformSpace.toTopologicalSpace",
"Real.i... | false |
Std.Internal.IO.Async.System.GroupId.rec | Std.Internal.Async.System | [
"Std.Internal.IO.Async.System.GroupId",
"Nat",
"Std.Internal.IO.Async.System.GroupId.mk"
] | false |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.reflects_cofiltered_limits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | [
"CategoryTheory.Functor",
"CategoryTheory.IsCofiltered",
"CategoryTheory.Limits.ReflectsLimitsOfShape",
"CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize",
"CategoryTheory.Category"
] | true |
Complex.logDeriv_exp | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | [
"logDeriv",
"NormedCommRing.toNormedRing",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"instHDiv",
"Semiring.toModule",
"NormedRing.toRing",
"sub_self",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Complex.exp_zero",
"Pi.instDiv",
"deriv",
"NormedSpace.toModule",
"AddMonoid.toAddZeroC... | true |
MeasureTheory.AEStronglyMeasurable._auto_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
CategoryTheory.PreOneHypercover.Homotopy.mk | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | [
"CategoryTheory.PreZeroHypercover.Hom.h₀",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.PreZeroHypercover.X",
"CategoryTheory.PreOneHypercover.Hom.... | true |
Std.Time.TimeZone.TZif.Header | Std.Time.Zoned.Database.TzIf | [
"Std.Time.TimeZone.TZif.Header.mk"
] | true |
WithBot.addMonoidWithOne._proof_2 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | [
"WithBot",
"AddMonoid.toAddSemigroup",
"AddMonoidWithOne.natCast_succ._autoParam",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"NatCast.natCast",
"autoParam",
"WithBot.one",
"AddMonoidWithOne.toOne",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"WithBot.addMonoid",
"WithBot.natCast",
... | false |
AlgEquiv.toOpposite._proof_1 | Mathlib.Algebra.Algebra.Opposite | [
"RingEquiv.toEquiv",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"MulOpposite",
"Distrib.toAdd",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"RingEquiv.map_mul'",
"Equiv.toFun",
"NonUnitalCommSemiring.toNonUnitalSemiring",
"CommSemiring",
"MulOpposite.instAdd",
"Distrib.toMul",
... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.vec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | [
"Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.w",
"Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget",
"Std.Sat.AIG",
"Nat",
"Hashable",
"Std.Sat.AIG.RefVec",
"DecidableEq"
] | true |
Lean.Meta.SynthInstance.Answer.noConfusionType | Lean.Meta.SynthInstance | [
"Lean.Meta.SynthInstance.Answer",
"Lean.Meta.AbstractMVarsResult",
"Lean.Expr",
"Nat",
"Lean.Meta.SynthInstance.Answer.casesOn",
"Eq"
] | false |
SimpleGraph.edist_bot_of_ne | Mathlib.Combinatorics.SimpleGraph.Metric | [
"instTopENat",
"Classical.not_not",
"congrArg",
"SimpleGraph.edist_ne_top_iff_reachable",
"Eq.mp",
"Iff.not",
"Ne",
"Bot.bot",
"ne_eq",
"SimpleGraph",
"SimpleGraph.reachable_bot",
"SimpleGraph.edist",
"ENat",
"propext",
"SimpleGraph.completeAtomicBooleanAlgebra",
"Top.top",
"Complete... | true |
Polynomial.taylorEquiv.eq_1 | Mathlib.RingTheory.Polynomial.DegreeLT | [
"NegZeroClass.toNeg",
"MulOne.toOne",
"CommRing",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"Polynomial.taylorAlgHom",
"Polynomial.taylorEquiv._proof_4",
"Equiv.mk",
"Algebra.id",
"SubtractionMonoid.toSubNegZeroMonoid",
"NonAssocSemiring.toMulZeroO... | true |
String.singleton_ne_empty | Init.Data.String.Lemmas.Basic | [
"False",
"congrArg",
"String",
"String.push",
"Ne",
"True",
"of_eq_true",
"Char",
"not_false_eq_true",
"String.singleton",
"Eq",
"Not",
"Eq.trans",
"String.push_ne_empty._simp_1"
] | true |
Equidecomp.ctorIdx | Mathlib.Algebra.Group.Action.Equidecomp | [
"SMul",
"Nat",
"Equidecomp"
] | false |
UInt16.xor_zero | Init.Data.UInt.Bitwise | [
"UInt16.toBitVec",
"BitVec",
"instOfNatNat",
"UInt16",
"Nat",
"HXor.hXor",
"Iff.mp",
"BitVec.xor_zero",
"instXorOpUInt16",
"OfNat.ofNat",
"UInt16.toBitVec_inj",
"Eq",
"UInt16.instOfNat",
"instHXorOfXorOp"
] | true |
finrank_eq_one_iff_of_nonzero | Mathlib.LinearAlgebra.FiniteDimensional.Basic | [
"Matrix.range_cons",
"IsNoetherianRing.strongRankCondition",
"Submodule",
"PrincipalIdealRing.isNoetherianRing",
"Ring.toNonAssocRing",
"Set.union_empty",
"instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors",
"instReflLe",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"PUnit.instUnique",
"PartialOr... | true |
PFunctor.M.iselect | Mathlib.Data.PFunctor.Univariate.M | [
"PFunctor",
"PFunctor.A",
"PFunctor.M",
"PFunctor.Approx.Path",
"PFunctor.M.isubtree",
"Inhabited",
"PFunctor.M.head",
"DecidableEq"
] | true |
AddActionHom.embMap._proof_1 | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | [
"Function.Embedding.vadd",
"HVAdd.hVAdd",
"Function.Embedding",
"AddAction",
"AddGroup",
"AddGroup.toSubNegMonoid",
"Function.Embedding.trans",
"instHVAdd",
"SubNegMonoid.toAddMonoid",
"Eq",
"rfl"
] | false |
SimpleGraph.IsClique.finsetMap | Mathlib.Combinatorics.SimpleGraph.Clique | [
"Eq.mpr",
"congrArg",
"Finset",
"SimpleGraph.isClique_map_image_iff._simp_1",
"Finset.map",
"id",
"Function.Embedding",
"SimpleGraph",
"SetLike.coe",
"Finset.instSetLike",
"Set.image",
"Finset.coe_map",
"Function.instFunLikeEmbedding",
"Eq",
"DFunLike.coe",
"Eq.trans",
"SimpleGraph.m... | true |
Polynomial.polynomial_map_coe | Mathlib.RingTheory.PowerSeries.Basic | [
"Polynomial.coeff_map",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"LinearMap.instFunLike",
"RingHom",
"PowerSeries.coeff",
"MvPowerSeries.instModule",
"LinearMap",
"Polynomial",
"Polynomial.coeff",
"MvPowerSeries.instAddCommMonoid",
"CommSemiring",
"MvPowerSeries.instSemi... | true |
AddMonCat.adj | Mathlib.Algebra.Category.MonCat.Adjunctions | [
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"AddMonCat.adj._proof_2",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Equiv.trans",
"AddMonoid.toAddZeroClass",
"FreeAddMonoid.instAddCancelMonoid",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"CategoryTheory... | true |
Lean.Compiler.LCNF.MonadFVarSubst.recOn | Lean.Compiler.LCNF.CompilerM | [
"Lean.Compiler.LCNF.MonadFVarSubst.mk",
"Lean.Compiler.LCNF.Purity",
"Lean.Compiler.LCNF.MonadFVarSubst.rec",
"Lean.Compiler.LCNF.MonadFVarSubst",
"Bool",
"Lean.Compiler.LCNF.FVarSubst"
] | false |
_private.Std.Data.ExtTreeSet.Lemmas.0.Std.ExtTreeSet.mem_ofList._simp_1_1 | Std.Data.ExtTreeSet.Lemmas | [
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Bool.true",
"Std.ExtTreeSet.mem_iff_contains",
"Std.ExtTreeSet.instMembershipOfTransCmp",
"propext",
"Std.ExtTreeSet",
"Bool",
"Std.ExtTreeSet.contains",
"Eq"
] | false |
CategoryTheory.Adjunction.whiskerLeftLCounitIsoOfIsIsoUnit_inv_app | Mathlib.CategoryTheory.Adjunction.FullyFaithful | [
"CategoryTheory.Functor",
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheo... | true |
Action.resEquiv | Mathlib.CategoryTheory.Action.Basic | [
"Monoid",
"CategoryTheory.Functor",
"MulEquiv.instEquivLike",
"Monoid.toMulOneClass",
"CategoryTheory.Functor.category",
"CategoryTheory.Equivalence",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"Action.resEquiv._proof_3",
"MulOne.toMul",
"MonoidHomClass.toMonoidHom",
"MonoidHo... | true |
Algebra.IsSeparable.recOn | Mathlib.FieldTheory.Separable | [
"CommRing",
"Algebra",
"Algebra.IsSeparable",
"CommRing.toCommSemiring",
"IsSeparable",
"Ring.toSemiring",
"Ring",
"Algebra.IsSeparable.mk",
"Algebra.IsSeparable.rec"
] | false |
_private.Mathlib.RingTheory.Valuation.Integers.0.Valuation.term𝓞 | Mathlib.RingTheory.Valuation.Integers | [
"Lean.Name.mkNum",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.Name.anonymous",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"OfNat.ofNat"
] | true |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.Limits.MulticospanShape.L",
"congrArg",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.Limits.WalkingMulticospan.instSmallCategory",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.Iso",
"CategoryT... | false |
instIsAlgebraicMvPolynomialOfNoZeroDivisors_1 | Mathlib.RingTheory.Algebraic.Integral | [
"Finsupp.instAddZeroClass",
"RingHom.instRingHomClass",
"Nat.instMulZeroClass",
"CommRing",
"MvPolynomial.algebraMvPolynomial",
"Algebra.algebraMap",
"AddMonoidAlgebra.commRing",
"congrArg",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"Finsupp.instAddMonoid",
"Algebra",
"Classical... | true |
Std.DHashMap.Raw.getKeyD_eq_fallback | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Eq.mpr",
"congrArg",
"Std.DHashMap.Raw",
"Membership.mem",
"Std.DHashMap.Raw.contains",
"_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.getKeyD_eq_fallback._simp_1_1",
"id",
"LawfulHashable",
"Std.DHashMap.Raw.get... | true |
Std.TreeMap.Raw.mem_toList_iff_getKey?_eq_some_and_getElem?_eq_some | Std.Data.TreeMap.Raw.Lemmas | [
"Std.TreeMap.Raw.WF.out",
"Std.TreeMap.Raw.toList",
"Option.some",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Prod.mk",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw.inner",
"Std.TreeMap.Raw",
"List",
"And",
"Iff",
"List.instMembership",
"Std.TreeMap.Raw.... | true |
Traversable.map_eq_traverse_id | Mathlib.Control.Traversable.Lemmas | [
"Pure.pure",
"Traversable.toFunctor",
"Monad.toApplicative",
"Function.comp",
"Id.run",
"Id",
"Applicative.toPure",
"LawfulTraversable",
"funext",
"Traversable.traverse",
"Traversable",
"LawfulTraversable.traverse_eq_map_id",
"Id.instMonad",
"Eq.symm",
"Eq",
"Functor.map"
] | true |
CategoryTheory.Limits.CatCospanTransform.category._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.whiskerRight_id'",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Functor.whiskerLeft",
"CategoryTheory.Limit... | false |
CategoryTheory.Limits.IsInitial.uniqueUpToIso_inv | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.IsInitial.uniqueUpToIso",
"CategoryTheory.Limits.IsInitial",
"CategoryTheory.Limits.IsInitial.to",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Iso.inv",
"CategoryTheory.Category"
] | true |
_private.Mathlib.Analysis.Complex.UnitDisc.Basic.0.Complex.UnitDisc.instSMulCommClass_circle_closedBall._proof_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"Algebra.to_smulCommClass",
"CommSemiring.toSemiring",
"Complex.instNormedField",
"Complex.instZero",
"Metric.unitClosedBall.instMonoid",
"Set.Elem",
"Algebra.id",
"DivInvMonoid.toMonoid",
"NormedDivisionRing.to_normOneClass",
"NormedField.toNorme... | false |
MvQPF.noConfusion | Mathlib.Data.QPF.Multivariate.Basic | [
"MvQPF.casesOn",
"MvPFunctor.Obj",
"MvPFunctor",
"HEq.refl",
"Nat",
"MvFunctor",
"MvQPF.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"MvQPF",
"TypeVec.Arrow",
"Eq",
"MvFunctor.map",
"MvPFunctor.instMvFunctorObj",
"TypeVec"
] | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.MulEqProof.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | [
"_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.MulEqProof.rec",
"Lean.Expr",
"Int",
"_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.MulEqProof.mulVar",
"_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.Mu... | false |
Finset.notMem_map_subtype_of_not_property | Mathlib.Data.Finset.Image | [
"Finset.property_of_mem_map_subtype",
"Finset",
"Finset.map",
"Membership.mem",
"mt",
"Subtype",
"Finset.instSetLike",
"Function.Embedding.subtype",
"Not",
"SetLike.instMembership"
] | true |
_private.Lean.Environment.0.Lean.VisibilityMap.public | Lean.Environment | [
"_private.Lean.Environment.0.Lean.VisibilityMap"
] | true |
Aesop.ElabRuleTerm.term | Aesop.RuleTac.RuleTerm | [
"Lean.Expr",
"Lean.Syntax.Term",
"Aesop.ElabRuleTerm",
"Aesop.ElabRuleTerm.term"
] | true |
CategoryTheory.Core.inclusion_obj | Mathlib.CategoryTheory.Core | [
"CategoryTheory.coreCategory",
"CategoryTheory.Core.of",
"CategoryTheory.Core.inclusion",
"Eq.refl",
"CategoryTheory.Groupoid.toCategory",
"CategoryTheory.Core",
"Eq",
"CategoryTheory.Functor.obj",
"CategoryTheory.Category"
] | true |
monotone_iff_apply₂ | Mathlib.Order.Monotone.Defs | [
"Pi.preorder",
"congrArg",
"Monotone",
"Preorder.toLE",
"forall_comm",
"LE.le",
"Pi.hasLe",
"iff_self",
"Iff",
"_private.Mathlib.Order.Monotone.Defs.0.monotone_iff_apply₂._simp_1_2",
"implies_congr",
"congr",
"True",
"propext",
"of_eq_true",
"Eq.refl",
"Preorder",
"Eq.trans",
"fo... | true |
Quiver.Path.toList_injective._f | Mathlib.Combinatorics.Quiver.Path | [
"Quiver.Hom",
"Quiver.Path.nil",
"congrArg",
"and_self",
"HEq.refl",
"False.elim",
"Quiver.Path.toList",
"noConfusion_of_Nat",
"heq_eq_eq",
"Eq.mp",
"Eq.casesOn",
"Quiver.Path",
"List.cons",
"List.cons.injEq",
"And.casesOn",
"Quiver.Path.below",
"List",
"And",
"Quiver.Path.cons",... | false |
ContDiffMapSupportedIn.postcompCLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"Continuous",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"IsBoundedSMul.toU... | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.getRatValue?.getRatValueNum? | Lean.Meta.LitValues | [
"Pure.pure",
"Unit.unit",
"Lean.Expr.isApp",
"Lean.Meta.State",
"Rat",
"Lean.Expr.cleanupAnnotations",
"Option.some",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Lean.Expr.appArg",
"Applicative.toPure",
"Nat.cast",
"Lean.Expr.appFnCleanup",
"dite",
"Bool.t... | true |
Set.Nonempty.not_disjoint | Mathlib.Data.Set.Disjoint | [
"Iff.mpr",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Set.not_disjoint_iff_nonempty_inter",
"Set.instInter",
"Set.instDistribLattice",
"Inter.inter",
"Set.Nonempty",
"Set.instBoundedOrder",
"BoundedOrder.toOrderBot",
... | true |
MvPolynomial.finitePresentation_universalFactorizationMap | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | [
"AlgHom.FinitePresentation",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"CommRing",
"Semiring.toModule",
"AddMonoidAlgebra.addAddCommMonoid",
"AddMonoidAlgebra.commRing",
"CommSemiring.toSemiring",
"Algebra.TensorProduct.instCommRing",
"AddMonoidAlgebra.algebra",
"Finsupp.instAddMonoid... | true |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Simp.0.Int.Linear.Poly.gcdCoeffs'.go._sunfold | Lean.Meta.Tactic.Simp.Arith.Int.Simp | [
"Nat.gcd",
"_private.Lean.Meta.Tactic.Simp.Arith.Int.Simp.0.Int.Linear.Poly.gcdCoeffs'.go",
"_private.Lean.Meta.Tactic.Simp.Arith.Int.Simp.0.Int.Linear.Poly.gcdAll.go.match_1",
"instDecidableEqBool",
"instOfNatNat",
"Int",
"Int.Linear.Var",
"instBEqOfDecidableEq",
"Bool.true",
"BEq.beq",
"Nat",
... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.