name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
Vector.finIdxOf?_mk | Init.Data.Vector.Lemmas | [
"Vector.finIdxOf?",
"Array",
"Fin.cast",
"Option.map",
"Vector.mk",
"Nat",
"Array.finIdxOf?",
"Fin",
"BEq",
"Eq",
"Array.size",
"rfl",
"Option"
] | true |
Finset.toRight | Mathlib.Data.Finset.Sum | [
"Finset.toRight._proof_2",
"Finset",
"Option.some",
"Sum",
"Finset.filterMap",
"Option.none",
"Sum.elim",
"Option"
] | true |
DirectedOn.le_of_minimal | Mathlib.Order.Bounds.Basic | [
"Preorder.toLE",
"DirectedOn",
"Membership.mem",
"Exists",
"LE.le",
"And.casesOn",
"And",
"Exists.casesOn",
"And.right",
"And.left",
"LE.le.trans",
"Minimal",
"Set.instMembership",
"Preorder",
"Set"
] | true |
WittVector.instIsocrystalStandardOneDimIsocrystal._proof_2 | Mathlib.RingTheory.WittVector.Isocrystal | [
"PerfectRing",
"CommRing",
"Nat.Prime",
"WittVector.FractionRing.frobenius",
"WittVector.instCommRing",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"RingEquiv.instRingEquivClass",
"AddGroupWithOne.toAddMonoidWithOne",
"FractionRing",
"nonZeroDivisors",
"Fact",
"RingHomCompTriple",
... | false |
Sum.instLocallyFiniteOrder._proof_1 | Mathlib.Data.Sum.Interval | [
"False",
"Sum.ctorIdx",
"iff_false",
"congrArg",
"and_self",
"Sum.inr.injEq",
"Finset",
"False.elim",
"Sum.instPreorderSum",
"false_and",
"noConfusion_of_Nat",
"Preorder.toLE",
"Finset.map",
"Membership.mem",
"Exists",
"Sum",
"Sum.inl",
"Sum.inl.injEq",
"LE.le",
"Finset.Icc",
... | false |
CanonicallyOrderedAddCommMonoid.toAddCancelCommMonoid | Mathlib.Algebra.Order.Sub.Basic | [
"AddCancelCommMonoid.mk",
"AddCancelCommMonoid",
"PartialOrder.toPreorder",
"Preorder.toLE",
"inferInstance",
"PartialOrder",
"OrderedSub",
"AddCommMonoid",
"CanonicallyOrderedAddCommMonoid.toAddCancelCommMonoid._proof_2",
"AddLeftReflectLE",
"AddCommSemigroup.toAddCommMagma",
"AddCommMonoid.t... | true |
Submodule.rank_sup_add_rank_inf_eq | Mathlib.LinearAlgebra.Dimension.RankNullity | [
"Submodule.comap_inf",
"Eq.mpr",
"Submodule",
"RingHomSurjective.ids",
"Lattice.toSemilatticeSup",
"Cardinal",
"Submodule.Quotient.addCommGroup",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.rank_quotient_add_rank",
"Submodule.addCommMonoid",
"Submodule.c... | true |
comp_partialSups | Mathlib.Order.PartialSups | [
"partialSups._proof_2",
"congrArg",
"Finset",
"map_finset_sup'",
"PartialOrder.toPreorder",
"Monotone",
"Function.comp",
"Membership.mem",
"LocallyFiniteOrderBot",
"Eq.rec",
"SemilatticeSup.toMax",
"partialSups",
"SupHomClass",
"funext",
"OrderHom.instFunLike",
"Finset.instSetLike",
... | true |
Module.End.UnifEigenvalues.val | Mathlib.LinearAlgebra.Eigenspace.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Module.End.HasUnifEigenvalue",
"AddCommGroup",
"CommRing.toCommSemiring",
"ENat",
"Module.End.UnifEigenvalues",
"Module.End",
"Module",
"Subtype.val"
] | true |
CategoryTheory.GradedObject.mapBifunctorLeftUnitor_naturality | Mathlib.CategoryTheory.GradedObject.Unitor | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.GradedObject.HasMap",
"CategoryTheory.GradedObject.mapBifunctorMapObj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"Cate... | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_eq_empty_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | [
"Real",
"Real.instZero",
"Real.instLT",
"PseudoEMetricSpace",
"Metric.thickening",
"Metric.thickening_eq_empty_iff_of_pos",
"LT.lt",
"propext",
"Set.instEmptyCollection",
"Zero.toOfNat0",
"EmptyCollection.emptyCollection",
"OfNat.ofNat",
"Eq",
"Set"
] | false |
Finset.addConst_neg_left | Mathlib.Combinatorics.Additive.DoublingConst | [
"neg_add_rev",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"SubtractionMonoid.toInvolutiveNeg",
"instHDiv",
"Finset.addConst",
"neg_add_eq_sub",
"congrArg",
"Finset.subConst",
"NNRat.instSemifield",
"Finset",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddCom... | true |
CategoryTheory.MorphismProperty.Over.pullbackMapHomPullback._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.instHasPullbacksOfHasPullbacks",
"CategoryTheory.MorphismProperty.HasPullbacksAlong",
"CategoryTheory.Limits.HasPullbacks",
"CategoryTheory.MorphismProperty.instHasPullbacksAlongOf... | false |
Congr!.Config._sizeOf_1 | Mathlib.Tactic.CongrExclamation | [
"Lean.Meta.TransparencyMode._sizeOf_inst",
"Option._sizeOf_inst",
"Congr!.Config.rec",
"instOfNatNat",
"Lean.Meta.TransparencyMode",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Bool",
"instAddNat",
"instSizeOfNat",
"Congr!.Config",
"OfNat.ofNat",
"Bool._sizeOf_inst",
"Option"
] | false |
Std.DHashMap.Internal.Raw₀.toList_map | Std.Data.DHashMap.Internal.RawLemmas | [
"Eq.mpr",
"congrArg",
"List.map",
"Std.DHashMap.Raw",
"Std.DHashMap.Raw.toList",
"id",
"List.Perm",
"Sigma.fst",
"List.Perm.rfl",
"instOfNatNat",
"List",
"Std.DHashMap.Internal.Raw₀.map",
"Nat",
"congr",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Std.DHashMap.Internal.toListModel",
"pro... | true |
Turing.TM2to1.StAct.rec | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"Turing.TM2to1.StAct.pop",
"Turing.TM2to1.StAct.peek",
"Turing.TM2to1.StAct.push",
"Turing.TM2to1.StAct",
"Option"
] | false |
CategoryTheory.Functor.CoconeTypes.IsColimit.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | [
"CategoryTheory.Functor",
"Function.comp",
"CategoryTheory.Functor.CoconeTypes.ι",
"CategoryTheory.Functor.CoconeTypes.pt",
"CategoryTheory.Functor.CoconeTypes.IsColimit",
"CategoryTheory.Functor.CoconeTypes",
"CategoryTheory.types",
"congr_fun",
"CategoryTheory.Functor.CoconeTypes.IsColimit.desc",
... | true |
Lean.Parser.doElemParser | Lean.Parser.Do | [
"Lean.Parser.Parser",
"Lean.Parser.categoryParser",
"instOfNatNat",
"Nat",
"optParam",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
HasDerivAt.comp_sub_const | Mathlib.Analysis.Calculus.Deriv.Shift | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"hasDerivAt_id'",
"NormedSpace.... | true |
NumberField.logHeight₁_eq | Mathlib.NumberTheory.Height.NumberField | [
"Multiset.sum",
"NumberField.InfinitePlace.instFunLikeReal",
"NumberField.FinitePlace._proof_2",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real.partialOrder",
"Real",
"instHSMul",
"HMul.hMul",
"Real.posLog",
"NumberField.RingOfIntegers.instIsFractionRing",
"Finset.univ",
"Multiset.map",
"N... | true |
Aesop.Script.StepTree.toMessageData | Aesop.Script.UScriptToSScript | [
"Aesop.Script.StepTree",
"Lean.MessageData",
"Std.instToFormatString",
"Aesop.Script.StepTree.toMessageData?",
"String",
"Option.getD",
"Function.comp",
"Lean.MessageData.ofFormat",
"Std.ToFormat.format",
"Std.Format"
] | true |
IsFiniteLength.of_subsingleton._simp_1 | Mathlib.RingTheory.FiniteLength | [
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"True",
"eq_true",
"Subsingleton",
"IsFiniteLength.of_subsingleton",
"Module",
"Ring.toSemiring",
"Eq",
"Ring",
"IsFiniteLength"
] | false |
MeasureTheory.Measure.MutuallySingular.zero_left | Mathlib.MeasureTheory.Measure.MutuallySingular | [
"MeasureTheory.Measure",
"MeasureTheory.Measure.instZero",
"MeasurableSpace",
"MeasureTheory.Measure.MutuallySingular.zero_right",
"MeasureTheory.Measure.MutuallySingular",
"Zero.toOfNat0",
"OfNat.ofNat",
"MeasureTheory.Measure.MutuallySingular.symm"
] | true |
Module.Basis.extendLe_subset | Mathlib.LinearAlgebra.Basis.VectorSpace | [
"LinearIndepOn.extend",
"Submodule",
"Module.Basis.extendLe",
"LinearIndepOn.extend_subset",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Module.Basis.range_extendLe",
"Eq.rec",
"DivisionRing.toDivisionSemiring",
"AddCommGroup",
"Set.Elem",
"id",
"HasSubset.... | true |
Lean.HeadIndex.lam.sizeOf_spec | Lean.HeadIndex | [
"Lean.HeadIndex.lam",
"instOfNatNat",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Lean.HeadIndex",
"Lean.HeadIndex._sizeOf_inst"
] | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.nontrivialTopology_iff_exists_nnnorm_ne_zero'._simp_1_2 | Mathlib.Analysis.Normed.Group.Basic | [
"NNDist.nndist",
"PseudoMetricSpace.toUniformSpace",
"PseudoMetricSpace.toNNDist",
"NNReal",
"NNReal.instZero",
"PseudoMetricSpace",
"propext",
"Zero.toOfNat0",
"Metric.inseparable_iff_nndist",
"OfNat.ofNat",
"UniformSpace.toTopologicalSpace",
"Eq",
"Inseparable"
] | false |
LinearIsometryEquiv.conjStarAlgEquiv._proof_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | [
"InnerProductSpace.toNormedSpace",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"NormedField.toField",
"smulCommClass_self",
"RCLike.toDenselyNormedField",
"RCLike",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"CommMonoid.toMonoid",
"Monoid.toSemigroup",
"Module.toDistribMulActi... | false |
Std.Internal.List.minKey?_eq_some_minKey | Std.Data.Internal.List.Associative | [
"Ord",
"congrArg",
"Std.TransOrd",
"Std.Internal.List.minKey?",
"Std.Internal.List.minKey_eq_get_minKey?._proof_1",
"Option.some",
"Option.some_get",
"List",
"Option.get",
"List.isEmpty",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Std.LawfulBEqOrd",
"Std.Internal.List.minKey",
"Bool.f... | true |
IsOrderedVAdd.vadd_le_vadd_right | Mathlib.Algebra.Order.AddTorsor | [
"VAdd",
"LE.le",
"LE",
"HVAdd.hVAdd",
"instHVAdd",
"IsOrderedVAdd"
] | true |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal.trace_mem_dual_one._simp_1_2 | Mathlib.RingTheory.DedekindDomain.Different | [
"FractionalIdeal.dual",
"IsIntegralClosure",
"IsDomain",
"IsDedekindDomain.toIsDomain",
"CommRing",
"IsDomain.to_noZeroDivisors",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"Subring.instSetLike",
"LinearMap.BilinForm",
"CommSemiring.to... | false |
Std.IteratorLoop.WithWF.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Loop | [
"Std.IteratorLoop.WellFounded",
"ForInStep",
"Std.Iterator",
"Std.IteratorLoop.WithWF",
"Std.IterM",
"Std.IteratorLoop.WithWF.mk"
] | false |
RelIso.eq_iff_eq | Mathlib.Order.RelIso.Basic | [
"Function.Injective.eq_iff",
"RelIso.injective",
"RelIso",
"Iff",
"RelIso.instFunLike",
"Eq",
"DFunLike.coe"
] | true |
CStarModule.innerₛₗ._proof_4 | Mathlib.Analysis.CStarAlgebra.Module.Defs | [
"AddHom.mk.congr_simp",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Complex.commRing",
"Inner.inner",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddHom",
"SMul",
"AddMonoid.toAddZeroClass",
"... | false |
Qq.instBEqQuoted._aux_1 | Qq.Typ | [
"Lean.Expr",
"Lean.Expr.eqv",
"Qq.Quoted",
"Bool"
] | false |
Batteries.RBNode.Balanced.del | Batteries.Data.RBMap.WF | [
"_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.del.match_1_2",
"Ordering.gt",
"Batteries.RBNode",
"Eq.mpr",
"False",
"Batteries.RBNode.del.match_1",
"Batteries.RBNode.balLeft",
"congrArg",
"Batteries.RBNode.del.eq_def",
"Batteries.RBNode.isBlack",
"Batteries.RBNode.Balanced.balLef... | true |
Fin.insertNth_sub | Mathlib.Algebra.Group.Fin.Tuple | [
"Fin.succAbove",
"Fin.insertNth_binop",
"HSub.hSub",
"Fin.insertNth",
"instOfNatNat",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Pi.instSub",
"OfNat.ofNat",
"Fin",
"Eq",
"Sub"
] | true |
Quaternion.imK_ratCast | Mathlib.Algebra.Quaternion | [
"NegZeroClass.toNeg",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Rat",
"AddGroupWithOne.toAddMonoidWithOne",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Quaternion.instRatCast",
"Field.toDivisionRing",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Ra... | true |
_private.Qq.AssertInstancesCommute.0.Qq.Impl._aux_Qq_AssertInstancesCommute___elabRules_Qq_Impl_termAssertInstancesCommuteImpl__1.match_1 | Qq.AssertInstancesCommute | [
"Unit.unit",
"Lean.Expr.const",
"Option.casesOn",
"Option.some",
"Lean.Name.mkStr3",
"Lean.FVarId",
"Prod.mk",
"Lean.Level",
"Option.none",
"Unit",
"Qq.Quoted",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Sigma.mk",
"Sigma.casesOn",
"Prod",
"Prod.casesOn",
"Sigma",
"List.nil",
"Optio... | false |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin._simp_1_5 | Mathlib.Topology.DiscreteSubset | [
"Membership.mem",
"SDiff.sdiff",
"And",
"Set.mem_diff",
"propext",
"Eq",
"Set.instMembership",
"Not",
"Set.instSDiff",
"Set"
] | false |
OrderAddMonoidHom.fst_apply | Mathlib.Algebra.Order.Monoid.Lex | [
"Prod.instAddZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"PartialOrder",
"OrderAddMonoidHom.instFunLike",
"Prod.fst",
"OrderAddMonoidHom.fst",
"AddMonoid",
"Prod.instPreorder",
"Eq.refl",
"Prod",
"OrderAddMonoidHom",
"Eq",
"DFunLike.coe",
"Preorder"
] | true |
QuotientAddGroup.homQuotientZSMulOfHom_comp | Mathlib.GroupTheory.QuotientGroup.Basic | [
"QuotientAddGroup.addMonoidHom_ext",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.range",
"AddCommGroup.toAddGroup",
"QuotientAddGroup.Quotient.addGroup",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Int",
"zsmulAddGroupHom",
"QuotientAddGroup.mk'",
"AddSubgroup",
"HasQuotient.Quotient",
"AddGrou... | true |
CategoryTheory.yonedaJointlyReflectsLimits._proof_1 | Mathlib.CategoryTheory.Limits.Yoneda | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Quiver.Hom.op",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"Quiver.Hom.unop",
"CategoryTheory.yoneda",... | false |
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.HasLimitsOfShape",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Limits.HasLimit",
"CategoryTheory.Limits.HasEqualizers",
"CategoryTheory.SmallCategory",
"Sigma.fst",
"CategoryTheory.Limit... | false |
CommAlgCat.algEquivOfIso_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | [
"CommAlgCat.algEquivOfIso",
"CommAlgCat.instConcreteCategoryAlgHomCarrier",
"CommRing",
"CommSemiring.toSemiring",
"CategoryTheory.ConcreteCategory.hom",
"AlgHom",
"AlgHom.funLike",
"CommAlgCat.commRing",
"CategoryTheory.Iso",
"CommAlgCat.instCategory",
"CommAlgCat.carrier",
"CommRing.toCommSe... | true |
Aesop.TreeRef.rec | Aesop.Tree.Traversal | [
"Aesop.TreeRef",
"Aesop.RappRef",
"Aesop.TreeRef.rapp",
"Aesop.GoalRef",
"Aesop.TreeRef.mvarCluster",
"Aesop.TreeRef.goal",
"Aesop.MVarClusterRef"
] | false |
div_ne_one | Mathlib.Algebra.Group.Basic | [
"instHDiv",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"HDiv.hDiv",
"Ne",
"Group.toDivInvMonoid",
"Iff",
"div_eq_one",
"DivInvMonoid.toDiv",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"not_congr"
] | true |
ENat.instUniqueUnits | Mathlib.Data.ENat.Basic | [
"Unique.mk",
"CommSemiring.toSemiring",
"Unique",
"ENat.instUniqueUnits._proof_1",
"Units",
"ENat",
"instCommSemiringENat",
"Units.instInhabited",
"MonoidWithZero.toMonoid",
"Semiring.toMonoidWithZero"
] | true |
ContinuousMultilinearMap.linearDeriv.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | [
"Pi.addCommMonoid",
"Pi.topologicalSpace",
"Pi.module",
"ContinuousMultilinearMap",
"Eq.rec",
"ContinuousMultilinearMap.linearDeriv",
"AddCommMonoid",
"ContinuousLinearMap",
"TopologicalSpace",
"Fintype",
"Semiring",
"Eq.refl",
"AddCommSemigroup.toAddCommMagma",
"Module",
"ContinuousAdd"... | true |
Subsemigroup.op._proof_1 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | [
"HMul.hMul",
"Subsemigroup.mul_mem",
"MulOpposite",
"Mul",
"Membership.mem",
"SetLike.coe",
"Set.preimage",
"Subsemigroup",
"MulOpposite.unop",
"Subsemigroup.instSetLike",
"Set.instMembership",
"SetLike.instMembership",
"instHMul",
"Set"
] | false |
CategoryTheory.Bicategory.Prod.sectL._proof_8 | Mathlib.CategoryTheory.Bicategory.Product | [
"CategoryTheory.Iso.inv_hom_id",
"CategoryTheory.prod",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Bicategory.unitors_inv_equal",
"Quiver.Hom",
"CategoryTheory.Bicategory.whiskerRight_id",
"congrArg",
"CategoryTheory.Prod.mkHom",
"CategoryTheory.Bicategory.rightUnitor",
"CategoryThe... | false |
FirstOrder.Language.presburger.funMap_one | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | [
"One",
"FirstOrder.Language.presburger",
"FirstOrder.presburgerFunc.one",
"instOfNatNat",
"Nat",
"One.toOfNat1",
"OfNat.ofNat",
"FirstOrder.Language.Structure.funMap",
"Fin",
"Eq",
"FirstOrder.Language.presburger.instStructure",
"Add",
"rfl",
"Zero"
] | true |
TopologicalSpace.prod_mono | Mathlib.Topology.Constructions.SumProd | [
"PartialOrder.toPreorder",
"instTopologicalSpaceProd",
"Preorder.toLE",
"inf_le_right",
"SemilatticeInf.toPartialOrder",
"CompleteLattice.toConditionallyCompleteLattice",
"TopologicalSpace.instCompleteLattice",
"SemilatticeInf.toMin",
"LE.le",
"le_inf",
"Prod.fst",
"TopologicalSpace",
"Topol... | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.mk.sizeOf_spec | Batteries.Data.MLList.Basic | [
"_private.Batteries.Data.MLList.Basic.0.MLList.Spec.mk",
"instOfNatNat",
"_private.Batteries.Data.MLList.Basic.0.MLList.Spec._sizeOf_inst",
"Unit",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"SizeOf",
"Prod",
"OfNat.ofNat",
"Monad",
"_private.Batteries.Data.MLList.Basic.0.MLList.Spec",
"Eq",
"Opti... | true |
coe_iterateFrobeniusEquiv | Mathlib.FieldTheory.Perfect | [
"iterateFrobeniusEquiv",
"PerfectRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"RingHom",
"ExpChar",
"Distrib.toAdd",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Monoid.toPow",
"CommSemiring",
"RingHom.instFunLike",
"Distrib.toMul",
... | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.incMod | Std.Sync.Channel | [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"instDecidableEqNat",
"OfNat.ofNat",
"Eq",
"ite"
] | true |
Flow.cont' | Mathlib.Dynamics.Flow | [
"Continuous",
"AddMonoid.toAddSemigroup",
"Flow",
"instTopologicalSpaceProd",
"TopologicalSpace",
"AddSemigroup.toAdd",
"AddMonoid",
"Function.uncurry",
"ContinuousAdd",
"Prod",
"Flow.toFun"
] | true |
Turing.Dir.ofNat_ctorIdx | Mathlib.Computability.TuringMachine.Tape | [
"Turing.Dir.ctorIdx",
"Turing.Dir.casesOn",
"Turing.Dir.left",
"Turing.Dir.ofNat",
"Eq.refl",
"Turing.Dir.right",
"Eq",
"Turing.Dir"
] | true |
_private.Mathlib.FieldTheory.Differential.Basic.0.Differential.logDeriv_div._simp_1_7 | Mathlib.FieldTheory.Differential.Basic | [
"False",
"eq_false",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"Nat.cast_add_one_ne_zero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"On... | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1.else_eq | Lean.Elab.Tactic.Try | [
"Option.ctorIdx",
"Option.casesOn",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"instOfNatNat",
"_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1",
"Bool.true",
"Nat.land",
"Option.none",
"absurd",
"Nat",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true"... | false |
Filter.prod_map_map_eq' | Mathlib.Order.Filter.Prod | [
"SProd.sprod",
"Filter.map",
"Prod.map",
"Filter.prod_map_map_eq",
"Prod",
"Filter.instSProd",
"Eq",
"Filter"
] | true |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_4 | Mathlib.LinearAlgebra.Finsupp.Span | [
"Submodule",
"Submodule.mem_bot",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Bot.bot",
"AddCommMonoid",
"AddZero.toZero",
"Submodule.instBot",
"Submodule.setLike",
"propext",
"Semiring",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"Module",
"OfNat.ofNat"... | false |
Submonoid.mk_inv_mul_mk_eq_one | Mathlib.Algebra.Group.Submonoid.Units | [
"Monoid",
"Submonoid.inv",
"MonoidHom.instFunLike",
"Units.coeHom",
"Submonoid.mul",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"MonoidHom",
"Monoid.toMulOneClass",
"Submonoid.units",
"Units.inv_mul",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"Uni... | true |
Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.goal.elim | Lean.Server.Test.Runner | [
"Lean.Server.Test.Runner.Client.HighlightedMsgEmbed",
"PULift.up",
"Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.goal",
"Lean.Server.Test.Runner.Client.InteractiveGoal",
"Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.ctorElim",
"Nat",
"Lean.Server.Test.Runner.Client.HighlightedMsgEmbed.ctorId... | false |
Lean.Elab.Term.LetRecDeclView.mk.inj | Lean.Elab.LetRec | [
"Lean.TSyntax",
"Lean.Elab.Term.LetRecDeclView.mk.noConfusion",
"Lean.Elab.Term.LetRecDeclView.mk",
"Lean.Syntax",
"Lean.Expr",
"List.cons",
"Lean.Elab.Attribute",
"Array",
"And",
"Lean.Elab.TerminationHints",
"And.intro",
"Bool",
"Lean.Name",
"Lean.Elab.Term.LetRecDeclView",
"Lean.Synta... | true |
_aux_Mathlib_Combinatorics_Quiver_Basic___unexpand_Quiver_Hom_1 | Mathlib.Combinatorics.Quiver.Basic | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.normalizationMonoidOfMonoidHomRightInverse._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | [
"Monoid",
"Units.val",
"Units.ext_iff",
"Units",
"propext",
"Eq"
] | false |
AlgebraicGeometry.Scheme.Modules.pushforwardId | Mathlib.AlgebraicGeometry.Modules.Sheaf | [
"CategoryTheory.Functor",
"AlgebraicGeometry.Scheme.Modules.pushforward",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.Scheme.Modules.instCategory",
"AlgebraicGeometry.PresheafedSpace.carrier",
"TopologicalSpace.Opens.instPartialOrder",
"CommRingCat",
"PartialOrder.toPreorder",
"CategoryTheory.Fun... | true |
Ideal.quotientToQuotientRangePowQuotSucc | Mathlib.NumberTheory.RamificationInertia.Basic | [
"Ideal.Quotient.commSemiring",
"Submodule",
"RingHomSurjective.ids",
"Nat.instMulZeroClass",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"Submodule.Quotient.addCommGroup",
"CommSemiring.toSemiring",
"I... | true |
CategoryTheory.MonoidalLinear.whiskerLeft_smul | Mathlib.CategoryTheory.Monoidal.Linear | [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.MonoidalCategory",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Linear",
"CategoryTheory.Monoid... | true |
EReal.sub_le_iff_le_add | Mathlib.Data.EReal.Operations | [
"Eq.mpr",
"congrArg",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"sub_eq_add_neg",
"HSub.hSub",
"EReal.instNeg",
"EReal",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"Eq.mp",
"instTopEReal",
"neg_neg",
"id",
"Ne",
"Bot.bot",
"EReal.neg_eq_top_iff._simp_1",
"LE.le",
"Su... | true |
CategoryTheory.Subobject.ofMkLE | Mathlib.CategoryTheory.Subobject.Basic | [
"CategoryTheory.Subobject.underlying",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Subobject.ofLE",
"Preorder.toLE",
"CategoryTheory.Subobject.underlyingIso",
"Preorder.smallCategory",
"LE.le",
"CategoryTheory.instPart... | true |
ContinuousAffineMap.const_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | [
"ContinuousAffineMap.contLinear",
"AddCommGroup.toAddCommMonoid",
"IsTopologicalAddTorsor",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"ContinuousLinearMap.zero",
"ContinuousLinearMap",
"TopologicalSpace",
"AddTorsor",
"ContinuousAffineMap.const",
"Zero.toOfNat0",
"Module",
"OfNat.ofNat",
... | true |
CategoryTheory.ObjectProperty.Is.rec | Mathlib.CategoryTheory.ObjectProperty.Basic | [
"CategoryTheory.ObjectProperty.Is",
"CategoryTheory.ObjectProperty.Is.mk",
"CategoryTheory.CategoryStruct",
"CategoryTheory.ObjectProperty"
] | false |
Std.ExtTreeSet.mem_inter_iff | Std.Data.ExtTreeSet.Lemmas | [
"Std.ExtTreeMap.mem_inter_iff",
"Membership.mem",
"Ordering",
"Std.ExtTreeSet.inner",
"Std.TransCmp",
"Inter.inter",
"And",
"Unit",
"Iff",
"Std.ExtTreeSet.instMembershipOfTransCmp",
"Std.ExtTreeSet",
"Std.ExtTreeSet.instInterOfTransCmp"
] | true |
HeytAlg.ext_iff | Mathlib.Order.Category.HeytAlg | [
"HeytAlg",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"HEq.refl",
"Eq.casesOn",
"Iff",
"HeytAlg.instConcreteCategoryHeytingHomCarrier",
"HeytAlg.carrier",
"HeytingHom",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"HeytAlg.instCategory",
... | true |
convexHull_neg | Mathlib.Analysis.Convex.Hull | [
"Eq.mpr",
"NegZeroClass.toNeg",
"MulOne.toOne",
"SubtractionMonoid.toInvolutiveNeg",
"AffineMap.instFunLike",
"CompleteLattice.instOmegaCompletePartialOrder",
"Monoid.toMulOneClass",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"AffineMap.instNeg",
"AddCommGroup.toAdd... | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_i | Mathlib.Algebra.Homology.ShortComplex.Abelian | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Epi",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.CokernelCofork",
"CategoryTheory.Limits.KernelFork",
"CategoryTheory.ShortComplex",
"Cate... | true |
Lean.Elab.MonadParentDecl.casesOn | Lean.Elab.InfoTree.Types | [
"Lean.Elab.MonadParentDecl",
"Lean.Elab.MonadParentDecl.rec",
"Lean.Name",
"Lean.Elab.MonadParentDecl.mk",
"Option"
] | false |
_private.Lean.Parser.Basic.0.Lean.Parser.rawStrLitFnAux.errorUnterminated | Lean.Parser.Basic | [
"String.Pos.Raw",
"Lean.Parser.ParserState",
"Lean.Parser.ParserState.mkUnexpectedErrorAt"
] | true |
RingEquiv.piOptionEquivProd | Mathlib.Algebra.Ring.Equiv | [
"Prod.instMul",
"Prod.instAdd",
"Equiv.piOptionEquivProd",
"Option.some",
"Equiv",
"Distrib.toAdd",
"Option.none",
"Pi.instAdd",
"RingEquiv.piOptionEquivProd._proof_1",
"Distrib.toMul",
"RingEquiv.piOptionEquivProd._proof_2",
"NonUnitalNonAssocSemiring.toDistrib",
"Pi.instMul",
"RingEquiv.... | true |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_1 | Mathlib.Analysis.Analytic.Composition | [
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"SemilatticeInf.toMin",
"And",
"LT.lt",
"propext",
"Eq",
"instDistribLatticeOfLinearOrder",
"Min.min",
"Lattice.toSemilatticeInf",
"lt_min_iff"
] | false |
instSubsingleton | Init.Core | [
"proof_irrel",
"Subsingleton.intro",
"Subsingleton"
] | true |
Complex.isAlgebraic_sin_rat_mul_pi | Mathlib.NumberTheory.Niven | [
"NormedCommRing.toNormedRing",
"Int.cast",
"RingHom.instRingHomClass",
"False",
"Real.pi",
"HMul.hMul",
"Complex.commRing",
"IsAlgebraic",
"Ring.toNonAssocRing",
"congrArg",
"CommSemiring.toSemiring",
"NormedDivisionRing.toNormMulClass",
"Rat",
"Complex.sin",
"Nat.instAtLeastTwoHAddOfNat... | true |
Lean.Parser.Command.recommended_spelling._regBuiltin.Lean.Parser.Command.recommended_spelling.formatter_7 | Lean.Parser.Command | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Parser.Command.recommended_spelling.formatter",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
Pi.evalNonUnitalRingHom._proof_2 | Mathlib.Algebra.Ring.Pi | [
"ZeroHom.toFun",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.toZeroHom",
"AddZeroClass.toAddZero",
"Pi.evalAddMonoidHom",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"Pi.addZeroClass",
"AddZero.toAdd",
"AddCommMonoid.toAddMonoid",
"AddMonoidHom.map_a... | false |
CategoryTheory.Cokleisli.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Kleisli | [
"CategoryTheory.Comonad",
"CategoryTheory.Cokleisli.mk",
"CategoryTheory.Cokleisli",
"CategoryTheory.Category"
] | false |
ContDiffBump.rOut | Mathlib.Analysis.Calculus.BumpFunction.Basic | [
"Real",
"ContDiffBump"
] | true |
NormedAddCommGroup.ofCoreReplaceTopology._proof_1 | Mathlib.Analysis.Normed.Module.Basic | [
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"Eq.mpr",
"NegZeroClass.toNeg",
"SeminormedAddCommGroup.ofCoreReplaceTopology",
"Real",
"SeminormedAddGroup.toAddGroup",
"Real.instZero",
"congrArg",
"PseudoEMetricSpace.ofSeminormedSpaceCore",
"sub_eq_zero",
"AddCommGroup.toAddCommMonoid",
"Norme... | false |
ContinuousLinearEquiv.summable | Mathlib.Topology.Algebra.InfiniteSum.Module | [
"ContinuousLinearEquiv.symm",
"SummationFilter",
"ContinuousLinearMap.summable",
"RingHom",
"ContinuousLinearEquiv.equivLike",
"ContinuousLinearEquiv.hasSum",
"AddCommMonoid",
"RingHomInvPair",
"HasSum.summable",
"TopologicalSpace",
"Iff",
"ContinuousLinearEquiv",
"Summable.hasSum",
"tsum"... | true |
Std.HashSet.Raw.Equiv.of_forall_contains_eq | Std.Data.HashSet.RawLemmas | [
"Std.HashSet.Raw.inner",
"Std.HashSet.Raw.contains",
"LawfulBEq",
"Std.HashSet.Raw.WF",
"Std.HashSet.Raw.Equiv",
"Std.HashSet.Raw.WF.out",
"Bool",
"Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq",
"Hashable",
"Std.HashSet.Raw.Equiv.mk",
"BEq",
"Eq",
"Std.HashSet.Raw"
] | true |
Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.74134663._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | [
"Lean.Option",
"IO",
"Lean.Name.mkStr3",
"Lean.Option.Decl.mk",
"Lean.KVMap.instValueBool",
"Lean.Option.register",
"Bool",
"Lean.Name.mkStr2",
"Bool.false"
] | false |
FreeAddMonoid.casesOn_zero | Mathlib.Algebra.FreeMonoid.Basic | [
"FreeAddMonoid.of",
"AddMonoid.toAddZeroClass",
"FreeAddMonoid.instAddCancelMonoid",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"AddRightCancelMonoid.toAddMonoid",
"FreeAddMonoid.casesOn",
"AddZero.toAdd",
"Zero.toOfNat0",
"... | true |
ContinuousMap.coeFnRingHom_apply | Mathlib.Topology.ContinuousMap.Algebra | [
"ContinuousMap.instNonAssocSemiringOfIsTopologicalSemiring",
"IsTopologicalSemiring",
"ContinuousMap",
"RingHom",
"TopologicalSpace",
"RingHom.instFunLike",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Pi.nonAssocSemiring",
"Semiring",
"Eq.refl",
"Semiring.toNonAssocSemiring",
"Eq",
"Con... | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.size | Std.Sync.Broadcast | [
"Nat",
"_private.Std.Sync.Broadcast.0.Std.Bounded.State"
] | true |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | [
"Eq.mpr",
"Vector.findFinIdx?",
"Vector",
"congrArg",
"Array.findFinIdx?_subtype",
"Vector.casesOn",
"Function.comp",
"Vector.unattach_mk",
"Eq.rec",
"Array.findFinIdx?_subtype._proof_1",
"id",
"Subtype",
"Vector.unattach",
"Vector.findFinIdx?_congr",
"Subtype.mk",
"Array",
"Fin.cast... | true |
AffineIsometryEquiv._sizeOf_1 | Mathlib.Analysis.Normed.Affine.Isometry | [
"NormedCommRing.toNormedRing",
"Norm.norm",
"AffineEquiv.linear",
"Real",
"SeminormedAddCommGroup",
"NormedRing.toRing",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"instOfNatNat",
"AffineIsometryEquiv",
"NormedField",
"SeminormedAddCommGroup.toNorm",
"instHAdd",... | false |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | [
"String",
"Lean.Lsp.DocumentFilter.mk",
"Lean.Lsp.DocumentFilter",
"Option"
] | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | [
"Set.mem_range",
"Membership.mem",
"Exists",
"propext",
"Set.range",
"Eq",
"Set.instMembership",
"Set"
] | false |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | [
"Inner.casesOn",
"Inner",
"HEq"
] | false |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | [
"instHSMul",
"SMulWithZero.toSMulZeroClass",
"PUnit.smulWithZero",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"PUnit",
"PUnit.instZero_mathlib",
"Zero.toOfNat0",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"SMulZeroClass.smul_zero",
"E... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.