name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Std.TreeMap.Raw.mem_ofList._simp_1 | Std.Data.TreeMap.Raw.Lemmas | [
"List.map",
"List.contains",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Std.TreeMap.Raw.ofList",
"Std.TransCmp",
"Prod.fst",
"Std.TreeMap.Raw",
"Bool.true",
"List",
"Std.LawfulBEqCmp",
"propext",
"Bool",
"Prod",
"BEq",
"Eq",
"Std.TreeMap.Raw.mem_ofList"
] | false |
List.maxOn_mem | Init.Data.List.MinMaxOn | [
"Membership.mem",
"inferInstance",
"Ne",
"LE",
"List",
"DecidableLE",
"List.instMembership",
"List.maxOn",
"Std.OppositeOrderInstances.instDecidableLEOpposite",
"List.minOn_mem",
"LE.opposite",
"List.nil"
] | true |
AddSubmonoid.mem_comap | Mathlib.Algebra.Group.Submonoid.Operations | [
"Iff.rfl",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid.comap",
"AddMonoidHomClass",
"AddSubmonoid",
"AddZeroClass",
"Iff",
"AddSubmonoid.instSetLike",
"DFunLike.coe",
"SetLike.instMembership",
"FunLike"
] | true |
CategoryTheory.Functor.instAdditiveTypeSigmaConst | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Functor.category",
"CategoryTheory.functorCategoryPreadditive",
"CategoryTheory.Limits.Si... | true |
_private.Mathlib.Data.Nat.Sqrt.0.Nat.sqrt_isSqrt._simp_1_5 | Mathlib.Data.Nat.Sqrt | [
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.add_assoc",
"instAddNat",
"Eq.symm",
"Eq"
] | false |
Mathlib.Tactic.Algebra.BaseType.mk.inj | Mathlib.Tactic.Algebra.Basic | [
"Lean.Expr.const",
"Mathlib.Tactic.Algebra.BaseType.mk",
"Mathlib.Tactic.Ring.ExSum",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"heq_of_eq",
"Qq.Quoted",
"Mathlib.Tactic.Algebra.BaseType",
"Lean.Expr.lam",
"Qq.Quoted.unsafeMk",
"Mathlib.Tactic.Algebra.BaseType.mk.noConfusion",
"eq_of_heq"... | true |
hasSum_of_subseq_of_summable | Mathlib.Analysis.Normed.Group.InfiniteSum | [
"Norm.norm",
"Real",
"SeminormedAddCommGroup",
"cauchySeq_finset_of_summable_norm",
"AddCommGroup.toAddCommMonoid",
"Finset",
"Filter.NeBot",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"nhds",
"tendsto_nhds_of_cauchySeq_of_subseq",
"Finset.partialOrder",
"Filter.atTop",
... | true |
IsSimpleAddGroup.toNontrivial | Mathlib.GroupTheory.Subgroup.Simple | [
"Nontrivial",
"AddGroup",
"IsSimpleAddGroup"
] | true |
Batteries.Tactic.«tacticPick_goal-_» | Batteries.Tactic.PermuteGoals | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.const",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1"
] | true |
Std.DTreeMap.Internal.Impl.getEntryLE?.go._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | [
"Ord",
"Std.DTreeMap.Internal.Impl.contains.match_3",
"Option.some",
"Ordering",
"Ord.compare",
"Std.DTreeMap.Internal.Impl.getEntryLE?.go._unsafe_rec",
"Unit",
"Nat",
"Std.DTreeMap.Internal.Impl.entryAtIdx?.match_1",
"Sigma.mk",
"Std.DTreeMap.Internal.Impl",
"Sigma",
"Option"
] | false |
EStateM.run'_modify | Batteries.Lean.EStateM | [
"modify",
"Option.some",
"EStateM.run'",
"EStateM.instMonadStateOf",
"PUnit",
"instMonadStateOfMonadStateOf",
"EStateM",
"PUnit.unit",
"Eq",
"rfl",
"Option"
] | true |
List.dedup.eq_1 | Mathlib.Data.List.Dedup | [
"instDecidableNot",
"List.dedup",
"Ne",
"List",
"Eq.refl",
"List.pwFilter",
"Eq",
"DecidableEq"
] | true |
groupHomology.chainsIso₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | [
"Rep.V",
"CommRing",
"Finsupp.module",
"Nat.instOne",
"ModuleCat",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Rep.hV2",
"LinearEquiv.toModuleIso",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Group",
"Rep.hV1",
"Finsupp.domLCongr",
... | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.lift._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"Preorder.toLT",
"Opposite",
"CategoryTheory.Limits.IsColimit.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"LinearOrder",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"CategoryTheory.Fun... | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.exists_lt_eVariationOn_inter_Icc._simp_1_7 | Mathlib.Topology.EMetricSpace.BoundedVariation | [
"Preorder.toLE",
"Membership.mem",
"LE.le",
"And",
"Set.Icc",
"propext",
"Set.mem_Icc",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
Mathlib.Tactic.Order.AtomicFact.isTop.noConfusion | Mathlib.Tactic.Order.CollectFacts | [
"id",
"Mathlib.Tactic.Order.AtomicFact.noConfusion",
"Mathlib.Tactic.Order.AtomicFact.isTop",
"Nat",
"Mathlib.Tactic.Order.AtomicFact",
"Eq"
] | false |
Ordinal.univ_umax | Mathlib.SetTheory.Ordinal.Univ | [
"Preorder.toLT",
"Ordinal.partialOrder",
"PartialOrder.toPreorder",
"Ordinal.univ",
"Ordinal.lift",
"Ordinal.type",
"Ordinal.univ._proof_1",
"LT.lt",
"congr_fun",
"Eq",
"Ordinal.lift_umax",
"Ordinal"
] | true |
AddCommGroup.DirectLimit.hom_ext_iff | Mathlib.Algebra.Colimit.Module | [
"AddCommGroup.DirectLimit",
"HEq.refl",
"AddMonoid.toAddZeroClass",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"Eq.casesOn",
"LE.le",
"AddCommMonoid",
"Iff",
"Iff.intro",
"AddCommGroup.DirectLimit.hom_ext",
"Eq.ndrec",
"Eq.refl",
"HEq",
"AddCommMonoid.toAddMonoid",
"AddCommGroup.Direct... | true |
MeasureTheory.IsStoppingTime.measurableSpace | Mathlib.Probability.Process.Stopping | [
"MeasureTheory.IsStoppingTime",
"MeasurableSet",
"MeasureTheory.Filtration.seq",
"WithTop.instPreorder",
"MeasureTheory.IsStoppingTime.measurableSpace._proof_3",
"setOf",
"Preorder.toLE",
"MeasureTheory.Filtration",
"MeasureTheory.IsStoppingTime.measurableSpace._proof_2",
"LE.le",
"Set.instInter... | true |
Lean.Compiler.LCNF.SimpleGroundExpr.array.injEq | Lean.Compiler.LCNF.SimpleGroundExpr | [
"Eq.propIntro",
"Array",
"Lean.Compiler.LCNF.SimpleGroundExpr",
"Eq.ndrec",
"Eq.refl",
"Lean.Compiler.LCNF.SimpleGroundExpr.array.inj",
"Lean.Compiler.LCNF.SimpleGroundExpr.array",
"Eq",
"Lean.Compiler.LCNF.SimpleGroundArg"
] | true |
LinearIndependent.group_smul_iff | Mathlib.LinearAlgebra.LinearIndependent.Basic | [
"Eq.mpr",
"instHSMul",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"DistribMulAction.toDistribSMul",
"HEq.refl",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"AddZeroClass.toAddZero",
"Eq.casesOn",
"DistribSMul.toSMulZ... | true |
dvd_gcd_mul_iff_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | [
"CommMonoidWithZero.toCommMonoid",
"Dvd.dvd",
"HMul.hMul",
"GCDMonoid",
"CommMonoid.toCommSemigroup",
"MulZeroClass.toMul",
"semigroupDvd",
"SemigroupWithZero.toSemigroup",
"mul_dvd_mul",
"CommMonoidWithZero.toMonoidWithZero",
"GCDMonoid.gcd",
"MonoidWithZero.toSemigroupWithZero",
"Iff",
"... | true |
Mathlib.Tactic.ITauto.AndKind.eq | Mathlib.Tactic.ITauto | [
"Mathlib.Tactic.ITauto.AndKind",
"Mathlib.Tactic.ITauto.AndKind.eq"
] | true |
Aesop.checkGoalLimit | Aesop.Search.Main | [
"Pure.pure",
"Aesop.Tree",
"Aesop.BaseM",
"Lean.MessageData",
"bne",
"Aesop.getTree",
"String",
"Aesop.SearchM.instMonad",
"Lean.MessageData.instAppend",
"Option.some",
"MonadReader.read",
"GE.ge",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Bool.and",
"instDecidableEqBool",
"instToFormatOfT... | true |
groupHomology.eq_d₃₂_comp_inv_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | [
"groupHomology.d₃₂",
"CategoryTheory.Category.assoc",
"Rep.V",
"CommRing",
"groupHomology.eq_d₃₂_comp_inv",
"Finsupp.module",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Rep.hV2"... | true |
Set.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | [
"Monoid",
"Eq.mpr",
"MulOne.toOne",
"instHSMul",
"Monoid.toMulOneClass",
"congrArg",
"Set.image_id'",
"Membership.mem",
"id",
"one_smul",
"MulOneClass.toMulOne",
"MulAction",
"True",
"Set.image_congr",
"eq_self",
"Monoid.toSemigroup",
"of_eq_true",
"One.toOfNat1",
"Set.image",
... | false |
Lean.Lsp.TextDocumentContentChangeEvent.casesOn | Lean.Data.Lsp.TextSync | [
"String",
"Lean.Lsp.TextDocumentContentChangeEvent.fullChange",
"Lean.Lsp.TextDocumentContentChangeEvent",
"Lean.Lsp.TextDocumentContentChangeEvent.rangeChange",
"Lean.Lsp.Range",
"Lean.Lsp.TextDocumentContentChangeEvent.rec"
] | false |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.Functor.FullyFaithful.isMonHom_preimage._simp_4 | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.monObjObj",
"CategoryTheory.Functor.map",
"CategoryTheory.Functor.obj.μ_def",
"CategoryTheory.Functor.LaxMonoidal.μ",
"CategoryTheory.MonoidalCategoryStruct.te... | false |
FGAlgCat.equivUnder._proof_9 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | [
"CategoryTheory.MorphismProperty.Under",
"CategoryTheory.MorphismProperty",
"CommRing",
"CategoryTheory.Comma.right",
"CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra",
"CommRingCat",
"RingHom.FiniteType",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.id",
"CommRingCat.instCatego... | false |
Ordnode.instSingleton | Mathlib.Data.Ordmap.Ordnode | [
"Ordnode",
"Singleton",
"Ordnode.singleton",
"Singleton.mk"
] | true |
Std.ExtHashMap.getThenInsertIfNew?_snd | Std.Data.ExtHashMap.Lemmas | [
"_private.Std.Data.ExtHashMap.Lemmas.0.Std.ExtHashMap.ext",
"Std.ExtHashMap.inner",
"LawfulHashable",
"Std.ExtHashMap",
"Std.ExtDHashMap.Const.getThenInsertIfNew?_snd",
"EquivBEq",
"Std.ExtHashMap.getThenInsertIfNew?",
"Std.ExtHashMap.insertIfNew",
"Hashable",
"BEq",
"Eq",
"Prod.snd",
"Optio... | true |
MDifferentiable.div | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"chartedSpaceSelf",
"DivInvOneMonoid.toInvOneClass",
"NormedSpace",
"Monoid.toMulOneClass",
"congrArg",
"Pi.instDiv",
"NormedDivisionRing.toNormedRing",
"PseudoMetricSpace.toUniformSpace",
"DivisionS... | true |
Lean.Elab.PreDefinition.ref | Lean.Elab.PreDefinition.Basic | [
"Lean.Syntax",
"Lean.Elab.PreDefinition"
] | true |
SimpleGraph.IsAcyclic.isPath_iff_isChain | Mathlib.Combinatorics.SimpleGraph.Acyclic | [
"List.head?",
"Iff.mpr",
"SimpleGraph.Walk.IsPath.eq_snd_of_mem_edges",
"Eq.mpr",
"SimpleGraph.Walk.nil_iff_support_eq",
"SimpleGraph.Walk.snd_takeUntil",
"False",
"Sym2.Rel",
"SimpleGraph.Walk.edges_nodup_of_support_nodup",
"Sym2.eq._simp_1",
"eq_false",
"SimpleGraph.Adj.ne",
"Sym2.mk",
"... | true |
Set.smulCommClass_set'' | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | [
"SMul",
"Set.smul",
"SMulCommClass.symm",
"Set.smulCommClass_set'",
"Set.smulSet",
"SMulCommClass",
"Set"
] | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_6 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | [
"Finset.mem_singleton",
"MulOne.toOne",
"False",
"HMul.hMul",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"Classical.byContradiction",
"Finset.prod_insert'",
"Classical.propDecidable",
"Membership.mem",
"Eq.mp",
"id",
"MulO... | false |
_private.Mathlib.Topology.Compactness.Compact.0.isCompact_iff_ultrafilter_le_nhds'._simp_1_1 | Mathlib.Topology.Compactness.Compact | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"nhds",
"LE.le",
"isCompact_iff_ultrafilter_le_nhds",
"TopologicalSpace",
"And",
"propext",
"Filter.principal",
"Ultrafilter",
"Eq",
"Set.instMembership",
"Filter",
"Ultrafilter.toFilter",
"IsCompact",
"Filter.... | false |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.not_isNilpotent_one.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | [
"MulOne.toOne",
"MulZeroOneClass.toMulOneClass",
"Monoid.toPow",
"MulOneClass.toMulOne",
"MonoidWithZero",
"Exists.casesOn",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"Exists.intro",
"One.toOfNat1",
"Zero.toOfNat0",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat... | false |
Algebra.TensorProduct.piRightHom_mul | Mathlib.RingTheory.TensorProduct.Pi | [
"add_mul",
"Distrib.leftDistribClass",
"Algebra.to_smulCommClass",
"Pi.addCommMonoid",
"HMul.hMul",
"IsScalarTower.right",
"SemilinearMapClass.distribMulActionSemiHomClass",
"congrArg",
"CommSemiring.toSemiring",
"IsScalarTower",
"TensorProduct.addCommMonoid",
"Pi.mulZeroClass",
"MulZeroClas... | true |
IsLocalRing.isRegular_of_perm | Mathlib.RingTheory.Regular.RegularSequence | [
"Set.ext",
"Ideal.subset_span",
"Submodule",
"False",
"CommRing",
"instHSMul",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"setOf",
"Function.comp",
"Membership.mem",
"AddCommGroup",
"List.Perm",
"Ne",
"Submodule.instTop",
"RingTheory... | true |
_private.Mathlib.Topology.Maps.Basic.0.Topology.isQuotientMap_iff_isClosed._simp_1_4 | Mathlib.Topology.Maps.Basic | [
"iff_comm",
"Iff",
"propext",
"Eq"
] | false |
CategoryTheory.Limits.IsInitial.orderBot | Mathlib.CategoryTheory.Limits.Preorder | [
"Preorder.toLE",
"OrderBot",
"Preorder.smallCategory",
"CategoryTheory.Limits.IsInitial",
"CategoryTheory.Limits.IsInitial.orderBot._proof_1",
"OrderBot.mk",
"Bot.mk",
"Preorder"
] | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew?.eq_1 | Std.Data.DHashMap.Internal.Model | [
"Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew?",
"Std.DHashMap.Internal.mkIdx",
"Array.instGetElemUSizeLtNatToNatSize",
"Std.DHashMap.Raw",
"Option.some",
"Subtype",
"Prod.mk",
"instOfNatNat",
"Std.DHashMap.Internal.Raw₀.expandIfNecessary",
"_private.Std.Data.DHashMap.Internal.Defs.0.Std.DH... | true |
EReal.neTopBotEquivReal | Mathlib.Data.EReal.Basic | [
"EReal.neTopBotEquivReal._proof_2",
"Real",
"Compl.compl",
"EReal",
"Membership.mem",
"Equiv.mk",
"Set.Elem",
"Set.instSingletonSet",
"instTopEReal",
"Equiv",
"Insert.insert",
"EReal.neTopBotEquivReal._proof_7",
"Bot.bot",
"EReal.neTopBotEquivReal._proof_3",
"Set.instCompl",
"Subtype.m... | true |
Nat.factorization_factorial_eq_zero_of_lt | Mathlib.Data.Nat.Choose.Factorization | [
"Finsupp.instFunLike",
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.recAux",
"HMul.hMul",
"congrArg",
"Nat.factorial_succ",
"Nat.factorization_mul",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"id",
"instMulNat",
"instOfNatNat",
"Pi.add_apply",
"AddZero.toZero"... | true |
Function.Injective.addSemigroup._proof_1 | Mathlib.Algebra.Group.InjSurj | [
"Eq.mpr",
"congrArg",
"add_assoc",
"id",
"AddSemigroup",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Eq.refl",
"Eq",
"Add"
] | false |
inv_le_of_inv_le' | Mathlib.Algebra.Order.Group.OrderIso | [
"inv_le'",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"MulLeftMono",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"MulRightMono",
"LE.le",
"LE",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Inv.inv",
"... | true |
AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_hom | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | [
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CommRingCat",
"TopCat.instCategory",
"TopCat.Presheaf.stalkSpecializes",
"ContinuousMap",
"AlgebraicGeometry.LocallyRingedSpace.instQuiver",
"C... | true |
AlgebraicGeometry.Scheme.instEpiTopCatPullbackComparisonForgetToTop | Mathlib.AlgebraicGeometry.PullbackCarrier | [
"CategoryTheory.Limits.hasFiniteLimits_of_hasLimits",
"Eq.mpr",
"CategoryTheory.Limits.pullback",
"CategoryTheory.instFaithfulForget",
"AlgebraicGeometry.Scheme",
"CategoryTheory.epi_iff_surjective",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limi... | true |
Left.mul_lt_one_of_lt_of_le | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | [
"MulOne.toOne",
"Preorder.toLT",
"HMul.hMul",
"mul_lt_of_lt_of_le_one",
"Preorder.toLE",
"MulLeftMono",
"MulOne.toMul",
"LE.le",
"MulOneClass.toMulOne",
"LT.lt",
"One.toOfNat1",
"MulOneClass",
"OfNat.ofNat",
"Preorder",
"instHMul"
] | true |
Option.map_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | [
"Option.some",
"Exists",
"Option.map",
"And",
"propext",
"Eq",
"Option.map_eq_some_iff",
"Option"
] | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | [
"_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure",
"Nat"
] | false |
CategoryTheory.Lax.StrongTrans.mkOfLax'._proof_4 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | [
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryTheory.Lax.LaxTrans.naturality",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Bicategory.whiskerRight",
"CategoryTheory.Bicategory.toCategoryStruct",
... | false |
Lean.instDecidableEqLocalDeclKind._proof_2 | Lean.LocalContext | [
"False",
"Lean.LocalDeclKind",
"Lean.LocalDeclKind.ctorIdx",
"absurd",
"Nat",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Not"
] | false |
Lean.Meta.Grind.CasesTypes.eraseDecl | Lean.Meta.Tactic.Grind.Cases | [
"Pure.pure",
"IO.RealWorld",
"EIO",
"instDecidableEqBool",
"instMonadEIO",
"Applicative.toPure",
"Bool.true",
"Lean.Meta.Grind.CasesTypes",
"Lean.Meta.Grind.CasesTypes.contains",
"Lean.Core.State",
"Lean.Core.CoreM",
"StateRefT'",
"StateRefT'.instMonad",
"Bool",
"Lean.Name",
"Lean.Meta... | true |
PrimeSpectrum.isIdempotentElemEquivClopens_symm_top | Mathlib.RingTheory.Spectrum.Prime.Topology | [
"CommRing",
"TopologicalSpace.Clopens.instMin",
"CommRing.toNonUnitalCommRing",
"instOrderTopSubtypeIsIdempotentElem",
"CommSemiring.toSemiring",
"IsIdempotentElem.one",
"TopologicalSpace.Clopens.instBooleanAlgebra",
"instBooleanAlgebraSubtypeIsIdempotentElem",
"PartialOrder.toPreorder",
"AddGroup... | true |
Polynomial.integralNormalization_mul_C_leadingCoeff | Mathlib.RingTheory.Polynomial.IntegralNormalization | [
"Polynomial.integralNormalization",
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Polynomial.coe_lt_degree",
"MulOne.toOne",
"Nat.instOrderedSub",
"Semigroup.toMul",
"WithBot",
"Preorder.toLT",
"Nat.instIsOrdere... | true |
ExceptCpsT.run_throw | Init.Control.ExceptCps | [
"Pure.pure",
"instMonadExceptOfMonadExceptOf",
"Monad.toApplicative",
"MonadExcept.throw",
"Except.error",
"ExceptCpsT.run",
"ExceptCpsT.instMonadExceptOf",
"Applicative.toPure",
"ExceptCpsT",
"Except",
"Monad",
"Eq",
"rfl"
] | true |
_private.Mathlib.CategoryTheory.Join.Pseudofunctor.0.CategoryTheory.Join.id.match_1.eq_2 | Mathlib.CategoryTheory.Join.Pseudofunctor | [
"CategoryTheory.Join.id.match_1",
"CategoryTheory.Join.left",
"CategoryTheory.Join.right",
"CategoryTheory.Join",
"Eq.refl",
"Eq",
"CategoryTheory.Category"
] | true |
ContDiffAt.prodMap | Mathlib.Analysis.Calculus.ContDiff.Operations | [
"Set.instSProd",
"ContDiffAt",
"Eq.mpr",
"Prod.normedSpace",
"Prod.normedAddCommGroup",
"NormedSpace",
"SProd.sprod",
"congrArg",
"Set.univ",
"ContDiffWithinAt.prodMap",
"Eq.mp",
"id",
"Prod.mk",
"Prod.map",
"Set.univ_prod_univ",
"ENat",
"NontriviallyNormedField",
"NontriviallyNorm... | true |
Lean.Parser.Term.forall._regBuiltin.Lean.Parser.Term.forall.declRange_3 | Lean.Parser.Term | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
Lean.Meta.Grind.Result.failure? | Lean.Meta.Tactic.Grind.Main | [
"Lean.Meta.Grind.Goal",
"Lean.Meta.Grind.Result",
"Option"
] | true |
Lean.Linter.UnusedVariables.FVarDefinition.noConfusionType | Lean.Linter.UnusedVariables | [
"Lean.Syntax",
"Lean.FVarId",
"Lean.Linter.UnusedVariables.FVarDefinition.casesOn",
"Array",
"Lean.Name",
"Lean.Options",
"Eq",
"Lean.Linter.UnusedVariables.FVarDefinition"
] | false |
Sym2.congr_left | Mathlib.Data.Sym.Sym2 | [
"Sym2.Rel",
"Sym2.eq._simp_1",
"and_true",
"Sym2.mk",
"congrArg",
"Prod.mk",
"Sym2.rel_iff'._simp_1",
"And",
"Iff",
"Prod.mk.injEq",
"congr",
"or_iff_left_iff_imp._simp_1",
"True",
"eq_self",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Or",
"implies_true",
"Prod.swap",
"Prod",
"... | true |
UInt32.toUInt16_shiftLeft_mod | Init.Data.UInt.Bitwise | [
"Eq.mpr",
"instModUInt16",
"UInt32.toBitVec",
"Dvd.dvd",
"instModUInt32",
"of_decide_eq_true",
"congrArg",
"UInt32.toUInt16_mod_of_dvd",
"HShiftLeft.hShiftLeft",
"instShiftLeftUInt16",
"UInt32.toUInt16_ofNat",
"id",
"instHMod",
"instOfNatNat",
"BitVec.toNat",
"UInt32.toUInt16",
"Nat.... | true |
_private.Mathlib.AlgebraicGeometry.ValuativeCriterion.0.AlgebraicGeometry.ValuativeCriterion.Existence.of_specializingMap._simp_1_3 | Mathlib.AlgebraicGeometry.ValuativeCriterion | [
"CategoryTheory.Limits.pullback",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.pullback.snd",
"CategoryTheory.Limits.HasPullback",
"CategoryTheory.Limits.pullback.fst",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory... | false |
ContDiffMapSupportedIn.integralAgainstBilinCLM_eq_integral | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContinuousLinearMap.topologicalSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.... | true |
Filter.le_smul_iff._simp_2 | Mathlib.Order.Filter.Pointwise | [
"Filter.instMembership",
"instHSMul",
"Filter.le_smul_iff",
"SMul",
"PartialOrder.toPreorder",
"Set.smul",
"Preorder.toLE",
"Membership.mem",
"LE.le",
"Filter.instSMul",
"propext",
"HSMul.hSMul",
"Eq",
"Filter",
"Filter.instPartialOrder",
"Set"
] | false |
Asymptotics.isBigO_const_mul_right_iff' | Mathlib.Analysis.Asymptotics.Defs | [
"SeminormedRing.toNorm",
"HMul.hMul",
"Asymptotics.IsBigO",
"IsUnit",
"SeminormedRing.toRing",
"Norm",
"instDistribOfSemiring",
"Iff",
"Distrib.toMul",
"Iff.intro",
"Semiring.toMonoid",
"Asymptotics.IsBigO.const_mul_right'",
"Ring.toSemiring",
"Asymptotics.IsBigO.of_const_mul_right",
"Se... | true |
Asymptotics.transIsLittleOEventuallyEq | Mathlib.Analysis.Asymptotics.Defs | [
"Norm",
"Filter.EventuallyEq",
"Asymptotics.IsLittleO.trans_eventuallyEq",
"Trans",
"Asymptotics.IsLittleO",
"Trans.mk",
"Filter"
] | true |
Algebra.TensorProduct.basisAux._proof_1 | Mathlib.RingTheory.TensorProduct.Free | [
"CommSemiring.toSemiring",
"RingHomCompTriple",
"CommSemiring",
"RingHom.id",
"RingHomCompTriple.ids",
"Semiring.toNonAssocSemiring"
] | false |
CategoryTheory.Limits.pointwiseBinaryBicone | Mathlib.CategoryTheory.Limits.FunctorCategory.BinaryBiproducts | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.biprod.map",
"CategoryTheory.Functor.mk",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.pointwiseBinaryBicone._proof_8",
"CategoryTheory.Limi... | true |
CategoryTheory.LocallySmall.mk._flat_ctor | Mathlib.CategoryTheory.EssentiallySmall | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.LocallySmall",
"CategoryTheory.LocallySmall.hom_small._autoParam",
"autoParam",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.LocallySmall.mk",
"Small",
"CategoryTheory.Category"
] | false |
gal_prod_isSolvable | Mathlib.FieldTheory.AbelRuffini | [
"Eq.mpr",
"IsSolvable",
"HMul.hMul",
"Monoid.toMulOneClass",
"Polynomial.Gal",
"congrArg",
"Multiset.instInsert",
"Multiset.prod_cons",
"Multiset.instHasSubset",
"Multiset.prod",
"Membership.mem",
"Multiset",
"Multiset.cons",
"id",
"MulOne.toMul",
"Insert.insert",
"Polynomial.instGro... | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.norm_le_norm_add_norm_inv_mul._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | [
"DivInvMonoid.toInv",
"zpow_neg_one",
"DivInvMonoid.toZPow",
"Int.instNegInt",
"Int",
"DivInvMonoid",
"Inv.inv",
"HPow.hPow",
"instOfNat",
"instHPow",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Neg.neg"
] | false |
Turing.TM1to1.writes.eq_def | Mathlib.Computability.TuringMachine.PostTuringMachine | [
"Eq.mpr",
"_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.SupportsStmt.match_1.splitter",
"Finset.univ",
"Finset.instUnion",
"Turing.TM1.Stmt.move",
"congrArg",
"Finset",
"Turing.TM1.Stmt.brecOn.eq",
"Classical.propDecidable",
"id",
"Turing.TM1to1.writes",
"Turing.... | true |
AffineEquiv.val_equivUnitsAffineMap_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | [
"Units.val",
"MulEquiv.instEquivLike",
"Monoid.toMulOneClass",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"Units",
"AddCommGroup",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"AffineMap",
"Group.toDivInvMonoid",
"AffineMap.instMonoid",
"MulOneClass.toMulOne",
"AffineEquiv.equi... | true |
Lean.Grind.Fin.instCommRingFinOfNeZeroNat._proof_8 | Init.GrindInstances.Ring.Fin | [
"Lean.Grind.Fin.intCast_neg",
"Int.cast",
"instHSMul",
"HMul.hMul",
"congrArg",
"Fin.neg",
"Zero.ofOfNat0",
"Lean.Grind.Fin.neg_mul",
"id",
"Int.instNegInt",
"SMul.mk",
"instOfNatNat",
"Int",
"Fin.IntCast.instIntCast",
"Fin.instMul",
"Nat",
"True",
"eq_self",
"of_eq_true",
"HSM... | false |
cfc_comp_pow | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Eq.mpr",
"spectrum",
"Ring.toNonAssocRing",
"congrArg",
"CommSemiring.toSemiring",
"cfc",
"IsTopologicalSemiring",
"IsTopologicalSemiring.toContinuousMul",
"ContinuousStar",
"PseudoMetricSpace.toUniformSpace",
"Algebra",
"id",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"cfc_comp... | true |
RingCone.instSetLike | Mathlib.Algebra.Order.Ring.Cone | [
"SetLike",
"Submonoid.toSubsemigroup",
"MulOne.toMul",
"NonAssocSemiring.toMulZeroOneClass",
"Subsemiring.toSubmonoid",
"MulZeroOneClass.toMulOneClass",
"SetLike.mk",
"MulOneClass.toMulOne",
"RingCone",
"RingCone.toSubsemiring",
"Subsemigroup.carrier",
"RingCone.instSetLike._proof_1",
"Semir... | true |
FinBddDistLat.hom_comp | Mathlib.Order.Category.FinBddDistLat | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"FinBddDistLat.instBoundedOrderCarrier",
"FinBddDistLat.instDistribLatticeCarrier",
"DistribLattice.toLattice",
"FinBddDistLat",
"BoundedLatticeHom",
"FinBddDistLat.Hom.hom",
"CategoryTheory.CategoryStruct.comp",
"BddDistLat.toDistLat",
"Fi... | true |
AlgebraicGeometry.Proj.basicOpenToSpec.eq_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | [
"SetLike",
"AlgebraicGeometry.Spec",
"CommRing",
"AlgebraicGeometry.Scheme",
"Opposite",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddGroupWithOne.toAddGroup",
"TopologicalSpace.Opens.instPartialOrder",
"CommSemiring.toSemiring",
"Com... | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_2 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | [
"False",
"eq_false",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"three_ne_zero",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
IsEvenlyCovered.comp_homeomorph | Mathlib.Topology.Covering.Basic | [
"Eq.mpr",
"Equiv.instEquivLike",
"Homeomorph.continuous",
"congrArg",
"Homeomorph.toEquiv",
"DiscreteTopology",
"instTopologicalSpaceProd",
"Function.comp",
"Membership.mem",
"Exists",
"Set.Elem",
"id",
"Equiv",
"IsEvenlyCovered",
"Set.preimage_comp",
"Homeomorph.image_symm",
"Prod.f... | true |
Turing.ToPartrec.Code.comp | Mathlib.Computability.TuringMachine.Config | [
"Turing.ToPartrec.Code.comp",
"Turing.ToPartrec.Code"
] | true |
Batteries.Tactic.«command#help_Term+____» | Batteries.Tactic.HelpCmd | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Lean.ParserDescr.parser",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.const",
"OfNat.ofNat",
"Bool.false",
"L... | true |
SSet.Truncated.Edge.CompStruct.noConfusion | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | [
"SSet.Truncated.Edge",
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"SSet.Truncated.Edge.CompStruct._proof_1",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ConcreteCategory.hom",
"SSet.Truncated.Edge._proof_2",
"SSet.Truncated.Edge.edge",
"Quiver.Hom.op",
"HEq.refl"... | false |
Lean.Meta.Grind.ExprWithAnchor.mk.injEq | Lean.Meta.Tactic.Grind.Anchor | [
"Eq.propIntro",
"UInt64",
"Lean.injEq_helper",
"Lean.Expr",
"Lean.Meta.Grind.ExprWithAnchor.mk",
"And",
"Eq.ndrec",
"Lean.Meta.Grind.ExprWithAnchor",
"Eq.refl",
"Lean.Meta.Grind.ExprWithAnchor.mk.inj",
"Eq"
] | true |
String.Slice.Pos.prevAux.go.congr_simp | Init.Data.String.Basic | [
"String.Slice",
"Eq.rec",
"String.Slice.utf8ByteSize",
"String.Pos.Raw",
"String.Slice.Pos.prevAux.go",
"Nat",
"LT.lt",
"Eq.ndrec",
"Eq.refl",
"instLTNat",
"Eq"
] | true |
intervalIntegral.norm_integral_le_abs_of_norm_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | [
"MeasureTheory.ae",
"Norm.norm",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"le_abs_self",
"Real.lattice",
"NormedSpace",
"Real.instRCLike",
"abs",
"congrArg",
"IntervalIntegrable",
"Filter.Eventually",
"intervalIntegral.abs_intervalInt... | true |
Nat.giCountNth | Mathlib.Data.Nat.Nth | [
"Nat.nth_monotone",
"Nat.le_nth_count",
"setOf",
"Nat.count_monotone",
"Nat.instPreorder",
"DecidablePred",
"Nat",
"Nat.count",
"Nat.count_nth_of_infinite",
"GaloisInsertion",
"Nat.nth",
"GaloisInsertion.monotoneIntro",
"Set.Infinite"
] | true |
UniformContinuousOn.eq_1 | Mathlib.Topology.UniformSpace.Defs | [
"Set.instSProd",
"UniformSpace",
"SProd.sprod",
"uniformity",
"Prod.mk",
"Filter.instInf",
"Prod.fst",
"Filter.Tendsto",
"Filter.principal",
"Eq.refl",
"UniformContinuousOn",
"Prod",
"Eq",
"Prod.snd",
"Filter",
"Min.min",
"Set"
] | true |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.toArray_mkSlice_rci._simp_1_1 | Init.Data.Slice.List.Lemmas | [
"Std.Slice.toList",
"Std.Iterators.Types.Take.instIterator",
"Std.Slice.Internal.ListSliceData",
"ListSlice.instToIterator",
"Std.Iterators.Types.ListIterator",
"Std.Slice.toArray",
"Monad.toApplicative",
"Std.Iterators.Types.Take",
"Id",
"Applicative.toPure",
"List.toArray",
"Array",
"Std.I... | false |
TypeVec.const | Mathlib.Data.TypeVec | [
"Fin2.brecOn",
"Nat",
"TypeVec.const._f",
"TypeVec.repeat",
"TypeVec.Arrow",
"Fin2",
"TypeVec"
] | true |
_private.Lean.Compiler.LCNF.Toposort.0.Lean.Compiler.LCNF.toposort.visitConsts._sparseCasesOn_4 | Lean.Compiler.LCNF.Toposort | [
"Lean.Compiler.LCNF.Arg",
"Lean.Compiler.LCNF.Code.setTag",
"Nat.ne_of_beq_eq_false",
"Lean.Compiler.LCNF.Code.unreach",
"Lean.Compiler.LCNF.Code.fun",
"Lean.Compiler.LCNF.Code.rec",
"Lean.Compiler.LCNF.Code.cases",
"Lean.Compiler.LCNF.Code.oset",
"Lean.Compiler.LCNF.Code.let",
"Nat.shiftRight",
... | false |
IsTopologicalAddGroup.tendstoLocallyUniformlyOn_iff | Mathlib.Topology.Algebra.IsUniformGroup.Basic | [
"Filter.instMembership",
"AddGroup.toSubtractionMonoid",
"UniformSpace",
"Eq.mpr",
"NegZeroClass.toNeg",
"TendstoLocallyUniformlyOn",
"congrArg",
"nhdsWithin",
"Filter.Eventually",
"AddMonoid.toAddZeroClass",
"uniformity",
"setOf",
"sub_eq_add_neg",
"HSub.hSub",
"Function.comp",
"Membe... | true |
_private.Lean.Meta.Tactic.Injection.0.Lean.Meta.injectionIntro.go._unsafe_rec | Lean.Meta.Tactic.Injection | [
"Pure.pure",
"Array.push",
"Lean.Meta.State",
"_private.Lean.Meta.Tactic.Injection.0.Lean.Meta.injectionIntro.go.match_3",
"Lean.MVarId",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.FVarId",
"Applicative.toPure",
"Array",
"List",
"Lean.Core.CoreM",
"Lean.Meta.instMonadMetaM",
"StateRefT'",
... | false |
_private.Init.Omega.Constraint.0.Lean.Omega.instAppendString | Init.Omega.Constraint | [
"Append",
"String",
"Append.mk",
"String.Internal.append"
] | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.app_inv_app'_assoc | Mathlib.Geometry.RingedSpace.OpenImmersion | [
"Iff.mpr",
"CategoryTheory.Category.assoc",
"Opposite",
"ChainCompletePartialOrder.instOfCompleteLattice",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopologicalSpace.Opens.instPartialOrder",
"congrArg",
"CategoryTheory.ConcreteCategory.ho... | true |
MeasureTheory.OuterMeasure.isCaratheodory_sum | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | [
"ChainCompletePartialOrder.instOfCompleteLattice",
"Function.onFun",
"ENNReal.instAddCommMonoid",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"MeasureTheory.OuterMeasure.IsCaratheodory",
"Disjoint",
"MeasureTheory.OuterMeasure",
"Nat.brecOn",
"Set.instInter",
"ChainCompletePartialOrder.toPa... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.