name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | [
"Lean.Parser.ParserAliasValue",
"Lean.Parser.ParserResolution.alias",
"Lean.Parser.ParserResolution"
] | true |
HasSubset.noConfusion | Init.Core | [
"HasSubset.casesOn",
"HEq.refl",
"HasSubset.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"HasSubset",
"Eq"
] | false |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | [
"String",
"Nat.hasNotBit",
"Lean.Name.ctorIdx",
"dite",
"Lean.Name.str",
"Eq.ndrec_symm",
"instDecidableEqString",
"Lean.Name",
"_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion._sparseCasesOn_1",
"Eq",
"Not"
] | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | [
"Lean.Compiler.LCNF.LetValue.reuse",
"Lean.Compiler.LCNF.Arg",
"Lean.Compiler.LCNF.LetValue.pap",
"Lean.Compiler.LCNF.instInhabitedLetValue",
"Lean.Compiler.LCNF.LetValue",
"panicWithPosWithDecl",
"Lean.Compiler.LCNF.LetValue.fap",
"ptrEq",
"Lean.FVarId",
"instDecidableEqBool",
"instOfNatNat",
... | true |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | [
"Eq.mpr",
"CategoryTheory.sum",
"Sum.ctorIdx",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"HEq.refl",
"False.elim",
"CategoryTheory.IsDiscrete",
"Sum.inr.noConfusion",
"noConfusion_of_Nat",
"CategoryTheory.IsDiscrete.mk",
"Sum.inl.noConfusion",
"Sum",
"id",
"Su... | true |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | [
"instLEUSize",
"HSub.hSub",
"instSubNat",
"LE.le",
"BitVec.toNat_sub_of_le",
"System.Platform.numBits",
"USize.toBitVec",
"instHSub",
"USize.toNat",
"Nat",
"instSubUSize",
"Eq",
"USize"
] | true |
Lean.Compiler.CSimp.replaceConstant | Lean.Compiler.CSimpAttr | [
"Pure.pure",
"Option.getD",
"Lean.Expr",
"IO.RealWorld",
"EIO",
"instMonadEIO",
"Applicative.toPure",
"Lean.Compiler.CSimp.replaceConstant?",
"Lean.Core.State",
"Lean.Core.CoreM",
"StateRefT'",
"StateRefT'.instMonad",
"Monad.toBind",
"Bind.bind",
"Lean.Core.instMonadCoreM",
"ReaderT.in... | true |
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3 | Init.Data.Array.BinSearch | [
"instDecidableNot",
"Int.instDiv",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"instHDiv",
"HMul.hMul",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Int.natCast_ediv",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HS... | false |
PNat.XgcdType.flip_b | Mathlib.Data.PNat.Xgcd | [
"PNat.XgcdType.flip",
"PNat.XgcdType",
"PNat.XgcdType.a",
"Eq",
"rfl",
"PNat.XgcdType.b",
"PNat"
] | true |
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | [
"Lean.Lsp.Decls",
"Lean.Lsp.LeanIleanInfoParams.rec",
"Lean.Lsp.ModuleRefs",
"Nat",
"Lean.Lsp.LeanIleanInfoParams",
"Lean.Lsp.LeanIleanInfoParams.mk"
] | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | [
"Ordering",
"Lean.Grind.CommRing.Mon.grevlex",
"Lean.Grind.CommRing.Mon.grevlex_k_eq_grevlex",
"Lean.Grind.CommRing.Mon.grevlex_k",
"Eq.symm",
"Eq",
"Lean.Grind.CommRing.Mon"
] | false |
Complex.isOpen_im_lt_EReal | Mathlib.Analysis.Complex.HalfPlane | [
"Iff.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Preorder.toLT",
"Continuous",
"isOpen_lt",
"Complex.im",
"EReal.instTopologicalSpace",
"PartialOrder.toPreorder",
"continuous_const",
"Complex.instNormedField",
"setOf",
"PseudoMetricSpace.toUniformSpace",
"EReal",
"OrderTopology... | true |
CategoryTheory.Bundled.mk.noConfusion | Mathlib.CategoryTheory.ConcreteCategory.Bundled | [
"CategoryTheory.Bundled.noConfusion",
"id",
"autoParam",
"CategoryTheory.Bundled.mk",
"heq_of_eq",
"CategoryTheory.Bundled",
"Eq.refl",
"HEq",
"CategoryTheory.Bundled.str._autoParam",
"Eq"
] | false |
Std.ExtDTreeMap.size_le_size_erase | Std.Data.ExtDTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.ExtDTreeMap.erase",
"Ordering",
"instOfNatNat",
"LE.le",
"Std.TransCmp",
"instLENat",
"Std.DTreeMap.size_le_size_erase",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Std.ExtDTreeMap.size",
"instAddNat",
"OfNat.ofNat"
] | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"CategoryTheory.ComposableArrows.map'._proof_2",
"Fin.mk",
"instOfNatNat",
"LE.le",
"instLENat",
"_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_6",
"autoParam",
"CategoryTheory.Compos... | false |
riemannZeta.eq_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | [
"Real",
"riemannZeta",
"AddCommGroup.toAddGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"Real.instAddCommGroup",
"SubtractionCommMonoid.toSubtractionMonoid",
"Real.instOne",
"UnitAddCircle",
"QuotientAddGroup.Quotient.addCommGroup",
"AddSubgroup.zmultiples",
... | true |
CategoryTheory.ProjectivePresentation.noConfusionType | Mathlib.CategoryTheory.Preadditive.Projective.Basic | [
"CategoryTheory.ProjectivePresentation",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Projective",
"HEq",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category",
"CategoryTheory.ProjectivePresentation.casesOn"
] | false |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | [
"MeasurableSet",
"Set.univ",
"MeasurableSpace",
"True",
"eq_true",
"Eq",
"MeasurableSet.univ"
] | false |
Filter.comk.congr_simp | Mathlib.Order.Filter.Basic | [
"Set.instUnion",
"Eq.rec",
"HasSubset.Subset",
"Set.instEmptyCollection",
"Eq.ndrec",
"Eq.refl",
"Union.union",
"EmptyCollection.emptyCollection",
"Eq",
"Filter.comk",
"Filter",
"Set.instHasSubset",
"Set"
] | true |
CategoryTheory.Pretriangulated.Triangle.epi₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | [
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Pretriangulated.Triangle.obj₁",
"CategoryTheory.Pretriangulated.Triangle.obj₃",
"CategoryTheory.shiftFunctor",
"Membership.mem",
"Int",
"Int.instAddMonoid",
"CategoryT... | true |
AddSemigroupIdeal.fg_iff | Mathlib.Algebra.Group.Ideal | [
"AddSemigroupIdeal.closure",
"instVAddOfAdd",
"Finset",
"Exists",
"AddSemigroupIdeal.FG",
"Iff",
"SetLike.coe",
"Finset.instSetLike",
"AddSemigroupIdeal",
"Eq",
"Add",
"SubAddAction.fg_iff"
] | true |
Std.ExtTreeMap.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeMap.Lemmas | [
"Std.ExtTreeMap.size",
"Std.ExtTreeMap.isEmpty",
"Std.ExtDTreeMap.isEmpty_eq_size_beq_zero",
"Ordering",
"instOfNatNat",
"instBEqOfDecidableEq",
"BEq.beq",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Nat",
"Bool",
"instDecidableEqNat",
"OfNat.ofNat",
"Eq"
] | true |
NormedAddGroupHom.incl._proof_3 | Mathlib.Analysis.Normed.Group.Hom | [
"Norm.norm",
"Real.instLE",
"Real",
"SeminormedAddCommGroup",
"HMul.hMul",
"AddSubgroup.seminormedAddCommGroup",
"NormedAddGroupHom.incl._proof_1",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"Subtype",
"LE.le",
"AddSubgroup",
"Real.instOne",
"SeminormedAddCommGroup.toNorm",
... | false |
Part.Mem | Mathlib.Data.Part | [
"Part",
"Exists",
"Part.get",
"Part.Dom",
"Eq"
] | true |
Lean.Server.Watchdog.WorkerEvent.casesOn | Lean.Server.Watchdog | [
"Lean.Server.Watchdog.WorkerEvent.importsChanged",
"Lean.Server.Watchdog.WorkerEvent",
"Lean.Server.Watchdog.WorkerEvent.rec",
"Lean.Server.Watchdog.WorkerEvent.crashed",
"Lean.Server.Watchdog.WorkerEvent.terminated",
"UInt32",
"IO.Error",
"Lean.Server.Watchdog.WorkerEvent.ioError"
] | false |
Acc.ndrec | Init.WF | [
"Acc",
"Acc.rec"
] | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameM | Lean.Elab.DeclNameGen | [
"Lean.Meta.MetaM",
"IO.RealWorld",
"StateRefT'",
"_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState"
] | true |
Std.DTreeMap.Const.get!_modify_self | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Const.modify",
"Ord.mk",
"Ordering",
"Std.DTreeMap.Const.get?",
"Option.get!",
"Std.DTreeMap.inner",
"Std.DTreeMap.Internal.Impl.Const.get!_modify_self",
"Std.TransCmp",
"Option.map",
"Std.DTreeMap.wf",
"Inhabited",
"Eq",
"Std.DTreeMap.Const.get!"
] | true |
Prod.instCoheytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | [
"Prod.instOrderTop",
"CoheytingAlgebra.toHNot",
"Iff.mpr",
"Lattice.toSemilatticeSup",
"Prod.instLE_mathlib",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Prod.instSDiff",
"CoheytingAlgebra.toOrderTop",
"Prod.ext_iff",
"CoheytingAlgebra",
"Prod.instHNot",
"HNot.hnot",
"Prod.fst",
"SDiff.... | false |
SSet.StrictSegal.ofIsStrictSegal._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | [
"SSet.Path",
"Opposite",
"Function.comp",
"id",
"SSet",
"funext",
"SSet.IsStrictSegal.segal",
"SimplexCategory.mk",
"Opposite.op",
"Nat",
"Equiv.ofBijective",
"CategoryTheory.types",
"SimplexCategory",
"CategoryTheory.Category.opposite",
"SSet.IsStrictSegal",
"SimplexCategory.smallCate... | false |
CoalgHom.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Hom | [
"CoalgebraStruct",
"instHSMul",
"Semiring.toModule",
"CommSemiring.toSemiring",
"CoalgHom",
"DistribMulAction.toDistribSMul",
"TensorProduct.addCommMonoid",
"AddMonoid.toAddZeroClass",
"CoalgHom.mk",
"RingHom",
"CoalgebraStruct.counit",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass"... | false |
vectorSpan_mono | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | [
"Submodule",
"vectorSpan",
"Set.vsub",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"HasSubset.Subset",
"Submodule.instPartialOrder",
"LE.le",
"AddTorsor.toVSub",
"VSub.vsub",
"Set.vsub_self_mono",
"Submodule.span_... | true |
BoxIntegral.Prepartition.mk.sizeOf_spec | Mathlib.Analysis.BoxIntegral.Partition.Basic | [
"Real",
"Function.onFun",
"BoxIntegral.Prepartition",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"BoxIntegral.Box.toSet",
"Finset",
"BoxIntegral.Prepartition._sizeOf_inst",
"Disjoint",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"BoxIntegral.Box._sizeOf_inst",
"... | true |
Lean.Name.str._impl | Init.Prelude | [
"UInt64",
"String",
"Lean.Name.str._impl",
"Lean.Name._impl",
"Lean.Name"
] | false |
conformalAt_id | Mathlib.Analysis.Calculus.Conformal.NormedSpace | [
"HasFDerivAt",
"Real",
"NormedSpace",
"Real.denselyNormedField",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"hasFDerivAt_id",
"Real.semiring",
"id",
"ContinuousLinearMap.id",
"ContinuousLinearMap",
"And",
"SeminormedAddCommGroup.toPseudoMetr... | true |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.runPass.match_5 | Mathlib.Tactic.TacticAnalysis | [
"Mathlib.TacticAnalysis.TriggerCondition.ctorIdx",
"Mathlib.TacticAnalysis.ComplexConfig",
"Nat.hasNotBit",
"Mathlib.TacticAnalysis.TriggerCondition",
"Mathlib.TacticAnalysis.ComplexConfig.ctx",
"Mathlib.TacticAnalysis.TriggerCondition.accept",
"_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAna... | false |
DirectSum.GradeZero.semiring._proof_3 | Mathlib.Algebra.DirectSum.Ring | [
"instAddCommMonoidDirectSum",
"AddMonoid.toAddZeroClass",
"DirectSum.GSemiring.toGMonoid",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"AddZero.toZero",
"GradedMonoid.GradeZero.one",
"DirectSum.GSemiring",
"AddMonoid",
"DirectSum.of",
"One.toOfNat1",
"Zero.toOfNat0",
"GradedMonoid.GMonoid.toG... | false |
Aesop.RuleResult.isSuccessful | Aesop.Search.Expansion | [
"Aesop.RappRef",
"Array",
"Bool.true",
"Unit",
"Bool",
"_private.Aesop.Search.Expansion.0.Aesop.RuleResult.toEmoji.match_1",
"Aesop.RuleResult",
"Bool.false"
] | true |
_private.Mathlib.Data.List.Count.0.List.countP_erase._proof_1_2 | Mathlib.Data.List.Count | [
"Lean.Grind.Nat.lt_eq",
"List.getElem_filter_eq_getElem_getElem_findIdxs._proof_2",
"instOfNatNat",
"LE.le",
"instLENat",
"List.findIdxs",
"List",
"Nat",
"List.filter",
"LT.lt",
"Eq.substr",
"Bool",
"instLTNat",
"OfNat.ofNat",
"List.length"
] | false |
MulChar.instMulCharClass | Mathlib.NumberTheory.MulChar.Basic | [
"MulOne.toOne",
"Monoid.toMulOneClass",
"MonoidHomClass.mk",
"MulOne.toMul",
"MulChar",
"MulChar.instFunLike",
"CommMonoidWithZero.toMonoidWithZero",
"MulCharClass",
"MulZeroOneClass.toMulOneClass",
"MulOneClass.toMulOne",
"MonoidWithZero.toMulZeroOneClass",
"OneHomClass.mk",
"CommMonoid.toM... | true |
Pi.seminormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Lemmas | [
"HMul.hMul",
"NonUnitalNonAssocRing.toMul",
"AddMonoid.toZero",
"NonUnitalNonAssocRing.toAddCommGroup",
"AddCommGroup.toAddGroup",
"NonUnitalRing.toNonUnitalNonAssocRing",
"NonUnitalNonAssocRing.zero_mul",
"Fintype",
"AddGroup.toSubNegMonoid",
"Zero.toOfNat0",
"Pi.nonUnitalSeminormedRing",
"Su... | false |
FractionalIdeal.count._proof_2 | Mathlib.RingTheory.DedekindDomain.Factorization | [
"IsDedekindDomain.toIsDomain",
"CommRing",
"FractionalIdeal.spanSingleton",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IsFractionRing",
"Algebra",
"RingHom",
"DivisionMonoid.toDivInvOneMonoid",
"nonZe... | false |
Nat.Ico_zero_eq_range | Mathlib.Order.Interval.Finset.Nat | [
"Eq.mpr",
"congrArg",
"Finset.Iio_eq_Ico",
"Finset",
"OrderBot.toBot",
"Finset.Iio",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"LocallyFiniteOrder.toLocallyFiniteOrderBot",
"id",
"Finset.Ico",
"instOfNatNat",
"Bot.bot",
"instLENat",
"Finset.range",
"Nat.instPreorder",
"Nat",
"... | true |
Vector.finIdxOf? | Init.Data.Vector.Basic | [
"Vector",
"Fin.cast",
"Option.map",
"Nat",
"Array.finIdxOf?",
"Vector.size_toArray",
"Fin",
"BEq",
"Array.size",
"Vector.toArray",
"Option"
] | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.flatten.match_1.splitter | Mathlib.Data.WSeq.Basic | [
"Sum",
"Sum.inl",
"Computation",
"Sum.inr",
"Stream'.WSeq",
"Stream'.WSeq.flatten.match_1"
] | true |
Batteries.RBSet.empty | Batteries.Data.RBMap.Basic | [
"Batteries.mkRBSet",
"Batteries.RBSet",
"Ordering"
] | true |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Submonoid.LocalizationMap.isCancelMul.match_1_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | [
"HMul.hMul",
"Monoid.toMulOneClass",
"Membership.mem",
"Exists",
"MulOne.toMul",
"Subtype",
"Prod.fst",
"MulOneClass.toMulOne",
"Exists.casesOn",
"CommMonoid.toMonoid",
"Submonoid.LocalizationMap",
"Submonoid.LocalizationMap.instFunLike",
"Exists.intro",
"Submonoid.instSetLike",
"Prod",
... | false |
CategoryTheory.Limits.HasBinaryProduct | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | [
"CategoryTheory.Limits.HasLimit",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.discreteCategory",
"CategoryTheory.Limits.pair",
"CategoryTheory.Category",
"CategoryTheory.Discrete"
] | true |
Array.isEmpty.eq_1 | Init.Data.Array.DecidableEq | [
"Array.isEmpty",
"instOfNatNat",
"Array",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"Decidable.decide",
"Eq",
"Array.size"
] | true |
Std.instLawfulOrderLeftLeaningMaxOfIsLinearOrderOfLawfulOrderSup | Init.Data.Order.Lemmas | [
"Std.LawfulOrderSup",
"congrArg",
"and_self",
"Std.IsLinearPreorder.toIsPreorder",
"Std.instReflLeOfIsPreorder",
"Std.le_refl._simp_1",
"Max",
"LE.le",
"Std.IsLinearOrder.toIsPartialOrder",
"Std.IsLinearOrder",
"LE",
"And",
"Std.LawfulOrderLeftLeaningMax.mk",
"Std.instAntisymmLeOfIsPartial... | true |
Std.IterM.filter.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Pure.pure",
"Monad.toApplicative",
"MonadLiftT.monadLift",
"instMonadLiftT",
"Option.some",
"instDecidableEqBool",
"Std.IterM.filterMap",
"Applicative.toPure",
"Std.IterM.filter",
"Std.Iterator",
"Bool.true",
"Option.none",
"Std.Iterators.instMonadPostconditionT",
"Std.Iterators.Types.Fil... | true |
TrivSqZeroExt.snd | Mathlib.Algebra.TrivSqZeroExt.Basic | [
"TrivSqZeroExt",
"Prod.snd"
] | true |
CauSeq.equiv | Mathlib.Algebra.Order.CauSeq.Basic | [
"LinearOrder",
"HSub.hSub",
"IsStrictOrderedRing",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Setoid",
"Field.toSemifield",
"instHSub",
"Semifield.toDivisionSemiring",
"CauSeq.instSub",
"Setoid.mk",
"IsAbsoluteValue",
"CauSeq",
"DivisionSemiring.toSemiring",
"Ring.toSe... | true |
add_lt_add_iff_right_of_ne_top | Mathlib.Algebra.Order.AddGroupWithTop | [
"add_right_strictMono_of_ne_top",
"Preorder.toLT",
"PartialOrder.toPreorder",
"LinearOrderedAddCommMonoidWithTop.toOrderTop",
"StrictMono.lt_iff_lt",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Ne",
"instHAdd",
"Iff",
"OrderTop.toTop",
"HAdd.hAdd",
"Linea... | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_cons_of_ne._proof_1_2 | Mathlib.Data.Finset.Basic | [
"Lean.Grind.of_eq_eq_true",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Lean.Grind.not_not",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"Finset.cons",
"congrArg",
"Finset",
"False.elim",
"Classical.byContradiction",
"_private.Mathlib.Data.Finset.Basic.0.Finset.erase_cons_... | false |
IsIntegral.mem_range_algebraMap_of_minpoly_splits | Mathlib.RingTheory.Adjoin.Field | [
"CommRing",
"Subring.instSetLike",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IsScalarTower",
"IsScalarTower.toAlgHom",
"Algebra",
"Algebra.toSMul",
"Membership.mem",
"Field.toDivisionRing",
"IsIntegral.mem_range_algHom_of_minpoly_splits",
"DivisionRing.toRing",
"CommRing.toNonAssocCo... | true |
NoBotOrder.casesOn | Mathlib.Order.Max | [
"Exists",
"LE.le",
"LE",
"NoBotOrder",
"NoBotOrder.mk",
"Not",
"NoBotOrder.rec"
] | false |
TendstoLocallyUniformlyOn.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | [
"UniformSpace",
"TendstoLocallyUniformlyOn",
"HSub.hSub",
"id",
"IsUniformAddGroup",
"SubNegMonoid.toSub",
"TopologicalSpace",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"Filter",
"TendstoLocallyUniformlyOn.sub",
"Set"
] | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.injOn_setOf_mem_Icc_setOf_lower_eq._simp_1_2 | Mathlib.Analysis.BoxIntegral.Partition.Basic | [
"setOf",
"Membership.mem",
"Set.mem_setOf",
"propext",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Init.Data.Int.Gcd.0.Int.gcd_eq_natAbs_right_iff_dvd._simp_1_1 | Init.Data.Int.Gcd | [
"Nat.gcd",
"Dvd.dvd",
"Nat.instDvd",
"Nat",
"propext",
"Eq",
"Nat.gcd_eq_right_iff_dvd"
] | false |
AlgHom.convOne_def | Mathlib.RingTheory.Bialgebra.Convolution | [
"WithConv.toConv",
"AlgHom.instOneWithConv",
"CommSemiring.toSemiring",
"AlgHom",
"Algebra",
"Algebra.id",
"Bialgebra.counitAlgHom",
"CommSemiring",
"Algebra.ofId",
"Bialgebra",
"Semiring",
"One.toOfNat1",
"Bialgebra.toAlgebra",
"WithConv",
"AlgHom.comp",
"OfNat.ofNat",
"Eq",
"rfl"... | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_451 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff'._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Positive | [
"ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric",
"InnerProductSpace.toNormedSpace",
"IsSelfAdjoint",
"CompleteSpace",
"ContinuousLinearMap.instStarId",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"NormedField.toField",
"ContinuousLinearMap.toLine... | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.parallelPair.match_1.eq_2 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"Unit.unit",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.WalkingParallelPair.one",
"CategoryTheory.Limits.parallelPair.match_1",
"Unit",
"Eq.refl",
"Eq",
"CategoryTheory.Limits.WalkingParallelPair.zero"
] | true |
IsRealClosed.rec | Mathlib.FieldTheory.IsRealClosed.Basic | [
"NegZeroClass.toNeg",
"IsSemireal",
"Polynomial.IsRoot",
"Odd",
"AddGroupWithOne.toAddMonoidWithOne",
"IsRealClosed",
"Exists",
"Field.toDivisionRing",
"Distrib.toAdd",
"DivisionRing.toRing",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.to... | false |
Lean.Lsp.FoldingRangeKind.ctorElim | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.FoldingRangeKind.region",
"Lean.Lsp.FoldingRangeKind.comment",
"Lean.Lsp.FoldingRangeKind.imports",
"Lean.Lsp.FoldingRangeKind.ctorIdx",
"Lean.Lsp.FoldingRangeKind",
"Nat",
"Eq.ndrec",
"Lean.Lsp.FoldingRangeKind.casesOn",
"PULift.down",
"Eq",
"Lean.Lsp.FoldingRangeKind.ctorElimType"
] | false |
Char.reduceIsUpper._regBuiltin.Char.reduceIsUpper.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.2972409855._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | [
"IO",
"Char.reduceIsUpper",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.Simproc"
] | false |
Ordnode.Bounded._sparseCasesOn_1.else_eq | Mathlib.Data.Ordmap.Ordset | [
"Option.ctorIdx",
"Option.casesOn",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.true",
"Nat.land",
"Option.none",
"absurd",
"Nat",
"Ordnode.Bounded._sparseCasesOn_1",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Eq... | false |
Std.Internal.List.Const.getValue_alterKey_self._proof_1 | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"BEq.rfl",
"congrArg",
"Eq.mp",
"instDecidableEqBool",
"Std.Internal.List.Const.containsKey_alterKey",
"Std.Internal.List.Const.alterKey",
"Bool.true",
"List",
"EquivBEq.toReflBEq",
"Std.Internal.List.containsKey",
"BEq.beq",
"EquivBEq",
"Std.Internal.List... | false |
_private.Init.Data.Array.Basic.0.Array.allDiffAux._proof_1 | Init.Data.Array.Basic | [
"InvImage",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Array",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Nat.sub_succ_lt_self",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"Array.size"
] | false |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxo.LawfulHasSize.of_closed._simp_6 | Init.Data.Range.Polymorphic.Instances | [
"Std.PRange.UpwardEnumerable",
"Std.Rxc.HasSize",
"Std.Rxc.LawfulHasSize",
"instOfNatNat",
"LE.le",
"LE",
"Nat",
"LT.lt",
"propext",
"Std.Rxc.size_pos_iff_le",
"instLTNat",
"Std.Rxc.HasSize.size",
"OfNat.ofNat",
"Eq"
] | false |
CoxeterSystem.exists_reduced_word | Mathlib.GroupTheory.Coxeter.Length | [
"CoxeterSystem.exists_isReduced",
"Group",
"CoxeterSystem.IsReduced",
"Exists",
"CoxeterMatrix",
"List",
"And",
"CoxeterSystem.wordProd",
"CoxeterSystem",
"Eq"
] | true |
Submodule.spanRank_toENat_eq_iInf_finset_card | Mathlib.Algebra.Module.SpanRank | [
"Iff.mpr",
"Eq.mpr",
"Submodule",
"Set.encard",
"iInf",
"instCompleteLinearOrderENat",
"ChainCompletePartialOrder.instOfCompleteLattice",
"Submodule.spanRank_toENat_eq_iInf_encard",
"ENat.instNatCast",
"Cardinal",
"CompleteLattice.toLattice",
"instTopENat",
"_private.Mathlib.Algebra.Module.S... | true |
ProofWidgets.Component.mk.sizeOf_spec | ProofWidgets.Component.Basic | [
"ProofWidgets.Component.mk",
"Lean.Widget.Module",
"String",
"Lean.Widget.Module._sizeOf_inst",
"ProofWidgets.Component",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"ProofWidgets.Component._sizeOf_inst",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"String._sizeOf_inst",
"Eq.refl",
"SizeOf",
"O... | true |
Int64.ofNat_add | Init.Data.SInt.Lemmas | [
"congrArg",
"_private.Init.Data.SInt.Lemmas.0.Int64.ofNat_add._simp_1_1",
"instAddInt64",
"Int64",
"Int",
"Nat.cast",
"instHAdd",
"HAdd.hAdd",
"Nat",
"congr",
"True",
"eq_self",
"of_eq_true",
"instAddNat",
"instNatCastInt",
"Int64.ofNat",
"Int64.ofInt",
"Eq",
"Int64.ofInt_add",
... | true |
Std.Http.URI.Builder.mk.noConfusion | Std.Internal.Http.Data.URI.Basic | [
"String",
"Std.Http.URI.Builder.noConfusion",
"Std.Http.URI.Host",
"id",
"Array",
"Std.Http.URI.Scheme",
"Std.Http.URI.Builder",
"Prod",
"Eq",
"Std.Http.URI.Port",
"Std.Http.URI.Builder.mk",
"Option",
"Std.Http.URI.UserInfo"
] | false |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | [
"instLawfulOrderLT_mathlib",
"Lean.RArray.leaf",
"Lean.Grind.Field.toCommRing",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Real.partialOrder",
"Real.instLE",
"Real",
"Preorder.toLT",
"Set.mem_Ioo",
"eq_false",
"Lean.Grind.iff_eq",
"Lean.Grind.Order.lt_eq_true_of_lt_k",
"Lean.Grind.Com... | false |
IsSolvable | Mathlib.GroupTheory.Solvable | [
"Group",
"IsSolvable.mk"
] | true |
AddSubgroup.relIndex_eq_two_iff | Mathlib.GroupTheory.Index | [
"Iff.of_eq",
"congrArg",
"AddSubgroup.index",
"AddMonoid.toAddZeroClass",
"Xor",
"AddSubgroup.toAddGroup",
"Membership.mem",
"Exists",
"Subtype.exists",
"AddZeroClass.toAddZero",
"Subtype.forall",
"Subtype",
"instOfNatNat",
"exists_prop",
"Subtype.mk",
"AddSubgroup",
"iff_self",
"f... | true |
ZMod.valMinAbs_natCast_eq_self._simp_1 | Mathlib.Data.ZMod.ValMinAbs | [
"Nat.instMulZeroClass",
"instHDiv",
"ZMod.commRing",
"ZMod.valMinAbs",
"AddGroupWithOne.toAddMonoidWithOne",
"HDiv.hDiv",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Int",
"LE.le",
"instLENat",
"Nat.cast",
"ZMod",
"Nat",
"Nat.instDiv",
"propext",
"ZMod.valMinAbs_natCast_eq_self",
... | false |
OpenSubgroup.instPartialOrder.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | [
"PartialOrder.ofSetLike",
"OpenSubgroup",
"OpenSubgroup.instPartialOrder",
"Group",
"OpenSubgroup.instSetLike",
"PartialOrder",
"TopologicalSpace",
"Eq.refl",
"Eq"
] | true |
AddOpposite.instNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Opposite | [
"HMul.hMul",
"AddOpposite",
"Distrib.toAdd",
"instHAdd",
"Distrib.right_distrib",
"Distrib.toMul",
"HAdd.hAdd",
"NonUnitalNonAssocSemiring.toDistrib",
"AddOpposite.instDistrib",
"NonUnitalNonAssocSemiring",
"Eq",
"instHMul"
] | false |
ModuleCon.instAddCommMagmaQuotient | Mathlib.Algebra.Module.Congruence.Defs | [
"SMul",
"ModuleCon.instAddCommMagmaQuotient._proof_1",
"AddCommMagma",
"AddCommMagma.mk",
"ModuleCon.instAddQuotient",
"ModuleCon",
"AddCommMagma.toAdd",
"ModuleCon.Quotient"
] | true |
_private.Lean.Server.CodeActions.Attr.0.Lean.CodeAction.mkHoleCodeAction.unsafe_impl_2 | Lean.Server.CodeActions.Attr | [
"Lean.Server.RequestContext",
"Classical.ofNonempty",
"Lean.Server.Snapshots.Snapshot",
"instNonemptyOfMonad",
"Lean.Server.RequestError",
"String",
"Lean.Server.RequestM",
"instNonemptyForall",
"ReaderT.instMonad",
"EIO",
"instMonadEIO",
"Lean.Elab.TermInfo",
"Id",
"Lean.Elab.ContextInfo"... | true |
List.diff.match_1 | Batteries.Data.List.Basic | [
"List.cons",
"List",
"List.casesOn",
"List.nil"
] | false |
_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.SymExtension.mk.inj | Lean.Meta.Sym.SymM | [
"_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.SymExtension.mk",
"_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.SymExtension.mk.noConfusion",
"IO",
"And",
"Nat",
"And.intro",
"eq_of_heq",
"HEq",
"Eq",
"Lean.Meta.Sym.SymExtension"
] | true |
UniformSpace.replaceTopology_eq | Mathlib.Topology.UniformSpace.Defs | [
"UniformSpace",
"UniformSpace.replaceTopology",
"uniformity",
"UniformSpace.ext",
"TopologicalSpace",
"Prod",
"UniformSpace.toTopologicalSpace",
"Eq",
"Filter",
"rfl"
] | true |
Equiv.Perm.cycleOf_apply_apply_self | Mathlib.GroupTheory.Perm.Cycle.Factors | [
"Eq.mpr",
"Equiv.instEquivLike",
"HEq.refl",
"DecidableRel",
"Equiv.Perm.cycleOf_apply_apply_pow_self",
"Equiv.Perm.instPowNat",
"Eq.casesOn",
"Equiv.Perm.SameCycle",
"instOfNatNat",
"instHAdd",
"HPow.hPow",
"HAdd.hAdd",
"Equiv.Perm",
"Nat",
"eq_of_heq",
"Eq.ndrec",
"instAddNat",
"... | true |
instContinuousMulULift | Mathlib.Topology.Algebra.Monoid | [
"ULift.topologicalSpace",
"Continuous.comp'",
"HMul.hMul",
"Continuous.snd",
"Continuous.comp",
"ULift",
"continuous_uliftUp",
"continuous_id'",
"instTopologicalSpaceProd",
"Mul",
"ContinuousMul.mk",
"Prod.fst",
"TopologicalSpace",
"ULift.mul",
"ContinuousMul",
"continuous_uliftDown",
... | true |
SetLike.GradeZero.instMonoid._aux_4 | Mathlib.Algebra.GradedMonoid | [
"SetLike",
"Monoid",
"MulOne.toOne",
"SubmonoidClass.toMonoid._proof_6",
"Monoid.toMulOneClass",
"AddMonoid.toAddZeroClass",
"Submonoid.toMonoid._proof_1",
"SetLike.GradeZero.submonoid",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"Subtype.mk",
"AddZero.toZero",
"MulOneClass.toM... | false |
WithZero.mapAddHom_injective | Mathlib.Algebra.Group.WithOne.Basic | [
"Eq.mpr",
"WithZero.coe_inj",
"AddHom",
"Function.Injective.eq_iff",
"_private.Mathlib.Algebra.Group.WithOne.Basic.0.WithZero.mapAddHom_injective.match_1_1",
"AddZeroClass.toAddZero",
"Eq.mp",
"id",
"AddHom.funLike",
"Option.none",
"WithZero.instAddZeroClass",
"WithZero",
"WithZero.coe",
"... | true |
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_15 | Mathlib.Data.Nat.Fib.Zeckendorf | [
"zero_le",
"LE.le",
"LE",
"IsBotZeroClass",
"True",
"eq_true",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Zero"
] | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionActionOfMonoidalFunctorToEndofunctorMopIso | Mathlib.CategoryTheory.Monoidal.Action.End | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalOpposite",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.monoidalCategoryMop",
"CategoryTheory.Iso.refl",
"CategoryTheory.Iso",
"CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionMop",
"CategoryTh... | true |
NormedRing.inverse_add_norm | Mathlib.Analysis.Normed.Ring.Units | [
"NormedCommRing.toNormedRing",
"NormedRing.inverse_one_sub_norm",
"Units.val",
"Eq.mpr",
"NegZeroClass.toNeg",
"MulOne.toOne",
"SeminormedRing.toNorm",
"Real",
"NormedRing.toRing",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"HasSummableGeomSeries",
"Add... | true |
nonempty_subtype | Mathlib.Logic.Nonempty | [
"Exists",
"Subtype",
"Nonempty.intro",
"Subtype.mk",
"Iff",
"Iff.intro",
"Exists.intro",
"Nonempty",
"_private.Mathlib.Logic.Nonempty.0.nonempty_subtype.match_1_3",
"_private.Mathlib.Logic.Nonempty.0.nonempty_subtype.match_1_1"
] | true |
CategoryTheory.Over.pullback.congr_simp | Mathlib.CategoryTheory.Comma.Over.Pullback | [
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Over.pullback",
"CategoryTheory.Limits.HasPullbacksAlong",
"Eq.rec",
"CategoryTheory.instCategoryOver",
"Eq.ndrec",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"E... | true |
SSet.stdSimplex.instFunLikeObjOppositeSimplexCategoryMkOpFinHAddNatOfNat | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | [
"Opposite",
"Equiv.instEquivLike",
"DFunLike.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Equiv",
"instOfNatNat",
"SSet",
"SSet.stdSimplex",
"instHAdd",
"OrderHom.instFunLike",
"Fin.instPartialOrder",
"HAdd.hA... | true |
NumberField.nrRealPlaces_eq_zero_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | [
"NumberField.InfinitePlace.not_isReal_iff_isComplex._simp_1",
"congrArg",
"NumberField.IsTotallyComplex",
"NumberField.InfinitePlace.IsComplex",
"Classical.propDecidable",
"Subtype.fintype",
"_private.Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex.0.NumberField.nrRealPlaces_eq_zero_if... | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_2 | Init.Data.List.Sort.Impl | [
"Eq.mpr",
"False",
"_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_def",
"congrArg",
"List.reverseAux",
"_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go",
"id",
"instDecidableEqBool",
"List.cons",
"Bool.true",
"List",
"Bool",
"Eq.refl",
"_p... | true |
HasCompactMulSupport.comp_homeomorph | Mathlib.Topology.Algebra.Support | [
"One",
"HasCompactMulSupport.comp_isClosedEmbedding",
"HasCompactMulSupport",
"Function.comp",
"TopologicalSpace",
"Homeomorph.instEquivLike",
"Homeomorph",
"Homeomorph.isClosedEmbedding",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.