name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
WittVector.frobeniusRotationCoeff | Mathlib.RingTheory.WittVector.FrobeniusFractionField | [
"Nat.Prime",
"WittVector.frobeniusRotationCoeff.match_1",
"InvImage",
"AddGroupWithOne.toAddMonoidWithOne",
"WellFounded.Nat.fix",
"WittVector.RecursionBase.solution",
"Field.toDivisionRing",
"Fact",
"WittVector.frobeniusRotationCoeff._proof_1",
"Ne",
"DivisionRing.toRing",
"instOfNatNat",
"... | true |
Std.Sat.AIG.Cache.WF.below.rec | Std.Sat.AIG.Basic | [
"Std.Sat.AIG.Decl",
"Array.push",
"Std.Sat.AIG.Cache.WF.below.push_id",
"Std.Sat.AIG.instHashableDecl",
"Std.Sat.AIG.instDecidableEqDecl",
"Std.Sat.AIG.Cache.WF.below",
"Std.Sat.AIG.Cache.WF",
"Std.Sat.AIG.Cache.WF.below.empty",
"Std.HashMap",
"Std.HashMap.instEmptyCollection",
"instBEqOfDecidab... | false |
CategoryTheory.LocalizerMorphism.IsLeftDerivabilityStructure | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Basic | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.LocalizerMorphism.IsLeftDerivabilityStructure.mk",
"CategoryTheory.Category",
"CategoryTheory.LocalizerMorphism"
] | true |
_private.Aesop.Forward.State.0.Aesop.instBEqPatSubstSource.beq._sparseCasesOn_1 | Aesop.Forward.State | [
"Aesop.PatSubstSource.hyp",
"Nat.ne_of_beq_eq_false",
"Aesop.PatSubstSource.target",
"Nat.shiftRight",
"Aesop.PatSubstSource.ctorIdx",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Nat.land",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Aesop.PatSubstSource",
"Aesop.PatSu... | false |
MeasureTheory.StronglyMeasurable.real_toNNReal | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | [
"NNReal.instTopologicalSpace",
"Real",
"PseudoMetricSpace.toUniformSpace",
"NNReal",
"MeasurableSpace",
"Continuous.comp_stronglyMeasurable",
"continuous_real_toNNReal",
"Real.pseudoMetricSpace",
"MeasureTheory.StronglyMeasurable",
"UniformSpace.toTopologicalSpace",
"Real.toNNReal"
] | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.balance1.match_1_2 | Batteries.Data.RBMap.WF | [
"Batteries.RBNode",
"Ordering",
"Batteries.RBNode.cmpLT",
"And.casesOn",
"And",
"Batteries.RBColor.red",
"And.intro",
"Batteries.RBNode.All",
"Batteries.RBNode.node"
] | false |
_private.Mathlib.Data.List.Intervals.0.List.Ico.mem._proof_1_2 | Mathlib.Data.List.Intervals | [
"Lean.Grind.of_eq_eq_true",
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"HMul.hMul",
"of_decide_eq_true",
"Lean.Grind.not_and",
"eq_false",
"Lean.Grind.iff_eq",
"Int.Linear.Expr.eq_of_norm_eq",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Lean.Grind.not_or",
"... | false |
ContinuousOpenMap.coe_id | Mathlib.Topology.Hom.Open | [
"id",
"ContinuousOpenMap.instFunLike",
"ContinuousOpenMap.id",
"TopologicalSpace",
"Eq",
"DFunLike.coe",
"rfl",
"ContinuousOpenMap"
] | true |
PrincipalSeg.image_Iio | Mathlib.Order.InitialSeg | [
"Preorder.toLT",
"PrincipalSeg",
"PartialOrder.toPreorder",
"PrincipalSeg.toRelEmbedding",
"PartialOrder",
"InitialSeg.image_Iio",
"PrincipalSeg.mem_range_of_rel",
"RelEmbedding",
"instIsTransLt",
"LT.lt",
"Set.image",
"InitialSeg.mk",
"Set.Iio",
"Eq",
"DFunLike.coe",
"RelEmbedding.ins... | true |
_private.Init.Omega.Int.0.Lean.Omega.Int.ofNat_min._simp_1_1 | Init.Omega.Int | [
"Int",
"LE.le",
"instLENat",
"Nat.cast",
"Nat",
"propext",
"instNatCastInt",
"Int.ofNat_le",
"Eq",
"Int.instLEInt"
] | false |
KaehlerDifferential.endEquiv._proof_1 | Mathlib.RingTheory.Kaehler.Basic | [
"CommRing",
"Algebra.to_smulCommClass",
"instAddCommGroupKaehlerDifferential",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Algebra",
"Algebra.id",
"smulCommClass_self",
"CommRing.toCommSemiring",
"CommMonoid.toMonoid",
"KaehlerDifferential.module'",
"Monoid.toSemigroup",
"Kae... | false |
ByteArray.set!.match_1 | Init.Data.ByteArray.Basic | [
"ByteArray.mk",
"ByteArray.casesOn",
"Array",
"Nat",
"ByteArray",
"UInt8"
] | false |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocs.match_1 | Lean.Linter.MissingDocs | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Lean.Linter.MissingDocs.Handler",
"_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocs._sparseCasesOn_1",
"Option"
] | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.map_map_equiv._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | [
"List.Perm",
"Std.DTreeMap.Internal.Impl.Equiv",
"propext",
"Std.DTreeMap.Internal.Impl.toListModel",
"Std.DTreeMap.Internal.Impl.equiv_iff_toListModel_perm",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Sigma"
] | false |
BitVec.DivModState.Lawful.hw | Init.Data.BitVec.Bitblast | [
"BitVec.DivModState.Lawful",
"instOfNatNat",
"Nat",
"LT.lt",
"BitVec.DivModState.Lawful.hw._proof_2",
"instLTNat",
"OfNat.ofNat",
"BitVec.DivModState",
"BitVec.DivModArgs"
] | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_inst | Lean.Meta.IndPredBelow | [
"_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context"
] | false |
KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale._proof_2 | Mathlib.RingTheory.Etale.Kaehler | [
"CommRing",
"CommSemiring.toSemiring",
"RingHomInvPair",
"CommRing.toCommSemiring",
"RingHomInvPair.ids",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
Lean.IR.LogEntry.noConfusionType | Lean.Compiler.IR.CompilerM | [
"Lean.IR.LogEntry",
"Lean.IR.LogEntry.casesOn",
"Array",
"Lean.IR.Decl",
"Std.Format",
"Lean.Name",
"Eq"
] | false |
AddCommute.add_right | Mathlib.Algebra.Group.Commute.Defs | [
"AddSemiconjBy.add_right",
"AddSemigroup",
"AddCommute",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd"
] | true |
DFinsupp.eq_mk_support | Mathlib.Data.DFinsupp.Defs | [
"DFinsupp.ext",
"Classical.ite_not",
"DFinsupp.mk",
"dite_congr",
"Classical.decidable_of_decidable_not",
"congrArg",
"Finset",
"Decidable",
"Membership.mem",
"DFinsupp.instDFunLike",
"Set.Elem",
"id",
"Subtype",
"Ne",
"DFinsupp.support",
"dite",
"right_eq_ite_iff._simp_1",
"Subtyp... | true |
Lean.Elab.WF.EqnInfo.mk | Lean.Elab.PreDefinition.WF.Eqns | [
"Lean.Elab.FixedParamPerms",
"Lean.Meta.ArgsPacker",
"Lean.Expr",
"Array",
"List",
"Lean.Elab.WF.EqnInfo",
"Lean.Name",
"Lean.Elab.WF.EqnInfo.mk"
] | true |
FilterBasis.mk._flat_ctor | Mathlib.Order.Filter.Bases.Basic | [
"Membership.mem",
"Exists",
"HasSubset.Subset",
"Set.instInter",
"Inter.inter",
"And",
"Set.Nonempty",
"FilterBasis",
"Set.instMembership",
"FilterBasis.mk",
"Set.instHasSubset",
"Set"
] | false |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.changesBefore | Lean.Widget.Diff | [
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiffTag",
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff",
"Lean.SubExpr.PosMap"
] | true |
SimplexCategoryGenRel.simplicialInsert._f | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | [
"instOfNatNat",
"List.cons",
"List",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"LT.lt",
"SimplexCategoryGenRel.simplicialInsert.match_1",
"Nat.decLt",
"instAddNat",
"List.below",
"instLTNat",
"OfNat.ofNat",
"List.nil",
"ite"
] | false |
Filter.cocompact_neBot_iff | Mathlib.Topology.Compactness.Compact | [
"Filter.NeBot",
"inferInstance",
"instNeBotCocompactOfNoncompactSpace",
"Filter.cocompact",
"TopologicalSpace",
"Iff",
"Iff.intro",
"noncompactSpace_of_neBot",
"NoncompactSpace"
] | true |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.ringId | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | [
"Lean.Meta.Grind.Arith.CommRing.RingM.Context",
"Nat"
] | true |
Equiv.piCongr.eq_1 | Mathlib.Logic.Equiv.Basic | [
"Equiv.instEquivLike",
"Equiv.trans",
"Equiv",
"Equiv.piCongrLeft",
"Equiv.piCongr",
"Equiv.piCongrRight",
"Eq.refl",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
CategoryTheory.Triangulated.TStructure.eTruncLT_map_eq_truncLTι._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | [
"WithBotTop.coe",
"WithBot.instPreorder",
"WithTop.instPreorder",
"le_top._simp_2",
"WithBot.instOrderTop",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"WithBot.instTop",
"Int",
"LE.le",
"OrderTop.toTop",
"WithTop.top",
"instLatticeInt",
"of_eq_true",
"... | false |
Std.DTreeMap.Internal.Impl.contains'.eq_1 | Std.Data.DTreeMap.Internal.Model | [
"Ord",
"Ordering",
"Std.DTreeMap.Internal.Impl.contains'",
"Std.DTreeMap.Internal.Impl.leaf",
"Bool",
"Eq.refl",
"Bool.false",
"Eq"
] | true |
TopologicalSpace.IsOpenCover.mk | Mathlib.Topology.Sets.OpenCover | [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"TopologicalSpace.Opens.instCompleteLattice",
"iSup",
"PartialOrder.toPreorder",
"TopologicalSpace.Opens",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toBoundedOrder",
"TopologicalSpace.IsOpenCover",
... | true |
IO.Error.mkResourceBusy | Init.System.IOError | [
"String",
"IO.Error.resourceBusy",
"UInt32",
"IO.Error"
] | true |
ENNReal.smul_toNNReal | Mathlib.Data.ENNReal.Action | [
"ENNReal.ofNNReal",
"instHSMul",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"id",
"NNReal",
"ENNReal.toNNReal",
"ENNReal.instCommSemiring",
"instDistribOfSemiring",
"Distrib.toMul",
"True",
"ENNReal.instSMulNNRealOfMulAction",
"eq_self",
"ENNReal",
"Semiring.toMonoid",
"of_e... | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_iSup._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | [
"Filter.instSupSet",
"iSup",
"Filter.principal",
"Eq.symm",
"Eq",
"Set.iUnion",
"Filter",
"Filter.iSup_principal",
"Set"
] | false |
Int.ldiff.eq_3 | Mathlib.Data.Int.Bitwise | [
"instHOrOfOrOp",
"Int.ldiff",
"Int.ofNat",
"Int",
"HOr.hOr",
"Nat",
"Eq.refl",
"Int.negSucc",
"Eq",
"Nat.instOrOp"
] | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.ext | Mathlib.AlgebraicTopology.ExtraDegeneracy | [
"CategoryTheory.Comma.right",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Fin.succ",
"HEq.refl",
"CategoryTheory.SimplicialObject.const",
"CategoryTheory.Functor.category",
"CategoryTheory.Comma.left",
"CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.s'_comp_ε._a... | true |
CochainComplex.XIsoOfEq_shift | Mathlib.Algebra.Homology.HomotopyCategory.Shift | [
"HomologicalComplex.instCategory",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemigroup",
"CochainComplex.instHasShiftInt",
"CochainComplex.XIsoOfEq_shift._proof_1",
"AddCancelMonoid.toAddRightCancelMonoid",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Iso",
"HomologicalCo... | true |
CategoryTheory.TwoSquare.whiskerVertical | Mathlib.CategoryTheory.GuitartExact.VerticalComposition | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.TwoSquare.whiskerLeft",
"CategoryTheory.TwoSquare.whiskerRight",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.TwoSquare",
"CategoryTheory.Category"
] | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxo.Iterator.instIteratorLoop.loop.wf.eq_def | Init.Data.Range.Polymorphic.RangeIterator | [
"Pure.pure",
"_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxo.Iterator.instIteratorLoop.loop.wf._unary.eq_def",
"_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loop.wf.match_1",
"Std.PRange.UpwardEnumerable",
"Monad.toApplicative",
"Std.PRange.LawfulUpw... | true |
BitVec.extractAndExtendAux._unary | Init.Data.BitVec.Bitblast | [
"HMul.hMul",
"BitVec.extractAndExtendAux._proof_6",
"BitVec.instHAppendHAddNat",
"InvImage",
"HSub.hSub",
"WellFounded.Nat.fix",
"BitVec.extractAndExtendAux._proof_4",
"BitVec.extractAndExtendAux._unary._proof_1",
"BitVec",
"PSigma.casesOn",
"BitVec.extractAndExtendAux._unary._proof_3",
"instS... | false |
UInt64.toInt64_sub | Init.Data.SInt.Lemmas | [
"UInt64",
"HSub.hSub",
"Int64",
"instHSub",
"instSubUInt64",
"UInt64.toInt64",
"instSubInt64",
"Eq",
"rfl"
] | true |
Equiv.pprodProd_apply | Mathlib.Logic.Equiv.Prod | [
"Equiv.instEquivLike",
"PProd.fst",
"PProd.snd",
"Equiv",
"Prod.mk",
"PProd",
"Eq.refl",
"Equiv.pprodProd",
"Prod",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Set.rangeFactorization_eq_rangeFactorization_iff | Mathlib.Data.Set.Operations | [
"Set.mem_range_self",
"congrArg",
"Membership.mem",
"Set.Elem",
"iff_self",
"Iff",
"True",
"Subtype.mk.injEq",
"of_eq_true",
"congrFun'",
"Set.range",
"Set.rangeFactorization",
"Eq",
"Set.instMembership",
"Eq.trans",
"Set"
] | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetEquiv._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | [
"NumberField.instCommRingRingOfIntegers",
"congrArg",
"CommSemiring.toSemiring",
"Membership.mem",
"Units",
"Set.Elem",
"NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul_stabilizer",
"id",
"Equiv",
"Subtype",
"QuotientGroup.instHasQuotientSubgroup",
"Quotient.out",
"Subgroup"... | false |
stronglyMeasurable_deriv_with_param | Mathlib.Analysis.Calculus.FDeriv.Measurable | [
"Set.mem_range_self",
"Iff.mpr",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Submodule",
"measurable_deriv_with_param",
"Set.image_univ",
"Continuous",
"CompleteSpace",
"NormedSpace.toIsBoundedSMul",
"dense_univ",
"NormedSpace",
"congrArg",
"NormedAddCommGroup.toMetricSpace",
"Dist... | true |
Batteries.Tactic.Lint.env_linter | Batteries.Tactic.Lint.Basic | [
"Lean.ParserDescr.nonReservedSymbol",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
AddSubsemigroup.prodEquiv.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | [
"AddSubsemigroup.prodEquiv._proof_1",
"AddSubsemigroup.instSetLike",
"Prod.instAdd",
"Membership.mem",
"AddSubsemigroup.instAddMemClass",
"Subtype",
"AddSubsemigroup.prodEquiv._proof_2",
"SetLike.coe",
"AddMemClass.add",
"AddEquiv.mk",
"AddSubsemigroup",
"Equiv.Set.prod",
"AddEquiv",
"Eq.r... | true |
SemiRingCat.hasForgetToAddCommMonCat._proof_2 | Mathlib.Algebra.Category.Ring.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddCommMonCat.instCategory",
"AddCommMonCat",
"SemiRingCat.Hom.hom",
"SemiRingCat.carrier",
"id",
"RingHom.toAddMonoidHom",
"SemiRingCat.semiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddCommMonCat.ofHom",
"SemiRingCat.instSemi... | false |
Topology.WithScott.ofScott | Mathlib.Topology.Order.ScottTopology | [
"Equiv",
"Topology.WithScott",
"Equiv.refl"
] | true |
UniformSpace.hausdorff.instCompactSpaceSet | Mathlib.Topology.UniformSpace.Closeds | [
"UniformSpace",
"Eq.mpr",
"le_refl",
"TopologicalSpace.vietoris.specializes_closure",
"congrArg",
"TopologicalSpace.vietoris.instCompactSpaceSet",
"TopologicalSpace.vietoris",
"Set.univ",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"nhds",
"id",
"LE.le",
"Co... | true |
sbtw_const_sub_iff | Mathlib.Analysis.Convex.Between | [
"AddCommGroup.toAddCommMonoid",
"sbtw_const_vsub_iff",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"PartialOrder",
"AddCommGroup",
"addGroupIsAddTorsor",
"SubNegMonoid.toSub",
"Iff",
"instHSub",
"AddGroup.toSubNegMonoid",
"Module",
"Ring.toSemiring",
"Ring",
"Sbtw"
] | true |
AddCommGrpCat.kernelIsoKer._proof_3 | Mathlib.Algebra.Category.Grp.Limits | [
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"AddMonoidHom.ext",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"AddCommGrpCat.carrier",
"AddSu... | false |
TopCat.Presheaf.stalkCongr_hom | Mathlib.Topology.Sheaves.Stalks | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopCat.Presheaf.stalkSpecializes",
"TopCat.Presheaf",
"TopCat.Presheaf.stalkCongr",
"TopCat.Presheaf.stalk",
"TopCat.str",
"TopCat.carrier",
"CategoryTheory.Limits.HasColimits",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Top... | true |
UInt64._sizeOf_inst.eq._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.415 | Mathlib.Util.CompileInductive | [
"UInt64",
"UInt64._sizeOf_inst._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.414",
"UInt64._sizeOf_inst",
"Eq.refl",
"SizeOf",
"Eq"
] | false |
Lean.Meta.ElimAltInfo.mk | Lean.Meta.Tactic.ElimInfo | [
"Lean.Meta.ElimAltInfo",
"Lean.Meta.ElimAltInfo.mk",
"Nat",
"Bool",
"Lean.Name",
"Option"
] | true |
CategoryTheory.Limits.DiagramOfCones.id | Mathlib.CategoryTheory.Limits.Fubini | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.Cone.pt",
"CategoryTheory.Functor.map",
"CategoryTheory.Limits.ConeMorphism.hom",
"CategoryT... | true |
Finset.lcm_congr | Mathlib.Algebra.GCDMonoid.Finset | [
"MulOne.toOne",
"Finset",
"instCommutativeLcm",
"NormalizedGCDMonoid",
"Membership.mem",
"instAssociativeLcm",
"Finset.fold_congr",
"CommMonoidWithZero.toMonoidWithZero",
"MulZeroOneClass.toMulOneClass",
"GCDMonoid.lcm",
"MulOneClass.toMulOne",
"MonoidWithZero.toMulZeroOneClass",
"Finset.ins... | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | [
"Lean.Meta.Grind.Arith.Cutsat.LeCnstr.casesOn",
"Lean.Meta.Grind.Arith.Cutsat.LeCnstr",
"Eq",
"Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof",
"Int.Linear.Poly"
] | false |
Std.TreeSet.maxD_eq_getLastD_toList | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeSet.toList",
"Std.TreeMap.maxKeyD_eq_getLastD_keys",
"Ordering",
"Std.TreeSet.inner",
"Std.TransCmp",
"Std.TreeSet.maxD",
"Unit",
"List.getLastD",
"Eq"
] | true |
Algebra.adjoin_root_eq_top_of_isSplittingField | Mathlib.FieldTheory.KummerExtension | [
"Iff.mpr",
"Eq.mpr",
"Polynomial.C",
"Lattice.toSemilatticeSup",
"adjoinRootXPowSubCEquiv_symm_eq_root",
"AdjoinRoot",
"Set.image_singleton",
"AlgEquiv.toAlgHom",
"Algebra.algebraMap",
"AlgEquiv.symm",
"CompleteLattice.toLattice",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.... | true |
Matrix.mvPolynomialX | Mathlib.LinearAlgebra.Matrix.MvPolynomial | [
"Equiv.instEquivLike",
"Matrix",
"Matrix.of",
"MvPolynomial.X",
"Equiv",
"Prod.mk",
"CommSemiring",
"MvPolynomial",
"Prod",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Std.Do.SPred.and_curry | Std.Do.SPred.Laws | [
"Iff.rfl",
"ULift",
"id",
"Prod.mk",
"List.rec",
"Std.Do.SVal.StateTuple",
"Std.Do.SPred.bientails",
"List.cons",
"List",
"And",
"Std.Do.SPred.and",
"Std.Do.SVal.curry",
"ULift.up",
"ULift.down",
"List.nil"
] | true |
AddOpposite.instIsUniformAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | [
"AddGroup.toSubtractionMonoid",
"UniformSpace",
"NegZeroClass.toNeg",
"instUniformSpaceProd",
"UniformContinuous.neg",
"AddMonoid.toAddSemigroup",
"Function.comp",
"AddOpposite.uniformContinuous_unop",
"AddOpposite",
"instUniformSpaceAddOpposite",
"AddOpposite.uniformContinuous_op",
"Subtracti... | true |
_private.Batteries.Tactic.GeneralizeProofs.0.Batteries.Tactic._aux_Batteries_Tactic_GeneralizeProofs___elabRules_Batteries_Tactic_generalizeProofsElab_1.match_9 | Batteries.Tactic.GeneralizeProofs | [
"Lean.FVarId",
"Prod.mk",
"Array",
"Bool",
"Prod",
"Prod.casesOn"
] | false |
_private.Std.Time.Date.Unit.Week.0.Std.Time.Week.Ordinal.instLawfulEqOrdOfMonth._proof_1 | Std.Time.Date.Unit.Week | [
"Int",
"LE.le",
"instOfNat",
"OfNat.ofNat",
"Std.LawfulEqOrd",
"Std.Time.Internal.Bounded.instLawfulEqOrd",
"Int.instLEInt",
"Std.Time.Week.Ordinal.OfMonth",
"Std.Time.Week.Ordinal.instOrdOfMonth"
] | false |
Std.TreeSet.Raw.get?_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | [
"List.Pairwise",
"Std.TreeSet.Raw.ofList",
"Std.TreeMap.Raw.getKey?_unitOfList_of_mem",
"Option.some",
"Membership.mem",
"Ordering",
"Ordering.eq",
"Std.TransCmp",
"List",
"List.instMembership",
"Eq",
"Not",
"Std.TreeSet.Raw.get?",
"Option"
] | true |
ValueDistribution.logCounting | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"WithTop.untop₀",
"NormedSpace",
"Function.locallyFinsuppWithin.instAddGroup",
"Real.instAddMonoid",
"Function.locallyFinsuppWithin.instAddMonoid",
"Function.locallyFinsupp",
"Set.univ",
"instPosPart",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"F... | true |
AddCircle.instAddQuotientMeasureEqMeasurePreimageSubtypeAddOppositeRealMemAddSubgroupOpZmultiplesVolume | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | [
"instWeaklyLocallyCompactSpaceOfLocallyCompactSpace",
"AddCircle.measure_univ",
"AddGroup.toSubtractionMonoid",
"Set.Ioc",
"locallyCompact_of_proper",
"Real",
"MeasureTheory.Measure",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instIsAddHaarMeasureVolume",
"instSeparatelyContinuousAddOfConti... | true |
Lean.Meta.Sym.State.maxFVar._default | Lean.Meta.Sym.SymM | [
"id",
"Lean.FVarId",
"Lean.PersistentHashMap.Node.entries",
"Lean.PersistentHashMap",
"Lean.PersistentHashMap.mk",
"Lean.Meta.Sym.instHashableExprPtr",
"Lean.PersistentHashMap.mkEmptyEntriesArray",
"Lean.Meta.Sym.ExprPtr",
"Lean.Meta.Sym.instBEqExprPtr",
"Option"
] | false |
_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.List.sum_hom_nonempty.match_1_1 | Mathlib.Algebra.BigOperators.Group.List.Basic | [
"False",
"False.elim",
"Ne",
"List.cons",
"List",
"absurd",
"List.casesOn",
"Eq.refl",
"Eq",
"List.nil"
] | false |
NonUnitalSubring.nonUnitalCommRingTopologicalClosure | Mathlib.Topology.Algebra.Ring.Basic | [
"NonUnitalSubring.instSetLike",
"Semigroup.toMul",
"HMul.hMul",
"NonUnitalSubring.topologicalClosure._proof_1",
"NonUnitalSubring.nonUnitalCommRingTopologicalClosure._proof_1",
"NonUnitalSubring.toSubsemigroup",
"Subsemigroup.topologicalClosure",
"NonUnitalSubring.topologicalClosure",
"NonUnitalSubr... | true |
Lean.MessageData.instCoeArrayExpr | Lean.Message | [
"Lean.MessageData",
"Std.instToFormatString",
"String",
"Function.comp",
"Coe.mk",
"Lean.Expr",
"instOfNatNat",
"Lean.MessageData.ofFormat",
"Std.ToFormat.format",
"Array",
"Lean.MessageData.arrayExpr.toMessageData",
"Nat",
"Std.Format",
"OfNat.ofNat",
"Coe"
] | true |
ContinuousDiv.continuous_div' | Mathlib.Topology.Algebra.Group.Defs | [
"Continuous",
"instHDiv",
"instTopologicalSpaceProd",
"HDiv.hDiv",
"Div",
"Prod.fst",
"TopologicalSpace",
"Prod",
"ContinuousDiv",
"Prod.snd"
] | true |
Lean.Meta.instImpl._@.Lean.Meta.Basic.383016249._hygCtx._hyg.24 | Lean.Meta.Basic | [
"TypeName",
"Lean.Name.mkStr3",
"Lean.Meta.FunInfo",
"TypeName.mk"
] | false |
Lean.ConstantInfo.recInfo.noConfusion | Lean.Declaration | [
"Lean.ConstantInfo.recInfo",
"Lean.ConstantInfo.noConfusion",
"id",
"Lean.RecursorVal",
"Lean.ConstantInfo",
"Eq"
] | false |
Lean.RBNode.isBlack | Lean.Data.RBMap | [
"Lean.RBNode",
"_private.Lean.Data.RBMap.0.Lean.RBNode.isBlack.match_1",
"Bool.true",
"Bool",
"Bool.false"
] | true |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk._flat_ctor | Lean.Meta.Tactic.Grind.Theorems | [
"_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk",
"Lean.PHashMap",
"Lean.Meta.Grind.Theorems",
"Lean.PHashSet",
"Lean.Meta.Grind.instBEqOrigin",
"List",
"Lean.Meta.Grind.Origin",
"Lean.Meta.Grind.instHashableOrigin",
"Lean.Name",
"Lean.Name.instBEq",
"Lean.instHashableNam... | false |
CategoryTheory.MonoidalCategory.curriedTensor | Mathlib.CategoryTheory.Monoidal.Category | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.MonoidalCategory.curriedTensor._proof_2",
"Categor... | true |
CategoryTheory.GradedObject.HasGoodTensor₁₂Tensor | Mathlib.CategoryTheory.GradedObject.Monoidal | [
"CategoryTheory.MonoidalCategory",
"CategoryTheory.GradedObject.Monoidal.ρ₁₂",
"AddMonoid",
"CategoryTheory.GradedObject",
"CategoryTheory.GradedObject.Monoidal.r₁₂₃",
"CategoryTheory.GradedObject.HasGoodTrifunctor₁₂Obj",
"CategoryTheory.Category",
"CategoryTheory.MonoidalCategory.curriedTensor"
] | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_mapM.match_1_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Std.IterStep",
"Monad.toApplicative",
"MonadLiftT.monadLift",
"Subtype.casesOn",
"Option.some",
"Std.IterM.IsPlausibleStep",
"Std.Iterators.Types.FilterMap.inner",
"Std.IterStep.skip",
"Std.Iterators.PostconditionT.attachLift",
"MonadLiftT",
"Std.IterM.internalState",
"Std.Iterator",
"Subty... | false |
Lean.Meta.Simp.Config.failIfUnchanged._default | Init.MetaTypes | [
"id",
"Bool.true",
"Bool"
] | false |
CategoryTheory.codiscreteEquiv._proof_4 | Mathlib.CategoryTheory.CodiscreteCategory | [
"CategoryTheory.Codiscrete.as",
"CategoryTheory.Codiscrete",
"CategoryTheory.Codiscrete.mk",
"eq_self",
"Function.RightInverse",
"of_eq_true",
"Eq"
] | false |
String.Pos.Raw.prev_lt_of_pos | Init.Data.String.Basic | [
"congrArg",
"String",
"String.Pos.Raw.utf8PrevAux_lt_of_pos",
"mt",
"Ne",
"instOfNatNat",
"Nat.zero_lt_of_ne_zero",
"String.Pos.Raw",
"String.Pos.Raw.mk",
"Nat",
"String.toList",
"LT.lt",
"String.Pos.Raw.prev",
"instLTNat",
"String.instOfNatRaw",
"OfNat.ofNat",
"String.Pos.Raw.byteId... | true |
Submodule.rTensorOne_tmul_one | Mathlib.LinearAlgebra.TensorProduct.Submodule | [
"Subalgebra.instSetLike",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"CommSemiring.toSemiring",
"Submodule.addCommMonoid",
"TensorProduct.addCommMonoid",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Algebra.instCompleteLattic... | true |
AdjoinRoot.powerBasisAux'._proof_8 | Mathlib.RingTheory.AdjoinRoot | [
"Pi.Function.module",
"CommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"CommRing.toNonUnitalCommRing",
"AdjoinRoot",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AdjoinRoot.powerBasisAux'._proof_3",
"AddMonoid.t... | false |
_private.Init.Data.List.Impl.0.List.take.match_1.eq_3 | Init.Data.List.Impl | [
"List.take.match_1",
"instOfNatNat",
"List.cons",
"List",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"List.nil"
] | true |
_private.Mathlib.Topology.Continuous.0.Continuous.tendsto.match_1_1 | Mathlib.Topology.Continuous | [
"Membership.mem",
"And.casesOn",
"TopologicalSpace",
"And",
"And.intro",
"IsOpen",
"Set.instMembership",
"Set"
] | false |
AlgebraicGeometry.LocallyRingedSpace.emptyTo._proof_3 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | [
"MulOne.toOne",
"Opposite",
"CommRingCat.carrier",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CommSemiring.toSemiring",
"CommRingCat",
"TopologicalSpace.Opens",
"CommRingCat.instCategory",
"Pi.instZero",
"NonAssocSemiring.toMulZeroOneClass",
"MulZeroOneClass.toMulOneClass",
"AlgebraicGeomet... | false |
Std.DTreeMap.getKey_filterMap | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap.Internal.Impl.getKey_filterMap",
"Std.DTreeMap",
"Std.DTreeMap.mem_of_mem_filterMap",
"Ord.mk",
"Membership.mem",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Std.DTreeMap.wf",
"Eq",
"Std.DTreeMap.filterMap",
"Std.DTreeMap.getKey",
"Option... | true |
Set.PartiallyWellOrderedOn.imageProdLex | Mathlib.Order.WellFoundedSet | [
"Set.IsPWO",
"Prod.Lex.monotone_fst",
"Equiv.instEquivLike",
"Lex",
"Preorder.toLE",
"Equiv",
"Prod.fst",
"Set.IsPWO.image_of_monotone",
"Prod.Lex.instPreorder",
"Set.image",
"Prod",
"ofLex",
"DFunLike.coe",
"Preorder",
"EquivLike.toFunLike",
"Set"
] | true |
Std.ExtTreeMap.getKey?_eq_some_iff | Std.Data.ExtTreeMap.Lemmas | [
"Std.ExtTreeMap.getKey?",
"Option.some",
"Membership.mem",
"Exists",
"Ordering",
"Std.TransCmp",
"Std.ExtTreeMap.getKey",
"Std.ExtDTreeMap.getKey?_eq_some_iff",
"Iff",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Std.ExtTreeMap.instMembershipOfTransCmp",
"Eq",
"Option"
] | true |
Fin.foldr.loop.congr_simp | Init.Data.Fin.Fold | [
"Eq.rec",
"Fin.foldr.loop",
"LE.le",
"instLENat",
"Nat",
"Eq.ndrec",
"Eq.refl",
"Fin",
"Eq"
] | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_filter_containsKey_iff.match_1_2 | Std.Data.Internal.List.Associative | [
"Sigma.mk",
"Sigma.casesOn",
"Sigma"
] | false |
Subring.centralizer._proof_1 | Mathlib.Algebra.Ring.Subring.Basic | [
"Ring.toNonAssocRing",
"Membership.mem",
"Set.centralizer",
"NonAssocRing.toNonUnitalNonAssocRing",
"instDistribOfSemiring",
"NonUnitalNonAssocRing.toHasDistribNeg",
"Set.neg_mem_centralizer",
"Distrib.toMul",
"HasDistribNeg.toInvolutiveNeg",
"InvolutiveNeg.toNeg",
"Ring.toSemiring",
"Set.inst... | false |
ne_iff_lt_iff_le._simp_2 | Mathlib.Order.Basic | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Ne",
"LE.le",
"Iff",
"LT.lt",
"propext",
"ne_iff_lt_iff_le",
"Eq"
] | false |
IsUnit.isSMulRegular | Mathlib.Algebra.Regular.SMul | [
"Monoid",
"Units.val",
"Units.isSMulRegular",
"IsUnit",
"Units",
"Exists.casesOn",
"MulAction",
"IsSMulRegular",
"Monoid.toSemigroup",
"Eq.ndrec",
"SemigroupAction.toSMul",
"MulAction.toSemigroupAction",
"Eq"
] | true |
DirectLimit.instStarAddMonoid._proof_2 | Mathlib.Algebra.Colimit.DirectLimit | [
"AddMonoid.toAddSemigroup",
"DirectLimit.instInvolutiveStar",
"AddMonoid.toAddZeroClass",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"StarHomClass",
"AddMonoidHomClass",
"DirectLimit.induction₂",
"LE.le",
"StarAddMonoid.toInvolutiveStar",
"DirectLimit",
"instHAdd",
"AddSemigroup.toAdd",
"D... | false |
Std.Sat.AIG.denote_not_invert | Std.Sat.AIG.Lemmas | [
"Std.Sat.AIG.Entrypoint.aig",
"Std.Sat.AIG.Decl",
"bne",
"Std.Sat.AIG.Ref.mk",
"Std.Sat.AIG.denote._proof_5",
"Bool.not",
"congrArg",
"id",
"instDecidableEqBool",
"Std.Sat.AIG.Entrypoint.ref",
"instBEqOfDecidableEq",
"Bool.xor",
"Std.Sat.AIG",
"Nat",
"LT.lt",
"True",
"eq_self",
"Bo... | true |
_private.Mathlib.Data.List.Sections.0.List.mem_sections._simp_1_2 | Mathlib.Data.List.Sections | [
"List.map",
"Membership.mem",
"Exists",
"List",
"And",
"List.instMembership",
"propext",
"List.mem_map",
"Eq"
] | false |
ContinuousLinearMap.topologicalSpace._proof_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | [
"NormedCommRing.toSeminormedCommRing",
"Bornology.IsVonNBounded",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"setOf",
"AddCommGroup.toAddGroup",
"RingHom",
"NormedField.toField",
"Exists",
"AddZeroClass.toAddZero",
"AddCommGroup",
"DistribSM... | false |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.SplitKind.considerIte.match_1 | Lean.Meta.Tactic.SplitIf | [
"Unit.unit",
"_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.SplitKind.considerIte._sparseCasesOn_1",
"Lean.Meta.SplitKind.ctorIdx",
"Lean.Meta.SplitKind.ite",
"Lean.Meta.SplitKind.both",
"Lean.Meta.SplitKind",
"Nat.hasNotBit",
"Unit"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.