name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.not_isBoundedUnder_of_tendsto_atBot | Mathlib.Order.Filter.IsBounded | [
"Preorder.toLT",
"NoMinOrder",
"Filter.not_isBoundedUnder_of_tendsto_atTop",
"Filter.NeBot",
"Preorder.toLE",
"GE.ge",
"Filter.Tendsto",
"OrderDual.noMaxOrder",
"Filter.atBot",
"OrderDual",
"OrderDual.instPreorder",
"Filter.IsBoundedUnder",
"Not",
"Filter",
"Preorder"
] | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.fac._proof_8 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | [
"Int",
"autoParam",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.fac._proof_7",
"CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.fac._auto_3",
"Int.inst... | false |
TopologicalSpace.MetrizableSpace.recOn | Mathlib.Topology.Metrizable.Basic | [
"TopologicalSpace.PseudoMetrizableSpace",
"TopologicalSpace.MetrizableSpace",
"TopologicalSpace.MetrizableSpace.rec",
"TopologicalSpace",
"TopologicalSpace.MetrizableSpace.mk",
"T0Space"
] | false |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent | Lean.Meta.Tactic.Grind.AC.Types | [
"Lean.Meta.Grind.AC.EqCnstr",
"Lean.Meta.Grind.AC.EqCnstrProof",
"Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent",
"Lean.Grind.AC.Var"
] | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.TFAE_exists_lt_isLittleO_pow.match_1_14 | Mathlib.Analysis.SpecificLimits.Normed | [
"Real.instLE",
"Real",
"Real.lattice",
"Real.instZero",
"abs",
"Filter.Eventually",
"Membership.mem",
"Exists",
"Real.instAddGroup",
"LE.le",
"Monoid.toPow",
"And.casesOn",
"Filter.atTop",
"Real.instMonoid",
"And",
"Exists.casesOn",
"HPow.hPow",
"Nat.instPreorder",
"Nat",
"And.... | false |
HahnSeries.SummableFamily.powers._proof_2 | Mathlib.RingTheory.HahnSeries.Summable | [
"Eq.mpr",
"WithTop.decidableLT",
"CommRing",
"HahnSeries.instSemiring",
"Preorder.toLT",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"eq_false",
"WithTop.instPreorder",
"congrArg",
"CommSemiring.toSemiring",
"LinearOrder",
"HahnSeries.orderTop",
"AddMon... | false |
OrderDual.instBooleanAlgebra._proof_2 | Mathlib.Order.BooleanAlgebra.Basic | [
"Disjoint.le_bot",
"BooleanAlgebra",
"Equiv.instEquivLike",
"OrderDual.ofDual",
"Compl.compl",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Equiv",
"BiheytingAlgebra.toHeytingAlgebra",
"Bot.bot",
"BiheytingAlgebra.toCoheytingAlgebra",
"Sem... | false |
Algebra.Extension.tensorCotangent.congr_simp | Mathlib.RingTheory.Etale.Kaehler | [
"Submodule.module._proof_1",
"CommRing",
"Algebra.to_smulCommClass",
"Algebra.Extension.commRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"instSMulOfMul",
"Algebra.Extension.Hom.toRingHom",
"Algebra.Extension.instModuleCotangent",
"IsScalarTower.right",
"CommRing.t... | true |
_private.Mathlib.CategoryTheory.Functor.KanExtension.Dense.0.CategoryTheory.Functor.IsDense.of_fullyFaithful_restrictedULiftYoneda.match_1_1.splitter | Mathlib.CategoryTheory.Functor.KanExtension.Dense | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Functor.category",
"CategoryTheory.yoneda",
"CategoryTheory.Presheaf.restrictedULiftYoneda",
"Opposite.op",
"CategoryTheory.types",
"_private.Mathlib.CategoryTheory.Functor.KanExtension.Dense.0.CategoryTheory.Functor.... | true |
ContDiffWithinAt.neg | Mathlib.Analysis.Calculus.ContDiff.Operations | [
"NegZeroClass.toNeg",
"NormedSpace",
"Set.univ",
"Membership.mem",
"ContDiffWithinAt.comp",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"Set.subset_preimage_univ",
"SubtractionCommMonoid.toSubtractionMonoid",
"contDiff_neg",
"ContDiff.contDiffWithinAt",
"ENat",
... | true |
Int.Linear.Poly.combine_mul_k | Init.Data.Int.Linear | [
"Int.Linear.Poly.combine_mul_k'",
"Int.Linear.Poly.mul_k",
"Int",
"Int.Linear.hugeFuel",
"instOfNat",
"Int.beq'",
"Bool.rec",
"Bool",
"OfNat.ofNat",
"Int.Linear.Poly"
] | true |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.IsUnit.aemeasurable_const_smul_iff.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | [
"Monoid",
"Units.val",
"IsUnit",
"Units",
"Exists.casesOn",
"Exists.intro",
"Eq"
] | false |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal.triangle_aux₂._simp_1_2 | Mathlib.CategoryTheory.Localization.Monoidal.Basic | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.IsMonoidal",
"CategoryTheory.Localization.Monoidal.id_tensorHom",
"CategoryTheory.MonoidalCategory"... | false |
_private.Mathlib.Tactic.LinearCombination.Lemmas.0.Mathlib.Ineq.mulRelConstData.match_1 | Mathlib.Tactic.LinearCombination.Lemmas | [
"Unit.unit",
"Mathlib.Ineq.WithStrictness.lt",
"Mathlib.Ineq.WithStrictness.le",
"Mathlib.Ineq.WithStrictness",
"Bool.true",
"Unit",
"Bool.casesOn",
"Mathlib.Ineq.WithStrictness.casesOn",
"Mathlib.Ineq.WithStrictness.eq",
"Bool",
"Bool.false"
] | false |
CategoryTheory.Limits.IsTerminal.isTerminalObj | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Terminal | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesLimit",
"Equiv.instEquivLike",
"CategoryTheory.Limits.IsTerminal",
"CategoryTheory.Functor.comp",
"Equiv",
"PEmpty",
"CategoryTheory.Limits.isLimitMapConeEmptyConeEquiv",
"CategoryTheory.Limits.IsLimit",
"CategoryTheory.discreteCategory",
... | true |
NNReal.sqrtHom.eq_1 | Mathlib.Data.Real.Sqrt | [
"NNReal.sqrt_zero",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderIso",
"NNReal.sqrt_mul",
"NNReal",
"ZeroHom.mk",
"instMulZeroOneClassOfSemiring",
"NNReal.sqrt",
"NNReal.instPartialOrder",
"MonoidWithZeroHom",
"NNReal.sqrtHom",
"instFunLikeOrderIso",
"NNReal.instSemiring",
"NNReal.s... | true |
MeasureTheory.memLp_indicator_iff_restrict | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | [
"MeasureTheory.Measure",
"Preorder.toLT",
"MeasurableSet",
"congrArg",
"Set.indicator",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"ESeminormedAddMonoid",
"AddZeroClass.toAddZero",
"MeasureTheory.Measure.restrict",
"MeasureTheory.MemLp",
"ESeminormedAddMonoid.toAddMonoid",
"Measu... | true |
Std.Time.TimeZone.TZif.TZifV2.noConfusion | Std.Time.Zoned.Database.TzIf | [
"String",
"Std.Time.TimeZone.TZif.TZifV2.casesOn",
"Std.Time.TimeZone.TZif.TZifV2",
"Std.Time.TimeZone.TZif.TZifV1",
"Std.Time.TimeZone.TZif.TZifV2.noConfusionType",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Option"
] | false |
ChevalleyThm.MvPolynomialC.numBound_casesOn_succ | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | [
"instHSMul",
"HMul.hMul",
"ChevalleyThm.MvPolynomialC.numBound",
"Nat.instMonoid",
"AddMonoid.toNSMul",
"Nat.instAddMonoid",
"PSum.inr",
"instMulNat",
"instOfNatNat",
"Monoid.toPow",
"instHAdd",
"HPow.hPow",
"HAdd.hAdd",
"Nat",
"instAddNat",
"HSMul.hSMul",
"Pi.addMonoid",
"instHPow... | true |
Std.Do.ExceptConds.imp.eq_3 | Std.Do.PostCond | [
"Std.Do.PostShape.except",
"Std.Do.Assertion",
"Prod.mk",
"Std.Do.PostShape",
"Std.Do.ExceptConds.imp",
"Prod.fst",
"Std.Do.SPred.imp",
"Eq.refl",
"Std.Do.PostShape.args",
"Eq",
"Prod.snd",
"Std.Do.ExceptConds"
] | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.simpleEnum.sizeOf_spec | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | [
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind._sizeOf_inst",
"Lean.ConstructorVal",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.simpleEnum",
"instOfNatNat",
"Array._sizeOf_inst",
"Array",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind",
"instHAdd",
"HAdd.hAdd",
"Nat"... | true |
LinearMap.BilinForm.Isometry.ext_iff | Mathlib.LinearAlgebra.BilinearForm.Isometry | [
"LinearMap.BilinForm",
"CommSemiring.toSemiring",
"HEq.refl",
"Eq.casesOn",
"AddCommMonoid",
"CommSemiring",
"Iff",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"LinearMap.BilinForm.Isometry.instFunLike",
"LinearMap.BilinForm.Isometry",
"LinearMap.BilinForm.Isometry.ext",
"Module",
"Eq.s... | true |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.biInf_le_nhds._simp_1_3 | Mathlib.Topology.Instances.ENNReal.Lemmas | [
"ENNReal.ofNNReal",
"NNReal",
"ENNReal.coe_one",
"ENNReal",
"One.toOfNat1",
"ENNReal.instOne",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"NNReal.instOne"
] | false |
Nat.pow_log_le_self | Mathlib.Data.Nat.Log | [
"instPowNat",
"le_rfl",
"Ne",
"instOfNatNat",
"LE.le",
"instLENat",
"instNatPowNat",
"HPow.hPow",
"Nat.instPreorder",
"Nat.pow_le_of_le_log",
"Nat",
"instHPow",
"Nat.log",
"OfNat.ofNat"
] | true |
DirectSum.IsInternal.isometryL2OfOrthogonalFamily._proof_3 | Mathlib.Analysis.InnerProductSpace.PiL2 | [
"NormedField.toField",
"Field.toSemifield",
"RingHomInvPair",
"RCLike.toDenselyNormedField",
"RCLike",
"Semifield.toDivisionSemiring",
"RingHomInvPair.ids",
"DivisionSemiring.toSemiring",
"DenselyNormedField.toNormedField",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
Lean.RBNode.any._sunfold | Lean.Data.RBMap | [
"Lean.RBColor",
"Lean.RBNode",
"Unit",
"Lean.RBNode.any",
"Bool",
"Bool.or",
"_private.Lean.Data.RBMap.0.Lean.RBNode.depth.match_1",
"Bool.false"
] | false |
EMetric.ball_prod_same | Mathlib.Topology.EMetricSpace.Defs | [
"Set.instSProd",
"Prod.pseudoEMetricSpaceMax",
"SProd.sprod",
"Prod.mk",
"Metric.eball",
"PseudoEMetricSpace",
"Metric.eball_prod_same",
"PseudoEMetricSpace.toEDist",
"ENNReal",
"Prod",
"Eq",
"Set"
] | true |
CoalgHom.End._proof_2 | Mathlib.RingTheory.Coalgebra.Hom | [
"CoalgebraStruct",
"Mul.mk",
"One.mk",
"HMul.hMul",
"CommSemiring.toSemiring",
"CoalgHom",
"Semigroup.mk",
"CoalgHom.comp",
"npowRecAuto",
"instOfNatNat",
"AddCommMonoid",
"CommSemiring",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"CoalgHom.id",
"Module",
"OfNat.o... | false |
CategoryTheory.Limits.CatCospanTransform.associator_inv_base_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.CatCospanTransform.associator",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.CatCospanTransform.comp",
"Eq.refl",
"CategoryTheory.Category.toCategoryS... | true |
_private.Mathlib.Analysis.Complex.Basic.0.Complex.continuous_normSq._simp_1_1 | Mathlib.Analysis.Complex.Basic | [
"Norm.norm",
"Real",
"MonoidWithZeroHom.funLike",
"Complex.normSq_eq_norm_sq",
"Complex.instNorm",
"Real.semiring",
"Complex.normSq",
"instOfNatNat",
"Monoid.toPow",
"instMulZeroOneClassOfSemiring",
"Real.instMonoid",
"MonoidWithZeroHom",
"HPow.hPow",
"Nat",
"instHPow",
"Complex",
"O... | false |
USize.ofInt | Init.Data.UInt.Basic | [
"instPowNat",
"USize.ofNat",
"instHMod",
"Int",
"Int.instNatPow",
"System.Platform.numBits",
"HMod.hMod",
"HPow.hPow",
"instOfNat",
"Nat",
"Int.instMod",
"Int.toNat",
"instHPow",
"OfNat.ofNat",
"USize"
] | true |
Mathlib.Meta.NormNum.NormNums.erase | Mathlib.Tactic.NormNum.Core | [
"Pure.pure",
"Lean.MessageData",
"Bool.not",
"Monad.toApplicative",
"String",
"Lean.Meta.DiscrTree.values",
"Lean.MessageData.instAppend",
"Lean.PersistentHashSet.contains",
"Lean.throwError",
"Bool.and",
"Array.any",
"instDecidableEqBool",
"instOfNatNat",
"Applicative.toPure",
"Mathlib.... | true |
AlgebraicGeometry.IsOpenImmersion.comp_lift._proof_2 | Mathlib.AlgebraicGeometry.OpenImmersion | [
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CommRingCat",
"TopCat.instCategory",
"ContinuousMap",
"_private.Mathlib.AlgebraicGeometry.OpenImmersion.0.AlgebraicGeometry.IsOpenI... | false |
_private.Mathlib.CategoryTheory.ObjectProperty.Small.0.CategoryTheory.ObjectProperty.instSmallMax.match_1.splitter | Mathlib.CategoryTheory.ObjectProperty.Small | [
"_private.Mathlib.CategoryTheory.ObjectProperty.Small.0.CategoryTheory.ObjectProperty.instSmallMax.match_1",
"Sum",
"Subtype",
"Sum.inl",
"Sum.inr",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.ObjectProperty",
"CategoryTheory.Category"
] | true |
RingEquiv.map_eq_zero_iff | Mathlib.Algebra.Ring.Equiv | [
"RingEquivClass.toNonUnitalRingHomClass",
"RingEquiv.instEquivLike",
"AddMonoid.toAddZeroClass",
"RingEquiv.instRingEquivClass",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"AddZeroClass.toAddZero",
"Distrib.toAdd",
"EquivLike.toEmbeddingLike",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Iff",
... | true |
CategoryTheory.PreOneHypercover.Hom.s₁' | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.PreOneHypercover.Hom.s₁",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"Prod.mk",
"Sigma.fst",
"CategoryTheory.PreOneHypercover.Hom.toHom",
"CategoryTheory.PreOneHypercover.I₁'",
"CategoryTheory.PreZer... | true |
CategoryTheory.Comma.opFunctor_map | Mathlib.CategoryTheory.Comma.Basic | [
"CategoryTheory.Comma.opFunctor._proof_4",
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Comma.left",
"CategoryTheory.Comma.hom",
"CategoryTheory.CommaMorphism.mk",
"Categor... | true |
Lean.Lsp.TextDocumentChangeRegistrationOptions.documentSelector? | Lean.Data.Lsp.TextSync | [
"Lean.Lsp.DocumentSelector",
"Lean.Lsp.TextDocumentChangeRegistrationOptions",
"Option"
] | true |
InnerProductSpace.HarmonicOnNhd.comp_CLM | Mathlib.Analysis.InnerProductSpace.Harmonic.Basic | [
"InnerProductSpace.toNormedSpace",
"Real",
"NormedSpace",
"Real.instRCLike",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"Membership.mem",
"Real.semiring",
"InnerProductSpace.HarmonicOnNhd",
"Cont... | true |
Bimod._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Bimod | [
"Bimod.rec",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategoryStruct.rightUnitor",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategoryStruct.leftUnitor",
"instSizeOfDefault",
"instOfNatNat",
... | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_8 | Init.Data.Array.BinSearch | [
"Std.IsLinearPreorder.toIsPreorder",
"Std.instReflLeOfIsPreorder",
"Std.le_refl._simp_1",
"LE.le",
"instLENat",
"Fin.val",
"Array",
"Nat",
"LT.lt",
"Fin.val_lt_of_le",
"of_eq_true",
"instLTNat",
"Fin",
"Array.size",
"Nat.instIsLinearOrder",
"Std.IsLinearOrder.toIsLinearPreorder"
] | false |
ContinuousLinearEquiv.restrictScalars_apply | Mathlib.Topology.Algebra.Module.Equiv | [
"ContinuousLinearEquiv.restrictScalars",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"ContinuousLinearEquiv.equivLike",
"AddCommMonoid",
"TopologicalSpace",
"AddZero.toZero",
"ContinuousLinearEquiv",
"RingHomInvPair.ids",... | true |
ContDiffPointwiseHolderAt.mk | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | [
"ContDiffAt",
"Norm.norm",
"Real.instPow",
"Real",
"ContDiffPointwiseHolderAt",
"NormedSpace",
"ContinuousMultilinearMap.instSub",
"ENat.instNatCast",
"Real.denselyNormedField",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"ContinuousMultilinearMap.hasOpNorm'",
"Asymptotics.IsBigO... | true |
Vector.get_tail | Batteries.Data.Vector.Lemmas | [
"Vector",
"Fin.succ",
"Vector.get",
"HSub.hSub",
"Fin.isLt",
"instSubNat",
"instOfNatNat",
"Fin.val",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Vector.tail",
"OfNat.ofNat",
"Fin",
"Eq",
"Vector.getElem_tail"
] | true |
CategoryTheory.Subobject.pullback.congr_simp | Mathlib.CategoryTheory.Subobject.Lattice | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"Eq.rec",
"Preorder.smallCategory",
"CategoryTheory.instPartialOrderSubobject",
"CategoryTheory.Limits.HasPullbacks",
"CategoryTheory.Subobject.pullback",
"Eq.refl",
"CategoryTheory.Categ... | true |
ProbabilityTheory._aux_Mathlib_Probability_Moments_Variance___unexpand_ProbabilityTheory_variance_1 | Mathlib.Probability.Moments.Variance | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.node5",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.... | false |
Con.comapQuotientEquivOfSurj_symm_mk' | Mathlib.GroupTheory.Congruence.Basic | [
"Iff.mpr",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"MonoidHom",
"MulEquiv.instMulEquivClass",
"MulOne.toMul",
"MonoidHomClass.toMonoidHom",
"MulEquiv.symm_apply_eq",
"Con.comapQuotientEquivOfSurj",
"Con.Quotient",
"MulEquiv.surjective",
"Quotient.mk",
"Con.hasMul",
"MulOneClass.... | true |
AlgebraicTopology.DoldKan.DegeneraciesVanish.comp | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | [
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"AlgebraicTopology.DoldKan.DegeneraciesVanish.σ_comp_assoc",
"_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.DegeneraciesVanish.comp._simp_1_1",
"instOfNatNat",
"CategoryTheory.Limits.H... | true |
AffineEquiv.coeFn_inj._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | [
"AddCommGroup.toAddCommMonoid",
"AffineEquiv.equivLike",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"AffineEquiv.coeFn_inj",
"AddTorsor",
"propext",
"Module",
"AffineEquiv",
"Ring.toSemiring",
"Eq",
"DFunLike.coe",
"Ring",
"EquivLike.toFunLike"
] | false |
«_aux_Mathlib_Order_Notation___macroRules_term_ᶜ_1» | Mathlib.Order.Notation | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.instMonad"... | false |
_private.Mathlib.Tactic.Nontriviality.Core.0.Mathlib.Tactic.Nontriviality.elabNontriviality.match_1 | Mathlib.Tactic.Nontriviality.Core | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"_private.Mathlib.Tactic.Nontriviality.Core.0.Mathlib.Tactic.Nontriviality.elabNontriviality._sparseCasesOn_1",
"Option"
] | false |
Lean.Parser.Syntax.unicodeAtom.parenthesizer | Lean.Parser.Syntax | [
"Lean.Parser.optional.parenthesizer",
"Lean.Parser.withCache.parenthesizer",
"Lean.Parser.mkAntiquot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer",
"instOfNatNat",
"Lean.PrettyPrinter.Parenthesizer.leadingNode.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.andthen.parenthesizer",
"Bool.true",
... | true |
StarSubalgebra.starRing._proof_2 | Mathlib.Algebra.Star.Subalgebra | [
"HMul.hMul",
"CommSemiring.toSemiring",
"StarSubalgebra.subsemiringClass",
"Algebra",
"Algebra.toSMul",
"Membership.mem",
"Subtype",
"StarSubalgebra",
"StarSubalgebra.setLike",
"SubsemiringClass.toSemiring",
"StarAddMonoid.toInvolutiveStar",
"CommSemiring",
"NonUnitalNonAssocSemiring.toAddCo... | false |
Finset.zsmul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"Finset",
"SMul",
"SMul.mk",
"Int",
"zsmulRec",
"Neg",
"nsmulRec",
"Finset.neg",
"Finset.zero",
"Finset.add",
"Add",
"DecidableEq",
"Zero"
] | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.main.unpack.go.match_1 | Lean.Elab.Match | [
"_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.main.unpack.go._sparseCasesOn_1",
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Expr.lam",
"Lean.Name",
"Lean.BinderInfo",
"Lean.Expr.ctorIdx"
] | false |
Aesop.GoalKind.noConfusion | Aesop.Stats.Basic | [
"noConfusionEnum",
"Nat",
"Aesop.GoalKind.ctorIdx",
"instDecidableEqNat",
"Eq",
"Aesop.GoalKind",
"Aesop.GoalKind.noConfusionType"
] | false |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.not_isUnit_X_add_C._proof_1_1 | Mathlib.Algebra.Polynomial.Monic | [
"Lean.RArray.leaf",
"False",
"Eq.mp",
"id",
"instOfNatNat",
"Nat.Linear.Expr.num",
"Polynomial",
"Bool.true",
"instHAdd",
"Nat.Linear.ExprCnstr.eq_false_of_isUnsat",
"HAdd.hAdd",
"Nat",
"True",
"eq_true",
"Bool",
"Semiring",
"instAddNat",
"Eq.refl",
"Nat.Linear.Expr.add",
"Poly... | false |
Ordering.isLE_eq_false | Init.Data.Ord.Basic | [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"id",
"instDecidableEqBool",
"Bool.true",
"Iff",
"Bool",
"Eq.refl",
"Ordering.instDecidableForallOfDecidablePred",
"Ordering.isLE",
"Bool.false",
"Decidable.decide",
"Eq",
"instDecidableIff"
] | true |
CategoryTheory.Limits.walkingParallelPairOpEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | [
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"HEq.refl",
"CategoryTheory.Limits.WalkingParallelPairHom",
"CategoryTheory.eqToHom",
"CategoryTheory.Limits.WalkingParallelPair.one",
"CategoryTheory.eqToIso",
"CategoryT... | false |
ENNReal.top_mul_top | Mathlib.Data.ENNReal.Operations | [
"HMul.hMul",
"LinearOrder.toDecidableEq",
"CommSemiring.toSemiring",
"NNReal",
"ENNReal.instCommSemiring",
"instDistribOfSemiring",
"Distrib.toMul",
"WithTop.top_mul_top",
"ENNReal",
"NNReal.instSemiring",
"ENNReal.instTop",
"Top.top",
"NNReal.instLinearOrder",
"Eq",
"instMulZeroClassOfS... | true |
Option.not_isNone | Init.Data.Option.Lemmas | [
"Option.isNone",
"Bool.not_false",
"Bool.not",
"congrArg",
"Option.casesOn",
"Option.some",
"Bool.true",
"Option.none",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"congrFun'",
"Option.isSome",
"Eq.symm",
"Bool.false",
"Eq",
"Eq.trans",
"Bool.not_true",
... | true |
Finset.forall_mem_compls | Mathlib.Data.Finset.Sups | [
"BooleanAlgebra",
"Finset.forall_mem_map",
"Compl.compl",
"Finset",
"Finset.compls",
"Membership.mem",
"Function.Embedding.mk",
"BooleanAlgebra.toCompl",
"compl_injective",
"Iff",
"Finset.instSetLike",
"SetLike.instMembership"
] | true |
Std.Roc.pairwise_toList_lt | Init.Data.Range.Polymorphic.Lemmas | [
"Iff.mpr",
"Std.Roc.pairwise_toList_upwardEnumerableLt",
"Std.PRange.UpwardEnumerable",
"List.Pairwise",
"Std.PRange.LawfulUpwardEnumerableLT",
"Std.PRange.UpwardEnumerable.LT",
"Std.Roc.toList",
"LE",
"DecidableLE",
"Std.Rxc.IsAlwaysFinite",
"LT.lt",
"Std.PRange.LawfulUpwardEnumerableLT.lt_if... | true |
DFinsupp.toFun_eq_coe | Mathlib.Data.DFinsupp.Defs | [
"DFinsupp.instDFunLike",
"DFinsupp",
"Eq",
"DFinsupp.toFun",
"DFunLike.coe",
"rfl",
"Zero"
] | true |
addMonoidAlgebraRingEquivDirectSum_apply | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | [
"AddMonoidAlgebra.semiring",
"NonUnitalNonAssocSemiring.directSumGNonUnitalNonAssocSemiring",
"AddMonoid.toAddSemigroup",
"Semiring.directSumGSemiring",
"RingEquiv.instEquivLike",
"Decidable",
"addMonoidAlgebraRingEquivDirectSum",
"Distrib.toAdd",
"Ne",
"instDistribOfSemiring",
"NonUnitalNonAsso... | true |
_private.Lean.Elab.Deriving.DecEq.0.Lean.Elab.Deriving.DecEq.mkMatchOld.mkSameCtorRhs.match_1 | Lean.Elab.Deriving.DecEq | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"_private.Lean.Elab.Deriving.DecEq.0.Lean.Elab.Deriving.DecEq.mkMatchOld.mkSameCtorRhs._sparseCasesOn_1",
"Lean.Name",
"Option"
] | false |
MulHom.prodMap | Mathlib.Algebra.Group.Prod | [
"MulHom.fst",
"MulHom",
"Prod.instMul",
"Mul",
"MulHom.comp",
"MulHom.snd",
"MulHom.prod",
"Prod"
] | true |
DoResultSBC.ctorElim | Init.Core | [
"DoResultSBC.pureReturn",
"DoResultSBC.ctorElimType",
"DoResultSBC.break",
"Nat",
"DoResultSBC.ctorIdx",
"Eq.ndrec",
"DoResultSBC",
"PULift.down",
"DoResultSBC.casesOn",
"Eq",
"DoResultSBC.continue"
] | false |
Std.DTreeMap.get?_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | [
"Eq.mpr",
"Std.DTreeMap.instUnion",
"Std.DTreeMap",
"congrArg",
"Ord.mk",
"Membership.mem",
"Ordering",
"id",
"Std.DTreeMap.contains_eq_false_iff_not_mem",
"Std.DTreeMap.inner",
"Std.DTreeMap.get?",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Std.LawfulEqCmp",
"Std.DTreeMap.wf",
"p... | true |
Nat.Perfect | Mathlib.NumberTheory.Divisors | [
"instOfNatNat",
"Nat.properDivisors",
"And",
"Nat",
"LT.lt",
"Nat.instAddCommMonoid",
"instLTNat",
"OfNat.ofNat",
"Eq",
"Finset.sum"
] | true |
Std.TreeMap.Raw.getKey?_inter_of_mem_right | Std.Data.TreeMap.Raw.Lemmas | [
"Std.TreeMap.Raw.WF.out",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw.inner",
"Inter.inter",
"Std.DTreeMap.Raw.getKey?_inter_of_mem_right",
"Std.TreeMap.Raw",
"Std.TreeMap.Raw.instInter",
"Std.TreeMap.Raw.getKey?",
"E... | true |
AddCommMonCat.limitAddCommMonoid._proof_10 | Mathlib.Algebra.Category.MonCat.Limits | [
"CategoryTheory.Functor",
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"Pi.addCommMonoid",
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCone",
"AddCommMonCat.instCategory",
"AddSubmonoid.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddMonoid.nsmul_zero._autoParam",
"Add... | false |
Std.TreeMap.Equiv.insertManyIfNewUnit_list | Std.Data.TreeMap.Lemmas | [
"Std.DTreeMap.Equiv.constInsertManyIfNewUnit_list",
"Std.TreeMap.Equiv",
"instForInOfForIn'",
"Std.TreeMap.Equiv.inner",
"Std.TreeMap.inner",
"Ordering",
"inferInstance",
"Std.TransCmp",
"Id",
"Membership",
"List",
"Unit",
"Std.TreeMap.insertManyIfNewUnit",
"List.instMembership",
"Std.Tr... | true |
Std.DHashMap.Raw.Equiv.diff_right | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"congrArg",
"Std.DHashMap.Raw",
"id",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"LawfulHashable",
"Std.DHashMap.Internal.Raw₀.Equiv.diff_right",
"Std.DHashMap.Raw.Equiv",
"Subtype.mk",
"SDiff.sdiff",
"Std.DHashMap.Raw.diff",
"Std.DHashMap.Raw.... | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.toUInt8_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | [
"UInt32.toNat",
"UInt32.lt_iff_toNat_lt",
"Nat",
"instLTUInt32",
"LT.lt",
"propext",
"UInt32",
"instLTNat",
"Eq"
] | false |
List.Pi.cons_def | Mathlib.Data.List.Pi | [
"List.Pi.cons",
"Membership.mem",
"Eq.rec",
"Or.resolve_left",
"dite",
"List.cons",
"List",
"List.instMembership",
"Iff.mp",
"Or",
"List.mem_cons",
"Eq.symm",
"Eq",
"Not",
"rfl",
"DecidableEq"
] | true |
CochainComplex.HomComplex.Cochain.leftUnshift_neg | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | [
"AddEquivClass.instAddMonoidHomClass",
"NegZeroClass.toNeg",
"HomologicalComplex.instCategory",
"CochainComplex.HomComplex.instAddCommGroupCochain",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemigroup",
"CochainCom... | true |
Prod.instCommGroup | Mathlib.Algebra.Group.Prod | [
"Prod.instCommGroup._proof_2",
"Prod.instGroup",
"CommGroup",
"CommGroup.mk",
"CommGroup.toGroup",
"Prod"
] | true |
ZeroHom.instAddMonoid._proof_5 | Mathlib.Algebra.Group.Hom.Instances | [
"ZeroHom.funLike",
"instHSMul",
"ZeroHom.instNSMul",
"ZeroHom.instAddMonoid._proof_1",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Function.Injective.addMonoid._proof_4",
"AddZeroClass.toAddZero",
"instOfNatNat",
"AddSemigroup.mk",
"ZeroHom.mk",
"ZeroHom",
"autoParam",
"AddZero.toZer... | false |
Simps.ProjectionRule.erase | Mathlib.Tactic.Simps.Basic | [
"Lean.Syntax",
"Simps.ProjectionRule.erase",
"Simps.ProjectionRule",
"Lean.Name"
] | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.revMatchAt?_eq_none_iff.match_1_2 | Init.Data.String.Lemmas.Pattern.Basic | [
"String.Slice.Pattern.Model.RevMatchesAt.mk",
"String.Slice",
"Exists",
"String.Slice.Pattern.Model.PatternModel",
"String.Slice.Pos",
"String.Slice.Pattern.Model.RevMatchesAt.casesOn",
"String.Slice.Pattern.Model.IsLongestRevMatchAt",
"String.Slice.Pattern.Model.RevMatchesAt"
] | false |
Metric.unitSphere.instMonoid._aux_4 | Mathlib.Analysis.Normed.Field.UnitBall | [
"NormOneClass",
"MulOne.toOne",
"SeminormedRing.toNorm",
"Real",
"SubmonoidClass.toMonoid._proof_6",
"Monoid.toMulOneClass",
"Submonoid.toMonoid._proof_1",
"AddGroupWithOne.toAddMonoidWithOne",
"SeminormedRing.toRing",
"Membership.mem",
"Set.Elem",
"NormMulClass",
"instDistribOfSemiring",
... | false |
Polynomial.ofFinsupp_ofNat | Mathlib.Algebra.Polynomial.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"AddMonoidWithOne.toNatCast",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Polynomial",
"Nat",
"Semiring",
"AddMonoidAlgebra.nonAssocSemiring",
"AddMonoidAlgebra",
"Polynomial.ofFinsupp",
"OfNat.ofNat",
... | true |
aeSeq.aeSeq_eq_fun_of_mem_aeSeqSet | Mathlib.MeasureTheory.Function.AEMeasurableSequence | [
"MeasureTheory.Measure",
"AEMeasurable",
"congrArg",
"Membership.mem",
"aeSeq",
"AEMeasurable.mk",
"aeSeq.mk_eq_fun_of_mem_aeSeqSet",
"MeasurableSpace",
"True",
"aeSeq.aeSeq_eq_mk_of_mem_aeSeqSet",
"eq_self",
"of_eq_true",
"congrFun'",
"aeSeqSet",
"Eq",
"Set.instMembership",
"Eq.tran... | true |
CategoryTheory.Abelian.FunctorCategory.functor_category_isIso_coimageImageComparison | Mathlib.CategoryTheory.Abelian.FunctorCategory | [
"CategoryTheory.Abelian.FunctorCategory.coimageImageComparison_app'",
"CategoryTheory.Abelian.toPreadditive",
"Eq.mpr",
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.Abelian.FunctorCategory.imageObjIso",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory... | true |
OrderIso.subLeft | Mathlib.Algebra.Order.Group.OrderIso | [
"OrderDual.instLE",
"OrderDual.toDual",
"Equiv.subLeft",
"RelIso.mk",
"Equiv.trans",
"AddMonoid.toAddZeroClass",
"AddLeftMono",
"AddRightMono",
"AddZeroClass.toAddZero",
"Equiv",
"sub_le_sub_iff_left",
"OrderIso",
"LE.le",
"LE",
"AddGroup",
"AddGroup.toSubNegMonoid",
"AddZero.toAdd",... | true |
CategoryTheory.Subobject.Classifier.Ω₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.Subobject.Classifier",
"CategoryTheory.Category"
] | true |
Polynomial.lt_rootMultiplicity_iff_isRoot_iterate_derivative | Mathlib.Algebra.Polynomial.FieldDivision | [
"Polynomial.derivative",
"CommRing",
"Semiring.toModule",
"CommSemiring.toSemiring",
"Polynomial.IsRoot",
"AddGroupWithOne.toAddMonoidWithOne",
"LinearMap.instFunLike",
"Nat.lt_of_le_of_lt",
"Ne",
"LE.le",
"instLENat",
"Nat.iterate",
"LinearMap",
"Polynomial",
"CharZero",
"instDistribO... | true |
_private.Init.Data.Nat.Basic.0.Nat.sub_lt_sub_right.match_1_1 | Init.Data.Nat.Basic | [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.le.step",
"instHAdd",
"HAdd.hAdd",
"Nat.le",
"Nat",
"LT.lt",
"Nat.ctorIdx",
"instAddNat",
"Nat.zero",
"Eq.refl",
"HEq",
"Nat.le.refl",
"instLTNat",
"Nat.le.casesOn",
"OfNat.o... | false |
Lean.Grind.instIsCharPISizeHPowNatOfNatNumBits | Init.GrindInstances.Ring.SInt | [
"instPowNat",
"Eq.mpr",
"Dvd.dvd",
"of_decide_eq_true",
"ISize.ofInt",
"congrArg",
"_private.Init.GrindInstances.Ring.SInt.0.Lean.Grind.instIsCharPISizeHPowNatOfNatNumBits._simp_1",
"Lean.Grind.CommSemiring.toSemiring",
"_private.Init.GrindInstances.Ring.SInt.0.Lean.Grind.instIsCharPInt8HPowNatOfNat... | true |
Aesop.ForwardInstantiationStats._sizeOf_1 | Aesop.Stats.Basic | [
"Aesop.ForwardInstantiationStats",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Aesop.ForwardInstantiationStats.rec",
"instSizeOfNat",
"OfNat.ofNat"
] | false |
Lean.Order.instCompleteLatticePProd | Init.Internal.Order.Basic | [
"Lean.Order.instCompleteLatticePProd._proof_1",
"Lean.Order.instPartialOrderPProd",
"Lean.Order.CompleteLattice",
"PProd",
"Lean.Order.CompleteLattice.mk",
"Lean.Order.CompleteLattice.toPartialOrder"
] | true |
PNat.add_coe._simp_1 | Mathlib.Data.PNat.Basic | [
"PNat.val",
"PNat.add_coe",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.symm",
"Eq",
"instAddPNat",
"PNat"
] | false |
Prod.seminormedCommRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | [
"Semigroup.toMul",
"HMul.hMul",
"SeminormedCommRing",
"SeminormedCommRing.toCommRing",
"Prod.instCommRing",
"Monoid.one_mul",
"Semiring.toMonoid",
"Monoid.toSemigroup",
"One.toOfNat1",
"Monoid.toOne",
"CommRing.toRing",
"Prod",
"OfNat.ofNat",
"Ring.toSemiring",
"Eq",
"instHMul"
] | false |
PerfectSpace.univ_preperfect | Mathlib.Topology.Perfect | [
"Set.univ",
"Preperfect",
"PerfectSpace",
"TopologicalSpace"
] | true |
Lean.Elab.Do.ControlStack.noConfusionType | Lean.Elab.Do.Control | [
"Lean.MessageData",
"Lean.Elab.Do.ControlStack.casesOn",
"Lean.Elab.Do.ControlStack",
"Lean.Expr",
"Lean.Elab.Do.DoElemCont",
"Unit",
"Lean.Elab.Do.DoElabM",
"Eq"
] | false |
Int.sqrt_eq | Mathlib.Data.Int.Sqrt | [
"Eq.mpr",
"Int.toNat_natCast",
"HMul.hMul",
"Int.natAbs_mul_self",
"congrArg",
"id",
"Int.sqrt.eq_1",
"instMulNat",
"Nat.sqrt",
"Int",
"Nat.cast",
"Int.instMul",
"Nat",
"Int.natAbs",
"Int.sqrt",
"Eq.refl",
"Nat.sqrt_eq",
"Int.toNat",
"instNatCastInt",
"Eq.symm",
"Eq",
"inst... | true |
Array.findFinIdx?_empty | Init.Data.Array.Find | [
"List.findFinIdx?_toArray",
"congrArg",
"instOfNatNat",
"List.toArray",
"Option.none",
"Array.findFinIdx?",
"Nat",
"True",
"eq_self",
"Bool",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Fin",
"Eq",
"Array.size",
"Eq.trans",
"List.nil",
"Option"
] | true |
CochainComplex.ConnectData.homologyIsoPos._proof_1 | Mathlib.Algebra.Homology.Embedding.Connect | [
"Nat.instCanonicallyOrderedAdd",
"CategoryTheory.Limits.HasZeroMorphisms",
"Nat.instMulZeroClass",
"Nat.instOrderedSub",
"ChainComplex",
"Nat.instIsOrderedAddMonoid",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"Nat.instOne",
"congrArg",
"AddMonoid.toAddZeroClass",
"HomologicalComplex.HasHomolog... | false |
Std.DHashMap.Internal.AssocList.casesOn | Std.Data.DHashMap.Internal.AssocList.Basic | [
"Std.DHashMap.Internal.AssocList.nil",
"Std.DHashMap.Internal.AssocList.rec",
"Std.DHashMap.Internal.AssocList",
"Std.DHashMap.Internal.AssocList.cons"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.