name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.FunInd.instHashableCall.hash | Lean.Meta.Tactic.FunIndCollect | [
"UInt64.instOfNat",
"_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.instHashableCall.hash.match_1",
"mixHash",
"UInt64",
"Lean.Expr",
"Hashable.hash",
"Lean.Meta.FunInd.Call",
"Lean.Expr.instHashable",
"OfNat.ofNat"
] | true |
Lean.Level.getParamSubst._unsafe_rec | Lean.Level | [
"Option.some",
"Lean.Level.getParamSubst._unsafe_rec",
"instDecidableEqBool",
"Lean.Level",
"Bool.true",
"Option.none",
"List",
"BEq.beq",
"Bool",
"Lean.Name",
"_private.Lean.Level.0.Lean.Level.getParamSubst.match_1",
"Eq",
"Lean.Name.instBEq",
"Option",
"ite"
] | false |
Int32.reduceOfNat._regBuiltin.Int32.reduceOfNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2667021113._hygCtx._hyg.362 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | [
"IO",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Int32.reduceOfNat",
"Lean.Meta.Simp.Simproc"
] | false |
Std.HashMap.Raw.getKey?_union_of_not_mem_left | Std.Data.HashMap.RawLemmas | [
"Std.HashMap.Raw.getKey?",
"Std.HashMap.Raw.WF.out",
"Membership.mem",
"Std.DHashMap.Raw.getKey?_union_of_not_mem_left",
"Std.HashMap.Raw.WF",
"LawfulHashable",
"Std.HashMap.Raw",
"EquivBEq",
"Std.HashMap.Raw.inner",
"Std.HashMap.Raw.instMembershipOfBEqOfHashable",
"Hashable",
"Union.union",
... | true |
SimpleGraph.IsAlternating.sup_edge | Mathlib.Combinatorics.SimpleGraph.Matching | [
"Eq.mpr",
"SimpleGraph.Adj.symm",
"False",
"SimpleGraph.edge",
"eq_false",
"congrArg",
"SimpleGraph.Adj",
"_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsAlternating.sup_edge._proof_1_3",
"iff_true",
"Classical.propDecidable",
"Eq.mp",
"id",
"_private.Mathlib.Combinatori... | true |
Int32.mul_zero | Init.Data.SInt.Lemmas | [
"Int32.toBitVec",
"BitVec.mul_zero",
"HMul.hMul",
"Int32.toBitVec_inj",
"BitVec",
"instOfNatNat",
"Nat",
"Iff.mp",
"Int32.instOfNat",
"instMulInt32",
"OfNat.ofNat",
"Eq",
"Int32",
"instHMul"
] | true |
Set.image2_right_comm | Mathlib.Data.Set.NAry | [
"Eq.mpr",
"congrArg",
"id",
"Set.image2_assoc",
"Set.image2",
"Set.image2_swap",
"Eq",
"Set"
] | true |
Fintype.equivOfCardEq.congr_simp | Mathlib.Analysis.Matrix.Spectrum | [
"Fintype.card",
"Equiv",
"Fintype",
"Nat",
"Eq.refl",
"Eq",
"Fintype.equivOfCardEq"
] | true |
Std.Time.TimeZone.TZif.LocalTimeType.mk.noConfusion | Std.Time.Zoned.Database.TzIf | [
"Std.Time.TimeZone.TZif.LocalTimeType",
"Std.Time.TimeZone.TZif.LocalTimeType.mk",
"id",
"Int",
"Bool",
"UInt8",
"Eq",
"Std.Time.TimeZone.TZif.LocalTimeType.noConfusion"
] | false |
Polynomial.mem_support_iff | Mathlib.Algebra.Polynomial.Basic | [
"Finsupp.instFunLike",
"congrArg",
"Polynomial.coeff_ofFinsupp",
"Finset",
"Finsupp.mem_support_iff._simp_1",
"Finsupp.support",
"Membership.mem",
"Polynomial.support_ofFinsupp",
"Ne",
"Polynomial.casesOn",
"Polynomial",
"Polynomial.coeff",
"iff_self",
"Iff",
"Finset.instSetLike",
"con... | true |
Set.eq_empty_of_subset_empty | Mathlib.Data.Set.Basic | [
"HasSubset.Subset",
"Iff.mp",
"Set.instEmptyCollection",
"Set.subset_empty_iff",
"EmptyCollection.emptyCollection",
"Eq",
"Set.instHasSubset",
"Set"
] | true |
LinearMap.inr_apply | Mathlib.LinearAlgebra.Prod | [
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"AddZeroClass.toAddZero",
"Prod.mk",
"LinearMap",
"AddCommMonoid",
"AddZero.toZero",
"Semiring",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"Module",
"Prod",
"Prod.instModule",
"OfNat.ofNat",
"RingHom.id",
"LinearMap.inr",
"Semi... | true |
_private.Mathlib.Algebra.Lie.TraceForm.0.LieModule.isLieAbelian_of_ker_traceForm_eq_bot._simp_1_1 | Mathlib.Algebra.Lie.TraceForm | [
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"OrderBot",
"SemilatticeInf.toPartialOrder",
"Bot.bot",
"SemilatticeInf.toMin",
"LE.le",
"SemilatticeInf",
"propext",
"disjoint_iff_inf_le",
"Eq",
"Min.min"
] | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.warnUnusedSimpArgs.match_1 | Lean.Elab.Tactic.Simp | [
"Lean.Meta.SimpEntry.casesOn",
"Lean.Meta.SimpTheorem",
"Array",
"Lean.Meta.SimpEntry.toUnfoldThms",
"Lean.Name",
"Lean.Meta.SimpEntry",
"Lean.Meta.SimpEntry.thm",
"Lean.Meta.SimpEntry.toUnfold"
] | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Sub.0.MeasureTheory.exists_setLIntegral_compl_lt._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Sub | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Ne",
"IsBotZeroClass",
"LT.lt",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"pos_iff_ne_zero",
"Zero"
] | false |
LocallyConstant.neg_apply | Mathlib.Topology.LocallyConstant.Algebra | [
"LocallyConstant",
"TopologicalSpace",
"Neg",
"LocallyConstant.instNeg",
"LocallyConstant.instFunLike",
"Eq",
"DFunLike.coe",
"Neg.neg",
"rfl"
] | true |
Finset.Iic_product_Iic | Mathlib.Order.Interval.Finset.Defs | [
"Prod.instLE_mathlib",
"SProd.sprod",
"Finset",
"Preorder.toLE",
"LocallyFiniteOrderBot",
"Prod.mk",
"Prod.instLocallyFiniteOrderBot",
"DecidableLE",
"Finset.instSProd",
"Prod.instPreorder",
"Finset.Iic",
"Prod",
"Eq",
"rfl",
"Preorder"
] | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.IsCircuit.minimal_not_indep._simp_1_1 | Mathlib.Combinatorics.Matroid.Circuit | [
"Set.minimal_iff_forall_ssubset",
"HasSSubset.SSubset",
"Set.instHasSSubset",
"And",
"Set.instLE",
"propext",
"Eq",
"Minimal",
"Not",
"Set"
] | false |
CategoryTheory.Limits.idCofork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"Eq.rec",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"rfl",
"CategoryTheory.Category"
] | false |
AddCon.le_def | Mathlib.GroupTheory.Congruence.Defs | [
"AddCon.instFunLikeForallProp",
"AddCon",
"Iff.rfl",
"AddCon.instLE",
"LE.le",
"Iff",
"DFunLike.coe",
"Add"
] | true |
CategoryTheory.Limits.Fork.isLimitEquivOfIsos._auto_5 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.rename._proof_2 | Mathlib.RingTheory.MvPowerSeries.Rename | [
"HMul.hMul",
"CommSemiring.toSemiring",
"MvPowerSeries",
"MvPowerSeries.instMul",
"MvPowerSeries.renameFun",
"_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.renameFun_mul",
"CommSemiring",
"Eq",
"Filter.TendstoCofinite",
"instHMul"
] | false |
PSet.toSet.eq_1 | Mathlib.SetTheory.ZFC.PSet | [
"PSet.instMembership",
"setOf",
"Membership.mem",
"PSet.toSet",
"PSet",
"Eq.refl",
"Eq",
"Set"
] | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore.0.SSet.Subcomplex.PairingCore.pairing._simp_8 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | [
"Exists",
"forall_exists_index",
"propext",
"Exists.intro",
"Eq"
] | false |
Std.ExtTreeMap.inter.congr_simp | Std.Data.ExtTreeMap.Lemmas | [
"Ordering",
"Eq.rec",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inter",
"Eq.refl",
"Eq"
] | true |
FiberPrebundle.toFiberBundle | Mathlib.Topology.FiberBundle.Basic | [
"FiberPrebundle.trivializationOfMemPretrivializationAtlas",
"FiberBundle",
"FiberBundle.mk",
"FiberPrebundle",
"setOf",
"FiberPrebundle.toFiberBundle._proof_2",
"Membership.mem",
"Exists",
"FiberPrebundle.pretrivializationAtlas",
"Bundle.Pretrivialization",
"FiberPrebundle.pretrivializationAt",
... | true |
Lean.Lsp.SemanticTokenType.parameter.elim | Lean.Data.Lsp.LanguageFeatures | [
"PULift.up",
"Lean.Lsp.SemanticTokenType.ctorIdx",
"Lean.Lsp.SemanticTokenType.parameter",
"Lean.Lsp.SemanticTokenType",
"Lean.Lsp.SemanticTokenType.ctorElim",
"Nat",
"Eq.symm",
"Eq"
] | false |
Convexity.StdSimplex.ext | Mathlib.Geometry.Convex.ConvexSpace.Defs | [
"Convexity.StdSimplex.weights_inj",
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddMonoidWithOne... | true |
FP.Float.add._sparseCasesOn_3 | Mathlib.Data.FP.Basic | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.ctorIdx",
"Bool.true",
"Nat.land",
"Nat",
"Bool.rec",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._simp_1_22 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | [
"ge_iff_le",
"GE.ge",
"LE.le",
"LE",
"propext",
"Eq"
] | false |
Lean.Meta.Grind.Entry.cases.injEq | Lean.Meta.Tactic.Grind.Extension | [
"Lean.Meta.Grind.Entry.cases.inj",
"Eq.propIntro",
"Lean.injEq_helper",
"And",
"Lean.Meta.Grind.Entry",
"Bool",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Meta.Grind.Entry.cases",
"Eq"
] | true |
AddCommGrpCat.Colimits.Quot.desc._simp_3 | Mathlib.Algebra.Category.Grp.Colimits | [
"SetLike",
"Membership.mem",
"SetLike.coe",
"SetLike.mem_coe",
"propext",
"Eq",
"Set.instMembership",
"SetLike.instMembership",
"Set"
] | false |
Finset.max'_lt_iff | Mathlib.Data.Finset.Max | [
"Preorder.toLT",
"Finset",
"Finset.max'_mem",
"LinearOrder",
"PartialOrder.toPreorder",
"Finset.max'",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Iff",
"Finset.instSetLike",
"Finset.le_max'",
"LT.lt",
"Iff.intro",
"Exists.intro",
"Finset.Nonempty",
... | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.xy_modEq_yn._simp_1_8 | Mathlib.NumberTheory.PellMatiyasevic | [
"Dvd.dvd",
"instOfNatNat",
"Nat.ModEq",
"Nat.instDvd",
"Nat",
"propext",
"Nat.modEq_zero_iff_dvd",
"OfNat.ofNat",
"Eq"
] | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.reduce | Std.Tactic.BVDecide.LRAT.Internal.Clause | [
"Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.clause",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.reduce_fold_fn",
"List.foldl",
"Array",
"Nat",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment",
"Std.Tactic.BVDecide.LRAT.Internal.ReduceResult",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultClause",... | true |
Std.ExtDHashMap.get_eq_getD | Std.Data.ExtDHashMap.Lemmas | [
"Std.ExtDHashMap.inner",
"Std.ExtDHashMap.instMembershipOfEquivBEqOfLawfulHashable",
"Std.ExtDHashMap.getD",
"instLawfulHashableOfLawfulBEq",
"Quot.pliftOn._proof_2",
"LawfulBEq",
"Membership.mem",
"Std.DHashMap.get_eq_getD",
"Std.ExtDHashMap.inductionOn",
"Std.ExtDHashMap.mk",
"_private.Std.Dat... | true |
DirSupClosed.empty._simp_1 | Mathlib.Order.DirSupClosed | [
"DirSupClosed.empty",
"DirSupClosed",
"True",
"eq_true",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Eq",
"Preorder",
"Set"
] | false |
Finset.sum_Ico_int_sub | Mathlib.Algebra.BigOperators.Group.Finset.Interval | [
"neg_add_rev",
"Int.instAddCommGroup",
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"CharP.cast_eq_zero",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"False",
"Nat.recAux",
"Preorder.toLT",
"_private.Mathlib.Algebra.BigOperators.Group.Finset.Interval.0.Finset.sum_Ic... | true |
SheafOfModules.instPreservesColimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | [
"CategoryTheory.Limits.preservesColimitsOfSize_shrink",
"CategoryTheory.Limits.PreservesColimitsOfSize",
"CategoryTheory.Functor",
"RingCat",
"CategoryTheory.GrothendieckTopology",
"SheafOfModules",
"RingCat.instCategory",
"SheafOfModules.instCategory",
"CategoryTheory.Sheaf",
"CategoryTheory.Cate... | true |
Lean.Grind.Ring.OfSemiring.neg._proof_1 | Init.Grind.Ring.Envelope | [
"Eq.mpr",
"Quot.sound",
"Lean.Grind.Ring.OfSemiring.r",
"Exists",
"Lean.Grind.Semiring.toAdd",
"id",
"Prod.mk",
"Lean.Grind.Ring.OfSemiring.Q.mk",
"forall_exists_index._simp_1",
"_private.Init.Grind.Ring.Envelope.0.Lean.Grind.Ring.OfSemiring.sub.match_3",
"instHAdd",
"HAdd.hAdd",
"Lean.Grind... | false |
LinearMap.IsReflective.dvd_two_mul | Mathlib.LinearAlgebra.RootSystem.OfBilinear | [
"CommRing",
"Algebra.to_smulCommClass",
"Dvd.dvd",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LinearMap.IsReflective",
"Nat.instAtLeastTwoHAddOfNat",
"semigroupDv... | true |
Rat.HeightOneSpectrum.natGenerator_dvd_iff | Mathlib.NumberTheory.Padics.HeightOneSpectrum | [
"NormedCommRing.toNormedRing",
"Rat.IsIntegralClosure.intEquiv",
"Eq.mpr",
"IsIntegralClosure",
"CommRing",
"Dvd.dvd",
"Semiring.toModule",
"NormedRing.toRing",
"Int.ofNat_dvd",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"Rat",... | true |
CategoryTheory.CategoryOfElements.costructuredArrowULiftYonedaEquivalence_inverse_map | Mathlib.CategoryTheory.Elements | [
"CategoryTheory.categoryOfElements",
"CategoryTheory.Functor.Elements",
"CategoryTheory.Functor",
"Opposite",
"Equiv.instEquivLike",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"CategoryTheory.Functor.elementsMk",
"CategoryTheory.Functor.category",... | true |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Icc_factorization_eq_pow_dvd._simp_1_3 | Mathlib.Data.Nat.Factorization.Basic | [
"Preorder.toLT",
"Finset",
"Preorder.toLE",
"Membership.mem",
"Finset.Ico",
"LE.le",
"And",
"Finset.instSetLike",
"LT.lt",
"propext",
"LocallyFiniteOrder",
"Eq",
"SetLike.instMembership",
"Preorder",
"Finset.mem_Ico"
] | false |
NonUnitalSubsemiring.map._proof_3 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | [
"Subsemigroup.map",
"NonUnitalSubsemiring.toSubsemigroup",
"HMul.hMul",
"Membership.mem",
"MulHomClass.toMulHom",
"Distrib.toMul",
"Subsemigroup.carrier",
"NonUnitalSubsemiring",
"NonUnitalNonAssocSemiring.toDistrib",
"NonUnitalRingHomClass",
"Subsemigroup.mul_mem'",
"NonUnitalNonAssocSemiring... | false |
Lean.Meta.ParamInfo.binderInfo._default | Lean.Meta.Basic | [
"id",
"Lean.BinderInfo.default",
"Lean.BinderInfo"
] | false |
TruncatedWittVector.commutes | Mathlib.RingTheory.WittVector.Compare | [
"Nat.Prime",
"ZMod.commRing",
"CommSemiring.toSemiring",
"Nat.instMonoid",
"pow_dvd_pow",
"RingHom",
"TruncatedWittVector.instCommRing",
"Fact",
"LE.le",
"instLENat",
"ZMod",
"Monoid.toPow",
"RingHom.ext_zmod",
"RingHom.comp",
"TruncatedWittVector.truncate",
"CommRing.toCommSemiring",
... | true |
Choose.choose_modEq_choose_mul_prod_range_choose._f | Mathlib.Data.Nat.Choose.Lucas | [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Semigroup.toMul",
"Nat.Prime",
"Nat.choose",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"Monoid.toMu... | false |
smul_eq_iff_eq_invOf_smul | Mathlib.Algebra.Group.Action.Basic | [
"Monoid",
"MulOne.toOne",
"Units.instMulAction",
"instHSMul",
"Monoid.toMulOneClass",
"Invertible.invOf",
"Units",
"MulOne.toMul",
"Units.instGroup",
"MulOneClass.toMulOne",
"Iff",
"MulAction",
"Monoid.toSemigroup",
"Invertible",
"unitOfInvertible",
"HSMul.hSMul",
"SemigroupAction.to... | true |
ISize.add_neg_eq_sub | Init.Data.SInt.Lemmas | [
"instAddISize",
"ISize.toBitVec_inj",
"HSub.hSub",
"BitVec",
"BitVec.add_neg_eq_sub",
"System.Platform.numBits",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"instSubISize",
"ISize.toBitVec",
"Iff.mp",
"ISize.instNeg",
"ISize",
"Eq",
"Neg.neg"
] | true |
lt_of_lt_of_eq' | Mathlib.Order.Basic | [
"flip",
"lt_of_eq_of_lt",
"LT.lt",
"Eq",
"LT"
] | true |
Std.Rxc.Iterator._sizeOf_1 | Init.Data.Range.Polymorphic.RangeIterator | [
"Std.Rxc.Iterator",
"Option._sizeOf_inst",
"instOfNatNat",
"Std.Rxc.Iterator.rec",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"SizeOf",
"OfNat.ofNat",
"Option"
] | false |
Lean.Meta.Structural.isInstMulNat | Lean.Meta.NatInstTesters | [
"Pure.pure",
"Unit.unit",
"Lean.Meta.State",
"Lean.Expr.cleanupAnnotations",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Applicative.toPure",
"Bool.true",
"Unit",
"Lean.Core.CoreM",
"Lean.Meta.instMonadMetaM",
"StateRefT'",
"StateRefT'.instMonad",
"Bool",
... | true |
BitVec.toInt_srem | Init.Data.BitVec.Bitblast | [
"BitVec.neg_zero",
"Iff.mpr",
"Int.tmod",
"BitVec.msb_umod_eq_false_of_left",
"Eq.mpr",
"Int.ofNat_tmod",
"BitVec.toInt_zero",
"BitVec.toNat_umod",
"congrArg",
"Int.tmod_zero",
"BitVec.neg_eq_zero_iff",
"BitVec.msb_umod_of_le_of_ne_zero_of_le",
"BitVec",
"Int.neg_tmod",
"BitVec.le_intMin... | true |
Option.length_toList_le | Init.Data.Option.List | [
"congrArg",
"Option.toList",
"Option.casesOn",
"Option.some",
"instOfNatNat",
"Nat.le_refl._simp_1",
"LE.le",
"instLENat",
"Option.none",
"Nat",
"True",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"congrFun'",
"Nat.zero_add",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"List.length",
"Nat.zero_... | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.LinearIsometryEquiv.toMatrix_mem_unitaryGroup._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | [
"InnerProductSpace.toNormedSpace",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Matrix.module",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Matrix",
"NormedSpace.toModule",
"NormedDivisionRing.toDivisionRing",
"NormedField.toField",
"NonUnitalNonAssocRin... | false |
PosNum.isOne | Mathlib.Data.Num.Basic | [
"PosNum.isOne.match_1",
"Bool.true",
"Unit",
"Bool",
"PosNum",
"Bool.false"
] | true |
NonUnitalStarAlgHom.subsingleton | Mathlib.Algebra.Star.NonUnitalSubalgebra | [
"NonUnitalStarAlgebra.mem_bot",
"NonUnitalStarAlgebra.mem_top",
"Lattice.toSemilatticeSup",
"MonoidHom.instFunLike",
"NonUnitalAlgSemiHomClass.toDistribMulActionSemiHomClass",
"instSMulOfMul",
"outParam",
"MonoidHom",
"CompleteLattice.toLattice",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring"... | true |
Set.biInter_gt_eq_iInf | Mathlib.Data.Set.Lattice | [
"biInf_gt_eq_iInf",
"NoMinOrder",
"Set.iInter",
"GT.gt",
"CompleteBooleanAlgebra.toCompleteLattice",
"Eq",
"CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra",
"Set.instCompleteAtomicBooleanAlgebra",
"LT",
"Set"
] | true |
ProbabilityTheory.iInf_rat_gt_defaultRatCDF | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | [
"Subtype.coe_mk",
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Rat.instOfNat",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"le_refl",
"Set.mem_range",
"Real.partialOrder",
"Real.instLE",... | true |
TopModuleCat.coker._proof_2 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | [
"TopModuleCat.instCategory",
"Submodule",
"RingHomSurjective.ids",
"AddMonoid.toAddSemigroup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Submodule.Quotient.addCommGroup",
"QuotientModule.Quotient.topologicalSpace",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"Submod... | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.notAnInvariantUse | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | [
"_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult",
"_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.notAnInvariantUse"
] | true |
CategoryTheory.GradedObject.cofanMapObjComp._proof_2 | Mathlib.CategoryTheory.GradedObject | [
"Eq.mpr",
"congrArg",
"Membership.mem",
"Set.instSingletonSet",
"id",
"Set.mem_singleton_iff",
"Set.preimage",
"propext",
"Eq.refl",
"Singleton.singleton",
"Eq",
"Set.instMembership",
"Set.mem_preimage",
"Set"
] | false |
Lean.Elab.Term.PatternElabException.mk | Lean.Elab.Match | [
"List",
"Lean.Elab.Term.PatternElabException",
"Lean.Elab.Term.PatternElabException.mk",
"Nat",
"Lean.Exception"
] | true |
_private.Mathlib.ModelTheory.Equivalence.0.FirstOrder.Language.Theory.bot_imp._simp_1_2 | Mathlib.ModelTheory.Equivalence | [
"False",
"FirstOrder.Language.BoundedFormula.Realize",
"Bot.bot",
"FirstOrder.Language.BoundedFormula.realize_bot",
"FirstOrder.Language.BoundedFormula.instBot",
"FirstOrder.Language.Structure",
"Nat",
"propext",
"FirstOrder.Language",
"FirstOrder.Language.BoundedFormula",
"Fin",
"Eq"
] | false |
HomologicalComplex.mapBifunctor₁₂.D₁.eq_1 | Mathlib.Algebra.Homology.BifunctorAssociator | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HomologicalComplex.mapBifunctor₁₂.d₁",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Functor.category",
"CategoryTheory.functorCategoryPreadditive",
"HomologicalComplex",... | true |
Ideal.Quotient.algEquivOfEqMap | Mathlib.RingTheory.Ideal.Over | [
"Ideal.Quotient.commSemiring",
"RingEquiv.toEquiv",
"Ideal.Quotient.algebraOfLiesOver",
"CommRing",
"CommSemiring.toSemiring",
"Ideal.Quotient.algEquivOfEqMap._proof_3",
"Algebra",
"Ideal.LiesOver",
"Distrib.toAdd",
"Ideal.map",
"RingEquivClass.toRingEquiv",
"AlgEquiv.mk",
"Ideal",
"Ideal.... | true |
Lean.Doc.MarkdownM.State._sizeOf_1 | Lean.DocString.Markdown | [
"Lean.Doc.MarkdownM.State.rec",
"String",
"Lean.Doc.MarkdownM.State",
"instOfNatNat",
"Array._sizeOf_inst",
"Array",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"String._sizeOf_inst",
"Prod._sizeOf_inst",
"Prod",
"OfNat.ofNat"
] | false |
essInf_eq_iInf | Mathlib.MeasureTheory.Function.EssSup | [
"MeasureTheory.ae",
"Iff.mpr",
"Eq.mpr",
"MeasureTheory.Measure",
"iInf",
"Filter.liminf",
"congrArg",
"MeasureTheory.ae_eq_top",
"CompleteLattice.toConditionallyCompleteLattice",
"essInf",
"Set.instSingletonSet",
"id",
"Ne",
"MeasurableSpace",
"ENNReal",
"Zero.toOfNat0",
"Eq.refl",
... | true |
Lean.Elab.Term.CoeExpansionTrace.rec | Lean.Elab.Term.TermElabM | [
"Lean.Elab.Term.CoeExpansionTrace",
"Lean.Elab.Term.CoeExpansionTrace.mk",
"List",
"Lean.Name"
] | false |
csInf_le_csSup_of_nonempty_inter._auto_3 | Mathlib.Order.ConditionallyCompleteLattice.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
CategoryTheory.FreeBicategory.liftHom.eq_3 | Mathlib.CategoryTheory.Bicategory.Free | [
"CategoryTheory.FreeBicategory.Hom.comp",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.FreeBicategory.liftHom",
"CategoryTheory.FreeBicategory",
"CategoryTheory.FreeBicategory.Hom",
"Prefunctor",
"CategoryTheory.CategoryStruct.comp",
"Quiver",
"Eq.refl",
"CategoryTheor... | true |
Sublattice.coe_eq_univ | Mathlib.Order.Sublattice | [
"Sublattice.instTop",
"Sublattice",
"Eq.mpr",
"Lattice",
"congrArg",
"Set.univ",
"Iff.rfl",
"id",
"Sublattice.coe_inj",
"Iff",
"SetLike.coe",
"propext",
"Sublattice.instSetLike",
"Top.top",
"Eq.symm",
"Eq",
"Sublattice.coe_top",
"Set"
] | true |
Lean.Lsp.SemanticTokensLegend.ctorIdx | Lean.Data.Lsp.LanguageFeatures | [
"Nat",
"Lean.Lsp.SemanticTokensLegend"
] | false |
Units.rec | Mathlib.Algebra.Group.Units.Defs | [
"Monoid",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"Units",
"MulOne.toMul",
"MulOneClass.toMulOne",
"Units.mk",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"instHMul"
] | false |
List.isEqv_cons_cons | Init.Data.List.Basic | [
"List.isEqv",
"Bool.and",
"List.cons",
"List",
"Bool",
"Eq",
"rfl"
] | true |
NumberField.mixedEmbedding.euclidean.integerLattice.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | [
"Submodule",
"Real",
"Ring.toNonAssocRing",
"NumberField.mixedEmbedding.matrixToStdBasis._proof_1",
"NumberField.InfinitePlace.IsComplex",
"WithLp.instAddCommGroup",
"Subtype",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"AddMonoidWithOne.toNatCast",
"EuclideanSpace",
"Int",
"AddCommM... | true |
Filter.Germ.instInvOneClass.eq_1 | Mathlib.Order.Filter.Germ.Basic | [
"InvOneClass.mk",
"InvOneClass.toOne",
"Filter.Germ.instInvOneClass._proof_1",
"Filter.Germ.instInvOneClass",
"Filter.Germ.instInv",
"InvOneClass",
"Filter.Germ",
"Filter.Germ.instOne",
"Eq.refl",
"InvOneClass.toInv",
"Eq",
"Filter"
] | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | [
"Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst._proof_6",
"Std.Sat.AIG.RefVec.get",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst._proof_4",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go._unary._proof_1",
"Std.Sat.AIG.RefVec.push",
"InvImage",
"HSub.hSub",
"W... | false |
ModularGroup.exists_row_one_eq_and_min_re | Mathlib.NumberTheory.Modular | [
"Eq.mpr",
"Real.instLE",
"Real",
"instHSMul",
"Matrix.SpecialLinearGroup",
"UpperHalfPlane.SLAction",
"Real.lattice",
"ModularGroup.bottom_row_surj",
"abs",
"congrArg",
"Matrix",
"ModularGroup.tendsto_abs_re_smul",
"Set.univ",
"PartialOrder.toPreorder",
"instDecidableEqFin",
"AddGroupW... | true |
IsClosed.powerset_hausdorff | Mathlib.Topology.UniformSpace.Closeds | [
"UniformSpace",
"Eq.mpr",
"IsClosed.isOpen_compl",
"congrArg",
"Compl.compl",
"setOf",
"Set.powerset",
"UniformSpace.hausdorff.isOpen_inter_nonempty_of_isOpen",
"id",
"HasSubset.Subset",
"Set.instInter",
"Set.instCompl",
"Inter.inter",
"IsClosed",
"funext",
"Set.Nonempty",
"_private.... | true |
RingEquiv.ext_iff | Mathlib.Algebra.Ring.Equiv | [
"HEq.refl",
"RingEquiv.instEquivLike",
"Mul",
"Eq.casesOn",
"RingEquiv.ext",
"Iff",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"RingEquiv",
"Eq.symm",
"Eq",
"DFunLike.coe",
"Add",
"EquivLike.toFunLike"
] | true |
ContinuousLinearMap.mk_id | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | [
"LinearMap.id",
"ContinuousLinearMap.mk",
"ContinuousLinearMap.id",
"AddCommMonoid",
"ContinuousLinearMap",
"TopologicalSpace",
"continuous_id",
"Semiring",
"Module",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Eq",
"rfl"
] | true |
Nonneg.coeRingHom._proof_2 | Mathlib.Algebra.Order.Nonneg.Basic | [
"HMul.hMul",
"MulZeroClass.toMul",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Subtype",
"LE.le",
"instDistribOfSemiring",
"PosMulMono",
"Distrib.toMul",
"Nonneg.coe_mul",
"Semiring",
"Zero.toOfNat0",
"Nonneg.mul",
"OfNat.ofNat",
"Subtype.val",
"Eq",
"MulZeroClass.... | false |
Finsupp.single_finset_sum | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"Finset",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"AddZero.toZero",
"AddCommMonoid.toAddMonoid",
"Finsupp.single_finsetSum",
"Eq",
"Finset.sum",
"Finsupp",
"Finsupp.single"
] | true |
Lean.Doc.instFromDocArgOption | Lean.Elab.DocString | [
"Lean.Doc.instFromDocArgOption._private_1",
"Lean.Doc.DocArg",
"Lean.Doc.FromDocArg.mk",
"Lean.Doc.FromDocArg",
"Option"
] | true |
FunLike.divisionCommMonoid._proof_5 | Mathlib.Data.FunLike.Group | [
"DivisionCommMonoid.toDivisionMonoid",
"Pow",
"DivisionCommMonoid",
"FunLike.coe_pow",
"Pi.instPow",
"DivInvMonoid.toMonoid",
"DivisionMonoid.toDivInvMonoid",
"Monoid.toPow",
"IsPowApply",
"HPow.hPow",
"Nat",
"instHPow",
"Eq",
"DFunLike.coe",
"FunLike"
] | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleFoldingRange.addRange | Lean.Server.FileWorker.RequestHandling | [
"Pure.pure",
"Lean.Server.RequestContext",
"bne",
"Lean.Server.RequestError",
"Array.push",
"modify",
"Monad.toApplicative",
"Lean.Server.RequestM",
"Lean.FileMap",
"_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleFoldingRange.match_10",
"Option.some",
"ReaderT.i... | true |
Sum.traverse_map | Mathlib.Control.Traversable.Instances | [
"Pure.pure",
"Traversable.toFunctor",
"Sum.traverse.match_1",
"Function.comp",
"Sum.casesOn",
"Sum",
"id",
"Sum.inl",
"Applicative.toPure",
"Applicative",
"Sum.traverse",
"Sum.inr",
"Eq.ndrec",
"Applicative.toFunctor",
"Eq.refl",
"Eq.symm",
"Eq",
"Functor.map",
"instTraversableSu... | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueProds.of_mulOpposite.match_1_1 | Mathlib.Algebra.Group.UniqueProds.Basic | [
"UniqueMul",
"Finset",
"MulOpposite",
"Mul",
"Finset.map",
"Membership.mem",
"Exists",
"Function.Embedding",
"And.casesOn",
"And",
"Exists.casesOn",
"Finset.instSetLike",
"And.intro",
"Exists.intro",
"SetLike.instMembership",
"MulOpposite.instMul"
] | false |
CategoryTheory.Limits.chosenEndFunctor._proof_4 | Mathlib.CategoryTheory.Limits.Chosen.End | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.chosenEnd.map",
"CategoryTheory.Limits.ChosenEndsOfShape",
"True",
"eq_self",
"CategoryTheory.CategoryStruct.comp",
"of_eq_true",
... | false |
_private.Init.Data.Int.Gcd.0.Int.lcm_eq_one_iff.match_1_1 | Init.Data.Int.Gcd | [
"Dvd.dvd",
"Int",
"Int.instDvd",
"And.casesOn",
"And",
"instOfNat",
"And.intro",
"OfNat.ofNat"
] | false |
RingTheory.Sequence.IsRegular.mk._flat_ctor | Mathlib.RingTheory.Regular.RegularSequence | [
"Submodule",
"CommRing",
"instHSMul",
"Semiring.toModule",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.hasQuotient",
"AddCommGroup",
"Ne",
"Submodule.instTop",
"RingTheory.Sequence.IsRegular.mk",
"Ideal",
"IsScalarTower.left",
"GetElem.getElem",
"HasQuotient.Quo... | false |
Std.Tactic.BVDecide.Normalize.BitVec.shiftLeft_zero' | Std.Tactic.BVDecide.Normalize.BitVec | [
"congrArg",
"GetElem.getElem.congr_simp",
"HShiftLeft.hShiftLeft",
"BitVec.shiftLeft",
"BitVec",
"id",
"instOfNatNat",
"BitVec.toNat",
"BitVec.ofNat",
"GetElem.getElem",
"BitVec.shiftLeft_zero",
"BitVec.toNat_ofNat",
"Nat",
"LT.lt",
"True",
"BitVec.instHShiftLeft",
"eq_self",
"Bool... | true |
Std.ExtHashSet.get!_diff_of_not_mem_left | Std.Data.ExtHashSet.Lemmas | [
"Inhabited.default",
"Std.ExtHashSet",
"Membership.mem",
"Std.ExtHashSet.instSDiffOfEquivBEqOfLawfulHashable",
"LawfulHashable",
"Std.ExtHashSet.get!",
"SDiff.sdiff",
"Unit",
"EquivBEq",
"Std.ExtHashSet.inner",
"Inhabited",
"Hashable",
"Std.ExtHashSet.instMembershipOfEquivBEqOfLawfulHashable... | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_3.eq_1 | Std.Data.DTreeMap.Internal.Zipper | [
"Unit.unit",
"Std.DTreeMap.Internal.Impl.inner",
"Unit",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.match_3",
"Eq.refl",
"Eq",
"Std.DTreeMap.Internal.Impl"
] | true |
HomotopyCategory.quasiIso | Mathlib.Algebra.Homology.Localization | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"instCategoryHomotopyCategory",
"ComplexShape",
"CategoryTheory.Functor.map",
"CategoryTheory.Preadditive",
"CategoryTheory.Preadditive.preadditiveHasZeroMorphisms",
"HomotopyCategory... | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.role.bracketed._unsafe_rec | Lean.DocString.Parser | [
"Lean.Doc.Parser.InlineCtxt",
"HAndThen.hAndThen",
"instHAndThenOfAndThen",
"Lean.Parser.instAndThenParserFn",
"Lean.Parser.manyFn",
"Unit",
"Lean.Parser.chFn",
"Lean.Doc.Parser.inline._unsafe_rec",
"Lean.Doc.Parser.recoverBlock",
"Lean.Parser.atomicFn",
"Bool.false",
"Lean.Parser.ParserFn",
... | false |
Lean.Parser.Term.structInstFieldDef | Lean.Parser.Term | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"Lean.Parser.optional",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Nat",
"Lean.Parser.withCache",
"OfNat.ofNat",
"Lean.Parser.mkAntiquot",
"Bool.fal... | true |
Matrix.isSimplyLaced_iff_of_linearOrder | Mathlib.Data.Matrix.Cartan | [
"Preorder.toLT",
"congrArg",
"Matrix",
"LinearOrder",
"PartialOrder.toPreorder",
"Matrix.IsSimplyLaced",
"SemilatticeInf.toPartialOrder",
"Eq.mp",
"DistribLattice.toLattice",
"Int.instNegInt",
"Ne",
"Int",
"Or.casesOn",
"LT.lt.ne'",
"Iff",
"instOfNat",
"congr",
"LT.lt",
"Iff.intr... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.