name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Server.References.ParentDecl._sizeOf_inst | Lean.Server.References | [
"Lean.Server.References.ParentDecl",
"SizeOf.mk",
"SizeOf",
"Lean.Server.References.ParentDecl._sizeOf_1"
] | false |
toIocMod_eq_sub | Mathlib.Algebra.Order.ToIntervalMod | [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddZeroClass.toAddZero",
"AddCommGroup",
"toIocMod_sub_eq_sub",
"DistribLat... | true |
_private.Lean.Meta.Constructions.BRecOn.0.Lean.buildBelowMinorPremise.go._unsafe_rec | Lean.Meta.Constructions.BRecOn | [
"_private.Lean.Meta.Constructions.BRecOn.0.Lean.buildBelowMinorPremise.go._unsafe_rec",
"Lean.Meta.mkPProd",
"Lean.mkAppN",
"Array.push",
"Lean.Meta.forallTelescope",
"Lean.Meta.PProdN.pack",
"instMonadControlTOfPure",
"Lean.Expr.instBEq",
"Lean.Expr.fvarId!",
"Lean.Meta.State",
"Lean.Meta.withL... | false |
Std.Net.SocketAddressV4._sizeOf_1 | Std.Net.Addr | [
"Std.Net.IPv4Addr",
"Std.Net.IPv4Addr._sizeOf_inst",
"instOfNatNat",
"Std.Net.SocketAddressV4.rec",
"instHAdd",
"UInt16",
"HAdd.hAdd",
"Std.Net.SocketAddressV4",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"UInt16._sizeOf_inst",
"OfNat.ofNat"
] | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_fin_Icc_eq_sum_nat_Icc._proof_1_6 | Mathlib.Algebra.BigOperators.Intervals | [
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"dite_congr",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"Lean.Grind.instLEFinCoOfNatIntCast",
"Lean.Grind.ToInt.toInt",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
... | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.PendingField.ctorIdx | Lean.Elab.StructInst | [
"Nat",
"_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.PendingField"
] | false |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.densityProcess_mono_kernel_left._simp_1_2 | Mathlib.Probability.Kernel.Disintegration.Density | [
"instHDiv",
"HDiv.hDiv",
"Ne",
"And",
"ENNReal.div_eq_top",
"ENNReal",
"ENNReal.instDivInvMonoid",
"propext",
"DivInvMonoid.toDiv",
"Zero.toOfNat0",
"ENNReal.instTop",
"Or",
"ENNReal.instZero",
"Top.top",
"OfNat.ofNat",
"Eq"
] | false |
Turing.FinTM2.casesOn | Mathlib.Computability.TuringMachine.Computable | [
"Turing.FinTM2.rec",
"Turing.FinTM2",
"Fintype",
"Turing.FinTM2.mk",
"Turing.TM2.Stmt",
"DecidableEq"
] | false |
SimpleGraph.addCayley_insert_zero | Mathlib.Combinatorics.SimpleGraph.Cayley | [
"congrArg",
"Set.instUnion",
"AddZeroClass.toAddZero",
"Set.instSingletonSet",
"SimpleGraph.addCayley",
"Insert.insert",
"BiheytingAlgebra.toCoheytingAlgebra",
"BooleanAlgebra.toBiheytingAlgebra",
"SimpleGraph",
"SDiff.sdiff",
"AddZero.toZero",
"AddZeroClass",
"Set.instInsert",
"SimpleGrap... | true |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_4 | Lean.Meta.Tactic.Grind.ProveEq | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... | false |
SpecializingMap.stableUnderSpecialization_range | Mathlib.Topology.Inseparable | [
"Set.image_univ",
"StableUnderSpecialization",
"Set.univ",
"SpecializingMap",
"Eq.rec",
"TopologicalSpace",
"StableUnderSpecialization.image",
"stableUnderSpecialization_univ",
"Set.image",
"Set.range",
"Eq",
"Set"
] | true |
OrderMonoidHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.Monoid | [
"OrderMonoidHom",
"SizeOf.mk",
"SizeOf",
"MulOneClass",
"OrderMonoidHom._sizeOf_1",
"Preorder"
] | false |
Module.finBasisOfFinrankEq | Mathlib.LinearAlgebra.Dimension.Free | [
"finCongr",
"Module.finBasis",
"AddCommMonoid",
"Module.Free",
"Module.Basis",
"StrongRankCondition",
"Nat",
"Semiring",
"Module.Basis.reindex",
"Module.Finite",
"Module",
"Fin",
"Eq",
"Module.finrank"
] | true |
LinearMap.toDistribMulActionHom | Mathlib.Algebra.Module.LinearMap.Defs | [
"DistribMulActionHom.mk",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"DistribMulActionHom",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"RingHom",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LinearMap.toAddHom",
"MulActionHom.mk",
"LinearMap... | true |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isNatValue | Lean.Meta.Tactic.Cbv.Util | [
"Lean.Expr",
"Nat",
"Bool",
"Option.isSome",
"Lean.Meta.Sym.getNatValue?"
] | true |
Mathlib.Tactic.Algebra.Cache._sizeOf_inst | Mathlib.Tactic.Algebra.Basic | [
"Lean.Expr.const",
"Lean.Expr.sort",
"Lean.Level",
"Mathlib.Tactic.Algebra.Cache",
"List.cons",
"Mathlib.Tactic.Algebra.Cache._sizeOf_1",
"Qq.Quoted",
"SizeOf.mk",
"Lean.Expr.app",
"SizeOf",
"Lean.Level.succ",
"Lean.Name.mkStr1",
"List.nil"
] | false |
_private.Mathlib.Algebra.Lie.Killing.0.LieAlgebra.killingForm_of_equiv_apply._simp_1_1 | Mathlib.Algebra.Lie.Killing | [
"LieHom",
"LieAlgebra.toModule",
"Module.End.instRing",
"CommRing",
"instSMulOfMul",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieAlgebra.ad",
"LieEquiv",
"LinearMap.module",
"IsScalarTower.left",
"smulCommClass_self",
"instDistribOfSemiring",
... | false |
CategoryTheory.Limits.colimitConstInitial | Mathlib.CategoryTheory.Limits.Shapes.Terminal | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.instHasColimitObjFunctorConstInitial",
"CategoryTheory.Iso",
"CategoryTheory.Limits.Cocone.mk",
"CategoryTheory.Limits.initial.to",
"CategoryTheory.Iso.mk",
"CategoryTheory.Limits.colimit",
"CategoryTheory.NatTrans.m... | true |
ContextFreeRule.reverse_injective | Mathlib.Computability.ContextFreeGrammar | [
"ContextFreeRule.reverse",
"Function.Bijective.injective",
"ContextFreeRule.reverse_bijective",
"Function.Injective",
"ContextFreeRule"
] | true |
Std.Iterators.Types.ULiftIterator.instIterator._proof_1 | Init.Data.Iterators.Combinators.Monadic.ULift | [
"Std.IterStep",
"Std.Shrink",
"ULift",
"Std.Iterators.ULiftT",
"Exists",
"Std.IterM.IsPlausibleStep",
"Std.Iterators.Types.ULiftIterator.Monadic.modifyStep",
"Std.IterM.internalState",
"Std.Iterator",
"Std.Iterators.Types.ULiftIterator",
"And",
"Std.Shrink.inflate",
"Std.Iterators.Types.ULif... | false |
MvPolynomial.finSuccEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Polynomial.C",
"AlgEquiv.instEquivLike",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"congrArg",
"CommSemiring.toSemiring",
"RingHom.coe_coe",
"AddMonoid.toAddZeroClass",
"AddMonoidAlgebra.algebra",
"Polynomial.algebraOfAlgebra",
"Finsupp.instA... | true |
AddSubmonoid.zero_mem' | Mathlib.Algebra.Group.Submonoid.Defs | [
"AddSubsemigroup.carrier",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid.toAddSubsemigroup",
"AddSubmonoid",
"AddZero.toZero",
"AddZeroClass",
"AddZero.toAdd",
"Zero.toOfNat0",
"OfNat.ofNat",
"Set.instMembership",
"Set"
] | true |
iInf_uniformity | Mathlib.Topology.UniformSpace.Basic | [
"UniformSpace",
"iInf",
"Filter.instInfSet",
"Filter.instCompleteLatticeFilter",
"uniformity",
"iInf_range",
"Prod",
"Eq",
"instInfSetUniformSpace",
"Filter"
] | true |
Std.LawfulOrderLeftLeaningMax.max_eq_left | Init.Data.Order.Classes | [
"Max",
"LE.le",
"LE",
"Max.max",
"Std.LawfulOrderLeftLeaningMax",
"Eq"
] | true |
List.pairwise_cons_cons | Batteries.Data.List.Lemmas | [
"List.Pairwise",
"_private.Batteries.Data.List.Lemmas.0.List.pairwise_cons_cons._proof_1_1",
"List.cons",
"List",
"And",
"Iff"
] | true |
Fin.forall_fin_zero._simp_1 | Init.Data.Fin.Lemmas | [
"instOfNatNat",
"Nat",
"True",
"propext",
"Fin.forall_fin_zero",
"OfNat.ofNat",
"Fin",
"Eq"
] | false |
Aesop.TreeRef.markSubtreeIrrelevant | Aesop.Tree.State | [
"Pure.pure",
"Aesop.TreeRef",
"Aesop.Rapp.setIsIrrelevant",
"IO.instMonadLiftSTRealWorldBaseIO",
"Monad.toApplicative",
"Aesop.Goal",
"ST.Ref.modify",
"instMonadLiftT",
"Aesop.RappRef",
"ST.Ref.get",
"Aesop.MVarCluster.isIrrelevant",
"Aesop.Rapp.isIrrelevant",
"IO.RealWorld",
"Aesop.Goal.i... | true |
Lean.Elab.Command.instMonadLogCommandElabM | Lean.Elab.Command | [
"Pure.pure",
"Lean.Elab.Command.Context.fileName",
"Lean.BaseMessage.pos",
"Lean.MessageData",
"Unit.unit",
"Lean.Elab.Command.instMonadLogCommandElabM.match_1",
"Lean.Elab.Command.State.nextMacroScope",
"Lean.MonadRef.getRef",
"Lean.NamingContext.mk",
"Lean.MonadResolveName.getOpenDecls",
"Lean... | true |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.State.map | Lean.Meta.Sym.AlphaShareCommon | [
"Lean.Expr",
"Std.HashMap",
"Lean.Meta.Sym.instHashableExprPtr",
"_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.State",
"Lean.Meta.Sym.ExprPtr",
"Lean.Meta.Sym.instBEqExprPtr"
] | true |
List.isChain_of_isChain_map | Mathlib.Data.List.Chain | [
"List.map",
"List.isChain_map",
"List.IsChain",
"List",
"Iff.mp",
"List.IsChain.imp"
] | true |
Matroid.isBase_restrict_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | [
"Matroid.E",
"Matroid.IsBase",
"HasSubset.Subset",
"autoParam",
"Matroid.isBase_restrict_iff._auto_1",
"propext",
"Matroid.isBase_restrict_iff",
"Matroid.restrict",
"Matroid.IsBasis",
"Eq",
"Matroid",
"Set.instHasSubset",
"Set"
] | false |
Std.TreeMap.Raw.getElem_filterMap'._proof_1 | Std.Data.TreeMap.Raw.Lemmas | [
"GetElem?.toGetElem",
"congrArg",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Eq.mp",
"Std.TreeMap.Raw.filterMap",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"GetElem.getElem",
"Std.TreeMap.Raw",
"Bool.true",
"Std.LawfulEqCmp",
"Std.TreeMap.Raw.mem_of_mem_filterMap",
"Std... | false |
Lean.Elab.Tactic.GuardMsgs.GuardMsgFailure.mk.sizeOf_spec | Lean.Elab.GuardMsgs | [
"Lean.Elab.Tactic.GuardMsgs.GuardMsgFailure",
"String",
"instOfNatNat",
"instHAdd",
"Lean.Elab.Tactic.GuardMsgs.GuardMsgFailure.mk",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"String._sizeOf_inst",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Lean.Elab.Tactic.GuardMsgs.GuardMsgFailure._sizeOf... | true |
Std.instAntisymmOfAsymm | Init.Data.Order.Lemmas | [
"Std.Antisymm",
"False.elim",
"Std.Asymm",
"Std.Antisymm.mk",
"Std.Asymm.asymm",
"Eq"
] | true |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerLeft_naturality_naturality_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | [
"CategoryTheory.Pseudofunctor.StrongTrans.naturality",
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Pseudofunctor.StrongTrans.whiskerLeft_naturality_naturality",
"Eq.mp",
"CategoryTheory.Bicategory.whiskerRight",
"id",
"Catego... | true |
List.suffix_cons._simp_1 | Init.Data.List.Sublist | [
"List.cons",
"List",
"True",
"List.IsSuffix",
"eq_true",
"List.suffix_cons",
"Eq"
] | false |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.one_mem_div_iff._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | [
"instHDiv",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"HDiv.hDiv",
"Group.toDivInvMonoid",
"div_eq_one",
"propext",
"DivInvMonoid.toDiv",
"One.toOfNat1",
"OfNat.ofNat",
"Eq"
] | false |
Std.Internal.UV.UDP.Socket.bind | Std.Internal.UV.UDP | [
"Inhabited.default",
"instInhabitedError",
"IO",
"Std.Net.SocketAddress",
"Std.Internal.UV.UDP.Socket",
"instInhabitedEIO",
"Unit",
"IO.Error"
] | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk | Std.Time.Format.Basic | [
"Std.Time.Week.Ordinal",
"Std.Time.TimeZone.Offset",
"Std.Time.Day.Ordinal.OfYear",
"String",
"Std.Time.Second.Ordinal",
"Std.Time.Month.Quarter",
"Int",
"_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk",
"Std.Time.Nanosecond.Ordinal",
"Std.Time.Year.Era",
"Bool.true",
"... | true |
Lean.getStructureCtor | Lean.Structure | [
"Lean.ConstructorVal",
"_private.Lean.Structure.0.Lean.getStructureCtor.match_1",
"Lean.Environment.find?",
"panicWithPosWithDecl",
"Lean.Expr",
"instOfNatNat",
"List",
"_private.Lean.Structure.0.Lean.getStructureCtor.match_4",
"Lean.instInhabitedConstructorVal",
"Nat",
"Bool",
"Lean.Name",
... | true |
AffineIsometryEquiv.linearIsometryEquiv._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | [
"NormedCommRing.toNormedRing",
"NormedRing.toRing",
"NormedField",
"RingHomInvPair",
"RingHomInvPair.ids",
"NormedField.toNormedCommRing",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Ring.toSemiring"
] | false |
LinearMap.mulRight_inj._simp_1 | Mathlib.Algebra.Module.LinearMap.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instSMulOfMul",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"LinearMap",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
... | false |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.seminormAux_le_bound | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | [
"Norm.norm",
"Real.instLE",
"Real",
"_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.bounds_bddBelow",
"HMul.hMul",
"NormedSpace",
"Real.denselyNormedField",
"Real.instZero",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"ContinuousMultilinearMap.hasOpNorm'",
... | true |
Task.spawn | Init.Core | [
"Unit.unit",
"Task",
"Task.pure",
"Task.Priority",
"Task.Priority.default",
"Unit",
"optParam"
] | true |
ContinuousLinearMap.flipₗᵢ._proof_7 | Mathlib.Analysis.Normed.Operator.Bilinear | [
"NormedCommRing.toSeminormedCommRing",
"instHSMul",
"SeminormedAddCommGroup",
"NormedSpace",
"ContinuousLinearMap.topologicalSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.distribMulAction",
"ContinuousLinearMap.flipₗᵢ._proof_1",
"NormedSpace.toModul... | false |
Int.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | [
"Eq.mpr",
"Int.instAddCommMonoid",
"Int.instDiv",
"Int.ediv_mul_cancel",
"Dvd.dvd",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"id"... | true |
OreLocalization.lift₂Expand_of | Mathlib.GroupTheory.OreLocalization.Basic | [
"Monoid",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"OreLocalization.OreSet",
"Membership.mem",
"MulOne.toMul",
"Subtype",
"OreLocalization.lift₂Expand",
"Subtype.mk",
"MulOneClass.toMulOne",
"MulAction",
"Monoid.toSemigroup",
"HSMul.hSMul",
"SemigroupAction.toSMul",
"Submonoid... | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_4 | Mathlib.LinearAlgebra.Goursat | [
"Submodule",
"LinearMap.instFunLike",
"RingHom",
"LinearMap.range",
"Submodule.instTop",
"LinearMap",
"LinearMap.range_eq_top",
"AddCommMonoid",
"propext",
"Semiring",
"RingHomSurjective",
"Module",
"Top.top",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe",
"Function.Surjective"... | false |
WithLp.pseudoMetricSpaceToProd._proof_1 | Mathlib.Analysis.Normed.Lp.ProdLp | [
"WithLp",
"instUniformSpaceProd",
"WithLp.toLp",
"Fact",
"LE.le",
"WithLp.instProdUniformSpace",
"PseudoMetricSpace",
"WithLp.isUniformInducing_toLp",
"PseudoEMetricSpace.toUniformSpace",
"ENNReal.instLE",
"ENNReal",
"IsUniformInducing",
"One.toOfNat1",
"ENNReal.instOne",
"Prod",
"OfNa... | false |
CategoryTheory.Limits.CokernelCofork.isColimitTensor._proof_2 | Mathlib.CategoryTheory.Monoidal.Limits.Cokernels | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.CokernelCofork",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.MonoidalPreadditive",
"CategoryTheory.Limits.wa... | false |
nhdsWithin_restrict | Mathlib.Topology.NhdsWithin | [
"nhdsWithin",
"Membership.mem",
"Set.instInter",
"nhdsWithin_restrict'",
"Inter.inter",
"TopologicalSpace",
"IsOpen.mem_nhds",
"IsOpen",
"Eq",
"Set.instMembership",
"Filter",
"Set"
] | true |
_private.Init.Data.List.Impl.0.List.takeTR.go._unsafe_rec | Init.Data.List.Impl | [
"Array.push",
"_private.Init.Data.List.Impl.0.List.setTR.go.match_1",
"Array.toList",
"_private.Init.Data.List.Impl.0.List.takeTR.go._unsafe_rec",
"Array",
"List",
"Nat"
] | false |
Set.preimage_mul_const_Ico₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | [
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"instHDiv",
"MulPosReflectLT",
"HMul.hMul",
"Set.Ici",
"GroupWithZero.toDivInvMonoid",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"GroupWithZero",
"PartialOrder",
"HDiv.hDiv",
"Set.instInter",
"Set.Ico",
"Inter.inter"... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_shift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | [
"Lean.RArray.leaf",
"False",
"HMul.hMul",
"congrArg",
"Classical.byContradiction",
"Eq.mp",
"Lean.RArray.branch",
"Int.Linear.Expr.add",
"id",
"Lean.RArray",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Int.Linear.Poly.num",
"Int.instMul",
"Int.Linear.Poly.add",
"Int.Linear.norm_eq",
... | false |
instCommSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | [
"Semigroup.toMul",
"HMul.hMul",
"Matrix",
"CommMonoid.mul_comm",
"CommSemiring",
"CommMonoid.toMonoid",
"CommSemiring.toCommMonoid",
"Monoid.toSemigroup",
"instCommMonoidWithConvMatrix",
"WithConv",
"Eq",
"instHMul"
] | false |
AddCommGrpCat.kernelIsoKer._proof_1 | Mathlib.Algebra.Category.Grp.Limits | [
"AddCommGrpCat.hasLimit",
"AddMonoidHom.instAddMonoidHomClass",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.... | false |
Finsupp.sigmaFinsuppLEquivPiFinsupp_apply | Mathlib.LinearAlgebra.Finsupp.SumProd | [
"Finsupp.instFunLike",
"Pi.addCommMonoid",
"Finsupp.module",
"Pi.module",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"AddZero.toZero",
"Fintype",
"RingHomInvPair.ids",
"LinearEquiv",
"Semiring",
"LinearEquiv.instEquivLike",
"AddCom... | true |
Lean.Compiler.LCNF.FixedParams.AbsValue.val | Lean.Compiler.LCNF.FixedParams | [
"Lean.Compiler.LCNF.FixedParams.AbsValue",
"Lean.Compiler.LCNF.FixedParams.AbsValue.val",
"Nat"
] | true |
Class.mem_wf | Mathlib.SetTheory.ZFC.Class | [
"Class.ofSet",
"ZFSet",
"ZFSet.inductionOn",
"Membership.mem",
"And.casesOn",
"Acc",
"And",
"Exists.casesOn",
"WellFounded.intro",
"Class",
"Eq.ndrec",
"WellFounded",
"Eq",
"ZFSet.instSetLike",
"SetLike.instMembership",
"Acc.intro",
"Class.instMembership"
] | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_X₃ | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc._auto_3",
"CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₃",
"CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageX._proof_2",
"CategoryTheory.Abelian",
"CategoryTheor... | true |
_private.Mathlib.GroupTheory.Solvable.0.isSolvable_of_subsingleton._simp_1 | Mathlib.GroupTheory.Solvable | [
"True",
"propext",
"Subsingleton",
"Eq",
"eq_iff_true_of_subsingleton"
] | false |
finTwoEquiv._proof_6 | Mathlib.Logic.Equiv.Defs | [
"Zero.ofOfNat0",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"NeZero",
"OfNat.ofNat"
] | false |
TypeVec.repeatEq.match_1 | Mathlib.Data.TypeVec | [
"instOfNatNat",
"Nat",
"Nat.zero",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn",
"TypeVec"
] | false |
NonUnitalSubsemiring.mem_map._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | [
"Membership.mem",
"Exists",
"And",
"NonUnitalSubsemiring.mem_map",
"propext",
"NonUnitalSubsemiring.instSetLike",
"NonUnitalSubsemiring",
"NonUnitalRingHomClass",
"NonUnitalSubsemiring.map",
"NonUnitalNonAssocSemiring",
"Eq",
"DFunLike.coe",
"SetLike.instMembership",
"FunLike"
] | false |
Lean.Meta.Grind.Arith.CommRing.ProofM.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | [
"Nat",
"Lean.Meta.Grind.Arith.CommRing.ProofM.State"
] | false |
PartOrdEmb.Hom.noConfusionType | Mathlib.Order.Category.PartOrdEmb | [
"PartOrdEmb.str",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartOrdEmb.carrier",
"PartOrdEmb.Hom.casesOn",
"HEq",
"OrderEmbedding",
"PartOrdEmb",
"PartOrdEmb.Hom"
] | false |
Prime.coprime_iff_not_dvd | Mathlib.RingTheory.PrincipalIdealDomain | [
"Prime.irreducible",
"IsDomain",
"CommRing",
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"semigroupDvd",
"Prime",
"CommSemiring.toCommMonoidWithZero",
"SemigroupWithZero.toSemigroup",
"IsBezout",
"NonUnitalSemiring.toSemigroupWithZero",
"NonUnitalCommSemiring.toNonU... | true |
singleton_div_ball | Mathlib.Analysis.Normed.Group.Pointwise | [
"Eq.mpr",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"SeminormedCommGroup.toPseudoMetricSpace",
"DivisionMonoid.toDivInvOneMonoid",
"Set.instSingletonSet",
"id",
"MulOne.... | true |
ENNReal.rpow_add_rpow_le_add | Mathlib.Analysis.MeanInequalitiesPow | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"ENNReal.instAdd",
"MulOne.toOne",
"Real.partialOrder",
"Real.instLE",
"Real",
"DivInvMonoid.toInv",
"Preorder.toLT",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"MulZeroCl... | true |
Equiv.prodCongr_apply | Mathlib.Logic.Equiv.Prod | [
"Equiv.instEquivLike",
"Equiv",
"Prod.map",
"Eq.refl",
"Prod",
"Equiv.prodCongr",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.orthonormal_subsingleton_iff._simp_1_3 | Mathlib.Analysis.InnerProductSpace.Orthonormal | [
"MulOne.toOne",
"MulZeroClass.toMul",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"ZeroLEOneClass",
"Ne",
"instOfNatNat",
"LE.le",
"MulZeroOneClass.toMulOneClass",
"Monoid.toPow",
"MulOneClass.toMulOne",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
... | false |
Filter.Realizer.comap | Mathlib.Data.Analysis.Filter | [
"Filter.Realizer.mk",
"CFilter.inf",
"CompleteLattice.toConditionallyCompleteLattice",
"Filter.Realizer.comap._proof_2",
"Filter.Realizer.comap._proof_3",
"Set.preimage",
"Filter.Realizer.F",
"CompleteBooleanAlgebra.toCompleteLattice",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"Condit... | true |
Ctop.Realizer.isClosed_iff | Mathlib.Data.Analysis.Topology | [
"Eq.mpr",
"not_exists._simp_1",
"congrArg",
"Compl.compl",
"_private.Mathlib.Data.Analysis.Topology.0.Ctop.Realizer.isClosed_iff._simp_1_4",
"not_imp_comm",
"Classical.propDecidable",
"Membership.mem",
"Exists",
"id",
"HasSubset.Subset",
"Ctop.Realizer.σ",
"Decidable.not_not._simp_1",
"Set... | true |
Std.Time.GenericFormat.mk.injEq | Std.Time.Format.Basic | [
"Eq.propIntro",
"Std.Time.FormatConfig",
"Lean.injEq_helper",
"And",
"Std.Time.GenericFormat.mk.inj",
"Std.Time.GenericFormat.mk",
"Eq.ndrec",
"Eq.refl",
"Std.Time.GenericFormat",
"Std.Time.FormatString",
"Std.Time.Awareness",
"Eq"
] | true |
NonUnitalSubsemiring.mem_top | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | [
"Membership.mem",
"NonUnitalSubsemiring.instTop",
"NonUnitalSubsemiring.instSetLike",
"Set.mem_univ",
"NonUnitalSubsemiring",
"Top.top",
"NonUnitalNonAssocSemiring",
"SetLike.instMembership"
] | true |
_private.Mathlib.Data.List.Defs.0.List.Forall.match_1.eq_2 | Mathlib.Data.List.Defs | [
"List.cons",
"List",
"List.Forall.match_1",
"Unit",
"Eq.refl",
"Eq",
"List.nil"
] | true |
Lean.Core.prependError | Lean.CoreM | [
"Lean.MessageData",
"Lean.indentD",
"Lean.Core.mapError",
"Lean.MessageData.instAppend",
"instHAppendOfAppend",
"MonadControlT",
"Lean.Core.CoreM",
"Lean.ToMessageData.toMessageData",
"Lean.instToMessageDataMessageData",
"Monad",
"HAppend.hAppend"
] | true |
ValueDistribution.logCounting_monotoneOn | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | [
"dite_cond_eq_true",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Set.Ioi",
"WithTop.untop₀",
"NormedSpace",
"eq_false",
"Function.locallyFinsuppWithin.instAddGroup",
"Real.instZero",
"Real.instAddMonoid",
"congrArg",
"Function.locallyFinsuppWithin.instAddMonoid",
"Function.lo... | true |
Multiset.count_sum' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | [
"Multiset.sum",
"Eq.mpr",
"Multiset.map",
"congrArg",
"Finset",
"Multiset.count_sum",
"Multiset.instAddCancelCommMonoid",
"Multiset.count",
"Multiset",
"id",
"Finset.val",
"Nat",
"AddCancelCommMonoid.toAddCommMonoid",
"Nat.instAddCommMonoid",
"Eq.refl",
"Eq",
"Finset.sum",
"Decidab... | true |
Set.Ioo_subset_Iio_self | Mathlib.Order.Interval.Set.Basic | [
"Preorder.toLT",
"HasSubset.Subset",
"And.right",
"LT.lt",
"Set.Iio",
"Set.Ioo",
"Preorder",
"Set.instHasSubset",
"Set"
] | true |
NonAssocCommSemiring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | [
"One.mk",
"Add.mk",
"id",
"Nat",
"Zero.mk",
"Nat.unaryCast"
] | false |
Int64.toISize_ofNat | Init.Data.SInt.Lemmas | [
"Int64",
"Int64.toISize_ofNat'",
"ISize.instOfNat",
"Nat",
"Int64.instOfNat",
"OfNat.ofNat",
"ISize",
"Eq",
"Int64.toISize"
] | true |
ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | [
"ValuationSubring.unitGroup",
"Subgroup.subtype",
"ValuationSubring.isLocalRing",
"Membership.mem",
"Units",
"Subtype",
"Subgroup",
"IsLocalRing.ResidueField.field",
"Units.instGroup",
"Field.toSemifield",
"MonoidHom.ker",
"IsLocalRing.ResidueField",
"ValuationSubring.instCommRingSubtypeMem"... | false |
Int32.one_mul | Init.Data.SInt.Lemmas | [
"Int32.toBitVec",
"BitVec.one_mul",
"HMul.hMul",
"Int32.toBitVec_inj",
"BitVec",
"instOfNatNat",
"Nat",
"Iff.mp",
"Int32.instOfNat",
"instMulInt32",
"OfNat.ofNat",
"Eq",
"Int32",
"instHMul"
] | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.rec | Lean.Compiler.LCNF.ExplicitRC | [
"_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo",
"Lean.FVarId",
"Array",
"_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.mk",
"Lean.FVarIdHashSet"
] | false |
Filter.Realizer.comap._proof_1 | Mathlib.Data.Analysis.Filter | [
"CFilter.inf",
"CompleteLattice.toConditionallyCompleteLattice",
"HasSubset.Subset",
"Set.preimage_mono",
"Set.preimage",
"Filter.Realizer.F",
"CompleteBooleanAlgebra.toCompleteLattice",
"CFilter.inf_le_left",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"ConditionallyCompleteLattice.toC... | false |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map._proof_6 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | [
"Order.succ",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"LE.le",
"Subtype.mk",
"Set.Iic",
"Order.le_succ",
"LE.le.trans",
"SuccOrder",
"Subtype.val",
"Set.instMembership",
"instDistribLattic... | false |
Algebra.TensorProduct.uliftEquiv._proof_2 | Mathlib.RingTheory.TensorProduct.Maps | [
"ULift.semiring",
"CommSemiring.toSemiring",
"SMulWithZero.toSMulZeroClass",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"ULift",
"Module.toMulActionWithZero",
"Algebra",
"Algebra.toSMul",
"AddZeroClass.toAddZero",
"Algebra.toModule",
"DistribSMul.toSMulZer... | false |
Batteries.BinomialHeap.Imp.Heap.foldM._unary | Batteries.Data.BinomialHeap.Basic | [
"Pure.pure",
"Batteries.BinomialHeap.Imp.Heap.deleteMin",
"Monad.toApplicative",
"Batteries.BinomialHeap.Imp.Heap",
"InvImage",
"Batteries.BinomialHeap.Imp.Heap.foldM._proof_3",
"Batteries.BinomialHeap.Imp.Heap.foldM._unary._proof_1",
"WellFounded.Nat.fix",
"Option.some",
"PSigma.casesOn",
"Prod... | false |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux._proof_1_4 | Init.Data.Fin.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval",
"Option.some",
... | false |
Subbimodule.toSubmodule._proof_1 | Mathlib.Algebra.Module.Bimodule | [
"Submodule",
"Submodule.toAddSubmonoid",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"TensorProduct.Algebra.module",
"AddMonoid.toAddZeroClass",
"Algebra",
"AddSubsemigroup.carrier",
"Algebra.toSMul",
"Membership.mem",
"AddZeroClass.toAddZero",
"Algebra.toMo... | false |
_private.Mathlib.Order.LatticeIntervals.0.Set.Iic.disjoint_iff._simp_1_1 | Mathlib.Order.LatticeIntervals | [
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"OrderBot",
"disjoint_iff",
"SemilatticeInf.toPartialOrder",
"Bot.bot",
"SemilatticeInf.toMin",
"SemilatticeInf",
"propext",
"Eq",
"Min.min"
] | false |
Pell.x_sub_y_dvd_pow | Mathlib.NumberTheory.PellMatiyasevic | [
"Dvd.dvd",
"HMul.hMul",
"Pell.yz",
"Nat.instMonoid",
"HSub.hSub",
"Nat.brecOn",
"instOfNatNat",
"Int",
"Nat.cast",
"Pell.xz",
"Int.instDvd",
"Monoid.toPow",
"Int.instMul",
"instHAdd",
"instHSub",
"HPow.hPow",
"instOfNat",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Int.instAdd",
"Int.ins... | true |
Std.DTreeMap.Internal.Impl.link!._unary.induct_unfolding | Std.Data.DTreeMap.Internal.Model | [
"Std.DTreeMap.Internal.Impl.insertMax!",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"InvImage",
"Std.DTreeMap.Internal.Impl.link!._unary.eq_def",
"instSizeOfDefault",
"WellFounded.Nat.fix",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"PSigma.casesOn",
"id",
"instMulNat",
... | false |
Lean.pp.analyze.trustOfNat | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Option",
"Lean.instInhabitedOption",
"Bool"
] | true |
Std.Ric.le_upper_of_mem | Init.Data.Range.Polymorphic.Basic | [
"Std.Ric.instMembershipOfLE",
"Membership.mem",
"LE.le",
"LE",
"Std.Ric",
"LT",
"Std.Ric.upper"
] | true |
IsSeparatedMap.pullback | Mathlib.Topology.SeparatedMap | [
"IsSeparatedMap",
"Eq.mpr",
"continuous_subtype_val",
"congrArg",
"Function.Pullback",
"Continuous.comp",
"instTopologicalSpaceProd",
"continuous_fst",
"Eq.mp",
"id",
"Function.Pullback.fst",
"Function.Pullback.snd",
"Prod.fst",
"IsClosed",
"TopologicalSpace",
"Function.PullbackSelf",
... | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion._sparseCasesOn_1 | Lean.Meta.LazyDiscrTree | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
UniformOnFun.instPseudoEMetricSpace._proof_4 | Mathlib.Topology.MetricSpace.UniformConvergence | [
"ENNReal.instAdd",
"Equiv.instEquivLike",
"congrArg",
"UniformFun.instEDist",
"UniformFun.instPseudoEMetricSpace",
"Finite",
"Set.sUnion",
"Set.Elem",
"Equiv",
"LE.le",
"PseudoEMetricSpace",
"UniformOnFun.toFun",
"UniformOnFun.instEDistOfFiniteElemSet",
"instHAdd",
"HAdd.hAdd",
"Unifor... | false |
Polynomial.comp.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | [
"Polynomial.C",
"Polynomial.eval₂",
"Polynomial",
"Polynomial.semiring",
"Semiring",
"Eq.refl",
"Eq",
"Polynomial.comp"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.