name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Grp.instMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | [
"CategoryTheory.Mon.instIsMonHomHom",
"CategoryTheory.Grp.instMonoidalCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Mon.Hom.hom",
"CategoryTheory.MonoidalCategoryStruct.leftUnitor",
"CategoryTheory.Grp.instCategory",
"CategoryTheory.GrpObj.toMonObj",
... | false |
Subgroup.instSMul | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | [
"Mul.toSMulMulOpposite",
"Monoid.toMulOneClass",
"SMul",
"MulOpposite",
"Group",
"Membership.mem",
"MulOne.toMul",
"Subtype",
"DivInvMonoid.toMonoid",
"Subgroup",
"Submonoid.smul",
"MulOpposite.instGroup",
"Subgroup.op",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"SetLike.instMemb... | true |
LaurentPolynomial.C_apply | Mathlib.Algebra.Polynomial.Laurent | [
"Finsupp.instFunLike",
"Eq.mpr",
"False",
"Decidable.casesOn",
"congrArg",
"False.elim",
"AddMonoid.toAddZeroClass",
"Decidable",
"LaurentPolynomial",
"RingHom",
"Int.instDecidableEq",
"Eq.mp",
"not_true_eq_false",
"id",
"Int",
"Int.instAddMonoid",
"ite_cond_eq_true",
"if_pos",
"... | true |
CategoryTheory.Functor.hom_ext_of_isLeftKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Basic | [
"CategoryTheory.StructuredArrow.IsUniversal.hom_ext",
"CategoryTheory.Functor",
"CategoryTheory.Functor.LeftExtension.mk",
"CategoryTheory.Functor.IsLeftKanExtension",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryT... | true |
Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply | Mathlib.Topology.FiberBundle.Trivialization | [
"instTopologicalSpaceProd",
"Membership.mem",
"Set.Elem",
"Set.instSingletonSet",
"Prod.mk",
"OpenPartialHomeomorph.toFun'",
"Subtype.mk",
"TopologicalSpace",
"Bundle.Trivialization.preimageSingletonHomeomorph_symm_apply._proof_1",
"Homeomorph.instEquivLike",
"Set.preimage",
"Bundle.Trivializa... | true |
Std.ExtTreeSet.forM_eq_forM_toList | Std.Data.ExtTreeSet.Lemmas | [
"Std.ExtTreeMap.forM_eq_forM_keys",
"ForM.forM",
"Ordering",
"Std.ExtTreeSet.inner",
"LawfulMonad",
"Std.TransCmp",
"Unit",
"Std.ExtTreeSet.toList",
"PUnit",
"Std.ExtTreeSet",
"Std.ExtTreeSet.instForMOfTransCmpOfLawfulMonad",
"List.forM",
"Monad",
"Eq"
] | true |
Lean.Elab.ExpandDeclIdResult._sizeOf_inst | Lean.Elab.DeclModifiers | [
"Lean.Elab.ExpandDeclIdResult",
"SizeOf.mk",
"Lean.Elab.ExpandDeclIdResult._sizeOf_1",
"SizeOf"
] | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux.match_1 | Mathlib.Lean.Expr.Basic | [
"_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux._sparseCasesOn_1",
"Lean.Expr",
"Nat.hasNotBit",
"instOfNatNat",
"dite",
"Lean.Expr.lam",
"Nat",
"Eq.ndrec_symm",
"Lean.Name",
"instDecidableEqNat",
"Lean.BinderInfo",
"Lean.Expr.ctorIdx",
"OfNat.ofNat",
"Nat.succ",
... | false |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.initAndRunWatchdogAux._sparseCasesOn_1 | Lean.Server.Watchdog | [
"Lean.Json",
"Nat.ne_of_beq_eq_false",
"Lean.JsonRpc.ErrorCode",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"Lean.JsonRpc.Message.rec",
"instOfNatNat",
"Lean.Json.Structured",
"Lean.JsonRpc.Message.notification",
"Lean.JsonRpc.Message",
"Nat.land",
"Lean.JsonRpc.Message.ctorIdx",
"Nat",
... | false |
Nat.toInt32 | Init.Data.SInt.Basic | [
"Int32.ofNat",
"Nat",
"Int32"
] | true |
Std.Time.DateTime.ofPlainDateTime | Std.Time.Zoned.DateTime | [
"Std.Time.Timestamp.ofPlainDateTimeAssumingUTC",
"Std.Time.PlainDateTime.subSeconds",
"Std.Time.TimeZone.toSeconds",
"Unit",
"Std.Time.DateTime",
"Thunk.mk",
"Std.Time.TimeZone",
"_private.Std.Time.Zoned.DateTime.0.Std.Time.DateTime.mk",
"Std.Time.PlainDateTime"
] | true |
CommRingCat.Colimits.descMorphism._proof_4 | Mathlib.Algebra.Category.Ring.Colimits | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CommRingCat.carrier",
"CommSemiring.toSemiring",
"CommRingCat",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"CommRingCat.instCategory",
"CategoryTheory.SmallCategory",
"AddCommMonoidWi... | false |
Finset.sum_sum_Ioi_add_eq_sum_sum_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | [
"Finset.mem_univ",
"Eq.mpr",
"Finset.Ioi_disjUnion_Iio",
"Preorder.toLT",
"LocallyFiniteOrderTop",
"Finset.univ",
"LinearOrder.toDecidableEq",
"Finset.Ioi",
"congrArg",
"Finset.sum_add_distrib",
"Compl.compl",
"Finset",
"Sigma.eta",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"PartialOr... | true |
Filter.Germ.liftPred_const_iff._simp_1 | Mathlib.Order.Filter.Germ.Basic | [
"Filter.NeBot",
"Filter.Germ.const",
"Filter.Germ.LiftPred",
"propext",
"Eq",
"Filter",
"Filter.Germ.liftPred_const_iff"
] | false |
Set.seq.eq_1 | Mathlib.Data.Set.Lattice.Image | [
"Set.image2",
"Eq.refl",
"Eq",
"Set.seq",
"Set"
] | true |
AddSubmonoid.multiples._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | [
"instHSMul",
"Equiv.instEquivLike",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"Equiv",
"iff_self",
"multiplesHom",
"Iff",
"Nat",
"AddMonoid",
"of_eq_true",
"HSMul.hSMul",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"Eq",
"DFunLi... | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_13 | Mathlib.MeasureTheory.Measure.AddContent | [
"instLawfulOrderLT_mathlib",
"Lean.Grind.of_eq_eq_true",
"Set.mem_union",
"Lean.Grind.eq_false_of_not_eq_true",
"Set.ext",
"Set.Ioc",
"Inhabited.default",
"of_eq_false",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"Lean.Grind.not_not",
"Lean.Grind.not_false",
"Lean.Grin... | false |
MeasureTheory.aemeasurable_mlconvolution | Mathlib.Analysis.LConvolution | [
"MeasureTheory.quasiMeasurePreserving_inv_mul",
"MeasureTheory.Measure",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"AEMeasurable",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"MeasureTheory.QuasiMeasurePreserving.fst",
"AEMeasurable.comp_quasiMeasurePreserving",
"Group",
"ENNReal.meas... | true |
CategoryTheory.SmallObject.functor._proof_11 | Mathlib.CategoryTheory.SmallObject.Construction | [
"CategoryTheory.Limits.WalkingSpan",
"CategoryTheory.Comma.right",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory.SmallObject.FunctorObjIndex",
"CategoryTheory.Limits.HasColimitsOfShape",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Comma.left",
"C... | false |
LinearEquiv.multilinearMapCongrLeft._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | [
"LinearEquiv.symm",
"congrArg",
"CommSemiring.toSemiring",
"MultilinearMap.addCommMonoid",
"LinearMap.instFunLike",
"LinearMap.toAddHom",
"LinearMap",
"MultilinearMap",
"smulCommClass_self",
"AddCommMonoid",
"MultilinearMap.compLinearMapₗ",
"CommSemiring",
"funext",
"LinearEquiv.toLinearMa... | false |
CategoryTheory.Limits.CatCospanTransform.mkIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.whiskerLeft",
"CategoryTheory.Iso",
"CategoryTheory.CatCommSq.iso",
"CategoryTheory.Functor.whiskerRight",
"True... | false |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.Subgroup.isLeast_of_closure_iff_eq_mabs._simp_1_3 | Mathlib.GroupTheory.ArchimedeanDensely | [
"Exists",
"forall_exists_index",
"propext",
"Exists.intro",
"Eq"
] | false |
Lean.Elab.Structural.EqnInfo.fixedParamPerms | Lean.Elab.PreDefinition.Structural.Eqns | [
"Lean.Elab.FixedParamPerms",
"Lean.Elab.Structural.EqnInfo"
] | true |
List.Cursor.at._proof_1 | Std.Do.Triple.SpecLemmas | [
"congrArg",
"List.take_append_drop",
"instHAppendOfAppend",
"List",
"List.drop",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"List.instAppend",
"Eq",
"List.take",
"HAppend.hAppend",
"Eq.trans"
] | false |
CategoryTheory.Tor._proof_2 | Mathlib.CategoryTheory.Monoidal.Tor | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.MonoidalPreadditive",
"CategoryTheory.MonoidalCategory.tensoringLeft",
"Catego... | false |
Nonneg.semiring._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"HMul.hMul",
"NonUnitalSemiring.mul_assoc",
"Function.Injective.nonUnitalSemiring",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddLeftMono",
"Preorder.toLE",
"PartialOrder",
"Nonneg.coe_zero",
"Subtype",
"Distrib.toAdd",
... | false |
ODE.FunSpace.recOn | Mathlib.Analysis.ODE.PicardLindelof | [
"Real",
"LipschitzWith",
"ODE.FunSpace",
"NormedAddCommGroup.toMetricSpace",
"instPseudoEMetricSpaceSubtype",
"Membership.mem",
"Set.Elem",
"EMetricSpace.toPseudoEMetricSpace",
"NNReal",
"Real.metricSpace",
"Set.Icc",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"MetricSpace.toEMetricSpace"... | false |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec | Lean.Meta.Basic | [
"Pure.pure",
"Lean.Meta.whnf",
"Array.push",
"_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec",
"Lean.Meta.State",
"Option.some",
"Option.isEqSome",
"Lean.Expr.instantiateRevRange",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
... | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_emod_unique'._simp_1_2 | Init.Data.Int.DivMod.Lemmas | [
"Int.instNegInt",
"Int",
"propext",
"Eq",
"Neg.neg",
"Int.neg_inj"
] | false |
SubStarSemigroup.mk | Mathlib.Algebra.Star.NonUnitalSubsemiring | [
"SubStarSemigroup",
"Mul",
"Membership.mem",
"SubStarSemigroup.mk",
"Star",
"Subsemigroup",
"Subsemigroup.carrier",
"Set.instMembership",
"Star.star",
"Set"
] | true |
Lean.Meta.Grind.Arith.pickUnusedValue | Lean.Meta.Tactic.Grind.Arith.ModelUtil | [
"Lean.Meta.Grind.Goal",
"Lean.Expr.instBEq",
"Rat",
"Std.HashSet",
"Int.instDecidableEq",
"Lean.Expr",
"Int",
"Std.HashMap",
"instBEqOfDecidableEq",
"Lean.Expr.instHashable",
"_private.Lean.Meta.Tactic.Grind.Arith.ModelUtil.0.Lean.Meta.Grind.Arith.pickUnusedValue.go",
"instHashableInt"
] | true |
instIsSemitopologicalSemiringMulOpposite | Mathlib.Topology.Algebra.Ring.Basic | [
"MulOpposite.instSeparatelyContinuousMul",
"MulOpposite",
"IsSemitopologicalSemiring.mk",
"instContinuousAddMulOpposite",
"TopologicalSpace",
"IsSemitopologicalSemiring.toSeparatelyContinuousMul",
"Distrib.toMul",
"MulOpposite.instTopologicalSpaceMulOpposite",
"NonUnitalNonAssocSemiring.toDistrib",
... | true |
CategoryTheory.Limits.CreatesFiniteProducts.creates._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Std.TreeMap.Raw.mem_of_mem_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | [
"Std.TreeMap.Raw.instUnion",
"Std.TreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.mem_of_mem_union_of_not_mem_left",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw.inner",
"Std.TreeMap.Raw",
"Union.union",
"Not"
] | true |
AlgebraicGeometry.Scheme.qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | [
"AlgebraicGeometry.Scheme",
"CategoryTheory.Precoverage",
"CategoryTheory.PreZeroHypercoverFamily.precoverage",
"AlgebraicGeometry.Scheme.instCategory",
"AlgebraicGeometry.Scheme.qcCoverFamily"
] | true |
Finsupp.degree_add | Mathlib.Data.Finsupp.Weight | [
"map_add",
"instHAdd",
"HAdd.hAdd",
"AddHomClass",
"Eq",
"DFunLike.coe",
"Add",
"FunLike"
] | true |
Encodable.fintypeArrowOfEncodable | Mathlib.Logic.Encodable.Pi | [
"Encodable.fintypeEquivFin",
"Equiv.arrowCongr",
"Fintype.card",
"Encodable.ofEquiv",
"Encodable.finPi",
"Fintype",
"Fin",
"Equiv.refl",
"Encodable"
] | true |
continuousOn_tsum | Mathlib.Analysis.Normed.Group.FunctionSeries | [
"Norm.norm",
"Real.instLE",
"Real",
"CompleteSpace",
"Filter.Frequently.of_forall",
"Finset.inhabitedFinset",
"AddCommGroup.toAddCommMonoid",
"Finset",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"Filter.atTop_neBot",
"AddCommGroup.toAddGroup",
"Membership.mem",
"tendsto... | true |
Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq | Std.Data.HashMap.RawLemmas | [
"Std.HashMap.Raw.WF.out",
"LawfulBEq",
"Std.DHashMap.Raw.Equiv.of_forall_contains_unit_eq",
"Std.HashMap.Raw.WF",
"Std.HashMap.Raw",
"Std.HashMap.Raw.contains",
"Unit",
"Bool",
"Std.HashMap.Raw.inner",
"Hashable",
"Std.HashMap.Raw.Equiv",
"BEq",
"Eq",
"Std.HashMap.Raw.Equiv.mk"
] | true |
HomotopicalAlgebra.CofibrantObject.instWeakEquivalenceHoCatAppιCompResolutionNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | [
"Eq.mpr",
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"HomotopicalAlgebra.weakEquivalence_iff_of_objectProperty",
"HomotopicalAlgebra.ModelCategory.cm1b",
"HomotopicalAlgebra.CofibrantObject.mk",
"congrArg",
"CategoryTheory.Quotient.category",
"CategoryTheory.Limits.hasColimitsOf... | true |
VectorFourier.hasFDerivAt_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | [
"MeasureTheory.ae",
"Continuous.neg",
"Iff.mpr",
"HasFDerivAt",
"NormedCommRing.toNormedRing",
"ContinuousLinearMap.continuous₂",
"MeasureTheory.Integrable.aestronglyMeasurable",
"_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.hasFDerivAt_fourierIntegral._simp_1_1",
"VectorF... | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsLE_iff_exists_Ioc_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | [
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"Exists",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Exists.casesOn",
"LT.lt",
"Exists.intro",
"instDistribLatticeOfLinearOrder",
"Lattice.toSemilatticeInf"
] | false |
Ordinal.toZFSetIso_symm_apply | Mathlib.SetTheory.ZFC.Ordinal | [
"Ordinal.partialOrder",
"ZFSet",
"PartialOrder.toPreorder",
"Preorder.toLE",
"ZFSet.IsOrdinal",
"Subtype",
"RelIso.symm",
"ZFSet.rank",
"LE.le",
"RelIso",
"RelIso.instFunLike",
"ZFSet.instPartialOrder",
"Eq.refl",
"Subtype.val",
"Eq",
"DFunLike.coe",
"Ordinal.toZFSetIso",
"Ordinal"... | true |
CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.diag",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.comp",
"CategoryTheory.CostructuredArrow.hom",
"CategoryTheory.Over.forget",
"CategoryTheory.Costructur... | true |
AnalyticAt.comp₂_analyticWithinAt | Mathlib.Analysis.Analytic.Constructions | [
"AnalyticAt.comp_analyticWithinAt",
"Prod.normedSpace",
"Prod.normedAddCommGroup",
"NormedSpace",
"AnalyticWithinAt.prod",
"AnalyticWithinAt",
"Prod.mk",
"AnalyticAt",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"Prod",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"... | true |
Batteries.Tactic.triv | Batteries.Tactic.Init | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false"
] | true |
Lean.Grind.Linarith.instReprPoly.repr._f | Init.Grind.Ordered.Linarith | [
"Std.Format.instAppend",
"Lean.Grind.Linarith.Poly.below",
"Std.Format.line",
"Std.Format.group",
"GE.ge",
"instOfNatNat",
"Int",
"Lean.Grind.Linarith.Var",
"instLENat",
"instHAppendOfAppend",
"Unit",
"instOfNat",
"Nat",
"Lean.Grind.Linarith.Poly.nil",
"Std.Format",
"_private.Init.Grin... | false |
DirectSum.GradeZero.ring._proof_10 | Mathlib.Algebra.DirectSum.Ring | [
"instAddCommMonoidDirectSum",
"AddCommGroup.toAddCommMonoid",
"DirectSum.GRing.toGSemiring",
"AddMonoid.toAddZeroClass",
"DirectSum.GSemiring.toGMonoid",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Monoid.toPow",
"AddZero.toZero",
"HPow.hPow",
"Nat",
"GradedMonoid.GradeZero.monoid",
"DirectSu... | false |
Append.noConfusion | Init.Prelude | [
"Append",
"HEq.refl",
"Append.casesOn",
"Append.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Eq"
] | false |
LightProfinite.Extend.cone._proof_2 | Mathlib.Topology.Category.LightProfinite.Extend | [
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"SecondCountableTopology",
"Finite",
"FintypeCat",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.StructuredArrow.hom",
"TotallyDisconn... | false |
TendstoUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | [
"Filter.instMembership",
"UniformSpace",
"instUniformSpaceProd",
"Filter.Eventually.diag_of_prod",
"SProd.sprod",
"AddMonoid.toAddZeroClass",
"uniformity",
"uniformContinuous_add",
"Function.comp",
"Membership.mem",
"AddZeroClass.toAddZero",
"Prod.mk",
"IsUniformAddGroup",
"UniformContinuo... | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData._auto_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_7 | Mathlib.Data.List.Chain | [
"Lean.Grind.nestedProof",
"congrArg",
"HEq.refl",
"cast",
"Membership.mem",
"Eq.rec",
"List.cons",
"List",
"List.instMembership",
"eq_of_heq",
"HEq",
"Eq",
"Lean.Grind.abstractFn",
"_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_2",
"List.nil"
] | false |
CategoryTheory.Quotient.lift | Mathlib.CategoryTheory.Quotient | [
"CategoryTheory.Quotient.lift._proof_3",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Quotient",
"Quiver.Hom",
"CategoryTheory.Quotient.category",
"CategoryTheory.Functor.mk",
"Quot.liftOn",
"HomRel",
"CategoryTheory.HomRel.CompClosure",
"CategoryTheory.Fun... | true |
PNat.modDivAux | Mathlib.Data.PNat.Defs | [
"Prod.mk",
"instOfNatNat",
"Subtype.mk",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.succ_pos",
"LT.lt",
"instAddNat",
"PNat.modDivAux.match_1",
"instLTNat",
"Prod",
"OfNat.ofNat",
"Nat.pred",
"PNat"
] | true |
SBtw.noConfusion | Mathlib.Order.Circular | [
"HEq.refl",
"SBtw.casesOn",
"SBtw.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"SBtw",
"Eq"
] | false |
SSet.Subcomplex.Pairing.I | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | [
"SSet.Subcomplex.N",
"SSet",
"SSet.Subcomplex.Pairing",
"SSet.Subcomplex",
"Set"
] | true |
ProbabilityTheory.Kernel.swapLeft_zero | Mathlib.Probability.Kernel.Composition.MapComap | [
"congrArg",
"MeasurableSpace",
"measurable_swap",
"True",
"eq_self",
"of_eq_true",
"ProbabilityTheory.Kernel.swapLeft",
"Zero.toOfNat0",
"congrFun'",
"Prod.swap",
"Prod",
"ProbabilityTheory.Kernel.comap_zero",
"OfNat.ofNat",
"Eq",
"ProbabilityTheory.Kernel",
"Eq.trans",
"ProbabilityT... | true |
AddSubsemigroup.le_op_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | [
"Function.Surjective.forall",
"AddSubsemigroup.instSetLike",
"AddSubsemigroup.unop",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"AddOpposite",
"AddOpposite.instAdd",
"AddSubsemigroup.op",
"LE.le",
"AddSubsemigroup.instPartialOrder",
"Iff",
"AddOpposite.op_surjective",
"A... | true |
Metric.mem_thickening_iff_exists_edist_lt | Mathlib.Topology.MetricSpace.Thickening | [
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Real",
"Preorder.toLT",
"ENNReal.ofReal",
"PartialOrder.toPreorder",
"Membership.mem",
"Exists",
"PseudoEMetricSpace",
"Metric.thickening",
"And",
"Iff",
"WeakPseudoEMetricSpace.toEDist",
"PseudoEMetricSpace.toUniformSpace",
"LT.lt",
"ENNRe... | true |
DomAddAct.instZeroOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | [
"AddOpposite",
"DomAddAct",
"Zero"
] | true |
CategoryTheory.ObjectProperty.trW_iff' | Mathlib.CategoryTheory.Triangulated.Subcategory | [
"Eq.mpr",
"NegZeroClass.toNeg",
"CategoryTheory.Functor",
"CategoryTheory.Equivalence.unitIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Pretriangulated.Triangle.obj₁",
"CategoryTheory.Pretriangulated.Triangle.obj₃",
"... | true |
LipschitzWith.lipschitzOnWith | Mathlib.Topology.EMetricSpace.Lipschitz | [
"LipschitzWith",
"Membership.mem",
"NNReal",
"PseudoEMetricSpace",
"LipschitzOnWith",
"Set.instMembership",
"Set"
] | true |
Multiset.countP_le_of_le | Mathlib.Data.Multiset.Count | [
"List.Sublist.countP_le",
"Multiset.leInductionOn",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Multiset",
"LE.le",
"instLENat",
"List",
"DecidablePred",
"Nat",
"List.Sublist",
"Multiset.countP",
"Decidable.decide",
"Multiset.instPartialOrder"
] | true |
CategoryTheory.Functor.OplaxMonoidal.id._proof_2 | Mathlib.CategoryTheory.Monoidal.Functor | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Category.comp_id",
"CategoryTheory.Functor.map",
"CategoryTheory.MonoidalCategoryStruct.whiskerRight",
"CategoryTh... | false |
iSup_eq_bot | Mathlib.Order.CompleteLattice.Basic | [
"sSup_eq_bot",
"Lattice.toSemilatticeSup",
"Set.forall_mem_range",
"CompleteLattice.toLattice",
"iSup",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toBoundedOrder",
"Bot.bot",
"Iff",
"BoundedOrder.toOrderBot",
"Iff.trans",
"CompleteSem... | true |
List.dropLast_eq_eraseIdx | Batteries.Data.List.Lemmas | [
"List.eraseIdx",
"List.instGetElem?NatLtLength",
"List.dropLast",
"instOfNatNat",
"Option.ext",
"List",
"instHAdd",
"List.ext_getElem?",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"_private.Batteries.Data.List.Lemmas.0.List.dropLast_eq_eraseIdx._proof_1_3",
"instLTNat",
"GetElem?.getElem... | true |
Lean.Parser.CacheableParserContext.noConfusion | Lean.Parser.Types | [
"Lean.Parser.CacheableParserContext.casesOn",
"Lean.Parser.Token",
"String.Pos.Raw",
"Nat",
"Bool",
"Eq.ndrec",
"Eq.refl",
"Lean.Parser.CacheableParserContext.noConfusionType",
"Lean.Parser.CacheableParserContext",
"Eq",
"Option"
] | false |
_private.Lean.Environment.0.Lean.AsyncConsts.normalizedTrie | Lean.Environment | [
"Lean.NameTrie",
"_private.Lean.Environment.0.Lean.AsyncConst",
"_private.Lean.Environment.0.Lean.AsyncConsts"
] | true |
Int.mul_fmod_left | Init.Data.Int.DivMod.Lemmas | [
"Eq.mpr",
"HMul.hMul",
"Int.fmod_def",
"congrArg",
"Int.fmod_zero",
"HSub.hSub",
"Int.instDecidableEq",
"Int.fdiv",
"id",
"Int",
"Int.fmod",
"dite",
"Int.instMul",
"instHSub",
"instOfNat",
"Int.mul_zero",
"congr",
"True",
"Int.sub_self",
"eq_self",
"of_eq_true",
"Eq.refl",
... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.VertexColoring.0.SimpleGraph.colorable_one_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Coloring.VertexColoring | [
"instOfNatNat",
"Nonempty.intro",
"SimpleGraph.Coloring",
"SimpleGraph",
"Nat",
"Nonempty.casesOn",
"SimpleGraph.Colorable",
"OfNat.ofNat",
"Fin"
] | false |
PNat.instMetricSpace._proof_16 | Mathlib.Topology.Instances.PNat | [
"PseudoMetricSpace.toUniformSpace",
"Subtype",
"Nat.instMetricSpace",
"instOfNatNat",
"PNat.instMetricSpace._aux_14",
"Filter.Tendsto",
"Nat",
"LT.lt",
"MetricSpace.toPseudoMetricSpace",
"Prod.swap",
"instLTNat",
"Prod",
"OfNat.ofNat",
"Subtype.val",
"UniformSpace.comap._proof_2",
"PNa... | false |
CategoryTheory.ShortComplex.cyclesMapIso'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | [
"Eq.mpr",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Iso.inv_hom_id",
"CategoryTheory.ShortComplex.LeftHomologyData",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.cyclesMap'",
"CategoryTheory.ShortCom... | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalWhiskerRightAux.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | [
"Mathlib.Tactic.BicategoryLike.Mor₂",
"Mathlib.Tactic.BicategoryLike.HorizontalComp.cons",
"Mathlib.Tactic.BicategoryLike.WhiskerRight",
"Mathlib.Tactic.BicategoryLike.HorizontalComp.casesOn",
"Mathlib.Tactic.BicategoryLike.Atom₁",
"Mathlib.Tactic.BicategoryLike.HorizontalComp.of",
"Mathlib.Tactic.Bicat... | false |
Array.filter_replicate_of_neg | Init.Data.Array.Lemmas | [
"Array.filter_replicate",
"False",
"congrArg",
"Array.replicate",
"Bool.false_eq_true",
"instDecidableEqBool",
"instOfNatNat",
"List.toArray",
"Array",
"Bool.true",
"Array.filter",
"Array.filter_congr",
"Nat",
"True",
"Bool.of_not_eq_true",
"eq_self",
"Bool",
"of_eq_true",
"Eq.re... | true |
LieEquiv.invFun | Mathlib.Algebra.Lie.Basic | [
"CommRing",
"LieEquiv",
"LieRing",
"LieAlgebra"
] | true |
UniformContinuous.sup_compacts | Mathlib.Topology.UniformSpace.Closeds | [
"UniformContinuous",
"UniformSpace",
"instUniformSpaceProd",
"TopologicalSpace.Compacts.uniformSpace",
"UniformContinuous.prodMk",
"Prod.mk",
"TopologicalSpace.Compacts.uniformContinuous_sup",
"Prod.fst",
"TopologicalSpace.Compacts.instMax",
"UniformContinuous.comp",
"Max.max",
"Prod",
"Unif... | true |
subset_of_subset_of_eq | Mathlib.Order.RelClasses | [
"Eq.mpr",
"congrArg",
"id",
"HasSubset.Subset",
"HasSubset",
"Eq.symm",
"Eq"
] | true |
toIcoDiv_add_intCast_mul | Mathlib.Algebra.Order.ToIntervalMod | [
"Int.cast",
"zsmul_eq_mul",
"instHSMul",
"Preorder.toLT",
"HMul.hMul",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"NonUnitalNonAssocRing.toAddCommGroup",
"PartialOrder.toPreorder",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartia... | true |
Set.biInter_subset_biUnion | Mathlib.Data.Set.Lattice | [
"Set.iInter",
"Membership.mem",
"HasSubset.Subset",
"Set.Nonempty",
"CompleteBooleanAlgebra.toCompleteLattice",
"biInf_le_biSup",
"Set.instMembership",
"Set.iUnion",
"CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra",
"Set.instCompleteAtomicBooleanAlgebra",
"Set.instHasSubset",
"Set"
] | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.foldAndCollect._sparseCasesOn_16 | Lean.Meta.Tactic.FunInd | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
AbstractCompletion.mapEquiv._proof_3 | Mathlib.Topology.UniformSpace.AbstractCompletion | [
"Iff.mpr",
"UniformSpace",
"AbstractCompletion",
"Function.LeftInverse",
"UniformEquiv.instEquivLike",
"AbstractCompletion.space",
"Function.comp",
"id",
"UniformEquiv.symm",
"Function.leftInverse_iff_comp",
"AbstractCompletion.mapEquiv._proof_1",
"AbstractCompletion.map",
"Eq",
"DFunLike.... | false |
SymAlg.addMonoid._proof_1 | Mathlib.Algebra.Symmetrized | [
"Equiv.instEquivLike",
"SymAlg.unsym_zero",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"Equiv",
"AddZero.toZero",
"SymAlg.unsym",
"AddMonoid",
"Zero.toOfNat0",
"SymAlg.instZero",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike",
"SymAlg"
] | false |
CategoryTheory.Coyoneda.colimitCocone_pt | Mathlib.CategoryTheory.Limits.Yoneda | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.coyoneda",
"CategoryTheory.Functor.category",
"CategoryTheory.Coyoneda.colimitCocone",
"PUnit",
"CategoryTheory.types",
"CategoryTheory.Category.opposite",
"Eq.refl",
"Eq",
"CategoryTheory.Functor.obj",
"CategoryTheory.Limits.Cocone.pt",
... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNeg | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg | [
"Std.Sat.AIG.RefVec.get",
"Eq.mpr",
"Bool.not",
"Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastConst",
"congrArg",
"Std.Sat.AIG.RefVecEntry.vec",
"Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastAdd",
"BitVec.neg_eq_not_add",
"Std.Sat.AIG.BinaryRefVec.rhs",
"BitVec.instAdd",
"BitVec",
"BitVe... | true |
Int8.neg_neg | Init.Data.SInt.Lemmas | [
"Int8.instNeg",
"Int8",
"BitVec",
"Int8.toBitVec_inj",
"instOfNatNat",
"Nat",
"BitVec.neg_neg",
"Iff.mp",
"Int8.toBitVec",
"OfNat.ofNat",
"Eq",
"Neg.neg"
] | true |
_private.Mathlib.Util.CompileInductive.0.Float.mk_eq | Mathlib.Util.CompileInductive | [
"Float",
"FloatSpec.float",
"floatSpec",
"Float.mk",
"_private.Mathlib.Util.CompileInductive.0.Float.mkImpl",
"Eq",
"rfl"
] | true |
Std.Do.Spec.forIn'_rii._proof_3 | Std.Do.Triple.SpecLemmas | [
"Std.PRange.UpwardEnumerable",
"List.append_assoc",
"congrArg",
"Std.Rxi.instIteratorIteratorIdOfUpwardEnumerable",
"List.cons",
"instHAppendOfAppend",
"List",
"Std.Rxi.IsAlwaysFinite",
"Std.Rii.toList",
"Std.Rxi.Iterator.instFinite",
"congr",
"True",
"eq_self",
"of_eq_true",
"Std.PRange... | false |
_private.Mathlib.FieldTheory.Normal.Closure.0.isNormalClosure_normalClosure.match_1 | Mathlib.FieldTheory.Normal.Closure | [
"AlgHom",
"Algebra",
"Nonempty.intro",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"Nonempty.casesOn",
"DivisionSemiring.toSemiring",
"Nonempty",
"Semifield.toCommSemiring",
"Field"
] | false |
Turing.PartrecToTM2.Λ'.rec | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Cont'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.Λ'.push",
"Turing.PartrecToTM2.Λ'.read",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToTM2.Λ'.clear",
"Turing.PartrecToTM2.Λ'.move",
"Turing.PartrecToTM2.Λ'.ret",
"Turing.PartrecToTM2.Λ'.copy",
... | false |
WithZero.le_log_of_exp_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | [
"Iff.mpr",
"Preorder.toLE",
"WithZero.log",
"LE.le",
"WithZero.le_log_iff_exp_le",
"WithZero.instZero",
"LT.lt.ne'",
"Multiplicative",
"AddGroup",
"AddGroup.toSubNegMonoid",
"LT.lt.trans_le",
"WithZero",
"WithZero.exp_pos",
"WithZero.exp",
"Zero.toOfNat0",
"Multiplicative.preorder",
... | true |
String.Slice.endsWith_string_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | [
"String.toSlice",
"String.Slice.Pattern.BackwardSliceSearcher.instBackwardPattern",
"congrArg",
"String",
"String.Slice",
"iff_self",
"Bool.true",
"String.Slice.copy",
"List",
"Iff",
"String.Slice.Pattern.BackwardSliceSearcher.instBackwardPattern_1",
"String.toList",
"String.Slice.endsWith_s... | true |
Rep.FiniteCyclicGroup.groupHomologyIsoOdd._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | [
"CommRing",
"ModuleCat",
"CommSemiring.toSemiring",
"CategoryTheory.ShortComplex.HasHomology",
"DivInvMonoid.toMonoid",
"CommGroup",
"Group.toDivInvMonoid",
"CommRing.toCommSemiring",
"Rep",
"Fintype",
"ModuleCat.abelian",
"CategoryTheory.CategoryWithHomology.hasHomology",
"ModuleCat.moduleC... | false |
EReal.neTopBotEquivReal._proof_7 | Mathlib.Data.EReal.Basic | [
"Real",
"Compl.compl",
"EReal",
"Membership.mem",
"Set.Elem",
"Set.instSingletonSet",
"instTopEReal",
"Insert.insert",
"Bot.bot",
"EReal.neTopBotEquivReal._proof_3",
"Set.instCompl",
"Subtype.mk",
"Set.instInsert",
"EReal.toReal",
"eq_self",
"of_eq_true",
"Top.top",
"Singleton.sing... | false |
ArchimedeanClass.FiniteResidueField.instLinearOrder._aux_1 | Mathlib.Algebra.Order.Ring.StandardPart | [
"Semiring.toModule",
"IsOrderedRing",
"ArchimedeanClass.instLinearOrderFiniteElement",
"ArchimedeanClass.FiniteResidueField._proof_1",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"IsLocalRing.maximalIdeal",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Quotient.lif... | false |
LinearMap.tensorKerBil._proof_6 | Mathlib.RingTheory.Flat.Equalizer | [
"Submodule",
"IsScalarTower.to_smulCommClass'",
"Submodule.module._proof_1",
"CommRing",
"instSMulOfMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"IsScalarTower",
"Submodule.addCommMonoid",
"TensorProduct.addCommMonoid",
"AddMonoid.toAddZero... | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe | Mathlib.Tactic.FBinop | [
"Lean.Expr",
"_private.Mathlib.Tactic.FBinop.0.FBinopElab.Tree",
"FBinopElab.SRec",
"Option.none",
"Lean.Elab.Term.TermElabM",
"_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe.go"
] | true |
max_le_max_left | Mathlib.Order.MinMax | [
"sup_le_sup_left",
"Lattice.toSemilatticeSup",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"DistribLattice.toLattice",
"LE.le",
"Max.max",
"instDistribLatticeOfLinearOrder",
"Lattice.toSemilatticeInf"
] | true |
Mathlib.Meta.FunProp.FunctionData.casesOn | Mathlib.Tactic.FunProp.FunctionData | [
"Mathlib.Meta.FunProp.FunctionData",
"Lean.Expr",
"Array",
"Mathlib.Meta.FunProp.Mor.Arg",
"Mathlib.Meta.FunProp.FunctionData.rec",
"Nat",
"Lean.LocalInstances",
"Lean.LocalContext",
"Mathlib.Meta.FunProp.FunctionData.mk"
] | false |
FourierSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | [
"instHSMul",
"FourierTransform",
"outParam",
"SMul",
"FourierSMul",
"FourierTransform.fourier",
"HSMul.hSMul",
"Eq",
"FourierSMul.mk"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.