name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Analysis.Meromorphic.NormalForm.0.MeromorphicOn.toMeromorphicNFOn_eq_self_on_nhdsNE._simp_1_2 | Mathlib.Analysis.Meromorphic.NormalForm | [
"Compl.compl",
"Membership.mem",
"Set.instCompl",
"propext",
"Eq",
"Set.instMembership",
"Not",
"Set.mem_compl_iff",
"Set"
] | false |
FirstOrder.Language.ElementaryEmbedding.comp_apply | Mathlib.ModelTheory.ElementaryMaps | [
"FirstOrder.Language.ElementaryEmbedding.comp",
"FirstOrder.Language.Structure",
"FirstOrder.Language.ElementaryEmbedding.instFunLike",
"FirstOrder.Language",
"FirstOrder.Language.ElementaryEmbedding",
"Eq",
"DFunLike.coe",
"rfl"
] | true |
sizeOf_default | Init.SizeOf | [
"instSizeOfDefault",
"instOfNatNat",
"Nat",
"SizeOf.sizeOf",
"OfNat.ofNat",
"Eq",
"rfl"
] | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_6 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | [
"Int.cast",
"CommRing",
"Matrix",
"Int.cast_det",
"Int",
"AddGroupWithOne.toIntCast",
"Fintype",
"Int.instCommRing",
"Matrix.map",
"CommRing.toRing",
"Eq.symm",
"Eq",
"Ring.toAddGroupWithOne",
"Matrix.det",
"DecidableEq"
] | false |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.Tendsto.if._simp_1_1 | Mathlib.Order.Filter.Tendsto | [
"Filter.instMembership",
"Filter.tendsto_def",
"Membership.mem",
"Set.preimage",
"Filter.Tendsto",
"propext",
"Eq",
"Filter",
"Set"
] | false |
Lean.Widget.MsgEmbed.brecOn_3.eq | Lean.Widget.InteractiveDiagnostic | [
"Lean.Widget.StrictOrLazy",
"Lean.Widget.MsgEmbed.below_2",
"Lean.Server.WithRpcRef",
"Array.casesOn",
"Lean.Widget.TaggedText",
"Array",
"Lean.Widget.MsgEmbed.below_4",
"Lean.Widget.MsgEmbed.brecOn_3",
"Lean.Widget.MsgEmbed.below_3",
"List",
"Lean.Widget.LazyTraceChildren",
"Lean.Widget.MsgEm... | true |
CategoryTheory.TwoSquare.hComp' | Mathlib.CategoryTheory.GuitartExact.HorizontalComposition | [
"CategoryTheory.Functor",
"CategoryTheory.TwoSquare.hComp",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Iso",
"CategoryTheory.TwoSquare.whiskerHorizontal",
"CategoryTheory.Iso.hom",
"CategoryTheory.Iso.inv",
"CategoryTheory.TwoSquare",
"CategoryTheory.Category... | true |
ProbabilityTheory.Kernel.instIsFiniteKernelWithDensityRnDeriv | Mathlib.Probability.Kernel.RadonNikodym | [
"Eq.mpr",
"ProbabilityTheory.IsFiniteKernel",
"MeasureTheory.Measure",
"Preorder.toLT",
"congrArg",
"Set.univ",
"ProbabilityTheory.IsFiniteKernel.mk",
"PartialOrder.toPreorder",
"ProbabilityTheory.Kernel.rnDeriv_eq_rnDeriv_measure",
"MeasureTheory.Measure.rnDeriv",
"MeasureTheory.Measure.lintegr... | true |
contDiffAt_fun_id | Mathlib.Analysis.Calculus.ContDiff.Basic | [
"ContDiffAt",
"NormedSpace",
"id",
"ENat",
"contDiffAt_id",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"NormedAddCommGroup",
"WithTop"
] | true |
TopCat.GlueData.recOn | Mathlib.Topology.Gluing | [
"TopCat.GlueData.rec",
"CategoryTheory.ConcreteCategory.hom",
"TopCat.instCategory",
"ContinuousMap",
"CategoryTheory.GlueData.f",
"CategoryTheory.GlueData.J",
"Prod.mk",
"TopCat.str",
"CategoryTheory.GlueData",
"TopCat.carrier",
"CategoryTheory.GlueData.V",
"Topology.IsOpenEmbedding",
"TopC... | false |
NonUnitalSubringClass.toNonUnitalNonAssocRing._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Defs | [
"SetLike",
"NonUnitalNonAssocRing",
"instHSMul",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"NonUnitalSubringClass.toNonUnitalSubsemiringClass",
"Subtype.val_injective",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGroup",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"AddCommGroup.to... | false |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanIso_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | [
"Multiset.instInsert",
"Exists",
"Multiset",
"Insert.insert",
"instOfNatNat",
"Multiset.instSingleton",
"Nat",
"Multiset.card_eq_two",
"propext",
"Multiset.card",
"Singleton.singleton",
"OfNat.ofNat",
"Eq"
] | false |
ModuleCat.instModuleCarrierMkOfSMul'._proof_3 | Mathlib.Algebra.Category.ModuleCat.Basic | [
"ModuleCat.instSMulCarrierMkOfSMul'",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"instHSMul",
"RingHomClass.toAddMonoidHomClass",
"ModuleCat.mkOfSMul'",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"congrArg",
"Cate... | false |
GrpTypeEquivalenceGrp.functor | Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp | [
"CategoryTheory.Functor",
"GrpCat",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.typesCartesianMonoidalCategory",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.Grp.instCategory",
"MonCat.Hom.hom",
"CategoryTheory.Grp.grp",
"MonCat",
"CategoryTheory.SemiCartesianMonoidal... | true |
Aesop.RuleTac.ofTacticSyntax | Aesop.RuleTac.Basic | [
"Pure.pure",
"Aesop.BaseM",
"Aesop.Script.TacticBuilder",
"Aesop.Script.LazyStep.mk",
"Lean.NameMap",
"Aesop.RuleTacInput",
"Lean.Meta.SavedState",
"Lean.Elab.Term.LevelMVarErrorInfo",
"Aesop.RuleTacInput.goal",
"Lean.Elab.Term.Context.mk",
"StateRefT'.instAlternativeOfMonad",
"Lean.Elab.Term.... | true |
ZMod.val.eq_2 | Mathlib.Data.ZMod.Basic | [
"instOfNatNat",
"Fin.val",
"ZMod",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"ZMod.val"
] | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState.recOn | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | [
"Lean.Expr.instBEq",
"_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState.mk",
"Std.HashSet",
"Lean.Expr",
"Lean.Meta.Hypothesis",
"Array",
"Lean.Expr.instHashable",
"_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.L... | false |
MeasureTheory.Integrable.aefinStronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp | [
"Iff.mpr",
"MeasureTheory.Measure",
"NeZero.charZero_one",
"ENNReal.instCharZero",
"PseudoMetricSpace.toUniformSpace",
"MeasureTheory.Integrable",
"SeminormedAddGroup.toContinuousENorm",
"MeasureTheory.AEFinStronglyMeasurable",
"NNReal",
"SubtractionMonoid.toSubNegZeroMonoid",
"AddCommMonoidWith... | true |
Subalgebra.map_topologicalClosure_le | Mathlib.Topology.Algebra.Algebra | [
"Subsemiring.instSetLike",
"AlgHom",
"AlgHom.funLike",
"PartialOrder.toPreorder",
"Algebra",
"Preorder.toLE",
"RingHom",
"Subalgebra.toSubsemiring",
"LE.le",
"Subsemiring",
"ContinuousAlgHom.continuous",
"CommSemiring",
"Subalgebra.topologicalClosure",
"Subalgebra.map",
"TopologicalSpace... | true |
Int.gcd_dvd_gcd_mul_right_right | Init.Data.Int.Gcd | [
"Nat.gcd",
"Int.gcd",
"Eq.mpr",
"Dvd.dvd",
"HMul.hMul",
"Int.natAbs_mul",
"congrArg",
"Nat.gcd_dvd_gcd_mul_right_right",
"id",
"instMulNat",
"Int",
"Int.instMul",
"Nat.instDvd",
"Nat",
"Int.natAbs",
"Eq",
"instHMul"
] | true |
Plausible.Shrinkable.mk._flat_ctor | Plausible.Shrinkable | [
"Plausible.Shrinkable.mk",
"List",
"Plausible.Shrinkable"
] | false |
MeasureTheory.JordanDecomposition.instSMul | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | [
"MeasureTheory.JordanDecomposition.posPart",
"instHSMul",
"MeasureTheory.Measure",
"CommSemiring.toSemiring",
"MeasureTheory.JordanDecomposition.instSMul._proof_2",
"SMul",
"NNReal",
"SMul.mk",
"MeasureTheory.JordanDecomposition.negPart",
"ENNReal.instCommSemiring",
"MeasureTheory.JordanDecompos... | true |
Finset.sum_Ioc_by_parts | Mathlib.Algebra.BigOperators.Module | [
"Eq.mpr",
"instHSMul",
"Nat.instOne",
"AddGroupWithOne.toAddGroup",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Finset",
"AddMonoid.toAddZeroClass",
"Nat.succ_lt_succ",
"PartialOrder.toPreorder",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"Nat.instLocallyFin... | true |
CompleteLinearOrder.toCompletelyDistribLattice | Mathlib.Order.CompleteBooleanAlgebra | [
"CompleteLinearOrder.toSDiff",
"CompleteLinearOrder.top_sdiff",
"CompletelyDistribLattice",
"CompleteLinearOrder.himp_bot",
"CompleteLinearOrder.le_himp_iff",
"CompleteLinearOrder",
"CompleteLinearOrder.toHNot",
"CompleteLinearOrder.sdiff_le_iff",
"CompleteLinearOrder.toCompletelyDistribLattice._pro... | true |
_private.Std.Internal.Http.Data.URI.Parser.0.Std.Http.URI.Parser.parseRequestTarget.absoluteFromScheme | Std.Internal.Http.Data.URI.Parser | [
"Pure.pure",
"Std.Internal.Parsec.ByteArray.instInputIteratorUInt8Nat",
"String",
"_private.Std.Internal.Http.Data.URI.Parser.0.Std.Http.URI.Parser.parseHierPart",
"ByteArray.Iterator",
"Option.getD",
"instDecidableEqUInt8",
"Std.Http.URI.Query.empty",
"Char.toUInt8",
"Applicative.toPure",
"Std.... | true |
_private.Init.Data.Array.Lemmas.0.Array.all_eq_true_iff_forall_mem._simp_1_3 | Init.Data.Array.Lemmas | [
"Array.instMembership",
"Membership.mem",
"Array.toList",
"Array",
"List",
"List.instMembership",
"propext",
"Array.mem_def",
"Eq"
] | false |
Lean.Meta.Tactic.TryThis.addSuggestion | Lean.Meta.Tactic.TryThis | [
"Lean.MessageData",
"Lean.logInfoAt",
"String",
"Lean.Meta.Hint.DiffGranularity",
"Lean.MessageData.instAppend",
"Lean.Core.instMonadOptionsCoreM",
"Lean.Syntax",
"Lean.instToMessageDataString",
"List.toArray",
"List.cons",
"Option.none",
"instHAppendOfAppend",
"Lean.Core.instMonadLogCoreM",... | true |
selfAdjointPart._proof_4 | Mathlib.Algebra.Star.Module | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Subtype.mk.congr_simp",
"Semigroup.toMul",
"instHSMul",
"HMul.hMul",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"StarModule.star_smul",
"AddMonoid.toAddZeroClass",
"StarMul",
"Nat.instAtLeastTwoHAddOfNat",
"Invert... | false |
Std.Rcc.eq_succMany?_of_toList_eq_append_cons | Init.Data.Range.Polymorphic.Lemmas | [
"Nat.zero_lt_succ._simp_1",
"Std.Rcc.lower",
"Std.PRange.UpwardEnumerable",
"Std.Rcc.isSome_succMany?_of_lt_length_toList",
"congrArg",
"Std.IsLinearPreorder.toIsPreorder",
"Nat.lt_add_right_iff_pos._simp_1",
"Std.instReflLeOfIsPreorder",
"GetElem.getElem.congr_simp",
"HSub.hSub",
"Std.le_refl._... | true |
LinearMap.BilinForm.Isometry.instSubsingleton | Mathlib.LinearAlgebra.BilinearForm.Isometry | [
"LinearMap.BilinForm",
"CommSemiring.toSemiring",
"AddCommMonoid",
"CommSemiring",
"Subsingleton.intro",
"Subsingleton",
"LinearMap.BilinForm.Isometry.instFunLike",
"LinearMap.BilinForm.Isometry",
"LinearMap.BilinForm.Isometry.ext",
"Module",
"Subsingleton.elim",
"DFunLike.coe"
] | true |
List.modify.eq_1 | Init.Data.List.Impl | [
"List.modify",
"List",
"Nat",
"Eq.refl",
"List.modifyHead",
"List.modifyTailIdx",
"Eq"
] | true |
HeytAlg.mk.noConfusion | Mathlib.Order.Category.HeytAlg | [
"HeytAlg",
"HeytAlg.noConfusion",
"id",
"HeytAlg.mk",
"HEq",
"HeytingAlgebra",
"Eq"
] | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.one_lt_rpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | [
"ENNReal.ofNNReal",
"Preorder.toLT",
"PartialOrder.toPreorder",
"NNReal",
"NNReal.instPartialOrder",
"LT.lt",
"ENNReal",
"propext",
"One.toOfNat1",
"ENNReal.instPartialOrder",
"ENNReal.one_lt_coe_iff",
"ENNReal.instOne",
"OfNat.ofNat",
"Eq",
"NNReal.instOne"
] | false |
Equiv.Perm.IsThreeCycle.inv_iff | Mathlib.GroupTheory.Perm.Cycle.Type | [
"Eq.mpr",
"Equiv.Perm.instInv",
"congrArg",
"InvolutiveInv.toInv",
"Group.toDivisionMonoid",
"id",
"DivisionMonoid.toInvolutiveInv",
"Equiv.Perm.IsThreeCycle.inv",
"Equiv.Perm.permGroup",
"Iff",
"Inv.inv",
"Fintype",
"Equiv.Perm",
"inv_inv",
"Iff.intro",
"Equiv.Perm.IsThreeCycle",
"E... | true |
le_iff_exists_sup | Mathlib.Order.Lattice | [
"Iff.mpr",
"le_sup_left",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists",
"SemilatticeSup.toMax",
"LE.le",
"Iff",
"Exists.casesOn",
"Max.max",
"sup_eq_right",
"Iff.intro",
"Exists.intro",
"Eq.ndrec",
"SemilatticeSup.toPartialOrder",
"Eq.symm",
"Eq",
"SemilatticeSup"
] | true |
Lean.Meta.Sym.MatchUnifyResult._sizeOf_inst | Lean.Meta.Sym.Pattern | [
"Lean.Meta.Sym.MatchUnifyResult",
"SizeOf.mk",
"Lean.Meta.Sym.MatchUnifyResult._sizeOf_1",
"SizeOf"
] | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.ValidFor.valid.match_1_1 | Batteries.Data.String.Lemmas | [
"Unit.unit",
"String.Legacy.Iterator.mk",
"HEq.refl",
"List.reverseAux",
"String.utf8Len",
"List",
"Unit",
"String.Pos.Raw.mk",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"String.Legacy.Iterator",
"Char",
"String.Legacy.Iterator.ValidFor",
"Eq.symm",
"String.Legacy.Iterator.ValidFor.... | false |
Lean.Elab.Command.PreElabHeaderResult.mk.injEq | Lean.Elab.MutualInductive | [
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Expr",
"Lean.Elab.Command.PreElabHeaderResult.mk.inj",
"Lean.Elab.Command.InductiveView",
"Array",
"List",
"And",
"Nat",
"Lean.Elab.Command.PreElabHeaderResult",
"Eq.ndrec",
"Lean.Elab.Command.PreElabHeaderResult.mk",
"Lean.Name",
"Eq.refl",
"Eq... | true |
WeakFEPair._sizeOf_inst | Mathlib.NumberTheory.LSeries.AbstractFuncEq | [
"WeakFEPair._sizeOf_1",
"NormedSpace",
"WeakFEPair",
"Complex.instNormedField",
"SizeOf.mk",
"SizeOf",
"Complex",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"NormedAddCommGroup"
] | false |
Representation.IntertwiningMap.mk | Mathlib.RepresentationTheory.Intertwining | [
"Monoid",
"Representation",
"MonoidHom.instFunLike",
"Monoid.toMulOneClass",
"Module.End.instSemiring",
"LinearMap",
"AddCommMonoid",
"MulZeroOneClass.toMulOneClass",
"instMulZeroOneClassOfSemiring",
"LinearMap.comp",
"MulOneClass.toMulOne",
"Representation.IntertwiningMap.mk",
"Semiring",
... | true |
_private.Mathlib.Analysis.Asymptotics.AsymptoticEquivalent.0.Asymptotics.IsEquivalent.smul._simp_1_9 | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | [
"False",
"eq_false",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"Nat.cast_add_one_ne_zero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"On... | false |
Metric.Snowflaking.image_toSnowflaking_image_ofSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | [
"Real.instLE",
"Real",
"Equiv.instEquivLike",
"Metric.Snowflaking.toSnowflaking",
"Real.instZero",
"Real.instLT",
"Equiv",
"LE.le",
"Real.instOne",
"LT.lt",
"One.toOfNat1",
"Zero.toOfNat0",
"Set.image",
"Metric.Snowflaking",
"OfNat.ofNat",
"Metric.Snowflaking.ofSnowflaking",
"Eq",
... | true |
Filter.lift_neBot_iff | Mathlib.Order.Filter.Lift | [
"Filter.instMembership",
"congrArg",
"_private.Mathlib.Order.Filter.Lift.0.Filter.lift_neBot_iff._simp_1_1",
"Filter.NeBot",
"PartialOrder.toPreorder",
"Monotone",
"_private.Mathlib.Order.Filter.Lift.0.Filter.lift_neBot_iff._simp_1_4",
"Membership.mem",
"_private.Mathlib.Order.Filter.Lift.0.Filter.l... | true |
MonadFinally.casesOn | Init.Control.Except | [
"MonadFinally.mk",
"MonadFinally",
"MonadFinally.rec",
"Prod",
"Option"
] | false |
Std.ExtDHashMap.insert.congr_simp | Std.Data.ExtDHashMap.Lemmas | [
"Eq.rec",
"LawfulHashable",
"Std.ExtDHashMap.insert",
"EquivBEq",
"Std.ExtDHashMap",
"Eq.refl",
"Hashable",
"BEq",
"Eq"
] | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.eq_singleton_iff_nonempty_unique_mem._proof_1_1 | Mathlib.Data.Finset.Insert | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"Finset.mem_singleton",
"False",
"Lean.Grind.not_not",
"Lean.Grind.not_and",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Lean.Grind.not_or",
"Finset",
"False.elim",
"Classical.byContradiction",
"Finset.ext",
"Membership.... | false |
_private.Init.Data.Slice.InternalLemmas.0.Std.Slice.Internal.size_eq_length_iter._simp_1_3 | Init.Data.Slice.InternalLemmas | [
"Std.Iter.length_toList_eq_length",
"Std.IteratorLoop",
"Std.Iterators.Finite",
"Std.Iter.length",
"Id",
"Std.Iterator",
"Std.Iter",
"Std.Iter.toList",
"Nat",
"Std.LawfulIteratorLoop",
"Id.instMonad",
"Eq.symm",
"Eq",
"List.length"
] | false |
Batteries.RBNode.any | Batteries.Data.RBMap.Basic | [
"Batteries.RBNode",
"Batteries.RBNode.brecOn",
"Bool",
"Batteries.RBNode.any._f"
] | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.mem_jacobson_iff.match_1_5 | Mathlib.RingTheory.Jacobson.Ideal | [
"Lattice.toSemilatticeSup",
"Semiring.toModule",
"HMul.hMul",
"Submodule.completeLattice",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"Preorder.toLE",
"Exists",
"CompleteLattice.toConditionallyCompleteLattice",
"SemilatticeSup.toMax",
"Set.instSingletonSet",
"Distrib.toAd... | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary._proof_14 | Init.Data.String.Pattern.String | [
"HSub.hSub",
"String.Slice",
"instSubNat",
"instOfNatNat",
"Array",
"GetElem.getElem",
"instHSub",
"Array.instGetElemNatLtSize",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"Nat.decLt",
"instLTNat",
"OfNat.ofNat",
"_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardS... | false |
Ideal.comap_idₐ | Mathlib.RingTheory.Ideal.Maps | [
"AlgHom.algHomClass",
"AlgHom",
"AlgHom.funLike",
"AlgHom.id",
"Algebra",
"Ideal",
"CommSemiring",
"Ideal.comap",
"Semiring",
"AlgHomClass.toRingHomClass",
"Eq",
"Ideal.comap_id"
] | true |
MeasureTheory.AEEqFun.coeFn_sup | Mathlib.MeasureTheory.Function.AEEqFun | [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"MeasureTheory.AEEqFun.coeFn_comp₂",
"MeasureTheory.AEEqFun.cast",
"SemilatticeSup.toMax",
"Filter.EventuallyEq",
"MeasureTheory.AEEqFun.instSup",
"MeasureTheory.AEEqFun",
"MeasurableSpace",
"TopologicalSpace",
"Max.max",
"ContinuousSup",
"Semilat... | true |
USize.toNat_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | [
"Eq.mpr",
"congrArg",
"USize.ofNatTruncate",
"HSub.hSub",
"id",
"USize.toNat_ofNatLT",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"dif_neg",
"dite",
"instHSub",
"USize.toNat",
"USize.ofNatTruncate.eq_1",
"Nat",
"USize.ofNatLT",
"LT.lt",
"Nat.decLt",
"Eq.refl",
"USize... | true |
IsCoprime.mul_sub_right_left_iff | Mathlib.RingTheory.Coprime.Basic | [
"Eq.mpr",
"NegZeroClass.toNeg",
"CommRing",
"IsCoprime.add_mul_right_left_iff",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg",
"CommSemiring.toSemiring",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"sub_eq_neg_add",
"HSub.hSub",
"AddZeroClass.toAddZero",
"id",
"Distrib.toAdd",
"Subt... | true |
ZNum.cmp.match_1 | Mathlib.Data.Num.Basic | [
"Unit.unit",
"ZNum.ctorIdx",
"ZNum.pos",
"ZNum.cmp._sparseCasesOn_2",
"Nat.hasNotBit",
"ZNum.zero",
"ZNum",
"Unit",
"ZNum.cmp._sparseCasesOn_1",
"ZNum.casesOn",
"PosNum",
"ZNum.neg"
] | false |
Lean.Expr.mvar | Lean.Expr | [
"Lean.Expr.mvar",
"Lean.MVarId",
"Lean.Expr"
] | true |
Multiset.rec._proof_1 | Mathlib.Data.Multiset.ZeroCons | [
"Quot.sound",
"HEq.refl",
"Multiset",
"Multiset.cons",
"List.Perm",
"Quotient.mk",
"List.cons",
"List",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"List.isSetoid",
"Eq",
"Setoid.r"
] | false |
Lean.Meta.SimpTheorems | Lean.Meta.Tactic.Simp.SimpTheorems | [
"Lean.Meta.SimpTheorems.mk"
] | true |
DFA.casesOn | Mathlib.Computability.DFA | [
"DFA.mk",
"DFA",
"DFA.rec",
"Set"
] | false |
FreeAbelianGroup.lift_add_apply | Mathlib.GroupTheory.FreeAbelianGroup | [
"NegZeroClass.toNeg",
"AddMonoidHom.map_zero",
"AddMonoidHom.instAddMonoidHomClass",
"Equiv.instEquivLike",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"FreeAbelianGroup.induction_on",
"AddCommGroup.toAddGroup",
"neg_add",
"AddZeroClass.toAddZero",
"AddCommGroup",
... | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg.match_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | [
"Unit.unit",
"Lean.BinderInfo.casesOn",
"Unit",
"Lean.BinderInfo.instImplicit",
"Lean.BinderInfo.default",
"Lean.BinderInfo",
"Lean.BinderInfo.strictImplicit",
"Lean.BinderInfo.implicit"
] | false |
Submodule.module'._proof_1 | Mathlib.Algebra.Module.Submodule.Defs | [
"Submodule",
"instHSMul",
"congrArg",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"Submodule.addCommMonoid",
"SMul",
"AddMonoid.toAddZeroClass",
"smul_zero",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"DistribSMul.toSMulZeroClass",
"Submodule.toSubMulAction",
"SubMulAc... | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.trimLeft.go.match_1 | Lean.DocString.Markdown | [
"String",
"Prod.mk",
"Prod",
"Prod.casesOn",
"Lean.Doc.Inline"
] | false |
Matrix.toBilin_comp | Mathlib.LinearAlgebra.Matrix.BilinearForm | [
"Finsupp.instFunLike",
"Eq.mpr",
"Matrix.toLin",
"LinearEquiv.symm",
"Algebra.to_smulCommClass",
"instHSMul",
"Semiring.toModule",
"Finsupp.module",
"HMul.hMul",
"Finset.univ",
"Matrix.module",
"LinearMap.BilinForm",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul"... | true |
CategoryTheory.Functor.obj.instComonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Comon_ | [
"CategoryTheory.ComonObj.comul",
"CategoryTheory.Functor.OplaxMonoidal.associativity",
"CategoryTheory.Functor.OplaxMonoidal.δ_natural_left_assoc",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.t... | false |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.casesOn | Lean.Meta.Sym.Simp.Have | [
"Lean.Expr",
"Lean.Level",
"_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.rec",
"Lean.Meta.Sym.Simp.Result",
"_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult.mk",
"_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.SimpHaveResult"
] | false |
Fintype.expect_equiv | Mathlib.Algebra.BigOperators.Expect | [
"Equiv.instEquivLike",
"Finset.univ",
"Finset.expect",
"Equiv.bijective",
"NNRat.instSemifield",
"Fintype.expect_bijective",
"Equiv",
"NNRat",
"AddCommMonoid",
"Semifield.toDivisionSemiring",
"Fintype",
"DivisionSemiring.toSemiring",
"Module",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike... | true |
Turing.PartrecToTM2.Cont'.halt.elim | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Cont'.ctorIdx",
"Turing.PartrecToTM2.Cont'",
"PULift.up",
"Nat",
"Turing.PartrecToTM2.Cont'.halt",
"Eq.symm",
"Turing.PartrecToTM2.Cont'.ctorElim",
"Eq"
] | false |
Except.emoji | Batteries.Lean.Except | [
"String",
"Except.emoji.match_1",
"Lean.checkEmoji",
"Lean.crossEmoji",
"Except"
] | true |
Subring.coe_prod | Mathlib.Algebra.Ring.Subring.Basic | [
"Set.instSProd",
"Subring.instSetLike",
"SProd.sprod",
"NonAssocRing",
"Prod.instNonAssocRing",
"Subring.prod",
"SetLike.coe",
"Subring",
"Prod",
"Eq",
"rfl",
"Set"
] | true |
ZMod.val.eq_1 | Mathlib.Data.ZMod.Basic | [
"instOfNatNat",
"ZMod",
"Nat",
"Int.natAbs",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"ZMod.val"
] | true |
_private.Mathlib.Util.SleepHeartbeats.0._aux_Mathlib_Util_SleepHeartbeats___elabRules_tacticSleep_heartbeats__1.match_1 | Mathlib.Util.SleepHeartbeats | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Nat",
"Option"
] | false |
StarAlgebra.elemental.instCompleteSpaceSubtypeMemStarSubalgebra | Mathlib.Topology.Algebra.StarSubalgebra | [
"UniformSpace",
"CompleteSpace",
"CommSemiring.toSemiring",
"ContinuousStar",
"Algebra",
"instUniformSpaceSubtype",
"Algebra.toSMul",
"Membership.mem",
"Set.instSingletonSet",
"Subtype",
"StarSubalgebra",
"StarSubalgebra.setLike",
"StarAlgebra.adjoin",
"StarAddMonoid.toInvolutiveStar",
"... | true |
QuasiErgodic.smul_measure | Mathlib.Dynamics.Ergodic.Ergodic | [
"instHSMul",
"MeasureTheory.Measure",
"instSMulOfMul",
"CommSemiring.toSemiring",
"IsScalarTower",
"SMul",
"QuasiErgodic.toQuasiMeasurePreserving",
"MeasureTheory.Measure.QuasiMeasurePreserving.smul_measure",
"PreErgodic.smul_measure",
"MeasureTheory.Measure.instSMul",
"ENNReal.instCommSemiring"... | true |
SkewMonoidAlgebra.coeff_one_one | Mathlib.Algebra.SkewMonoidAlgebra.Basic | [
"One",
"Finsupp.single_eq_same",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"True",
"eq_self",
"SkewMonoidAlgebra",
"of_eq_true",
"One.toOfNat1",
"congrFun'",
"SkewMonoidAlgebra.instOne",
"AddMonoidWithOne.toAddMonoid",
... | true |
Std.ExtDTreeMap.Const.contains_alter | Std.Data.ExtDTreeMap.Lemmas | [
"instDecidableEqOrdering",
"Std.DTreeMap",
"Std.ExtDTreeMap.Const.alter",
"Ordering",
"Ordering.eq",
"Std.DTreeMap.Const.contains_alter",
"Std.TransCmp",
"Std.ExtDTreeMap.contains",
"Std.ExtDTreeMap.Const.get?",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Bool",
"Option.isSome",
"Eq... | true |
ContinuousLinearEquiv.map_nhds_eq | Mathlib.Topology.Algebra.Module.Equiv | [
"Filter.map",
"Homeomorph.map_nhds_eq",
"RingHom",
"nhds",
"ContinuousLinearEquiv.equivLike",
"AddCommMonoid",
"RingHomInvPair",
"TopologicalSpace",
"ContinuousLinearEquiv",
"Semiring",
"ContinuousLinearEquiv.toHomeomorph",
"Module",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe",
... | true |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.mkMotiveAndRefls | Lean.Meta.Tactic.Grind.CasesMatch | [
"Pure.pure",
"Lean.mkAppN",
"Lean.Meta.MatcherApp",
"Lean.mkSort",
"instMonadControlTOfPure",
"Lean.Meta.State",
"Lean.Meta.MatcherApp.params",
"Option.some",
"Lean.MVarId",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Prod.mk",
"Lean.MVarId.getType",
"Lean.Level",
"Lean.Meta.Match... | true |
Set.monotone_mem._simp_1 | Mathlib.Order.UpperLower.Basic | [
"PartialOrder.toPreorder",
"Monotone",
"IsUpperSet",
"Preorder.toLE",
"Membership.mem",
"Set.monotone_mem",
"propext",
"Prop.partialOrder",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
Nat.or_mod_two_pow | Init.Data.Nat.Bitwise.Lemmas | [
"instPowNat",
"instHOrOfOrOp",
"Nat.instMod",
"instHMod",
"instOfNatNat",
"Nat.bitwise_mod_two_pow",
"instNatPowNat",
"HOr.hOr",
"HMod.hMod",
"HPow.hPow",
"Nat",
"Bool",
"Bool.or",
"Eq.refl",
"instHPow",
"OfNat.ofNat",
"Bool.false",
"Eq",
"Nat.instOrOp"
] | true |
Nat.log_eq_iff | Mathlib.Data.Nat.Log | [
"instPowNat",
"Nat.le_one_iff_eq_zero_or_eq_one",
"Eq.mpr",
"False",
"Preorder.toLT",
"_private.Mathlib.Data.Nat.Log.0.Nat.log_eq_iff._proof_1_2",
"eq_false",
"and_true",
"Classical.not_not",
"congrArg",
"and_self",
"Nat.log_zero_left",
"Nat.log_zero_right",
"Nat.log_lt_iff_lt_pow",
"Iff... | true |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_ne_zero_of_eq_nat._simp_1_1 | Mathlib.Algebra.Lie.Sl2 | [
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"And",
"HAdd.hAdd",
"propext",
"AddZero.toAdd",
"Zero.toOfNat0",
"Subsingleton",
"AddCommMonoid.toAddMonoid",
"add_eq_zero",
"OfNat.ofNat",
"Eq",
"AddUnits"
] | false |
isNilpotent_iff_zero_mem_powers | Mathlib.RingTheory.Nilpotent.Lemmas | [
"Monoid",
"Monoid.toMulOneClass",
"Iff.rfl",
"Membership.mem",
"Monoid.toPow",
"Iff",
"Submonoid.powers",
"Zero.toOfNat0",
"Submonoid.instSetLike",
"OfNat.ofNat",
"IsNilpotent",
"SetLike.instMembership",
"Submonoid",
"Zero"
] | true |
Lean.Grind.OrderedRing.mul_pos | Init.Grind.Ordered.Ring | [
"Lean.Grind.OrderedRing.mul_lt_mul_of_pos_right",
"HMul.hMul",
"congrArg",
"Eq.mp",
"Lean.Grind.AddCommMonoid.toZero",
"Lean.Grind.Semiring.toMul",
"LE",
"Lean.Grind.Semiring.ofNat",
"Lean.Grind.Semiring.zero_mul",
"Std.IsPreorder",
"Lean.Grind.Ring",
"LT.lt",
"Zero.toOfNat0",
"congrFun'",... | true |
false_of_ne | Init.Core | [
"False",
"Ne",
"Ne.irrefl"
] | true |
TopCat.GlueData._sizeOf_1 | Mathlib.Topology.Gluing | [
"TopCat.GlueData.rec",
"CategoryTheory.ConcreteCategory.hom",
"TopCat.instCategory",
"ContinuousMap",
"CategoryTheory.GlueData.f",
"CategoryTheory.GlueData.J",
"Prod.mk",
"instOfNatNat",
"TopCat.str",
"CategoryTheory.GlueData",
"instHAdd",
"CategoryTheory.GlueData._sizeOf_inst",
"TopCat.carr... | false |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.rightDistributor_assoc._simp_1_2 | Mathlib.CategoryTheory.Monoidal.Preadditive | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.MonoidalCategoryStruct.tensorObj",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.MonoidalCategory.comp_tensor_id",
"CategoryTheory.MonoidalCategory.toM... | false |
hasFDerivAt_iff_tendsto | Mathlib.Analysis.Calculus.FDeriv.Basic | [
"HasFDerivAt",
"Norm.norm",
"Eq.mpr",
"Real",
"HMul.hMul",
"NormedSpace",
"Real.instZero",
"nhdsWithin_univ",
"congrArg",
"Real.instInv",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"Set.univ",
"nhdsWithin",
"NormedSpace.toModule",
"Iff.rfl",
"HSub.hSub",
"Pseudo... | true |
CategoryTheory.Limits.ReflectsFilteredColimits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.ReflectsFilteredColimitsOfSize",
"CategoryTheory.Category"
] | true |
Aesop.Strategy.noConfusion | Aesop.Options.Public | [
"noConfusionEnum",
"Aesop.Strategy",
"Nat",
"Aesop.Strategy.ctorIdx",
"instDecidableEqNat",
"Eq",
"Aesop.Strategy.noConfusionType"
] | false |
SymmetricPower.mk._proof_2 | Mathlib.LinearAlgebra.TensorPower.Symmetric | [
"PiTensorProduct.instModule",
"instHSMul",
"AddCon.addZeroClass",
"addConGen",
"SymmetricPower.Rel",
"ZeroHom.toFun",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.toZeroHom",
"SymmetricPower",
"AddZeroClass.toAddZero",
"DistribSMul.to... | false |
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.isValue.formatter_7 | Lean.Meta.Tactic.Grind.Parser | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Name.mkStr6",
"Lean.Parser.Command.GrindCnstr.isValue.formatter",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.resRec_of_clz_le._proof_1_1 | Init.Data.BitVec.Bitblast | [
"instPowNat",
"Lean.Omega.LinearCombo.coordinate_eval_6",
"Nat.lt_of_not_le",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"Lean.Ome... | false |
CategoryTheory.GradedObject.total | Mathlib.CategoryTheory.GradedObject | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.GradedObject.total._proof_1",
"CategoryTheory.GradedObject.total._proof_2",
"CategoryTheory.Limits.HasCoproducts",
"CategoryTheory.GradedObject.categoryOfGradedObjects",
"Ca... | true |
CategoryTheory.Limits.colimit.pre | Mathlib.CategoryTheory.Limits.HasLimits | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.Cocone.whisker",
"CategoryTheory.Limits.colimit",
"CategoryTheory.Limits.colimit.desc",
"CategoryTheory.Limits.HasColimit",
"CategoryTheory.Limits.colimit.cocone",
... | true |
Std.Time.OffsetX.hourMinute.elim | Std.Time.Format.Basic | [
"PULift.up",
"Std.Time.OffsetX.hourMinute",
"Nat",
"Std.Time.OffsetX.ctorIdx",
"Std.Time.OffsetX",
"Eq.symm",
"Std.Time.OffsetX.ctorElim",
"Eq"
] | false |
Rat.toNNRat_le_toNNRat_iff._simp_1 | Mathlib.Data.NNRat.Defs | [
"Rat.instOfNat",
"Rat",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"NNRat",
"LE.le",
"Rat.instLE",
"Rat.toNNRat",
"propext",
"Rat.toNNRat_le_toNNRat_iff",
"OfNat.ofNat",
"Eq",
"instDistribLatticeOfLinearOrder",
"instLinearOr... | false |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy._simp_12 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | [
"SimpleGraph.Adj",
"SimpleGraph.completeEquipartiteGraph_adj",
"Ne",
"Prod.fst",
"Nat",
"propext",
"Prod",
"SimpleGraph.completeEquipartiteGraph",
"Fin",
"Eq"
] | false |
HomotopicalAlgebra.PathObject.instIsCofibrantPOfIsVeryGood | Mathlib.AlgebraicTopology.ModelCategory.PathObject | [
"HomotopicalAlgebra.PathObject",
"HomotopicalAlgebra.IsCofibrant",
"CategoryTheory.MorphismProperty.IsStableUnderComposition",
"HomotopicalAlgebra.PathObject.IsVeryGood.cofibration_ι",
"HomotopicalAlgebra.PathObject.toPrepathObject",
"HomotopicalAlgebra.PrepathObject.P",
"CategoryTheory.Limits.HasBinary... | true |
MLList.thunk | Batteries.Data.MLList.Basic | [
"_private.Batteries.Data.MLList.Basic.0.MLList.Spec.thunk",
"Unit",
"_private.Batteries.Data.MLList.Basic.0.MLList.spec",
"MLList"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.