name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
convex_sum | Mathlib.Analysis.Convex.Basic | [
"convexAddSubmonoid",
"DistribMulAction.toDistribSMul",
"Finset",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"PartialOrder",
"Set.addCommMonoid",
"DistribSMul.toSMulZeroClass",
"AddCommMonoid",
"AddZero.toZero",
"Finset.instSetLike",
"Convex",
"Semiring.toMonoi... | true |
Lean.Compiler.LCNF.CodeDecl.uset.injEq | Lean.Compiler.LCNF.Basic | [
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Compiler.LCNF.CodeDecl._auto_5",
"Lean.FVarId",
"Lean.Compiler.LCNF.Purity",
"autoParam",
"Lean.Compiler.LCNF.CodeDecl.uset",
"And",
"Lean.Compiler.LCNF.Purity.impure",
"Nat",
"Lean.Compiler.LCNF.CodeDecl",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Com... | true |
Lean.Parser.Tactic._aux_Init_TacticsExtra___macroRules_Lean_Parser_Tactic_tacIfThenElse_1 | Init.TacticsExtra | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"ReaderT",
"Monad.toApplicative",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax.atom",
"Lean.TSy... | false |
AddMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | [
"AddMonoid.toAddZeroClass",
"_private.Mathlib.Algebra.Category.MonCat.Basic.0.AddMonCat.Hom.mk",
"AddZeroClass.toAddZero",
"id",
"AddMonCat.str",
"AddMonCat",
"AddMonCat.Hom.hom'",
"Eq.refl",
"AddMonoidHom",
"AddMonCat.carrier",
"Eq"
] | false |
Equiv.divisionRing._proof_13 | Mathlib.Algebra.Field.TransferInstance | [
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"DivisionRing.toDivisionSemiring",
"Equiv",
"Monoid.toPow",
"HPow.hPow",
"Nat",
"Semiring.toMonoid",
"DivisionSemiring.toSemiring",
"DivisionRing",
"instHPow",
"Equiv.symm",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | false |
CategoryTheory.MorphismProperty.pretopology_inf | Mathlib.CategoryTheory.Sites.MorphismProperty | [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
"CategoryTheory.Precoverage",
"CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra",
"CategoryTheory.Presieve",
"congrArg",
"CategoryTheory.MorphismProperty.IsMultiplicative.inf",
"CategoryTheory.Precoverage.instMin",
"CategoryTheory.MorphismProper... | true |
_private.Mathlib.Logic.ExistsUnique.0.ExistsUnique.elim₂.match_1_1 | Mathlib.Logic.ExistsUnique | [
"Exists",
"Exists.casesOn",
"Exists.intro"
] | false |
AddMonCat.limitAddMonoid._proof_4 | Mathlib.Algebra.Category.MonCat.Limits | [
"CategoryTheory.Functor",
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"instHSMul",
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCone",
"AddMonoid.toAddZeroClass",
"AddMonoid.nsmul_zero._autoParam",
"AddMonoid.toNSMul",
"CategoryTheory.Functor.comp",
"AddZeroClass.toAddZe... | false |
OrderEmbedding.image_setOf_minimal | Mathlib.Order.Minimal | [
"image_monotone_setOf_minimal",
"congrArg",
"setOf",
"Preorder.toLE",
"Membership.mem",
"LE.le",
"iff_self",
"Iff",
"implies_congr",
"True",
"propext",
"of_eq_true",
"Eq.refl",
"Set.image",
"congrFun'",
"implies_true",
"OrderEmbedding",
"OrderEmbedding.le_iff_le",
"Eq",
"Minima... | true |
QuadraticMap.exists_companion' | Mathlib.LinearAlgebra.QuadraticForm.Basic | [
"CommSemiring.toSemiring",
"LinearMap.BilinMap",
"LinearMap.instFunLike",
"Exists",
"LinearMap.module",
"LinearMap",
"AddCommMonoid",
"CommSemiring",
"instHAdd",
"QuadraticMap.toFun",
"HAdd.hAdd",
"LinearMap.addCommMonoid",
"AddCommSemigroup.toAddCommMagma",
"Module",
"AddCommMonoid.toAd... | true |
IsDedekindDomain.HeightOneSpectrum.instIsLocalRingSubtypeMemSubalgebraOfFieldPrimeComplAsIdeal | Mathlib.RingTheory.DedekindDomain.AdicValuation | [
"Subalgebra.instSetLike",
"IsDedekindDomain.toIsDomain",
"CommRing",
"IsDomain.to_noZeroDivisors",
"CommSemiring.toSemiring",
"Localization.subalgebra.ofField",
"IsFractionRing",
"IsDedekindDomain.HeightOneSpectrum",
"Algebra",
"Membership.mem",
"IsDedekindDomain.HeightOneSpectrum.asIdeal",
"S... | true |
LawfulMonadStateOf.mk | Batteries.Control.LawfulMonadState | [
"Pure.pure",
"LawfulMonadStateOf",
"MonadStateOf",
"Monad.toApplicative",
"MonadState.get",
"LawfulMonad",
"Applicative.toPure",
"Prod.fst",
"semiOutParam",
"MonadState.modifyGet",
"PUnit",
"instMonadStateOfMonadStateOf",
"Applicative.toFunctor",
"Monad.toBind",
"Bind.bind",
"PUnit.uni... | true |
List.decidableDuplicate.match_3 | Mathlib.Data.List.Duplicate | [
"Unit.unit",
"List.cons",
"List",
"Unit",
"List.casesOn",
"List.nil"
] | false |
ContDiffAt.continuousLinearMap_comp | Mathlib.Analysis.Calculus.ContDiff.Basic | [
"ContDiffAt",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"Set.univ",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"NormedField.toField",
"ContDiffWithinAt.continuousLinearMap_comp",
"Field.toSemifield",
"ContinuousLinearMap",
... | true |
FirstOrder.Language.LEquiv.onBoundedFormula_symm_apply | Mathlib.ModelTheory.Syntax | [
"Equiv.instEquivLike",
"FirstOrder.Language.LEquiv.onBoundedFormula",
"Equiv",
"Nat",
"Eq.refl",
"FirstOrder.Language.LEquiv",
"FirstOrder.Language",
"Equiv.symm",
"FirstOrder.Language.BoundedFormula",
"FirstOrder.Language.LHom.onBoundedFormula",
"Eq",
"DFunLike.coe",
"FirstOrder.Language.LE... | true |
CategoryTheory.ObjectProperty.IsMonoidal.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | [
"CategoryTheory.MonoidalCategory",
"CategoryTheory.ObjectProperty.ContainsUnit",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.ObjectProperty.TensorLE",
"CategoryTheory.ObjectProperty.IsMonoidal",
"CategoryTheory.ObjectProperty",
"CategoryTheory.ObjectProperty.IsMonoidal.mk",
"CategoryTh... | true |
Continuous.matrixOf | Mathlib.Topology.Instances.Matrix | [
"Iff.mpr",
"Continuous",
"Equiv.instEquivLike",
"Pi.topologicalSpace",
"Matrix",
"Matrix.of",
"continuous_matrixOf",
"Equiv",
"TopologicalSpace",
"instTopologicalSpaceMatrix",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
_private.Aesop.Util.Basic.0.Aesop.compareArrayLex.match_3 | Aesop.Util.Basic | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Ordering",
"Option.none",
"Unit",
"Option"
] | false |
Std.DTreeMap.Raw.Equiv.insert | Std.Data.DTreeMap.Raw.Lemmas | [
"Ord.mk",
"Ordering",
"Std.DTreeMap.Raw.Equiv",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Std.DTreeMap.Raw.Equiv.inner",
"Std.DTreeMap.Raw.Equiv.mk",
"Std.DTreeMap.Internal.Impl.Equiv.insert!",
"Std.DTreeMap.Raw.insert",
"Std.DTreeMap.Raw.WF",
"Std.DTreeMap.Raw"
] | true |
IsDedekindDomain.adjoin_union_eq_top_of_isCoprime_differentialIdeal | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | [
"Eq.mpr",
"IsIntegralClosure",
"IsDomain",
"IntermediateField.isScalarTower_mid'",
"FractionRing.field",
"IsDedekindDomain.toIsDomain",
"CommRing",
"Lattice.toSemilatticeSup",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instSMulOfMul",
"CommRing.toNonUnitalCommRing",
"IsScalarTower.coe_t... | true |
Lean.DeclarationLocation.recOn | Lean.Data.DeclarationRange | [
"Lean.DeclarationLocation.mk",
"Lean.DeclarationRange",
"Lean.Name",
"Lean.DeclarationLocation",
"Lean.DeclarationLocation.rec"
] | false |
Mathlib.Tactic.Order.updateGraphWithNltInfSup | Mathlib.Tactic.Order | [
"Pure.pure",
"Option.isNone",
"_private.Mathlib.Tactic.Order.0.Mathlib.Tactic.Order.updateGraphWithNltInfSup.match_12",
"_private.Mathlib.Tactic.Order.0.Mathlib.Tactic.Order.updateGraphWithNltInfSup._proof_1",
"_private.Mathlib.Tactic.Order.0.Mathlib.Tactic.Order.updateGraphWithNltInfSup.match_1",
"Bool.n... | true |
Representation.coind._proof_2 | Mathlib.RepresentationTheory.Coinduced | [
"Monoid",
"Pi.Function.module",
"Submodule",
"MulOne.toOne",
"Representation",
"Pi.addCommMonoid",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"LinearMap.ext",
"congrArg",
"Submodule.addCommMonoid",
"LinearMap.restrict.congr_simp",
"Module.End.instSemiring",
"LinearMap.instFunLike"... | false |
_private.Mathlib.Data.Finmap.0.Finmap.keysLookupEquiv._simp_11 | Mathlib.Data.Finmap | [
"Option.some",
"Exists",
"Bool.true",
"Option.isSome_iff_exists",
"propext",
"Bool",
"Option.isSome",
"Eq",
"Option"
] | false |
MeasureTheory.isTightMeasureSet_of_tendsto_measure_compl_closedBall | Mathlib.MeasureTheory.Measure.TightNormed | [
"Iff.mpr",
"Real",
"MeasureTheory.Measure",
"Preorder.toLT",
"le_rfl",
"congrArg",
"iSup",
"Compl.compl",
"Real.instSemilatticeSup",
"CompletelyDistribLattice.toCompleteLattice",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"Preorder.toLE",
"Membership.mem",
"Exists",
... | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileStrArg.match_4 | Lean.Compiler.LCNF.SimpleGroundExpr | [
"_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileFinalLet._sparseCasesOn_14",
"_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.SimpleGroundValue",
"_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.SimpleGroundValue.arg",
"_p... | false |
Graph.not_isLink_of_notMem_edgeSet._simp_1 | Mathlib.Combinatorics.Graph.Basic | [
"False",
"eq_false",
"Membership.mem",
"Graph",
"Graph.IsLink",
"Graph.not_isLink_of_notMem_edgeSet",
"Graph.edgeSet",
"Eq",
"Set.instMembership",
"Not",
"Set"
] | false |
AddOpposite.op_nonpos | Mathlib.Algebra.Order.Group.Opposite | [
"AddOpposite.instPreorder",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddOpposite.instZero",
"AddZeroClass.toAddZero",
"AddOpposite",
"PartialOrder",
"LE.le",
"AddCommMonoid",
"AddZero.toZero",
"Iff",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",... | true |
MvQPF.Const.mvqpf._proof_1 | Mathlib.Data.QPF.Multivariate.Constructions.Const | [
"MvPFunctor.const.get",
"Nat",
"MvPFunctor.const.get_mk",
"MvQPF.Const",
"MvPFunctor.const.mk",
"Eq",
"TypeVec"
] | false |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.sylvesterDeriv_updateRow._proof_1_6 | Mathlib.RingTheory.Polynomial.Resultant.Basic | [
"Int.Linear.eq_of_core",
"Int.Linear.not_eq_norm_expr",
"Lean.RArray.leaf",
"False",
"Int.Linear.le_coeff",
"HMul.hMul",
"Int.Linear.norm_le",
"Lean.Grind.not_and",
"eq_false",
"Int.Linear.Expr.eq_of_norm_eq",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Int.Linear.le_neg... | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State | Std.Sync.Channel | [
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State.mk"
] | true |
Turing.PartrecToTM2.trPosNum_natEnd | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Γ'",
"Membership.mem",
"Turing.PartrecToTM2.trPosNum",
"Turing.PartrecToTM2.trPosNum_natEnd._f",
"Turing.PartrecToTM2.natEnd",
"List",
"List.instMembership",
"Bool",
"PosNum.brecOn",
"PosNum",
"Bool.false",
"Eq"
] | true |
Polynomial.div_prod_eq_quo_add_sum_rem_div | Mathlib.Algebra.Polynomial.PartialFractions | [
"Algebra.cast",
"Nontrivial",
"WithBot.instPreorder",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"CommRing",
"DivInvMonoid.toInv",
"WithBot",
"Preorder.toLT",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"... | true |
isClosedMap_fst_of_compactSpace | Mathlib.Topology.Maps.Proper.Basic | [
"IsProperMap.isClosedMap",
"instTopologicalSpaceProd",
"isProperMap_fst_of_compactSpace",
"IsClosedMap",
"Prod.fst",
"CompactSpace",
"TopologicalSpace",
"Prod"
] | true |
Std.ExtTreeSet.isEmpty_union | Std.Data.ExtTreeSet.Lemmas | [
"Std.ExtTreeSet.isEmpty",
"Std.ExtTreeSet.instUnionOfTransCmp",
"Ordering",
"Std.ExtTreeSet.inner",
"Bool.and",
"Std.TransCmp",
"Unit",
"Std.ExtTreeSet",
"Bool",
"Union.union",
"Std.ExtTreeMap.isEmpty_union",
"Eq"
] | true |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isSyntheticTacticCompletion | Lean.Server.Completion.SyntheticCompletion | [
"Lean.FileMap.toPosition",
"Lean.FileMap",
"Lean.Syntax",
"_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isSyntheticTacticCompletion.go",
"instOfNatNat",
"Id.run",
"Lean.Position",
"String.Pos.Raw",
"Nat",
"Bool",
"OfNat.ofNat"
] | true |
_private.Mathlib.Algebra.Order.BigOperators.Ring.Finset.0.Mathlib.Meta.Positivity.evalFinsetProd._proof_2 | Mathlib.Algebra.Order.BigOperators.Ring.Finset | [
"Qq.QuotedDefEq",
"Lean.Expr.const",
"Lean.Expr",
"PLift",
"Lean.Expr.sort",
"Lean.Level",
"PLift.down",
"Prod.fst",
"List.cons",
"Qq.Quoted",
"Qq.Quoted.unsafeMk",
"Bool",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Lean.Level.succ",
"Prod",
"Lean.Name.mkStr1",
"Prod.snd",
"List.nil"
... | false |
AlgebraicGeometry.Scheme.restrictRestrictComm._proof_2 | Mathlib.AlgebraicGeometry.Restrict | [
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"TopologicalSpace.Opens.instPartialOrder",
"CommRingCat",
"PartialOrder.toPreorder",
"TopologicalSpace.Opens",
"AlgebraicGeometry.IsOpenImmersion.comp",
"CommRingCat.instCategory",
"Preorder.smallCategory",
"AlgebraicGeometry... | false |
derivationQuotKerSq._simp_4 | Mathlib.RingTheory.Smooth.Kaehler | [
"CommRing",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Ideal.Quotient.mk",
"Ideal.Quotient.algebraMap_eq",
"RingHom",
"Algebra.id",
"Ideal.instAlgebraQuotient",
"Ideal",
"HasQuotient.Quotient",
"Ideal.Quotient.ring",
"Ideal.instIsTwoSided_1",
"CommRing.toCommSemiring",
"Ideal.instHa... | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.throwUnexpected | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | [
"Lean.Meta.Grind.GrindM",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstr.pp",
"Lean.indentD",
"Lean.Meta.Grind.Goal",
"Lean.Meta.Grind.State",
"ReaderT",
"String",
"Lean.Meta.State",
"Lean.instAddErrorMessageContextOfAddM... | true |
Lean.Meta.Grind.ActionResult.closed.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | [
"Lean.TSyntax._sizeOf_inst",
"Lean.Meta.Grind.ActionResult._sizeOf_inst",
"instOfNatNat",
"Lean.Meta.Grind.ActionResult.closed",
"List.cons",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List._sizeOf_inst",
"Lean.Meta.Grind.TGrind",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"Lean.Meta.Grind.... | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic.match_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | [
"Polynomial.C",
"Semigroup.toMul",
"Dvd.dvd",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"semigroupDvd",
"HSub.hSub",
"RingHom",
"Field.toDivisionRing",
"SemigroupWithZero.toSemigroup",
"DivisionRing.toRing",
"Polynomial.divByMonic",
"NonUnitalSemiring.toSemigroupWithZero",
"Field.toSemi... | false |
Std.LawfulLeftIdentity.mk | Init.Core | [
"outParam",
"Std.LeftIdentity",
"Std.LawfulLeftIdentity",
"Std.LawfulLeftIdentity.mk",
"Eq"
] | true |
PresheafOfModules.Derivation.Universal.noConfusion | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | [
"PresheafOfModules.Derivation.Universal",
"PresheafOfModules.Derivation.Universal.noConfusionType",
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"PresheafOfModules.Derivation.Universal.postcomp_injective._autoParam",
"Opposite",
"CommRingCat.carrier",
"CategoryTheory.CategoryStruct.toQuiver"... | false |
toIcoMod_zero_one | Mathlib.Algebra.Order.ToIntervalMod | [
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"AddGroupWithOne.toAddGroup",
"congrArg",
"sub_zero",
"Int.fract",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"IsStrictOrderedRing",
"DivisionMonoid.toDivInvOneMonoid",
"Field... | true |
MvPolynomial.irreducible_of_disjoint_support | Mathlib.RingTheory.MvPolynomial.IrreducibleQuadratic | [
"Finsupp.support_eq_empty._simp_1",
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Eq.mpr",
"not_exists._simp_1",
"Nat.instCanonicallyOrderedAdd",
"RingHom.instRingHomClass",
"IsDomain",
"Finsupp.instLE",
"False",
"Nat.instMulZeroClass",
"Finsupp.erase",
"AddMonoidAlgebra.semiring",
"... | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termG₁ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | [
"Lean.Name.mkNum",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.Name.anonymous",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"OfNat.ofNat"
] | true |
ClassGroup.mk0_eq_mk0_inv_iff | Mathlib.RingTheory.ClassGroup | [
"Eq.mpr",
"Submodule",
"MonoidHom.instMonoidHomClass",
"IsDomain",
"nonZeroDivisorsRight",
"CommRing",
"MonoidHom.instFunLike",
"Semiring.toModule",
"InvOneClass.toOne",
"Submonoid.mul",
"HMul.hMul",
"IsScalarTower.right",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneCla... | true |
Bundle.Trivialization.coordChangeHomeomorph_coe | Mathlib.Topology.FiberBundle.Trivialization | [
"Bundle.Trivialization.coordChangeHomeomorph",
"Membership.mem",
"Bundle.Trivialization.coordChange",
"TopologicalSpace",
"Homeomorph.instEquivLike",
"Bundle.Trivialization",
"Homeomorph",
"Bundle.Trivialization.baseSet",
"Eq",
"Set.instMembership",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLik... | true |
CategoryTheory.yonedaAddGrpFullyFaithful.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | [
"CategoryTheory.yonedaAddMonFullyFaithful",
"CategoryTheory.Functor",
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddGrpCat.instCategory",
"AddGrpCat.hasForgetToAddMonCat",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Add... | true |
Submonoid.pow_coe | Mathlib.Algebra.Group.Submonoid.Membership | [
"Monoid",
"Monoid.toMulOneClass",
"Membership.mem",
"Monoid.toPow",
"HPow.hPow",
"Nat",
"Submonoid.powers",
"Eq.refl",
"Submonoid.instSetLike",
"instHPow",
"Submonoid.pow",
"Subtype.val",
"Eq",
"SetLike.instMembership",
"Submonoid"
] | true |
Array.instDecidableEq_csimp | Init.Data.Array.DecidableEq | [
"instSubsingletonDecidable",
"Decidable",
"Pi.instSubsingleton",
"Array",
"Subsingleton.allEq",
"Array.instDecidableEq",
"Eq",
"Array.instDecidableEqImpl",
"DecidableEq"
] | true |
OrderHom.range_eq_iff | Mathlib.Data.Finset.Sort | [
"DFunLike.congr_fun",
"OrderHom.monotone",
"LinearOrder",
"Finite",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"PartialOrder",
"DistribLattice.toLattice",
"id",
"funext",
"OrderHom.ext",
"OrderHom.instFunLike",
"Iff",
"OrderEmbedding.ofStrictMono",
"Mo... | true |
List.attach_toArray._proof_1 | Init.Data.Array.Attach | [
"Array.instMembership",
"Membership.mem",
"List.mem_toArray._simp_1",
"imp_self._simp_1",
"List.toArray",
"Array",
"List",
"List.instMembership",
"implies_congr",
"True",
"of_eq_true",
"Eq.refl",
"implies_true",
"Eq.trans",
"forall_congr"
] | false |
WeierstrassCurve.Affine.Point.some.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | [
"CommRing",
"WeierstrassCurve.Affine.Point.some.noConfusion",
"And",
"WeierstrassCurve.Affine.Nonsingular",
"WeierstrassCurve.Affine.Point.some",
"And.intro",
"WeierstrassCurve.Affine",
"eq_of_heq",
"WeierstrassCurve.Affine.Point",
"HEq",
"Eq"
] | true |
HDiv.ctorIdx | Init.Prelude | [
"outParam",
"Nat",
"HDiv"
] | false |
CategoryTheory.prodComonad_map | Mathlib.CategoryTheory.Monad.Products | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.prod.associator._proof_1",
"CategoryTheory.Limits.HasBinaryProducts",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Functor.map",
"CategoryTheory.Comonad.toFunctor",
"Eq.refl",
"CategoryTheory.Category.toCategoryStr... | true |
Lean.Meta.AbstractMVars.State.ctorIdx | Lean.Meta.AbstractMVars | [
"Nat",
"Lean.Meta.AbstractMVars.State"
] | false |
Complex.continuousAt_Gamma | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | [
"IsModuleTopology.toContinuousSMul",
"NormedCommRing.toSeminormedCommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"IsTopologicalRing.toIsTopologicalSemiring",
"ContinuousAt",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"IsSemitopologicalRing.toIs... | true |
Lean.Server.Test.Cancel._aux_Lean_Server_Test_Cancel___elabRules_Lean_Server_Test_Cancel_tacticWait_for_cancel_once_async_1 | Lean.Server.Test.Cancel | [
"Pure.pure",
"Lean.MessageData",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Std.instToFormatString",
"Lean.log",
"Task",
"IO.Promise.new",
"IO.CancelToken.isSet",
"BaseIO.asTask",
"Lean.Name.toString",
"Lean.Core.instMonadLiftIOCoreM",
"instMonadReaderOfReaderTOfMonad",
"Lean.El... | false |
CategoryTheory.shrinkYonedaObjObjEquiv_obj_map | Mathlib.CategoryTheory.ShrinkYoneda | [
"CategoryTheory.instSmallOppositeObjFunctorTypeYoneda",
"CategoryTheory.Functor",
"Opposite",
"Equiv.instEquivLike",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Equiv.symm_apply_apply",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.LocallySmal... | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1.eq_1 | Init.Data.String.Decode | [
"ByteArray.utf8DecodeChar?.FirstByte.invalid",
"Unit.unit",
"ByteArray.utf8DecodeChar?.FirstByte.threeMore",
"ByteArray.utf8DecodeChar?.FirstByte.twoMore",
"_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1",
"Unit",
"Eq.refl",
"ByteArray.utf8DecodeChar?.First... | true |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.changesAfter | Lean.Widget.Diff | [
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiffTag",
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff",
"Lean.SubExpr.PosMap"
] | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_subset_Iic._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | [
"Finset",
"HasSubset.Subset",
"SetLike.coe",
"Finset.instSetLike",
"propext",
"Finset.instHasSubset",
"Eq.symm",
"Eq",
"Set.instHasSubset",
"Finset.coe_subset",
"Set"
] | false |
_private.Mathlib.RingTheory.MvPowerSeries.PiTopology.0.MvPowerSeries.WithPiTopology.continuous_C._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.PiTopology | [
"Continuous",
"ContinuousAt",
"TopologicalSpace",
"propext",
"Eq",
"continuous_iff_continuousAt"
] | false |
Combinatorics.Line.toSubspace._proof_1 | Mathlib.Combinatorics.HalesJewett | [
"Exists",
"Sum",
"Prod.mk",
"Sum.inl",
"Combinatorics.Line.proper",
"Combinatorics.Line",
"Prod.fst",
"Combinatorics.Line.idxFun",
"Option.none",
"Combinatorics.Line.toSubspace.match_1",
"Sum.inr",
"Combinatorics.Line.toSubspace._proof_3",
"Exists.intro",
"Prod",
"Option.elim",
"Eq",
... | false |
PartOrdEmb.hasForgetToPartOrd._proof_3 | Mathlib.Order.Category.PartOrdEmb | [
"PartOrdEmb.str",
"PartialOrder.toPreorder",
"RelEmbedding.instRelHomClass",
"Preorder.toLE",
"LE.le",
"RelEmbedding",
"PartOrdEmb.carrier",
"RelHomClass",
"PartOrdEmb",
"RelEmbedding.instFunLike"
] | false |
ONote.ofNat.eq_2 | Mathlib.SetTheory.Ordinal.Notation | [
"ONote.oadd",
"ONote.instZero",
"ONote.ofNat",
"Nat.succPNat",
"Nat",
"Zero.toOfNat0",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"ONote"
] | true |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.ValueGroup₀.zero_or_exists_mk'.match_1_1 | Mathlib.Algebra.GroupWithZero.Range | [
"GroupWithZero.toMonoidWithZero",
"Membership.mem",
"Exists",
"Units",
"Subtype",
"Subgroup",
"Ne",
"Units.instGroup",
"MonoidWithZeroHomClass",
"MonoidWithZeroHom.ValueGroup₀",
"MonoidWithZero",
"Exists.casesOn",
"MonoidWithZero.toMulZeroOneClass",
"MonoidWithZeroHom.valueGroup.mk",
"Wi... | false |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_alter | Std.Data.DHashMap.Internal.RawLemmas | [
"Option.isNone",
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"Std.DHashMap.Internal.Raw₀.contains",
"Std.DHashMap.Internal.Raw₀.Const.get?",
"Std.DHashMap.Internal.Raw.WF.out",
"congrArg",
"Std.DHashMap.Raw",
"Std.DHashMap.Internal.Raw₀.contains_eq_containsKey",
"id",
"Bool.and",
"instOfNatNat",
"Std.D... | true |
_private.Lean.Meta.Basic.0.Lean.Meta.getDefInfoTemp._sparseCasesOn_1 | Lean.Meta.Basic | [
"Lean.Meta.TransparencyMode.ctorIdx",
"Nat.ne_of_beq_eq_false",
"Lean.Meta.TransparencyMode.none",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Meta.TransparencyMode",
"Lean.Meta.TransparencyMode.default",
"Lean.Meta.TransparencyMode.all",
"Nat.land",
"Lean.Meta.TransparencyMode.inst... | false |
_private.Mathlib.FieldTheory.Galois.GaloisClosure.0.FiniteGaloisIntermediateField.mem_fixingSubgroup_iff._simp_1_2 | Mathlib.FieldTheory.Galois.GaloisClosure | [
"AlgEquiv.ext_iff",
"Algebra",
"CommSemiring",
"AlgEquiv",
"propext",
"Semiring",
"Eq",
"DFunLike.coe",
"AlgEquiv.instFunLike"
] | false |
ProofWidgets.ExprPresenter.noConfusionType | ProofWidgets.Presentation.Expr | [
"ProofWidgets.ExprPresenter",
"ProofWidgets.Html",
"String",
"Lean.Expr",
"Lean.Meta.MetaM",
"ProofWidgets.LayoutKind",
"Eq",
"ProofWidgets.ExprPresenter.casesOn"
] | false |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Submonoid.isLocalizationMap_iff_bijective.match_1_5 | Mathlib.GroupTheory.MonoidLocalization.Basic | [
"HMul.hMul",
"Monoid.toMulOneClass",
"Membership.mem",
"Exists",
"MulOne.toMul",
"Subtype",
"DivInvMonoid.toMonoid",
"CommGroup",
"Prod.fst",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Exists.casesOn",
"CommMonoid.toMonoid",
"Exists.intro",
"Submonoid.instSetLike",
"CommGroup.toG... | false |
Std.Iter.flatMapM | Init.Data.Iterators.Combinators.FlatMap | [
"Pure.pure",
"Monad.toApplicative",
"MonadLiftT.monadLift",
"instMonadLiftT",
"Std.Iter.flatMapAfterM",
"Std.Iterators.PostconditionT.attachLift",
"Id",
"Applicative.toPure",
"Std.Iterator",
"Option.none",
"Std.Iterators.instMonadPostconditionT",
"Std.Iter",
"Std.Iterators.Types.Map",
"Mon... | true |
ClosureOperator.conjBy_trans | Mathlib.Order.Closure | [
"Preorder.toLE",
"OrderIso",
"ClosureOperator",
"ClosureOperator.conjBy",
"Eq",
"rfl",
"Preorder",
"OrderIso.trans"
] | true |
Std.DTreeMap.Raw.getKey_modify | Std.Data.DTreeMap.Raw.Lemmas | [
"instDecidableEqOrdering",
"Std.DTreeMap.Raw.modify",
"Std.DTreeMap.Raw.instMembership",
"Ord.mk",
"Membership.mem",
"Ordering",
"Ordering.eq",
"Std.TransCmp",
"Std.DTreeMap.Internal.Impl.getKey_modify",
"Std.DTreeMap.Raw.getKey",
"Std.DTreeMap.Raw.WF.out",
"Std.LawfulEqCmp",
"Std.DTreeMap.R... | true |
ComputablePred.ite | Mathlib.Computability.RE | [
"cond",
"ComputablePred.decide",
"congrArg",
"Primcodable.ofDenumerable",
"Eq.mp",
"funext",
"DecidablePred",
"Nat",
"Denumerable.nat",
"Computable.cond",
"ComputablePred",
"Computable",
"Decidable.decide",
"Bool.cond_decide",
"ite"
] | true |
_private.Mathlib.Data.List.Nodup.0.List.nodup_flatMap._simp_1_6 | Mathlib.Data.List.Nodup | [
"and_imp",
"And",
"propext",
"Eq"
] | false |
Lean.Elab.Command.AssertExists._sizeOf_inst | Lean.Elab.AssertExists | [
"Lean.Elab.Command.AssertExists",
"SizeOf.mk",
"SizeOf",
"Lean.Elab.Command.AssertExists._sizeOf_1"
] | false |
_private.Lean.Elab.BuiltinDo.Match.0.Lean.Elab.Do.tryPostponeIfDiscrTypeIsMVar | Lean.Elab.BuiltinDo.Match | [
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"Lean.instantiateMVars",
"Lean.TSyntax",
"Lean.MessageData",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.instMonadMCtxOfMonadLift",
"Lean.Elab.Term.elabTerm",
"instForInOfForIn'",
"Lea... | true |
MvPolynomial.hsymm | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | [
"Nat.instMulZeroClass",
"Finset.univ",
"AddMonoidAlgebra.addAddCommMonoid",
"Multiset.map",
"CommSemiring.toSemiring",
"Sym.instFintype",
"Multiset.prod",
"MvPolynomial.X",
"AddMonoidAlgebra.commSemiring",
"Multiset",
"Finsupp.instAddCommMonoid",
"CommSemiring",
"Fintype",
"Nat",
"CommSe... | true |
Lean.Meta.Grind.Arith.CommRing.NonCommRingM.Context.ringId | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommRingM | [
"Lean.Meta.Grind.Arith.CommRing.NonCommRingM.Context",
"Nat"
] | true |
Quaternion.coe_neg._simp_1 | Mathlib.Algebra.Quaternion | [
"Quaternion.coe",
"NegZeroClass.toNeg",
"CommRing",
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"AddMonoidWithOne.toOne",
"CommRing.toCommSemiring",
"Ring.... | false |
BitVec.toInt_signExtend | Init.Data.BitVec.Lemmas | [
"instPowNat",
"Eq.mpr",
"congrArg",
"Nat.min_le_right",
"BitVec",
"id",
"instOfNatNat",
"Int",
"BitVec.toNat",
"Nat.cast",
"Int.bmod_bmod_of_dvd",
"instNatPowNat",
"HPow.hPow",
"Int.bmod",
"Nat",
"BitVec.signExtend",
"BitVec.toInt_eq_toNat_bmod",
"Eq.refl",
"BitVec.toInt",
"ins... | true |
TopologicalSpace.Opens.coe_sSup._simp_1 | Mathlib.Topology.Sets.Opens | [
"TopologicalSpace.Opens.instCompleteLattice",
"TopologicalSpace.Opens",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"TopologicalSpace.Opens.instSetLike",
"TopologicalSpace",
"SetLike.coe",
"TopologicalSpace.Opens.coe_sSup",
"ConditionallyCompleteLattice.toConditionallyComplet... | false |
CategoryTheory.Discrete.functor._proof_1 | Mathlib.CategoryTheory.Discrete.Basic | [
"ULift.casesOn",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.eqToHom",
"Function.comp",
"CategoryTheory.CategoryStruct.id",
"id",
"PLift",
"CategoryTheory.Discrete.as",
"CategoryTheory.discreteCategory",
"PLift.casesOn",
"Eq.refl",
"CategoryTheory.Ca... | false |
_private.Mathlib.Tactic.DefEqTransformations.0.Mathlib.Tactic.etaStruct?.findProj | Mathlib.Tactic.DefEqTransformations | [
"Pure.pure",
"Lean.ConstructorVal",
"Lean.ConstructorVal.induct",
"instForInOfForIn'",
"ReaderT",
"Lean.Meta.State",
"_private.Mathlib.Tactic.DefEqTransformations.0.Mathlib.Tactic.etaStruct?.findProj.match_1",
"Lean.LOption.undef",
"Option.some",
"ForInStep.done",
"_private.Mathlib.Tactic.DefEqT... | true |
PowerSeries.constantCoeff_comp_C | Mathlib.RingTheory.PowerSeries.Basic | [
"RingHom",
"PowerSeries.constantCoeff",
"MvPowerSeries.instSemiring",
"PowerSeries.C",
"RingHom.comp",
"Unit",
"Semiring",
"PowerSeries",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Eq",
"rfl"
] | true |
Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go._unary.eq_def | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker | [
"Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go._unary._proof_2",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction",
"Eq.mpr",
"Std.Tactic.BVDecide.LRAT.Internal.Clause.toList",
"instSubsingletonDecidable",
"_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker.0.PSigma.casesOn._arg... | false |
_private.Lean.Meta.Tactic.Delta.0.Lean.Meta.deltaExpand.match_1 | Lean.Meta.Tactic.Delta | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Lean.Expr",
"Option.none",
"Unit",
"Option"
] | false |
Lean.Compiler.LCNF.instAddMessageContextCompilerM | Lean.Compiler.LCNF.CompilerM | [
"Pure.pure",
"Lean.instMonadEnvOfMonadLift",
"Lean.MessageData",
"Lean.instBEqMVarId",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"Lean.Core.instMonadEnvCoreM",
"Lean.MetavarContext.mk",
"instMonadLiftT",
"MonadState.get",
"IO",
"Lean.Compiler.LCNF.LCtx.toLocalConte... | true |
Lean.Elab.Tactic.Omega.Justification.toString._unsafe_rec | Lean.Elab.Tactic.Omega.Core | [
"String",
"Lean.Omega.Constraint.exact",
"instToStringList",
"Int.instDecidableEq",
"Lean.Elab.Tactic.Omega.Justification",
"Bool.and",
"instDecidableEqBool",
"Int",
"ToString.toString",
"instBEqOfDecidableEq",
"Bool.true",
"instAppendString",
"instHAppendOfAppend",
"instToStringNat",
"B... | false |
CategoryTheory.ShortComplex.SnakeInput.op._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.op_mono_of_epi",
"Opposite",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom.op",
"CategoryTheory.ShortComplex.SnakeInput",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.Abelian",
"inferInstance",
"id",
"C... | false |
MonadWithReaderOf.ctorIdx | Init.Prelude | [
"MonadWithReaderOf",
"semiOutParam",
"Nat"
] | false |
MeasureTheory.measurePreserving_prod_div | Mathlib.MeasureTheory.Group.Prod | [
"MeasureTheory.MeasurePreserving",
"MeasureTheory.Measure",
"instHDiv",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"MeasureTheory.MeasurePreserving.symm",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"MeasurableEquiv.symm",
"MulOne.toMul",
"HDiv.hDiv",
... | true |
ProbabilityTheory.setLIntegral_toKernel_univ | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | [
"Iff.mpr",
"Set.instSProd",
"Eq.mpr",
"Set.prod_subset_prod_iff",
"instClosedIicTopology",
"Real",
"ProbabilityTheory.IsFiniteKernel",
"MeasureTheory.Measure",
"Pi.preorder",
"ChainCompletePartialOrder.instOfCompleteLattice",
"Real.lattice",
"MeasurableSet",
"MeasureTheory.lintegral_iSup_dir... | true |
CategoryTheory.Enriched.FunctorCategory.homEquiv._proof_3 | Mathlib.CategoryTheory.Enriched.FunctorCategory | [
"CategoryTheory.Functor.op",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"Opposite",
"Equiv.instEquivLike",
"CategoryTheory.EnrichedOrdinaryCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Monoida... | false |
ContinuousMonoidHom.mul.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | [
"Monoid.toMulOneClass",
"ContinuousMonoidHom.mk",
"instTopologicalSpaceProd",
"MulOne.toMul",
"ContinuousMonoidHom.mul._proof_1",
"Prod.instMonoid",
"TopologicalSpace",
"MulOneClass.toMulOne",
"ContinuousMul",
"CommMonoid.toMonoid",
"Eq.refl",
"ContinuousMonoidHom",
"mulMonoidHom",
"Prod",... | true |
LinearMap.mk₂'_apply | Mathlib.LinearAlgebra.BilinearMap | [
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LinearMap.module",
"LinearMap",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"LinearMap.addCommMonoid",
"Semiring.toM... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.