name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
instHasCountableLimitsLightCondMod | Mathlib.Condensed.Light.Limits | [
"LightCondensed._proof_1",
"CategoryTheory.Functor",
"CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits",
"Opposite",
"ModuleCat",
"CategoryTheory.Limits.HasLimitsOfShape",
"SecondCountableTopology",
"CategoryTheory.Functor.category",
"inferInstance",
"CategoryTheory.SmallCategory",
"CategoryThe... | true |
Lean.Parser.Term.doContinue | Lean.Parser.Do | [
"Lean.Parser.Parser",
"Lean.Parser.leadingNode",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Nat",
"Lean.Parser.withCache",
"OfNat.ofNat",
"Lean.Parser.mkAntiquot",
"Bool.false",
"Lean.Name.mkStr4"
] | true |
AddCommGroupWithOne.toNatCast | Mathlib.Data.Int.Cast.Defs | [
"AddCommGroupWithOne",
"NatCast"
] | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda | Lean.Elab.Term.TermElabM | [
"Pure.pure",
"Unit.unit",
"Lean.Elab.Term.UseImplicitLambdaResult",
"Lean.Elab.Term.isLocalIdent?",
"Lean.Elab.Term.blockImplicitLambda",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"Lean.Elab.Term.hasNoImplicitLambdaAnnotation",
"Lean.Elab.Term.UseImplic... | true |
Affine.Simplex.centroid_reindex | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | [
"Iff.mpr",
"Eq.mpr",
"Pi.Function.module",
"Affine.Simplex.points",
"Fintype.card_fin",
"Semiring.toModule",
"AffineMap.instFunLike",
"Equiv.instEquivLike",
"Equiv.symm_comp_self",
"Finset.univ",
"outParam",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"HEq.refl",
"Finset",
"Affine.Simp... | true |
ENNReal.div_lt_top | Mathlib.Data.ENNReal.Inv | [
"Iff.mpr",
"Preorder.toLT",
"instHDiv",
"PartialOrder.toPreorder",
"ENNReal.inv_ne_top",
"HDiv.hDiv",
"Ne",
"ENNReal.mul_lt_top",
"Inv.inv",
"Ne.lt_top",
"LT.lt",
"ENNReal",
"ENNReal.instDivInvMonoid",
"DivInvMonoid.toDiv",
"ENNReal.instPartialOrder",
"Zero.toOfNat0",
"ENNReal.instIn... | true |
List.length_range | Init.Data.List.Range | [
"congrArg",
"List.range'",
"List.length_range'",
"instOfNatNat",
"List.range",
"List",
"Nat",
"List.range_eq_range'",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Eq",
"List.length",
"Eq.trans"
] | true |
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1 | Mathlib.CategoryTheory.Monad.Limits | [
"CategoryTheory.Monad.ForgetCreatesColimits.commuting",
"Eq.mpr",
"CategoryTheory.Monad",
"CategoryTheory.Functor",
"CategoryTheory.Monad.forget",
"CategoryTheory.Monad.Algebra.unit_assoc",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Limits.IsColimit.hom_ext",
"CategoryTheory.CategoryStruct.toQu... | false |
MeasureTheory.integral_union_eq_left_of_forall | Mathlib.MeasureTheory.Integral.Bochner.Set | [
"Real",
"MeasureTheory.Measure",
"MeasurableSet",
"NormedSpace",
"MeasurableSet.nullMeasurableSet",
"Membership.mem",
"Set.instUnion",
"MeasureTheory.Measure.restrict",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"Meas... | true |
ModuleCat.linearOverField._proof_2 | Mathlib.Algebra.Category.ModuleCat.Algebra | [
"IsScalarTower.to_smulCommClass'",
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"LinearMap.ext",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"ModuleCat.moduleOfAlgebraMod... | false |
Lean.Meta.CaseValuesSubgoal.noConfusion | Lean.Meta.Match.CaseValues | [
"Lean.Meta.CaseValuesSubgoal.noConfusionType",
"Lean.MVarId",
"Lean.FVarId",
"Lean.Meta.CaseValuesSubgoal.casesOn",
"Array",
"Lean.Meta.CaseValuesSubgoal",
"Lean.Meta.FVarSubst",
"Eq.ndrec",
"Eq.refl",
"Eq"
] | false |
TensorPower.gmonoid._proof_1 | Mathlib.LinearAlgebra.TensorPower.Basic | [
"Nat.instMulZeroClass",
"instHSMul",
"AddMonoid.toAddSemigroup",
"GradedMonoid.GOne.toOne",
"GradedMonoid.GMul.mk",
"CommSemiring.toSemiring",
"GradedMonoid.GMonoid.gnpowRec",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"GradedMonoid.GMonoid.... | false |
ContDiffWithinAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | [
"Real",
"NormedSpace",
"Real.denselyNormedField",
"Real.sinh",
"Real.normedAddCommGroup",
"ContDiffAt.comp_contDiffWithinAt",
"Real.contDiff_sinh",
"ENat",
"NontriviallyNormedField.toNormedField",
"Real.normedField",
"DenselyNormedField.toNontriviallyNormedField",
"NormedField.toNormedSpace",
... | true |
_private.Init.Data.Vector.Count.0.Vector.count_le_count_map._simp_1_1 | Init.Data.Vector.Count | [
"Array.count_le_count_map",
"LawfulBEq",
"Array.map",
"LE.le",
"instLENat",
"Array",
"Nat",
"True",
"eq_true",
"BEq",
"Eq",
"Array.count"
] | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk.noConfusion | Lean.Meta.Tactic.Grind.Theorems | [
"_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk",
"Lean.Meta.Grind.Theorems.noConfusion",
"Lean.PHashMap",
"id",
"Lean.Meta.Grind.Theorems",
"Lean.PHashSet",
"Lean.Meta.Grind.instBEqOrigin",
"List",
"heq_of_eq",
"Lean.Meta.Grind.Origin",
"Lean.Meta.Grind.instHashableOrigi... | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | [
"SetLike",
"CommRing",
"AlgebraicGeometry.PresheafedSpace.carrier",
"AddGroupWithOne.toAddGroup",
"TopologicalSpace.Opens.instPartialOrder",
"CommSemiring.toSemiring",
"CategoryTheory.ConcreteCategory.hom",
"ProjectiveSpectrum.basicOpen",
"CommRingCat",
"TopCat.instCategory",
"ContinuousMap",
... | false |
CategoryTheory.RigidCategory.ctorIdx | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | [
"CategoryTheory.MonoidalCategory",
"Nat",
"CategoryTheory.RigidCategory",
"CategoryTheory.Category"
] | false |
Array.all_subtype | Init.Data.Array.Attach | [
"List.unattach",
"Eq.mpr",
"List.all",
"Array.all_congr",
"Array.all",
"congrArg",
"List.unattach_toArray",
"List.length_unattach",
"Array.casesOn",
"Subtype",
"instOfNatNat",
"List.toArray",
"Subtype.mk",
"Array",
"List",
"List.all_toArray'",
"List.size_toArray",
"Nat",
"congr",... | true |
Ordinal.ToType.mk._proof_3 | Mathlib.SetTheory.Ordinal.Basic | [
"Preorder.toLT",
"isWellOrder_lt",
"Ordinal.partialOrder",
"PartialOrder.toPreorder",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Ordinal.ToType.mk._proof_2",
"Eq.rec",
"Ordinal.type",
"inferInstance",
"Set.Elem",
"DistribLattice.toLattice",
"linearOrder_toType",
"IsWellOrder",
"... | false |
List.hasDecEq.match_1 | Init.Prelude | [
"Decidable.isTrue",
"Decidable.casesOn",
"Decidable",
"List",
"Decidable.isFalse",
"Eq",
"Not"
] | false |
gcd_comm | Mathlib.Algebra.GCDMonoid.Basic | [
"GCDMonoid.toIsCancelMulZero",
"NormalizedGCDMonoid",
"dvd_antisymm_of_normalize_eq",
"GCDMonoid.dvd_gcd",
"normalize_gcd",
"GCDMonoid.gcd",
"NormalizedGCDMonoid.toGCDMonoid",
"CommMonoidWithZero",
"NormalizedGCDMonoid.toNormalizationMonoid",
"GCDMonoid.gcd_dvd_left",
"GCDMonoid.gcd_dvd_right",
... | true |
Finset.fold_const | Mathlib.Data.Finset.Fold | [
"Std.Commutative",
"Eq.mpr",
"False",
"congrArg",
"Finset",
"Finset.fold",
"if_false",
"Decidable",
"Classical.propDecidable",
"Membership.mem",
"id",
"Insert.insert",
"_private.Mathlib.Data.Finset.Fold.0.Finset.fold_const._simp_1_2",
"Finset.decidableEq",
"ite_cond_eq_true",
"if_pos",... | true |
MonadStateOf.casesOn | Init.Prelude | [
"MonadStateOf.mk",
"MonadStateOf",
"MonadStateOf.rec",
"PUnit",
"Prod"
] | false |
BoxIntegral.Box.instPartialOrder._proof_3 | Mathlib.Analysis.BoxIntegral.Box.Basic | [
"Real",
"Preorder.toLT",
"BoxIntegral.Box.toSet",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLattice",
"LE.le",
"And",
"Iff",
"Preorder.lt_iff_le_not_ge",
"LT.lt",
"CompleteBooleanAlgebra.toCompleteLattice",
"ConditionallyCompletePartialOrderSup.toPar... | false |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.map_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | [
"Bool.coe_iff_coe",
"Bool.true",
"Iff",
"propext",
"Bool",
"Eq"
] | false |
SemimoduleCat.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Semi | [
"SemimoduleCat.isModule",
"SemimoduleCat.moduleCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"SemimoduleCat.isAddCommMonoid",
"HEq.refl",
"SemimoduleCat.hom_ext",
"Eq.casesOn",
"SemimoduleCat",
"LinearMap",
"SemimoduleCat.carrier",
"Iff",
"Iff.intro",
"Eq.ndrec",
"Se... | true |
Real.pow_mul_norm_iteratedFDeriv_fourier_le | Mathlib.Analysis.Fourier.FourierTransformDeriv | [
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"mul_nonneg",
"NormedCommRing.toSeminormedCommRing",
"MulOne.toOne",
"False",
"pow_pos",
"MeasureTheory.integral_non... | true |
ContinuousMap.toAEEqFunAddHom._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | [
"ContinuousMap.toAEEqFun",
"TopologicalSpace.PseudoMetrizableSpace",
"MeasureTheory.Measure",
"ContinuousMap",
"AddMonoid.toAddZeroClass",
"BorelSpace",
"AddZeroClass.toAddZero",
"ContinuousMap.instAddZeroClassOfContinuousAdd",
"IsTopologicalAddGroup.toContinuousAdd",
"MeasureTheory.AEEqFun",
"M... | false |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect.0.Std.IterM.Equiv.toList_eq._simp_1_1 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect | [
"Monad.toApplicative",
"Std.Iterators.Finite",
"Std.IterM.toListRev",
"LawfulMonad",
"Std.Iterator",
"List",
"List.reverse",
"Applicative.toFunctor",
"Std.IterM",
"Std.IterM.toList",
"Std.IterM.reverse_toListRev",
"Eq.symm",
"Monad",
"Eq",
"Functor.map"
] | false |
groupHomology.H0π_comp_H0Iso_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | [
"CategoryTheory.Category.assoc",
"Rep.coinvariantsFunctor",
"Rep.V",
"CommRing",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Rep.hV2",
"groupHomology.H0",
"LinearMap.instFunLike",
"Group",
"R... | true |
SzemerediRegularity.increment.congr_simp | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | [
"Real",
"instSubsingletonDecidable",
"Finset.univ",
"Finset",
"SimpleGraph.Adj",
"DecidableRel",
"Decidable",
"Eq.rec",
"Pi.instSubsingleton",
"SzemerediRegularity.increment",
"SimpleGraph",
"Fintype",
"Finset.instLattice",
"Eq.ndrec",
"Eq.refl",
"Subsingleton.elim",
"Finset.instOrde... | true |
SkewMonoidAlgebra.equivMapDomain._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | [
"Equiv.instEquivLike",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"Finset.map",
"Membership.mem",
"AddZeroClass.toAddZero",
"Equiv",
"Ne",
"Finset.mem_map_equiv._simp_1",
"SkewMonoidAlgebra.mem_support_iff._simp_1",
"AddCommMonoid",
"iff_self",
"AddZero.toZero",
"Iff",
"SkewMono... | false |
Finsupp.support_indicator_subset | Mathlib.Data.Finsupp.Indicator | [
"Finsupp.mem_support_iff",
"Finsupp.instFunLike",
"Finsupp.indicator",
"congrArg",
"Finset",
"Finsupp.indicator_of_notMem",
"Classical.byContradiction",
"Finsupp.support",
"Membership.mem",
"Eq.mp",
"HasSubset.Subset",
"Ne",
"Finset.instSetLike",
"propext",
"Finset.instHasSubset",
"Zer... | true |
ArchimedeanClass.FiniteElement._proof_1 | Mathlib.Algebra.Order.Ring.StandardPart | [
"IsDomain.to_noZeroDivisors",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"IsOrderedRing",
"CommSemiring.toSemiring",
"LinearOrder",
"PartialOrder.toPreorder",
"Field.toDivisionRing",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"DivisionRing.... | false |
AddSubsemigroup.centerToAddOpposite._proof_4 | Mathlib.GroupTheory.Submonoid.Center | [
"Iff.mpr",
"AddSubsemigroup.instSetLike",
"Membership.mem",
"AddOpposite.unop_mem_center_iff",
"AddOpposite",
"AddOpposite.instAdd",
"Subtype",
"AddSubsemigroup.center",
"Set.addCenter",
"AddSubsemigroup",
"AddOpposite.unop",
"Subtype.val",
"Set.instMembership",
"SetLike.instMembership",
... | false |
Substring.Raw.Valid.data_drop | Batteries.Data.String.Lemmas | [
"String.toList_ofList",
"congrArg",
"String",
"Substring.Raw.Valid.validFor",
"_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.data_drop.match_1_1",
"Exists",
"Substring.Raw.ValidFor",
"Substring.Raw.drop",
"Substring.Raw",
"Substring.Raw.toString",
"instHAppendOfAppend",
"List",
... | true |
_private.Mathlib.MeasureTheory.Integral.IntervalAverage.0.exists_eq_interval_average_of_noAtoms._proof_1_1 | Mathlib.MeasureTheory.Integral.IntervalAverage | [
"instLawfulOrderLT_mathlib",
"Set.Ioc",
"Lean.Grind.Field.toCommRing",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Real.partialOrder",
"Real.instLE",
"Real",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"eq_false",
"Lean.Grind.Order.le_lt_trans_k",
"Lean.Grind.iff_eq",
"Lean.Grind.Orde... | false |
Int.getElem?_toArray_roo_eq_none | Init.Data.Range.Polymorphic.IntLemmas | [
"Std.Rco.toArray",
"congrArg",
"Std.PRange.instUpwardEnumerableInt",
"HSub.hSub",
"Int.getElem?_toArray_rco_eq_none",
"Int",
"LE.le",
"instLENat",
"Std.PRange.instIsAlwaysFiniteInt_1",
"Array",
"Int.instLTInt",
"Option.none",
"instHAdd",
"instHSub",
"instOfNat",
"HAdd.hAdd",
"Nat",
... | true |
Lean.Widget.WidgetSource.mk.noConfusion | Lean.Widget.UserWidget | [
"Lean.Widget.WidgetSource.noConfusion",
"Lean.Widget.WidgetSource",
"String",
"id",
"Lean.Widget.WidgetSource.mk",
"Eq"
] | false |
Lean.Grind.IntModule.OfNatModule.mk_le_mk | Init.Grind.Module.Envelope | [
"Iff.rfl",
"Prod.mk",
"Lean.Grind.IntModule.OfNatModule.Q.mk",
"LE.le",
"LE",
"Lean.Grind.IntModule.OfNatModule.Q",
"instHAdd",
"Iff",
"Std.IsPreorder",
"HAdd.hAdd",
"Lean.Grind.AddCommMonoid.toAdd",
"Lean.Grind.IntModule.OfNatModule.instLEQOfOrderedAdd",
"Lean.Grind.NatModule",
"Lean.Grin... | true |
_private.Mathlib.Algebra.Category.ModuleCat.Semi.0.SemimoduleCat.mk | Mathlib.Algebra.Category.ModuleCat.Semi | [
"SemimoduleCat",
"AddCommMonoid",
"Semiring",
"Module",
"_private.Mathlib.Algebra.Category.ModuleCat.Semi.0.SemimoduleCat.mk"
] | true |
StructureGroupoid.id_mem_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | [
"chartedSpaceSelf",
"Membership.mem",
"StructureGroupoid",
"chartedSpaceSelf_atlas._simp_1",
"TopologicalSpace",
"StructureGroupoid.subset_maximalAtlas",
"True",
"eq_self",
"of_eq_true",
"StructureGroupoid.maximalAtlas",
"atlas",
"hasGroupoid_model_space",
"Eq",
"Set.instMembership",
"Op... | true |
_private.Mathlib.Algebra.Exact.Sequence.0.Module.sum_neg_one_pow_finrank_eq_zero_of_exact._proof_1_3 | Mathlib.Algebra.Exact.Sequence | [
"Int.instAddCommGroup",
"Submodule",
"instNeZeroNatHAdd_1",
"RingHomSurjective.ids",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Fin.succ",
"Lean.Omega.Constraint.mk",
"AddCommGroup.toAddCommMonoid",
"Submodule.addComm... | false |
Array.mapIdx_mapIdx | Init.Data.Array.MapIdx | [
"Array.getElem?_mapIdx",
"congrArg",
"Array.mapIdx",
"Function.comp",
"Array",
"_private.Init.Data.Array.MapIdx.0.Array.mapIdx_mapIdx._simp_1_1",
"Option.map",
"Option.map_map",
"Nat",
"congr",
"LT.lt",
"True",
"eq_self",
"of_eq_true",
"implies_true",
"instLTNat",
"GetElem?.getElem?"... | true |
QuasiconcaveOn.dual | Mathlib.Analysis.Convex.Quasiconvex | [
"OrderDual.instLE",
"OrderDual.toDual",
"Equiv.instEquivLike",
"SMul",
"Function.comp",
"PartialOrder",
"id",
"Equiv",
"LE",
"AddCommMonoid",
"Semiring",
"QuasiconcaveOn",
"OrderDual",
"QuasiconvexOn",
"DFunLike.coe",
"EquivLike.toFunLike",
"Set"
] | true |
IsDedekindDomain.HeightOneSpectrum.under._proof_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | [
"CommRing",
"CommSemiring.toSemiring",
"IsDedekindDomain.HeightOneSpectrum",
"Algebra",
"IsDedekindDomain.HeightOneSpectrum.asIdeal",
"CommRing.toCommSemiring",
"Ideal.IsPrime",
"Ideal.IsPrime.under",
"IsDedekindDomain.HeightOneSpectrum.isPrime",
"Ideal.under"
] | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.isValidSearchFrom_iff_isValidSearchFrom_beq._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | [
"String.Slice",
"instBEqOfDecidableEq",
"BEq.beq",
"String.Slice.Pattern.Model.CharPred.instPatternModelForallCharBool",
"String.Slice.Pattern.Model.Char.instPatternModelChar",
"propext",
"Bool",
"String.Slice.Pattern.Model.Char.isLongestMatchAt_iff_isLongestMatchAt_beq",
"String.Slice.Pos",
"Char... | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order.0.isStrictlyPositive_add._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | [
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"NormedRing.toRing",
"eq_false",
"Lean.Grind.iff_eq",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"Lean.Grind.eq_false_of_imp_eq_true",
"Lean.Grind.and_eq_of_eq_true_left",
"IsUnit",
"Preorder.toLE",
"CStarAlgebra.toNormedRing",
"CSt... | false |
_private.Mathlib.Algebra.Star.Module.0.selfAdjointPart_comp_subtype_skewAdjoint.match_1_1 | Mathlib.Algebra.Star.Module | [
"NegZeroClass.toNeg",
"Submodule",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"StarMul",
"Subtype.casesOn",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Subtype",
"DistribSMul.toSMulZeroClass",
"S... | false |
Std.ExtDTreeMap.Const.alter_eq_empty_iff | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.erase_eq_empty_iff",
"Eq.mpr",
"Std.ExtDTreeMap.Const.alter",
"congrArg",
"Std.ExtDTreeMap.erase",
"Iff.rfl",
"Membership.mem",
"Ordering",
"id",
"Std.ExtDTreeMap.instEmptyCollection",
"instOfNatNat",
"Std.TransCmp",
"Std.ExtDTreeMap.Const.get?",
"Option.none",
"And",
... | true |
Set.image_list_prod._f | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | [
"Monoid",
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"List.map_cons",
"Monoid.toMulOneClass",
"congrArg",
"Set.one",
"_private.Mathlib.Algebra.Group.Pointwise.Set.BigOperators.0.Set.image_list_prod.match_1_1",
"List.map",
"MonoidHomClass.toOneHomClass",
"Set.image_one",
"Set.instSingletonSet",
... | false |
CategoryTheory.Sheaf.instPreservesFiniteLimitsFunctorOppositeSheafToPresheafOfHasFiniteLimits | Mathlib.CategoryTheory.Sites.Limits | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesFiniteLimits",
"Opposite",
"CategoryTheory.Limits.HasFiniteLimits",
"CategoryTheory.Functor.category",
"inferInstance",
"CategoryTheory.Limits.PreservesFiniteLimits.mk",
"CategoryTheory.Sheaf.createsLimitsOfShape",
"CategoryTheory.SmallCatego... | true |
AddCon.addSubgroup_quotientAddGroupCon | Mathlib.GroupTheory.QuotientGroup.Defs | [
"AddCon.instFunLikeForallProp",
"QuotientAddGroup.leftRel_apply",
"AddGroup.toSubtractionMonoid",
"AddCon",
"NegZeroClass.toNeg",
"SubtractionMonoid.toInvolutiveNeg",
"neg_mem_iff",
"QuotientAddGroup.con._proof_1",
"congrArg",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZe... | true |
ContinuousMultilinearMap.uniformContinuous_restrictScalars | Mathlib.Topology.Algebra.Module.Multilinear.Topology | [
"UniformContinuous",
"UniformSpace",
"NormedCommRing.toSeminormedCommRing",
"ContinuousSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"SeminormedRing.toRing",
"AddCommGroup.toAddGroup",
"... | true |
BoxIntegral.unitPartition.prepartition_isHenstock | Mathlib.Analysis.BoxIntegral.UnitPartition | [
"Eq.mpr",
"BoxIntegral.unitPartition.prepartition_tag",
"Nat.instMulZeroClass",
"Real",
"BoxIntegral.unitPartition.tag_mem",
"congrArg",
"Finset",
"BoxIntegral.Box.Icc",
"BoxIntegral.unitPartition.tag",
"Membership.mem",
"Exists",
"id",
"BoxIntegral.TaggedPrepartition.tag",
"BoxIntegral.Ta... | true |
Finset.gcd_congr | Mathlib.Algebra.GCDMonoid.Finset | [
"Finset",
"NormalizedGCDMonoid",
"Membership.mem",
"Finset.fold_congr",
"CommMonoidWithZero.toMonoidWithZero",
"Finset.gcd",
"GCDMonoid.gcd",
"MonoidWithZero.toMulZeroOneClass",
"Finset.instSetLike",
"NormalizedGCDMonoid.toGCDMonoid",
"CommMonoidWithZero",
"instCommutativeGcd",
"Eq.ndrec",
... | true |
LowerSet.notMem_bot._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | [
"False",
"eq_false",
"LowerSet.instBot",
"Membership.mem",
"Bot.bot",
"LE",
"LowerSet.notMem_bot",
"LowerSet",
"Eq",
"SetLike.instMembership",
"LowerSet.instSetLike"
] | false |
Std.DHashMap.Equiv.constGet_eq | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.Equiv",
"Std.DHashMap.Internal.Raw₀.Const.get_eq_of_equiv",
"Std.DHashMap.Raw",
"Membership.mem",
"Std.DHashMap.instMembership",
"Std.DHashMap.wf",
"Std.DHashMap.Equiv.mem_iff",
"instOfNatNat",
"LawfulHashable",
"Subtype.mk",
"EquivBEq",
"Std.DHashMap.inner",
"Nat",
"Std.DHas... | true |
CategoryTheory.NatTrans.removeOp._proof_2 | Mathlib.CategoryTheory.Opposites | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op_inj",
"CategoryTheory.Functor.category",
"Quiver.Hom.unop",
"CategoryTheory.Functor.map",
"Opposite.op",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheo... | false |
Valuation.mem_nhds_iff | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | [
"Filter.instMembership",
"AddGroup.toSubtractionMonoid",
"Units.val",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"NegZeroClass.toNeg",
"ValuativeRel.instLinearOrderValueGroupWithZero",
"Preorder.toLT",
"ValuationClass.toMonoidWit... | true |
_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.getSize.match_3 | Std.Http.Protocol.H1.Message | [
"Unit.unit",
"Option.ctorIdx",
"_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.getSize._sparseCasesOn_5",
"_private.Std.Http.Protocol.H1.Message.0.Std.Http.Protocol.H1.Message.Head.getSize._sparseCasesOn_4",
"Option.some",
"Nat.hasNotBit",
"_private.Std.Http.Protocol.H1.Messag... | false |
Std.TreeMap.getKeyD_insert_self | Std.Data.TreeMap.Lemmas | [
"Std.TreeMap.insert",
"Std.TreeMap.inner",
"Ordering",
"Std.TransCmp",
"Std.TreeMap.getKeyD",
"Std.DTreeMap.getKeyD_insert_self",
"Eq",
"Std.TreeMap"
] | true |
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_slice._proof_1_2 | Init.Data.String.Basic | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"String.Slice.Pos.offset",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Ome... | false |
Representation.instAddCommGroupAsModule._proof_8 | Mathlib.RepresentationTheory.Basic | [
"Monoid",
"Representation",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toZero",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Int",
"SubNegMonoid.zsmul_zero'._autoParam",
"autoParam",
"Representation.asModule",
"Representation.instAddCommMonoidAsModule",
"AddGroup.toSubNegMonoid",
"instOfNat",... | false |
PositiveLinearMap.toOrderHom_comp | Mathlib.Algebra.Order.Module.PositiveLinearMap | [
"PartialOrder.toPreorder",
"PartialOrder",
"OrderHom.comp",
"AddCommMonoid",
"PositiveLinearMap",
"Semiring",
"PositiveLinearMap.comp",
"PositiveLinearMap.toOrderHom",
"Module",
"Eq",
"OrderHom",
"rfl"
] | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit'.eq_def | Lean.Elab.DeclNameGen | [
"Pure.pure",
"_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit",
"StateRefT'.instAlternativeOfMonad",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"modify",
"String",
"Lean.Meta.State",
"instMonadLiftT",
"IO",
"_private.Lean.Elab.DeclNameG... | true |
TopCat.ι₁_fst_assoc | Mathlib.Topology.Category.TopCat.Monoidal | [
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"TopCat.instCategory",
"TopCat.instCartesianMonoidalCategory",
"CategoryTheory.CategoryStruct.id",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryTheory.SemiCartesianMonoidalCatego... | true |
CategoryTheory.rightExactFunctor | Mathlib.CategoryTheory.Limits.ExactFunctor | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.PreservesFiniteColimits",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.ObjectProperty",
"CategoryTheory.Category"
] | true |
Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars.elim | Mathlib.Tactic.ClickSuggestions.Util | [
"PULift.up",
"Mathlib.Tactic.ClickSuggestions.RwKind.hasBVars",
"Mathlib.Tactic.ClickSuggestions.RwKind.ctorIdx",
"Mathlib.Tactic.ClickSuggestions.RwKind.ctorElim",
"Nat",
"Mathlib.Tactic.ClickSuggestions.RwKind",
"Eq.symm",
"Eq"
] | false |
AddGrpCat.limitAddGroup._aux_4 | Mathlib.Algebra.Category.Grp.Limits | [
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCone",
"AddGrpCat.instCategory",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.comp",
"AddZeroClass.toAddZero",
"Set.Elem",
"Equiv",
"CategoryTheory.Limits.Cone.pt",
"AddGrpCat",
"AddZero.toZero",
... | false |
DilationEquiv.coe_one | Mathlib.Topology.MetricSpace.DilationEquiv | [
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"DilationEquiv.instEquivLike",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"id",
"PseudoEMetricSpace",
"DilationEquiv.instGroup",
"One.toOfNat1",
"DilationEquiv",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLik... | true |
OrderType.instOfNat | Mathlib.Order.Types.Arithmetic | [
"OrderType.type",
"Fin.instLinearOrder",
"Nat",
"OfNat.mk",
"OrderType",
"Fin",
"OfNat"
] | true |
CategoryTheory.Subfunctor.Subpresheaf.range_id | Mathlib.CategoryTheory.Subfunctor.Image | [
"CategoryTheory.Functor",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Preorder.toLE",
"CategoryTheory.CategoryStruct.id",
"CompleteLattice.toBoundedOrder",
"CategoryTheory.instCompleteLatticeSubfunctor",
"CategoryTheory.Su... | true |
Std.TreeSet.getD_diff_of_mem_right | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeSet.getD",
"Membership.mem",
"Ordering",
"Std.TreeSet.inner",
"Std.TransCmp",
"Std.TreeSet.instSDiff",
"Std.TreeMap.getKeyD_diff_of_mem_right",
"SDiff.sdiff",
"Unit",
"Eq",
"Std.TreeSet.instMembership"
] | true |
List.length_mapFinIdx | Init.Data.List.MapIdx | [
"List.length_mapFinIdx_go",
"congrArg",
"List.mapFinIdx",
"List.toArray",
"List",
"Nat",
"LT.lt",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"instLTNat",
"List.mapFinIdx._proof_5",
"Eq",
"List.length",
"Eq.trans",
"List.nil"
] | true |
Subalgebra.normedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | [
"Subalgebra.instSetLike",
"NormedCommRing.toNormedRing",
"NormedCommRing.toCommRing",
"Real",
"CommRing",
"NormedRing.toRing",
"NormedCommRing",
"Real.instZero",
"CommSemiring.toSemiring",
"Algebra",
"Membership.mem",
"Subtype",
"Subalgebra.normedRing",
"MetricSpace.eq_of_dist_eq_zero",
... | false |
RelSeries.head_fromListIsChain | Mathlib.Order.RelSeries | [
"List.head",
"instNeZeroNatHAdd_1",
"SetRel",
"congrArg",
"RelSeries.fromListIsChain._proof_3",
"GetElem.getElem.congr_simp",
"HSub.hSub",
"Membership.mem",
"RelSeries.fromListIsChain_toFun",
"Fin.instOfNat",
"RelSeries.length",
"Nat.instMod",
"List.IsChain",
"instHMod",
"Prod.mk",
"in... | true |
_private.Mathlib.Tactic.Hint.0.Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1._sparseCasesOn_1 | Mathlib.Tactic.Hint | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
Graph.IsLoopAt.mono | Mathlib.Combinatorics.Graph.Subgraph | [
"Graph.IsLink.mono",
"Graph.IsLoopAt",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Graph",
"LE.le",
"Graph.instPartialOrder"
] | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take.match_1.splitter | Mathlib.Data.Seq.Basic | [
"Stream'.Seq",
"instOfNatNat",
"Nat",
"Stream'.Seq.take.match_1",
"OfNat.ofNat",
"Nat.succ"
] | true |
IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots | Mathlib.NumberTheory.Cyclotomic.Basic | [
"Subalgebra.instSetLike",
"Iff.mpr",
"Eq.mpr",
"Polynomial.eval",
"IsDomain",
"Nat.instMulZeroClass",
"CommRing",
"Polynomial.cyclotomic_ne_zero",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"Finset",
"Polynom... | true |
ExteriorAlgebra.ι_inj._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | [
"ExteriorAlgebra.ι_inj",
"CommRing",
"Semiring.toModule",
"QuadraticMap.instZero",
"ExteriorAlgebra",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"instAlgebraCliffordAlgebra",
"QuadraticForm",
"LinearMap.instFunLike",
"AddCommGroup",
"Algebra.toModule",
"LinearMap",
"CommRin... | false |
CategoryTheory.NatTrans.leftOpWhiskerRight_assoc | Mathlib.CategoryTheory.Opposites | [
"CategoryTheory.Functor.op",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"Eq.mp",
"CategoryTheory.Functor.whiskerLeft",
"id",
"Math... | true |
NumberField.IsCMField.complexConj_eq_self_iff | Mathlib.NumberTheory.NumberField.CMField | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"NumberField.IsCMField.zpowers_complexConj_eq_top",
"SubsemiringClass.nontrivial",
"Lattice.toSemilatticeSup",
"Subfield.toAlgebra",
"Algebra.algebraMap",
"CompleteLattice.toLattice",
"NumberField.maximalRealSubfield",
"congrArg",
"CommSemirin... | true |
_private.Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape.0.CategoryTheory.ObjectProperty.limitsOfShape_isEmpty_iff.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.LimitPresentation.casesOn",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.LimitPresentation",
"CategoryTheory.Functor.category",
"CategoryTheory.ObjectProperty.LimitOfShape.casesOn",
"CategoryTheory.ObjectProperty.LimitO... | false |
IsSemitopologicalSemiring | Mathlib.Topology.Algebra.Ring.Basic | [
"IsSemitopologicalSemiring.mk",
"TopologicalSpace",
"NonUnitalNonAssocSemiring"
] | true |
LieAlgebra.IsKilling.disjoint_ker_weight_corootSpace | Mathlib.Algebra.Lie.Weights.Killing | [
"LieAlgebra.toModule",
"Iff.mpr",
"LieSubalgebra.lieAlgebra",
"Eq.mpr",
"Submodule",
"instIsPrincipalIdealRingOfIsSemisimpleRing",
"SetLike.mem_coe._simp_1",
"LieModule.Weight.instFunLike",
"Semiring.toModule",
"LieAlgebra.IsKilling",
"LieRing.toAddCommGroup",
"LieSubalgebra.instSetLike",
"i... | true |
edist_nndist | Mathlib.Topology.MetricSpace.Pseudo.Defs | [
"Eq.mpr",
"NNDist.nndist",
"Real",
"ENNReal.ofNNReal",
"ENNReal.ofReal",
"congrArg",
"PseudoMetricSpace.toNNDist",
"id",
"dist_nndist",
"PseudoMetricSpace",
"edist_dist",
"PseudoMetricSpace.toEDist",
"ENNReal.ofReal_coe_nnreal",
"ENNReal",
"Eq.refl",
"Dist.dist",
"PseudoMetricSpace.t... | true |
List.forM_nil | Init.Data.List.Control | [
"Pure.pure",
"ForM.forM",
"Monad.toApplicative",
"Applicative.toPure",
"List",
"PUnit",
"PUnit.unit",
"Monad",
"Eq",
"rfl",
"List.instForMOfMonad",
"List.nil"
] | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.comp",
"CategoryTheory.CostructuredArrow.hom",
"CategoryTheory.O... | false |
PNat.XgcdType.mk.sizeOf_spec | Mathlib.Data.PNat.Xgcd | [
"PNat.XgcdType._sizeOf_inst",
"instOfNatNat",
"PNat.XgcdType",
"instHAdd",
"PNat.XgcdType.mk",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"instSizeOfNat",
"OfNat.ofNat",
"Eq"
] | true |
linearOrderOfSTO._proof_1 | Mathlib.Order.RelClasses | [
"asymm_of",
"asymm_of_isTrans_of_irrefl",
"irrefl_of",
"IsStrictOrder.toIsTrans",
"Eq.rec",
"id",
"Or.resolve_left",
"IsStrictTotalOrder",
"Iff",
"IsStrictTotalOrder.toIsStrictOrder",
"Iff.intro",
"Or",
"Or.imp",
"Or.elim",
"Eq.symm",
"trichotomous_of",
"Eq",
"IsStrictTotalOrder.to... | false |
CategoryTheory.ProjectiveResolution.quasiIso._autoParam | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
bihimp_comm | Mathlib.Order.SymmDiff | [
"congrArg",
"GeneralizedHeytingAlgebra.toHImp",
"SemilatticeInf.toMin",
"inf_comm",
"bihimp",
"GeneralizedHeytingAlgebra.toLattice",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Eq",
"GeneralizedHeytingAlgebra",
"Min.min",
"Eq.trans",
"HImp.himp",
"Lattice.toSemilatticeInf"
] | true |
Lean.Expr.proj.elim | Lean.Expr | [
"PULift.up",
"Lean.Expr",
"Nat",
"Lean.Expr.ctorElim",
"Lean.Name",
"Lean.Expr.ctorIdx",
"Eq.symm",
"Eq",
"Lean.Expr.proj"
] | false |
CategoryTheory.PreZeroHypercoverFamily._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | [
"CategoryTheory.PreZeroHypercoverFamily._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"CategoryTheory.PreZeroHypercoverFamily",
"CategoryTheory.Category"
] | false |
Lean.Lsp.InitializationOptions.ctorIdx | Lean.Data.Lsp.InitShutdown | [
"Lean.Lsp.InitializationOptions",
"Nat"
] | false |
instDecidableIrrationalSqrtOfNatReal | Mathlib.NumberTheory.Real.Irrational | [
"instDecidableNot",
"Real",
"Decidable",
"instMulNat",
"instOfNatNat",
"Nat.instDecidablePredIsSquare",
"Irrational",
"Nat",
"IsSquare",
"decidable_of_iff'",
"Real.sqrt",
"OfNat.ofNat",
"irrational_sqrt_ofNat_iff",
"instOfNatAtLeastTwo",
"Not",
"Nat.AtLeastTwo",
"Real.instNatCast"
] | true |
mul_le_mul_of_nonpos_of_nonneg' | Mathlib.Algebra.Order.Ring.Unbundled.Basic | [
"mul_le_mul_of_nonpos_right",
"HMul.hMul",
"Preorder.toLE",
"AddRightMono",
"Distrib.toAdd",
"LE.le",
"instDistribOfSemiring",
"MulPosMono",
"ExistsAddOfLE",
"AddRightReflectLE",
"PosMulMono",
"Distrib.toMul",
"Semiring",
"Zero.toOfNat0",
"LE.le.trans",
"OfNat.ofNat",
"mul_le_mul_of_... | true |
ZeroAtInftyContinuousMap.rec | Mathlib.Topology.ContinuousMap.ZeroAtInfty | [
"ContinuousMap",
"nhds",
"Filter.cocompact",
"TopologicalSpace",
"Filter.Tendsto",
"ZeroAtInftyContinuousMap.mk",
"Zero.toOfNat0",
"ContinuousMap.toFun",
"ZeroAtInftyContinuousMap",
"OfNat.ofNat",
"Zero"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.