name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_map_eq_of_injective._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | [
"ZeroHomClass",
"Ne",
"propext",
"Zero.toOfNat0",
"map_ne_zero_iff",
"Function.Injective",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"FunLike",
"Zero"
] | false |
AlgebraicGeometry.instCanonicallyOverFiber | Mathlib.AlgebraicGeometry.Fiber | [
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CanonicallyOverClass.mk",
"CommRingCat",
"CommRingCat.instCategory",
"AlgebraicGeometry.Scheme.CanonicallyOver",
"AlgebraicGeometry.Scheme.Hom.fiberι",
"... | true |
Rep.standardComplex.εToSingle₀ | Mathlib.RepresentationTheory.Homological.Resolution | [
"Monoid",
"ChainComplex",
"CommRing",
"HomologicalComplex.instCategory",
"Semiring.toModule",
"Equiv.instEquivLike",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommSemiring.toSemiring",
"ChainComplex.toSingle₀Equiv",
"AddRightCancelSemigroup.toAddSemigroup",
"Add... | true |
_private.Lean.Meta.Tactic.UnifyEq.0.Lean.Meta.heqToEq' | Lean.Meta.Tactic.UnifyEq | [
"Lean.Meta.whnf",
"Lean.MVarId",
"Lean.Expr",
"Lean.Meta.MetaM",
"Bool.true",
"Lean.MVarId.clear",
"Lean.LocalDecl.fvarId",
"Lean.Meta.instMonadMetaM",
"Lean.MVarId.assert",
"Lean.LocalDecl.userName",
"Monad.toBind",
"Bind.bind",
"Lean.LocalDecl",
"Lean.Meta.mkEqOfHEq",
"Lean.mkFVar",
... | true |
add_neg_lt_iff_lt_add._simp_1 | Mathlib.Algebra.Order.Group.Unbundled.Basic | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"AddMonoid.toAddZeroClass",
"AddRightStrictMono",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"instHAdd",
"AddGroup",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"LT.lt",
"propext",
"... | false |
Lean.Parser.Category.attr | Init.Notation | [
"Lean.Parser.Category.mk",
"Lean.Parser.Category"
] | true |
Std.HashMap.contains_union | Std.Data.HashMap.Lemmas | [
"Std.HashMap.contains",
"Std.DHashMap.contains_union",
"Std.HashMap",
"Std.HashMap.instUnion",
"LawfulHashable",
"EquivBEq",
"Bool",
"Bool.or",
"Hashable",
"Union.union",
"Std.HashMap.inner",
"BEq",
"Eq"
] | true |
iInf_range' | Mathlib.Order.CompleteLattice.Basic | [
"Eq.mpr",
"iInf",
"congrArg",
"Membership.mem",
"Set.Elem",
"InfSet",
"id",
"Set.image_eq_range",
"iInf.eq_1",
"Eq.refl",
"Set.image",
"Set.range",
"Eq.symm",
"Set.range_comp'",
"Subtype.val",
"Eq",
"Set.instMembership",
"InfSet.sInf",
"Set"
] | true |
Con._sizeOf_inst | Mathlib.GroupTheory.Congruence.Defs | [
"Mul",
"SizeOf.mk",
"Con",
"SizeOf",
"Con._sizeOf_1"
] | false |
ByteArray.toList_data_append | Init.Data.ByteArray.Lemmas | [
"congrArg",
"Array.toList",
"instHAppendOfAppend",
"List",
"ByteArray.data",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"ByteArray.instAppend",
"ByteArray",
"List.instAppend",
"UInt8",
"Eq",
"HAppend.hAppend",
"ByteArray.toList_data_append'",
"Eq.trans"
] | true |
SimpleGraph.addCayley_mono | Mathlib.Combinatorics.SimpleGraph.Cayley | [
"SimpleGraph.addCayley_monotone",
"SimpleGraph.addCayley",
"HasSubset.Subset",
"LE.le",
"SimpleGraph",
"Add",
"Set.instHasSubset",
"SimpleGraph.instLE",
"Set"
] | true |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat.match_93 | Mathlib.Tactic.NormNum.IsSquare | [
"Lean.Expr.const",
"Lean.Level",
"List.cons",
"Qq.Quoted",
"Lean.Level.zero",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Sigma.mk",
"Sigma.casesOn",
"Lean.Level.succ",
"Lean.Name.mkStr1",
"Sigma",
"List.nil"
] | false |
CategoryTheory.Limits.MulticospanIndex._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"CategoryTheory.Limits.MulticospanIndex.rec",
"CategoryTheory.Limits.MulticospanShape.snd",
"CategoryTheory.Limits.MulticospanShape.L",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"instOfNatNat",
"CategoryTheory.Limits.MulticospanIndex",
"CategoryTheory.Limits.MulticospanShape.fst",
"Nat... | false |
Derivation.map_one_eq_zero' | Mathlib.RingTheory.Derivation.Basic | [
"Derivation",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Derivation.toLinearMap",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"Algebra",
"AddZeroClass.toAddZero",
"Algebra.toModule",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"LinearMap",
"AddCommMonoid",
... | true |
DiffeologicalSpace.ext_iff | Mathlib.Geometry.Diffeology.Basic | [
"Real",
"HEq.refl",
"Diffeology.IsPlot",
"Eq.casesOn",
"EuclideanSpace",
"DiffeologicalSpace.ext",
"Iff",
"DiffeologicalSpace",
"Nat",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Fin",
"Eq"
] | true |
LieRinehartAlgebra.Hom.instCoeFunForall | Mathlib.Algebra.LieRinehartAlgebra.Defs | [
"LieHom",
"CommRing",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AlgHom",
"Algebra",
"CoeFun.mk",
"LieRinehartAlgebra.Hom.toLieHom",
"LieRing",
"CommRing.toCommSemiring",
"LieRingModule",
"LieRinehartAlgebra.Hom",
"LieRing.ofAssociativeRing",
"L... | true |
CategoryTheory.Bicategory.LeftLift.whiskerHom | Mathlib.CategoryTheory.Bicategory.Extension | [
"CategoryTheory.StructuredArrow.homMk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.LeftLift.lift",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory.postcomp",
"CategoryTheory.Bicategory.LeftLift.whisker",
"CategoryTheory.Bicategory",
"C... | true |
Std.DTreeMap.Raw.instCoeWFWFInner | Std.Data.DTreeMap.Raw.Basic | [
"Ord.mk",
"Ordering",
"Coe.mk",
"Std.DTreeMap.Internal.Impl.WF",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Coe",
"Std.DTreeMap.Raw.WF",
"Std.DTreeMap.Raw"
] | true |
Lean.PrettyPrinter.combinatorFormatterAttribute | Lean.PrettyPrinter.Formatter | [
"Inhabited.default",
"Lean.ParserCompiler.CombinatorAttribute",
"Lean.ParserCompiler.instInhabitedCombinatorAttribute"
] | true |
FloorRing.mk.noConfusion | Mathlib.Algebra.Order.Floor.Defs | [
"Int.cast",
"HEq.refl",
"LinearOrder",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"FloorRing.mk",
"DistribLattice.toLattice",
"id",
"Int",
"FloorRing.noConfusion",
"AddGroupWithOne.toIntCast",
"heq_of_eq",
"instLatticeInt",
"Eq.refl",
"HEq",
"FloorRing",
"Eq",
"Rin... | false |
UInt16.lt_or_le | Init.Data.UInt.Lemmas | [
"_private.Init.Data.UInt.Lemmas.0.UInt16.lt_or_le._simp_1_2",
"Eq.mpr",
"_private.Init.Data.UInt.Lemmas.0.UInt16.lt_or_le._proof_1_3",
"congrArg",
"instLEUInt16",
"id",
"LE.le",
"instLENat",
"UInt16",
"Nat",
"congr",
"LT.lt",
"Decidable.byContradiction",
"Nat.decLt",
"instLTUInt16",
"U... | true |
_private.Lean.Attributes.0.Lean.registerParametricAttribute.match_1 | Lean.Attributes | [
"Lean.NameMap",
"Prod.mk",
"List",
"Lean.Name",
"Prod",
"Prod.casesOn"
] | false |
CategoryTheory.Limits.Cotrident.ext._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | [
"CategoryTheory.Limits.WalkingParallelFamily.one",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.WalkingParallelFamily",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.CoconeMorphism.hom",
"CategoryTheory.CategoryStruc... | false |
SSet.Subcomplex.Pairing.inter | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | [
"SSet.Subcomplex.N",
"SSet",
"Set.instInter",
"SSet.Subcomplex.Pairing",
"Inter.inter",
"SSet.Subcomplex.Pairing.I",
"Set.instEmptyCollection",
"SSet.Subcomplex",
"EmptyCollection.emptyCollection",
"SSet.Subcomplex.Pairing.II",
"Eq",
"Set"
] | true |
TypeCat.ofHom_apply | Mathlib.CategoryTheory.Types.Basic | [
"CategoryTheory.ConcreteCategory.hom",
"TypeCat.instFunLikeFun",
"TypeCat.ofHom",
"TypeCat.Fun",
"CategoryTheory.types",
"Eq",
"DFunLike.coe",
"rfl",
"instConcreteCategoryTypeFun"
] | true |
Std.Rcc._sizeOf_inst | Init.Data.Range.Polymorphic.PRange | [
"SizeOf.mk",
"SizeOf",
"Std.Rcc._sizeOf_1",
"Std.Rcc"
] | false |
Multiset.inter_eq_zero_iff_disjoint | Mathlib.Data.Multiset.UnionInter | [
"Eq.mpr",
"False",
"Multiset.notMem_zero._simp_1",
"Multiset.instInter",
"congrArg",
"Multiset.instHasSubset",
"Disjoint",
"Membership.mem",
"Multiset",
"id",
"_private.Mathlib.Data.Multiset.UnionInter.0.Multiset.inter_eq_zero_iff_disjoint._simp_1_1",
"HasSubset.Subset",
"Multiset.instOrderB... | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.mem_closure_range_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | [
"Real",
"Real.instZero",
"PseudoMetricSpace.toUniformSpace",
"Real.instLT",
"Membership.mem",
"Exists",
"Metric.mem_closure_iff",
"GT.gt",
"And",
"PseudoMetricSpace",
"closure",
"LT.lt",
"propext",
"Zero.toOfNat0",
"Dist.dist",
"PseudoMetricSpace.toDist",
"OfNat.ofNat",
"UniformSpa... | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.collectSingletons.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | [
"Lean.Expr",
"Prod.mk",
"List",
"Prod",
"Prod.casesOn",
"Lean.HeadIndex"
] | false |
Trans.trans.congr_simp | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | [
"Trans.trans",
"Eq.rec",
"Trans",
"Eq.refl",
"Eq"
] | true |
_private.Mathlib.Order.Filter.Map.0.Filter.map_eq_map_iff_of_injOn._simp_1_1 | Mathlib.Order.Filter.Map | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"And",
"le_antisymm_iff",
"propext",
"Eq"
] | false |
CategoryTheory.MonoidalCategory.noConfusion | Mathlib.CategoryTheory.Monoidal.Category | [
"CategoryTheory.MonoidalCategory.id_tensorHom_id._autoParam",
"CategoryTheory.MonoidalCategory.casesOn",
"CategoryTheory.MonoidalCategoryStruct",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategoryStruct.rightUnito... | false |
TopCat.isLimitConeOfForget._proof_3 | Mathlib.Topology.Category.TopCat.Limits.Basic | [
"ContinuousMap.continuous",
"Eq.mpr",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"iInf",
"Continuous",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"TopCat.instCategory",
"HEq.refl",
... | false |
Mathlib.Tactic.LibraryRewrite.renderRewrites | Mathlib.Tactic.Widget.LibraryRewrite | [
"Pure.pure",
"Array.instAppend",
"ProofWidgets.instRpcEncodableInteractiveCodeProps",
"Lean.Json",
"Lean.Widget.ppExprTagged",
"Lean.Json.mkObj",
"ProofWidgets.InteractiveCode",
"Mathlib.Tactic.LibraryRewrite.Kind",
"ProofWidgets.Html",
"String",
"Lean.Meta.State",
"Array.filterMapM",
"Proof... | true |
CommMonCat.forget₂Mon_preservesLimitsOfSize | Mathlib.Algebra.Category.MonCat.Limits | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesLimit",
"MonoidHom.instFunLike",
"CommMonCat.forget₂CreatesLimit",
"UnivLE",
"CommMonCat.instConcreteCategoryMonoidHomCarrier",
"MonoidHom",
"Monoid.toMulOneClass",
"CategoryTheory.Limits.PreservesLimitsOfSize.mk",
"CategoryTheory.Functor.c... | true |
Stream'.Seq.all_of_get | Mathlib.Data.Seq.Basic | [
"_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.all_of_get._proof_1_2",
"Eq.mpr",
"Stream'.Seq",
"_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.all_of_get._simp_1_1",
"Option.some",
"Membership.mem",
"Exists",
"id",
"Stream'.Seq.instMembership",
"implies_congr",
"Nat",
"Eq.refl",
"Eq",
"Str... | true |
spectrum.nonempty_of_isAlgClosed_of_finiteDimensional | Mathlib.FieldTheory.IsAlgClosed.Spectrum | [
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"Polynomial.C",
"Polynomial.eval",
"MulOne.toOne",
"False",
"Polynomial.roots",
"NeZero.one",
"isIntegral_of_noetherian",
"Algebra.algebraMap",
"spectrum",
"Multiset.map",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AlgHo... | true |
MeasureTheory.StronglyMeasurable.separableSpace_range_union_singleton | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | [
"TopologicalSpace.PseudoMetrizableSpace",
"MeasureTheory.StronglyMeasurable.isSeparable_range",
"Membership.mem",
"Set.instUnion",
"Set.Elem",
"Set.instSingletonSet",
"MeasurableSpace",
"TopologicalSpace",
"Set.Finite.isSeparable",
"TopologicalSpace.IsSeparable.separableSpace",
"instTopologicalS... | true |
CategoryTheory.Discrete.equivalence._proof_2 | Mathlib.CategoryTheory.Discrete.Basic | [
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"congrArg",
"CategoryTheory.Functor.comp",
"CategoryTheory.Discrete.functor",
"Function.comp",
"CategoryTheory.Functor.id",
"Equiv",
"CategoryTheory.Discrete.mk",
"CategoryTheory.Discrete.as",
"CategoryTheory.discreteCategory",
"True",
"eq_sel... | false |
_private.Mathlib.Topology.Ultrafilter.0.isClosed_iff_ultrafilter._simp_1_1 | Mathlib.Topology.Ultrafilter | [
"Membership.mem",
"IsClosed",
"TopologicalSpace",
"ClusterPt",
"isClosed_iff_clusterPt",
"propext",
"Filter.principal",
"Eq",
"Set.instMembership",
"Set"
] | false |
MeasureTheory.Measure.dirac_conv_dirac | Mathlib.MeasureTheory.Group.Convolution | [
"Eq.mpr",
"MeasureTheory.Measure",
"MeasureTheory.instSFiniteOfSigmaFinite",
"congrArg",
"AddMonoid.toAddZeroClass",
"Measurable.add_const",
"AddZeroClass.toAddZero",
"id",
"MeasureTheory.Measure.dirac",
"MeasureTheory.Measure.conv",
"MeasureTheory.Measure.map_dirac'",
"MeasurableSpace",
"in... | true |
Complex.zero_im | Mathlib.Data.Complex.Basic | [
"Real",
"Real.instZero",
"Complex.im",
"Complex.instZero",
"Zero.toOfNat0",
"Complex",
"OfNat.ofNat",
"Eq",
"rfl"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.isMaximalClique_compl._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Clique | [
"SimpleGraph.IsIndepSet",
"HasSubset.Subset",
"SimpleGraph",
"And",
"Set.instLE",
"SimpleGraph.isMaximalIndepSet_iff",
"propext",
"Maximal",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
_private.Mathlib.Topology.UniformSpace.Path.0.Path.uniformContinuous_trans.match_1_5 | Mathlib.Topology.UniformSpace.Path | [
"UniformSpace",
"entourageProd",
"Real",
"SetRel",
"setOf",
"Membership.mem",
"Set.Elem",
"Prod.mk",
"Prod.fst",
"Path.instFunLike",
"Path",
"Prod",
"Prod.casesOn",
"UniformSpace.toTopologicalSpace",
"Set.instMembership",
"Prod.snd",
"DFunLike.coe",
"unitInterval",
"Set"
] | false |
CategoryTheory.Grothendieck.faithful_ι | Mathlib.CategoryTheory.Grothendieck | [
"CategoryTheory.Cat.category",
"CategoryTheory.Functor",
"CategoryTheory.Grothendieck.Hom.mk.noConfusion",
"CategoryTheory.Grothendieck.fiber",
"CategoryTheory.Grothendieck.base",
"CategoryTheory.Grothendieck.ι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.e... | true |
toDual_one | Mathlib.Algebra.Order.Group.Synonym | [
"OrderDual.toDual",
"One",
"Equiv.instEquivLike",
"Equiv",
"One.toOfNat1",
"OrderDual",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"OrderDual.instOne",
"rfl",
"EquivLike.toFunLike"
] | true |
continuousOn_prod_of_discrete_right | Mathlib.Topology.ContinuousOn | [
"Eq.mpr",
"ContinuousWithinAt",
"congrArg",
"DiscreteTopology",
"setOf",
"instTopologicalSpaceProd",
"Membership.mem",
"forall_comm",
"id",
"Prod.mk",
"Prod.fst",
"TopologicalSpace",
"_private.Mathlib.Topology.ContinuousOn.0.continuousOn_prod_of_discrete_right._simp_1_2",
"Iff",
"_privat... | true |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.max_eq_iSup._simp_1_2 | Mathlib.NumberTheory.Height.Basic | [
"Fin.forall_fin_two",
"Fin.instOfNat",
"instOfNatNat",
"And",
"Nat.instNeZeroSucc",
"Nat",
"propext",
"OfNat.ofNat",
"Fin",
"Eq"
] | false |
Representation.Equiv.right_inv | Mathlib.RepresentationTheory.Intertwining | [
"Monoid",
"Representation",
"LinearMap.toAddHom",
"AddCommMonoid",
"Representation.Equiv",
"Function.RightInverse",
"Representation.Equiv.toIntertwiningMap",
"Semiring",
"AddCommSemigroup.toAddCommMagma",
"Module",
"AddCommMonoid.toAddCommSemigroup",
"RingHom.id",
"Semiring.toNonAssocSemirin... | true |
Lean.Grind.Ring.OfSemiring.mul | Init.Grind.Ring.Envelope | [
"Lean.Grind.Ring.OfSemiring.mul._proof_1",
"HMul.hMul",
"Lean.Grind.Semiring.toAdd",
"Prod.mk",
"Lean.Grind.Ring.OfSemiring.Q.liftOn₂",
"Lean.Grind.Semiring.toMul",
"Lean.Grind.Ring.OfSemiring.Q.mk",
"instHAdd",
"HAdd.hAdd",
"Lean.Grind.Semiring",
"Lean.Grind.Ring.OfSemiring.Q",
"Prod",
"Lea... | true |
isEmpty_pprod._simp_1 | Mathlib.Logic.IsEmpty.Basic | [
"IsEmpty",
"isEmpty_pprod",
"PProd",
"propext",
"Or",
"Eq"
] | false |
CategoryTheory.Limits.WidePushoutShape.Hom.id.elim | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | [
"PULift.up",
"CategoryTheory.Limits.WidePushoutShape.Hom.id",
"CategoryTheory.Limits.WidePushoutShape.Hom.ctorElim",
"CategoryTheory.Limits.WidePushoutShape.Hom",
"Nat",
"Eq.symm",
"Eq",
"CategoryTheory.Limits.WidePushoutShape",
"CategoryTheory.Limits.WidePushoutShape.Hom.ctorIdx"
] | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.eval._sparseCasesOn_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | [
"Mathlib.Tactic.BicategoryLike.Mor₂Iso.comp",
"Nat.ne_of_beq_eq_false",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso.horizontalComp",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso",
"Mathlib.Tactic.BicategoryLike.CoherenceHom",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso.ctorIdx",
"Nat.shiftRight",
"Mathlib.Tactic.Bica... | false |
CommRing.Pic.instAddCommGroupAsModule | Mathlib.RingTheory.PicardGroup | [
"SemimoduleCat.isModule",
"Units.val",
"SemimoduleCat.moduleCategory",
"CommRing",
"Equiv.instEquivLike",
"Module.addCommMonoidToAddCommGroup",
"SemimoduleCat.isAddCommMonoid",
"CommSemiring.toSemiring",
"Units",
"AddCommGroup",
"Equiv",
"CategoryTheory.isIsomorphicSetoid",
"Quotient.out",
... | true |
CategoryTheory.Mon.instHasInitial | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Limits.hasInitial_of_unique",
"CategoryTheory.Mon.uniqueHomFromTrivial",
"Unique.instSubsingleton",
"CategoryTheory.Mon",
"instNonemptyOfInhabited",
"CategoryTheory.Mon.instCategory",
"Catego... | true |
Aesop.RuleApplication.mk.inj | Aesop.RuleTac.Basic | [
"Lean.Meta.SavedState",
"Aesop.RuleApplication.mk",
"Aesop.Subgoal",
"Aesop.RuleApplication.mk.noConfusion",
"Array",
"And",
"Aesop.RuleApplication",
"And.intro",
"Aesop.Percent",
"Eq",
"Aesop.Script.LazyStep",
"Option"
] | true |
_private.Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy.0.CategoryTheory.MorphismProperty.IsInvertedBy.map_iff._simp_1_1 | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Functor",
"CategoryTheory.MorphismProperty.IsInvertedBy.iff_map_le_isomorphisms",
"CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CategoryTheory.MorphismProperty.isomorphisms",
"LE.le",
"Cat... | false |
ComplexShape.Embedding.boundaryGE | Mathlib.Algebra.Homology.Embedding.Boundary | [
"Eq.mpr",
"ComplexShape.Embedding.BoundaryGE",
"congrArg",
"id",
"ComplexShape.prev",
"Ne",
"ComplexShape",
"ComplexShape.prev_eq'",
"And.intro",
"ComplexShape.Embedding.f",
"ComplexShape.Embedding",
"Eq.refl",
"congrFun'",
"Eq.symm",
"Eq",
"Not",
"ComplexShape.Rel"
] | true |
Finsupp.unique_single_eq_iff | Mathlib.Data.Finsupp.Single | [
"Finsupp.instFunLike",
"Eq.mpr",
"Inhabited.default",
"Finsupp.single_eq_same",
"congrArg",
"Unique",
"Iff.rfl",
"id",
"Unique.eq_default",
"Iff",
"propext",
"Finsupp.unique_ext_iff",
"Unique.instInhabited",
"Eq",
"DFunLike.coe",
"Finsupp",
"Finsupp.single",
"Zero"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.good_vertices_triangle_card | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"and_or_left",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.toNeg",
"mul_nonneg",
"NonAssocSemiring.toAddCommMonoidWi... | true |
CategoryTheory.ShortComplex.RightHomologyData.unop_i | Mathlib.Algebra.Homology.ShortComplex.RightHomology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex.RightHomologyData",
"CategoryTheory.ShortComplex",
"Quiver.Hom.unop",
"CategoryTheory.ShortComplex.RightHomologyData.unop",
"CategoryTheory.ShortComplex.RightHom... | true |
Std.OppositeOrderInstances.instDecidableLEOpposite | Init.Data.Order.Opposite | [
"LE",
"DecidableLE",
"LE.opposite"
] | true |
MvPolynomial.C._proof_4 | Mathlib.Algebra.MvPolynomial.Basic | [
"Finsupp.instAddZeroClass",
"RingHom.map_add'",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.instMulZeroClass",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"NonAssocSemiring.toMulZeroOneClass",
"AddCommMonoidWithOne.toA... | false |
_private.Std.Sync.Barrier.0.Std.BarrierState._sizeOf_inst | Std.Sync.Barrier | [
"_private.Std.Sync.Barrier.0.Std.BarrierState",
"SizeOf.mk",
"SizeOf",
"_private.Std.Sync.Barrier.0.Std.BarrierState._sizeOf_1"
] | false |
Lean.Parser.Term.completion._regBuiltin.Lean.Parser.Term.completion.parenthesizer_11 | Lean.Parser.Term | [
"Lean.Name.mkStr5",
"IO",
"Lean.PrettyPrinter.Parenthesizer",
"Lean.PrettyPrinter.parenthesizerAttribute",
"Unit",
"Lean.Parser.Term.completion.parenthesizer",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
ModuleCat.imageIsoRange_hom_subtype_apply | Mathlib.Algebra.Category.ModuleCat.Images | [
"Submodule",
"RingHomSurjective.ids",
"CategoryTheory.Limits.HasImages.has_image",
"ModuleCat.imageIsoRange",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"ModuleCat.imageIsoRange_hom_subty... | true |
Lean.Grind.OrderConfig.locals._inherited_default | Init.Grind.Config | [
"id",
"Bool",
"Bool.false"
] | false |
Lean.Order.prod_sup_is_sup | Init.Internal.Order.Basic | [
"Lean.Order.PProd.snd",
"PProd.mk",
"Lean.Order.PProd.fst",
"PProd.fst",
"Lean.Order.prod_sup",
"Exists",
"Lean.Order.instPartialOrderPProd",
"PProd.snd",
"id",
"Lean.Order.sup_le",
"Lean.Order.PartialOrder.rel_trans",
"Lean.Order.CompleteLattice",
"Lean.Order.PartialOrder.rel",
"Iff",
"... | true |
_private.Std.Do.WP.Monad.0.ExceptT.run_bind.match_1.splitter | Std.Do.WP.Monad | [
"Except.ok",
"ExceptT.run_bind.match_1",
"Except.error",
"Except"
] | true |
List.getElem_replace._proof_1 | Init.Data.List.Lemmas | [
"Eq.mpr",
"congrArg",
"id",
"List.replace",
"List",
"Nat",
"LT.lt",
"instLTNat",
"List.length_replace",
"BEq",
"Eq",
"List.length"
] | false |
DirectSum.toSemiring_of | Mathlib.Algebra.DirectSum.Ring | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"instAddCommMonoidDirectSum",
"AddMonoid.toAddZeroClass",
"DirectSum.GSemiring.toGNonUnitalNonAssocSemiring",
"DirectSum.GSemiring.toGMonoid",
"RingHom",
"AddZeroClass.toAddZero",
"GradedMonoid.GMul.mul",
"Graded... | true |
_private.Lean.Parser.Basic.0.Lean.Parser.sepByFnAux.parse._unsafe_rec | Lean.Parser.Basic | [
"Pure.pure",
"Lean.Parser.ParserState.mkNode",
"String.instLTRaw",
"Lean.Syntax.missing",
"Monad.toApplicative",
"Lean.Parser.ParserState.restore",
"Lean.Parser.ParserState.stackSize",
"instDecidableEqBool",
"instOfNatNat",
"Lean.Parser.ParserState.pos",
"Id.run",
"Id",
"Lean.Parser.ParserSt... | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.injective_map_zero._proof_1_1 | Mathlib.Topology.CWComplex.Classical.Basic | [
"Topology.RelCWComplex",
"False",
"Lean.Grind.not_not",
"eq_false",
"Classical.byContradiction",
"heq_eq_eq",
"Eq.mp",
"Sigma.mk.noConfusion",
"id",
"instOfNatNat",
"TopologicalSpace",
"Nat",
"Topology.RelCWComplex.cell",
"True",
"eq_self",
"eq_true",
"Lean.Grind.intro_with_eq",
"H... | false |
Orientation.map_refl | Mathlib.LinearAlgebra.Orientation | [
"AlternatingMap",
"AlternatingMap.domLCongr_refl",
"Eq.mpr",
"Module.Ray",
"Orientation",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"Orientation.map.eq_1",
"IsStrictOrderedRing",
"PartialOrder",
"Module.Ray.map",
"id",
"Equiv",
"Module.Ray.map_refl",
"AddCommMonoid",
... | true |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_6 | Mathlib.MeasureTheory.Measure.Tilted | [
"GroupWithZero.toMonoidWithZero",
"False",
"GroupWithZero.toDivInvMonoid",
"eq_false",
"GroupWithZero",
"DivInvMonoid.toZPow",
"Ne",
"Int",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Zero.toOfNat0",
"zpow_ne_zero",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq... | false |
CategoryTheory.coprodMonad_η_app | Mathlib.CategoryTheory.Monad.Products | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.id",
"CategoryTheory.Limits.coprod.functor",
"CategoryTheory.Monad.η",
"CategoryTheory.Limits.coprod.inr",
"CategoryTheory.Limits.coprod.braiding._proof_1",
... | true |
FirstOrder.Language.Substructure.CG.map | Mathlib.ModelTheory.FinitelyGenerated | [
"Iff.mpr",
"Eq.mpr",
"ChainCompletePartialOrder.instOfCompleteLattice",
"FirstOrder.Language.Substructure.cg_def",
"congrArg",
"PartialOrder.toPreorder",
"FirstOrder.Language.Substructure.instSetLike",
"Exists",
"id",
"FirstOrder.Language.Hom",
"ChainCompletePartialOrder.toPartialOrder",
"Set.... | true |
Lean.Meta.Diagnostics.heuristicCounter._default | Lean.Meta.Basic | [
"id",
"Lean.PersistentHashMap.Node.entries",
"Lean.PersistentHashMap",
"Lean.PersistentHashMap.mk",
"Nat",
"Lean.Name",
"Lean.PersistentHashMap.mkEmptyEntriesArray",
"Lean.Name.instBEq",
"Lean.instHashableName"
] | false |
UInt64.pow._f | Init.Data.UInt.Basic | [
"UInt64.instOfNat",
"UInt64",
"instOfNatNat",
"Nat.below",
"UInt64.mul",
"Unit",
"Nat",
"UInt8.pow.match_1",
"OfNat.ofNat",
"Nat.succ"
] | false |
NumberField.HeightOneSpectrum.isNonarchimedean_adicAbv | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroOneClass",
"NumberField.HeightOneSpectrum.adicAbv",
"IsDedekindDomain.toIsDomain",
"Real.partialOrder",
"Real",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Ideal.absNorm",
"CommSemiring.t... | true |
MulEquiv.toContinuousMulEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | [
"Function.LeftInverse",
"Mul",
"MulEquiv.toEquiv",
"Equiv.toFun",
"MulEquiv",
"Equiv.invFun",
"Equiv.left_inv"
] | false |
Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons.injEq | Mathlib.Tactic.NormNum.BigOperators | [
"Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons",
"Eq.propIntro",
"Lean.Expr.const",
"Lean.injEq_helper",
"Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons.inj",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"And",
"Qq.Quoted",
"Eq.ndrec",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Eq.refl",
... | true |
LocallyFiniteOrder.orderMonoidWithZeroHom._proof_3 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"MulOne.toOne",
"False",
"Decidable.casesOn",
"OrderMonoidHom",
"WithZero.instIsBotZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"e... | false |
AlgEquiv.toUnder | Mathlib.Algebra.Category.Ring.Under.Basic | [
"CategoryTheory.instCategoryUnder",
"CommRing",
"CommRingCat.carrier",
"AlgEquiv.toAlgHom",
"AlgEquiv.symm",
"CommSemiring.toSemiring",
"CommRingCat",
"CommRingCat.mkUnder",
"Algebra",
"AlgEquiv.toUnder._proof_1",
"CommRingCat.instCategory",
"CategoryTheory.Iso",
"CategoryTheory.Iso.mk",
"... | true |
Int8.right_eq_add | Init.Data.SInt.Lemmas | [
"Int8.toBitVec_add",
"Int8.toBitVec_ofNat",
"congrArg",
"BitVec.instAdd",
"Int8",
"BitVec",
"instOfNatNat",
"BitVec.ofNat",
"iff_self",
"instHAdd",
"Iff",
"instAddInt8",
"BitVec.self_eq_add_left._simp_1",
"HAdd.hAdd",
"Int8.eq_iff_toBitVec_eq._simp_1",
"Nat",
"congr",
"True",
"of... | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.getOtherDeclMonoType.match_1 | Lean.Compiler.LCNF.MonoTypes | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Lean.Expr",
"Option.none",
"Unit",
"Option"
] | false |
CategoryTheory.TwoSquare.structuredArrowDownwardsComp._proof_2 | Mathlib.CategoryTheory.GuitartExact.VerticalComposition | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso.refl",
"CategoryTheory.... | false |
FiniteIndexNormalSubgroup.instLattice._proof_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | [
"PartialOrder.toPreorder",
"Group",
"SemilatticeInf.inf_le_left",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"LE.le",
"SemilatticeInf.inf",
"FiniteIndexNormalSubgroup.instSemilatticeInfFiniteIndexNormalSubgroup",
"FiniteIndexNormalSubgroup"
] | false |
Set.mem_of_mem_insert_of_ne | Mathlib.Data.Set.Insert | [
"Membership.mem",
"Insert.insert",
"Or.resolve_left",
"Ne",
"Set.instInsert",
"Eq",
"Set.instMembership",
"Set"
] | true |
Nat.ceilRoot_zero_right | Mathlib.Data.Nat.Factorization.Root | [
"Nat.instMulZeroClass",
"instHDiv",
"congrArg",
"Nat.instMonoid",
"HSub.hSub",
"Nat.ceilRoot",
"HDiv.hDiv",
"instSubNat",
"instOfNatNat",
"ite_cond_eq_true",
"Monoid.toPow",
"instHAdd",
"instHSub",
"HPow.hPow",
"HAdd.hAdd",
"Nat",
"True",
"eq_self",
"Nat.instDiv",
"Nat.instComm... | true |
Submodule.comap_smul | Mathlib.Algebra.Module.Submodule.Map | [
"Submodule",
"instHSMul",
"instSMulOfMul",
"Submodule.mem_comap._simp_1",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"Membership.mem",
"AddZeroClass.toAddZero",
"Semifield",
"DistribSMul.toSMulZeroClass",
"Ne",
"LinearMap",
"IsScala... | true |
CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.recOn | Mathlib.CategoryTheory.Sites.Continuous | [
"CategoryTheory.Functor",
"CategoryTheory.PreZeroHypercover.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreZeroHypercover.sieve₀",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.PreOneHypercover.map",
"Membership.mem",
"CategoryTheory.PreZeroHy... | false |
Std.HashMap.Equiv.getElem?_eq | Std.Data.HashMap.Lemmas | [
"Membership.mem",
"Std.HashMap",
"LawfulHashable",
"EquivBEq",
"Std.HashMap.Equiv",
"Std.HashMap.Equiv.inner",
"Hashable",
"GetElem?.getElem?",
"Std.HashMap.instGetElem?Mem",
"Std.HashMap.inner",
"BEq",
"Eq",
"Std.DHashMap.Equiv.constGet?_eq",
"Std.HashMap.instMembership",
"Option"
] | true |
Std.DTreeMap.Internal.Impl.Tree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.Tree.mk",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Nat",
"Eq",
"Std.DTreeMap.Internal.Impl.Tree",
"Std.DTreeMap.Internal.Impl"
] | false |
Lean.Server.GoToKind.rec | Lean.Server.GoTo | [
"Lean.Server.GoToKind.declaration",
"Lean.Server.GoToKind.type",
"Lean.Server.GoToKind",
"Lean.Server.GoToKind.definition"
] | false |
Lean.Grind.CommRing.d_normEq0_cert | Init.Grind.Ring.CommSolver | [
"Bool.and'",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Poly.normEq0",
"Lean.Grind.CommRing.Poly.beq'",
"Int",
"Nat.cast",
"Nat",
"Bool",
"instNatCastInt",
"Lean.Grind.CommRing.Poly.num"
] | true |
CategoryTheory.ComposableArrows.homMk₂._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | [
"_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._proof_246",
"CategoryTheory.ComposableArrows.homMk₁._proof_4",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"CategoryTheory.ComposableArrows.map'._proof_6",
"Nat",
"LT.lt",
"instAddNat",
"instLTNat",
"OfNat.ofNat"
] | false |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff.match_1_1 | Init.Data.List.Find | [
"Exists",
"LE.le",
"instLENat",
"GetElem.getElem",
"List",
"Exists.casesOn",
"List.lt_findIdx_iff._proof_2",
"Nat",
"LT.lt",
"Exists.intro",
"Bool",
"instLTNat",
"List.instGetElemNatLtLength",
"Bool.false",
"Eq",
"List.length"
] | false |
MvPFunctor.M.pathDestLeft | Mathlib.Data.PFunctor.Multivariate.M | [
"MvPFunctor",
"PFunctor.A",
"PFunctor.Obj",
"PFunctor.M",
"PFunctor.B",
"MvPFunctor.M.Path.root",
"instOfNatNat",
"MvPFunctor.A",
"instHAdd",
"HAdd.hAdd",
"Nat",
"MvPFunctor.M.Path",
"MvPFunctor.B",
"MvPFunctor.last",
"PFunctor.M.dest",
"instAddNat",
"Sigma.mk",
"MvPFunctor.drop",
... | true |
Lean.Meta.Grind.Arith.CommRing.Ring.denote._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | [
"id",
"Lean.PersistentHashMap.Node.entries",
"Lean.PersistentHashMap",
"Lean.PersistentHashMap.mk",
"Lean.Meta.Sym.instHashableExprPtr",
"Lean.Meta.Grind.Arith.CommRing.RingExpr",
"Lean.PersistentHashMap.mkEmptyEntriesArray",
"Lean.Meta.Sym.ExprPtr",
"Lean.Meta.Sym.instBEqExprPtr"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.