name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.WithInitial.mkCommaObject_right_map | Mathlib.CategoryTheory.WithTerminal.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.WithInitial.incl",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.id",
"CategoryTheory.Functor.map",
"CategoryTheory.WithInitial",
"CategoryTheory.WithInitial... | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctor_obj | Mathlib.CategoryTheory.Sites.Descent.DescentData | [
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pseudofunctor.DescentData.pullFunctorObj",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.Pseudofunctor.DescentData.instCategory",
"CategoryTheory.Cat",
"CategoryTheory.LocallyDiscrete",
"CategoryTheory.... | true |
SimpleGraph.Subgraph.topIso._proof_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | [
"SimpleGraph.Subgraph",
"Membership.mem",
"Set.Elem",
"Subtype",
"SimpleGraph.Subgraph.instTop",
"Subtype.mk",
"SimpleGraph",
"Set.mem_univ",
"SimpleGraph.Subgraph.topIso._proof_2",
"Subtype.eta",
"Top.top",
"Subtype.val",
"Eq",
"Set.instMembership",
"SimpleGraph.Subgraph.verts",
"Set"... | false |
BotHom.instDistribLattice._proof_4 | Mathlib.Order.Hom.Bounded | [
"Lattice.toSemilatticeSup",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderBot",
"DistribLattice.toLattice",
"BotHom.instMin",
"Bot",
"DistribLattice",
"BotHom.instFunLike",
"SemilatticeSup.toPartialOrder",
"Eq",
"DFunLike.coe",
"BotHom",
"Min.min",
"rfl",
"Latti... | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.toOption.eq_3 | Init.Data.String.Pattern.String | [
"String.instLTRaw",
"Vector",
"HSub.hSub",
"String.Slice.rawEndPos",
"Option.some",
"String.Slice",
"Prod.mk",
"instSubNat",
"String.Slice.utf8ByteSize",
"String.Pos.Raw",
"String.Slice.Pattern.ForwardSliceSearcher.proper",
"instHSub",
"String.Slice.Pattern.ForwardSliceSearcher.buildTable",
... | true |
ProbabilityTheory.variance_sub_const | Mathlib.Probability.Moments.Variance | [
"Eq.mpr",
"Real",
"MeasureTheory.Measure",
"congrArg",
"Real.instSub",
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"PseudoMetricSpace.toUniformSpace",
"ProbabilityTheory.variance_add_const",
"AddZeroClass.toAddZero",
"id",
"Real.instAddGroup",
"ProbabilityTheory.variance",
... | true |
Mathlib.Tactic.Ring.Common.Cache.ctorIdx | Mathlib.Tactic.Ring.Common | [
"Mathlib.Tactic.Ring.Common.Cache",
"Lean.Expr.const",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"Qq.Quoted",
"Nat",
"Lean.Expr.app",
"Lean.Level.succ",
"Lean.Name.mkStr1",
"List.nil"
] | false |
_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instBEqAuxDeclCacheKey.beq._proof_2 | Lean.Compiler.LCNF.AuxDeclCache | [
"instLawfulBEq",
"HEq.refl",
"Lean.Compiler.LCNF.instDecidableEqPurity",
"Lean.Compiler.LCNF.Purity",
"instBEqOfDecidableEq",
"Bool.true",
"BEq.beq",
"Bool",
"_private.Lean.Compiler.LCNF.AuxDeclCache.0.Lean.Compiler.LCNF.instBEqAuxDeclCacheKey.beq._proof_1",
"HEq",
"LawfulBEq.eq_of_beq",
"Eq"
... | false |
_private.Init.Data.Option.Instances.0.Option.eq_none_of_isNone.match_1_1 | Init.Data.Option.Instances | [
"Option.isNone",
"False",
"HEq.refl",
"False.elim",
"Option.casesOn",
"noConfusion_of_Nat",
"Option.some",
"Eq.casesOn",
"Bool.ctorIdx",
"Bool.true",
"Option.none",
"Bool",
"Eq.refl",
"HEq",
"Bool.false",
"Eq",
"Option"
] | false |
Order.IsIdeal.Directed | Mathlib.Order.Ideal | [
"DirectedOn",
"LE.le",
"LE",
"Order.IsIdeal",
"Set"
] | true |
CategoryTheory.Pretriangulated.productTriangle.π_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | [
"CategoryTheory.Limits.HasProduct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pretriangulated.Triangle.obj₁",
"CategoryTheory.Pretriangulated.Triangle.obj₃",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Limits.Pi.π",
"Int",
"Int.instAddMonoid",
"CategoryTheory.Pretr... | true |
SimpleGraph.Subgraph.instFinite | Mathlib.Combinatorics.SimpleGraph.Subgraph | [
"SimpleGraph.Subgraph",
"SimpleGraph.Adj",
"Finite",
"Classical.propDecidable",
"inferInstance",
"Finite.of_fintype",
"Nonempty.intro",
"SimpleGraph",
"nonempty_fintype",
"Fintype",
"Nonempty.casesOn",
"Nonempty",
"SimpleGraph.Subgraph.instFintypeOfDecidableEqOfDecidableRelAdj",
"Eq.refl",... | true |
CategoryTheory.Limits.Pi.map_π | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"CategoryTheory.Limits.limMap_π",
"CategoryTheory.Limits.limit.π",
"CategoryTheory.Limits.HasProduct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Limits.Pi.π",
"CategoryTheory.Discrete.natTrans",
"CategoryTheory.Discrete.m... | true |
MeasureTheory.AEEqFun.mul_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"HMul.hMul",
"MeasureTheory.AEEqFun.toGerm",
"continuous_mul",
"Mul",
"Filter.Germ.instMul",
"MeasureTheory.AEEqFun",
"MeasurableSpace",
"TopologicalSpace",
"ContinuousMul",
"MeasureTheory.AEEqFun.comp₂_toGerm",
"Filter.Germ",
"MeasureTheory.AEE... | true |
MvPolynomial.coeff_linearCombination_X_pow | Mathlib.Algebra.MvPolynomial.Coeff | [
"Finsupp.instFunLike",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"Semiring.toModule",
"Finsupp.module",
"HMul.hMul",
"AddMonoidAlgebra.addAddCommMonoid",
"congrArg",
"CommSemiring.toSemiring",
"LinearMap.instFunLike",
"Finsupp.m... | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.prove._sparseCasesOn_3 | Mathlib.Lean.Meta.CongrTheorems | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.rec",
"List.cons",
"Nat.land",
"List",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"List.ctorIdx",
"List.nil"
] | false |
UpperSet.Ici_ne_top._simp_2 | Mathlib.Order.UpperLower.Principal | [
"False",
"UpperSet",
"eq_false",
"UpperSet.Ici_ne_top",
"Preorder.toLE",
"UpperSet.Ici",
"UpperSet.instTop",
"Top.top",
"Eq",
"Preorder"
] | false |
CategoryTheory.ObjectProperty.fullMonoidalClosedSubcategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Subcategory | [
"CategoryTheory.ihom.coev_naturality",
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ihom.coev",
"CategoryTheory.ObjectProperty.ι",
"CategoryTheory.ObjectPro... | false |
_private.Lean.IdentifierSuggestion.0.Lean.throwUnknownNameWithSuggestions.match_1 | Lean.IdentifierSuggestion | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Lean.Name",
"Option"
] | false |
_private.Std.Time.Format.Basic.0.Std.Time.exactlyChars.go._unary._proof_1 | Std.Time.Format.Basic | [
"Nat.lt_of_not_le",
"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",
"InvImage",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dich... | false |
Lean.Elab.Tactic.Do.ProofMode.initFn._@.Lean.Elab.Tactic.Do.ProofMode.Cases.723085142._hygCtx._hyg.2 | Lean.Elab.Tactic.Do.ProofMode.Cases | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Unit",
"Nat",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr4"
] | false |
SupHom.subtypeVal | Mathlib.Order.Hom.Lattice | [
"SemilatticeSup.toMax",
"Subtype",
"Subtype.semilatticeSup",
"Max.max",
"SupHom",
"Subtype.val",
"SemilatticeSup",
"SupHom.mk",
"SupHom.subtypeVal._proof_1"
] | true |
CStarMatrix.of_add_of | Mathlib.Analysis.CStarAlgebra.CStarMatrix | [
"Matrix.add",
"Equiv.instEquivLike",
"Matrix",
"Equiv",
"CStarMatrix.ofMatrix",
"CStarMatrix",
"instHAdd",
"HAdd.hAdd",
"CStarMatrix.instAdd",
"Eq",
"DFunLike.coe",
"Add",
"rfl",
"EquivLike.toFunLike"
] | true |
Lean.Expr.hasLooseBVarInExplicitDomain | Lean.Expr | [
"Lean.Expr.brecOn",
"Lean.Expr.hasLooseBVarInExplicitDomain._f",
"Lean.Expr",
"Nat",
"Bool"
] | true |
CategoryTheory.Adjunction.homEquiv_naturality_right_square | Mathlib.CategoryTheory.Adjunction.Basic | [
"Eq.mpr",
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"id",
"Equiv",
"CategoryTheory.Functor.map",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Adjunction.homEquiv_naturality_right_symm",
"Eq.refl",
"CategoryTh... | true |
LinearEquiv.coe_injective | Mathlib.Algebra.Module.Equiv.Defs | [
"RingHom",
"AddCommMonoid",
"RingHomInvPair",
"DFunLike.coe_injective",
"LinearEquiv",
"Semiring",
"LinearEquiv.instEquivLike",
"Function.Injective",
"Module",
"Semiring.toNonAssocSemiring",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Mathlib.Tactic.Group.group | Mathlib.Tactic.Group | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Parser.Tactic.location",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
Std.Rxi.HasSize.casesOn | Init.Data.Range.Polymorphic.Basic | [
"Std.Rxi.HasSize.rec",
"Nat",
"Std.Rxi.HasSize",
"Std.Rxi.HasSize.mk"
] | false |
_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM.match_1 | Lean.Util.ReplaceLevel | [
"_private.Lean.Util.ReplaceLevel.0.Lean.Expr.ReplaceLevelImpl.replaceUnsafeM._sparseCasesOn_1",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Expr.sort",
"Lean.Level",
"Lean.Expr.mdata",
"Lean.Expr.forallE",
"List",
"Lean.MData",
"Lean.Expr.lam",
"Nat",
"Bool",
... | false |
SeparationQuotient.instRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | [
"IsSemitopologicalRing.toIsTopologicalAddGroup",
"Semiring.toNatCast",
"NegZeroClass.toNeg",
"SeparationQuotient.instSemiring",
"AddGroupWithOne.intCast_ofNat._autoParam",
"SeparationQuotient.instIntCast",
"Ring.toNonAssocRing",
"IsTopologicalRing.toIsTopologicalSemiring",
"AddGroupWithOne.toAddGrou... | false |
Congr!.plausiblyEqualTypes._unsafe_rec | Mathlib.Tactic.CongrExclamation | [
"Pure.pure",
"_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_1",
"Subarray",
"Lean.Meta.isProp",
"instForInOfForIn'",
"ReaderT",
"instMonadControlTOfPure",
"Lean.Meta.State",
"_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_3",
"Std.Stream.n... | false |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_list | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Std.DTreeMap.Internal.Impl.isEmpty_eq_isEmpty",
"Std.Internal.List.insertList",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"instForInOfForIn'",
"beqOfOrd",
"Std.DTreeMap.Internal.Impl.toListModel_insertMany_list",
"Std.TransOrd",
... | true |
MeasurableEq.mk | Mathlib.MeasureTheory.MeasurableSpace.Constructions | [
"MeasurableSet",
"MeasurableEq",
"MeasurableSpace",
"Set.diagonal",
"MeasurableEq.mk",
"Prod",
"Prod.instMeasurableSpace"
] | true |
instComplSubtypeProdAndEqHMulFstSndOfNatHAdd | Mathlib.Algebra.Order.Ring.Idempotent | [
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"MulOne.toMul",
"Subtype",
"Prod.mk",
"Prod.fst",
"AddCommMonoid",
"Subtype.mk",
"AddZero.toZero",
"instHAdd",
"MulOneClass.toMulOne",
"And",
"HAdd.hAdd",
"CommMonoid.toMonoid",... | true |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | [
"NegZeroClass.toNeg",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubtractionMonoid.toSubNegMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubNegMonoid.toSub",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"SubtractionMonoid",
"AddZero.toA... | false |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balance1.match_1.splitter._sparseCasesOn_2 | Batteries.Data.RBMap.Lemmas | [
"Batteries.RBNode",
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"Batteries.RBNode.nil",
"instOfNatNat",
"Batteries.RBNode.ctorIdx",
"Nat.land",
"Batteries.RBNode.rec",
"Batteries.RBColor",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Batteries.RBNode.node"
] | false |
Plausible.InjectiveFunction.instArbitraryInt | Mathlib.Testing.Plausible.Functions | [
"Pure.pure",
"Plausible.InjectiveFunction.mk",
"HMul.hMul",
"Plausible.Gen.getSize",
"Plausible.Gen.permutationOf",
"ReaderT",
"Monad.toApplicative",
"ULift",
"Plausible.InjectiveFunction.instArbitraryInt._proof_1",
"ReaderT.instMonad",
"Plausible.InjectiveFunction.instArbitraryInt.match_1",
"... | true |
HomotopicalAlgebra.CategoryWithCofibrations.recOn | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | [
"CategoryTheory.MorphismProperty",
"HomotopicalAlgebra.CategoryWithCofibrations.mk",
"CategoryTheory.Category.toCategoryStruct",
"HomotopicalAlgebra.CategoryWithCofibrations",
"HomotopicalAlgebra.CategoryWithCofibrations.rec",
"CategoryTheory.Category"
] | false |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.restrict_lintegral._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | [
"Finset",
"MeasureTheory.SimpleFunc",
"Membership.mem",
"MeasureTheory.SimpleFunc.instFunLike",
"MeasurableSpace",
"Finset.instSetLike",
"True",
"eq_true",
"MeasureTheory.SimpleFunc.range",
"MeasureTheory.SimpleFunc.mem_range_self",
"Eq",
"DFunLike.coe",
"SetLike.instMembership"
] | false |
LieAlgebra.isNilpotent_ad_of_mem_rootSpace | Mathlib.Algebra.Lie.Weights.Chain | [
"LieHom",
"LieAlgebra.toModule",
"Module.End.instRing",
"LieSubalgebra.lieAlgebra",
"LieSubmodule.instSetLike",
"Module.End.instMonoid",
"instSMulOfMul",
"LieRing.toAddCommGroup",
"LieSubalgebra.instSetLike",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieAlgebra.ad",
"LieMod... | true |
Nat.isLeast_nth_of_infinite | Mathlib.Data.Nat.Nth | [
"setOf",
"Set.Finite",
"Nat.isLeast_nth",
"instLENat",
"IsLeast",
"And",
"absurd",
"Set.Finite.toFinset",
"Nat",
"LT.lt",
"Finset.card",
"Nat.nth",
"instLTNat",
"Set.Infinite"
] | true |
CliffordAlgebra.reverseOp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | [
"CliffordAlgebra.ι",
"CommRing",
"CliffordAlgebra.lift_ι_apply",
"Ring.toNonAssocRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"CliffordAlgebra",
"AlgHom",
"MulOpposite.opLinearEquiv",
"instAlgebraCliffordAlgebra",
"AlgHom.funLike",
"MulOpposite.instAlgebra",
"MulOpposite... | true |
Std.Time.Modifier.s.noConfusion | Std.Time.Format.Basic | [
"Std.Time.Modifier.noConfusion",
"id",
"Std.Time.Modifier.s",
"Std.Time.Number",
"Std.Time.Modifier",
"Eq"
] | false |
Lean.Meta.Grind.mkExtension._auto_1 | Lean.Meta.Tactic.Grind.Extension | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Lean.ScopedEnvExtension.ScopedEntries.casesOn | Lean.ScopedEnvExtension | [
"Lean.ScopedEnvExtension.ScopedEntries.mk",
"Lean.PArray",
"Lean.ScopedEnvExtension.ScopedEntries",
"Lean.ScopedEnvExtension.ScopedEntries.rec",
"Lean.SMap",
"Lean.Name",
"Lean.Name.instBEq",
"Lean.instHashableName"
] | false |
NonUnitalSubsemiring.instSetLike | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | [
"SetLike",
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"AddZeroClass.toAddZero",
"AddSubmonoid.toAddSubsemigroup",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"SetLike.mk",
"NonUnitalSubsemiring.toAddSubmonoid",
"NonUnitalSubsemiring",
"AddZero.toAdd",
"AddCommMonoid.toAddMonoid",
... | true |
_private.Mathlib.CategoryTheory.Generator.Preadditive.0.CategoryTheory.Preadditive.isSeparating_iff._simp_1_1 | Mathlib.CategoryTheory.Generator.Preadditive | [
"AddGroup.toSubtractionMonoid",
"sub_eq_zero",
"HSub.hSub",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubNegMonoid.toSub",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"NegZeroClass.toZero",
"Eq"
] | false |
Lean.Server.handleCodeActionResolve | Lean.Server.CodeActions.Basic | [
"Pure.pure",
"Lean.Server.LazyCodeAction.lazy?",
"Lean.instMonadEnvOfMonadLift",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.NameMap",
"Lean.Server.RequestContext",
"Lean.Json",
"Lean.Server.Snapshots.Snapshot",
"_private.Lean.Server.CodeActions.Basic.0.Lean.Server.handleCo... | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.M.tell | Lean.Meta.Tactic.FunInd | [
"Pure.pure",
"Unit.unit",
"Array.push",
"Lean.Meta.State",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Prod.mk",
"Applicative.toPure",
"Array",
"Unit",
"Lean.Core.CoreM",
"StateRefT'",
"StateRefT'.instMonad",
"Lean.Core.instMonadCoreM",
"Prod",
"ReaderT.instApplicativeOfMonad",
... | true |
Lean.Elab.Rewrites.evalExact._regBuiltin.Lean.Elab.Rewrites.evalExact.declRange_3 | Lean.Elab.Tactic.Rewrites | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
Lean.Elab.Term.elabWithoutExpectedTypeAttr | Lean.Elab.App | [
"Inhabited.default",
"Lean.TagAttribute",
"Lean.instInhabitedTagAttribute"
] | true |
PseudoMetricSpace.noConfusionType | Mathlib.Topology.MetricSpace.Pseudo.Defs | [
"UniformSpace",
"PseudoMetricSpace.casesOn",
"Real.instLE",
"Real",
"iInf",
"Real.instZero",
"ENNReal.ofReal",
"Compl.compl",
"Filter.instInfSet",
"uniformity",
"setOf",
"Real.instLT",
"Membership.mem",
"Exists",
"Filter.sets",
"LE.le",
"Set.instCompl",
"Prod.fst",
"Real.instAdd"... | false |
Real.tendsto_rightDeriv_mul_log_atTop | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | [
"Iff.mpr",
"Real.instIsOrderedRing",
"Eq.mpr",
"Real.partialOrder",
"Real",
"Set.Ioi",
"Real.instArchimedean",
"Semiring.toModule",
"HMul.hMul",
"Real.denselyNormedField",
"Real.instZero",
"Real.instZeroLEOneClass",
"congrArg",
"tendsto_const_nhds",
"Filter.Eventually",
"AddMonoid.toAd... | true |
Lean.Kernel.Exception.toMessageData | Lean.Message | [
"Lean.instBEqFVarId",
"Lean.MessageData",
"Lean.Kernel.Exception",
"Std.instToFormatString",
"Array.mkEmpty",
"Lean.LocalContext.mk",
"Lean.PersistentArrayNode.node",
"Lean.FVarIdMap",
"String",
"Lean.MessageData.instAppend",
"Lean.instEmptyCollectionFVarIdMap",
"Function.comp",
"Lean.Reduci... | true |
Std.DTreeMap.Internal.Impl.getKeyD_alter! | Std.Data.DTreeMap.Internal.Lemmas | [
"Std.DTreeMap.Internal.Impl.getKeyD",
"Std.DTreeMap.Internal.Impl.alter!",
"Std.DTreeMap.Internal.Impl.alter_eq_alter!",
"instDecidableEqOrdering",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"Ord",
"congrArg",
"Std.DTreeMap.Internal.Impl.get?",
"Std.TransOrd",
"HSub.hSub",
"Ordering",
... | true |
Lean.Lsp.instFromJsonPartialResultParams | Lean.Data.Lsp.Basic | [
"Lean.Lsp.PartialResultParams",
"Lean.FromJson",
"Lean.FromJson.mk",
"Lean.Lsp.instFromJsonPartialResultParams.fromJson"
] | true |
isOpen_sum_iff | Mathlib.Topology.Constructions.SumProd | [
"Iff.rfl",
"Sum",
"Sum.inl",
"instTopologicalSpaceSum",
"TopologicalSpace",
"And",
"Iff",
"Set.preimage",
"Sum.inr",
"IsOpen",
"Set"
] | true |
UniformSpace.Completion.uniformSpace._proof_4 | Mathlib.Topology.UniformSpace.Completion | [
"UniformSpace",
"Filter.map",
"SeparationQuotient.instUniformSpace._proof_1",
"uniformity",
"Prod.map",
"CauchyFilter.instUniformSpace",
"Filter.Tendsto",
"SeparationQuotient",
"SeparationQuotient.mk",
"Prod.swap",
"CauchyFilter",
"Prod",
"UniformSpace.toTopologicalSpace",
"UniformSpace.Co... | false |
Monoid.toMulAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | [
"Monoid",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"MulOne.toMul",
"MulOneClass.toMulOne",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"one_mul",
"instHMul"
] | false |
subsingleton_iff_zero_eq_one | Mathlib.Algebra.GroupWithZero.Basic | [
"MulOne.toOne",
"inferInstance",
"MulZeroOneClass",
"uniqueOfZeroEqOne",
"MulZeroOneClass.toMulOneClass",
"Unique.instSubsingleton",
"MulOneClass.toMulOne",
"Iff",
"Iff.intro",
"One.toOfNat1",
"Zero.toOfNat0",
"Subsingleton",
"MulZeroOneClass.toMulZeroClass",
"Subsingleton.elim",
"OfNat.... | true |
Lean.instEmptyCollectionPrefixTree | Lean.Data.PrefixTree | [
"Ordering",
"EmptyCollection.mk",
"Lean.PrefixTree.empty",
"Lean.PrefixTree",
"EmptyCollection"
] | true |
Equiv.removeNone_aux_none | Mathlib.Logic.Equiv.Option | [
"Iff.mpr",
"Equiv.removeNone_aux",
"of_eq_false",
"False",
"Equiv.instEquivLike",
"Equiv.removeNone_aux._proof_1",
"congrArg",
"Option.not_isSome_iff_eq_none",
"Bool.false_eq_true",
"Option.some",
"Equiv",
"instDecidableEqBool",
"Option.some_get",
"Bool.true",
"Option.none",
"Option.ge... | true |
Int32.toISize_ofNat | Init.Data.SInt.Lemmas | [
"instPowNat",
"Eq.mpr",
"congrArg",
"HSub.hSub",
"Int32.maxValue",
"Int.decLe",
"Int32.toISize_ofNat'",
"id",
"instOfNatNat",
"Int",
"Int.instNatPow",
"LE.le",
"Int32.toInt",
"instLENat",
"Nat.cast",
"instHSub",
"HPow.hPow",
"instOfNat",
"ISize.instOfNat",
"Int32.toISize",
"N... | true |
MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | [
"MeasureTheory.ae",
"Iff.mpr",
"essSup_le_of_ae_le",
"ENNReal.ofNNReal",
"MeasureTheory.Measure",
"Filter.map",
"SeminormedAddGroup.toNNNorm",
"NNNorm.nnnorm",
"Filter.Eventually",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"Preorder.toLE",
"SeminormedAddGroup.toContinuou... | true |
ZeroLEOneClass.rec | Mathlib.Algebra.Order.ZeroLEOne | [
"One",
"ZeroLEOneClass.mk",
"ZeroLEOneClass",
"LE.le",
"LE",
"One.toOfNat1",
"Zero.toOfNat0",
"OfNat.ofNat",
"Zero"
] | false |
UpperHalfPlane.IsZeroAtImInfty.petersson_isZeroAtImInfty_left | Mathlib.NumberTheory.ModularForms.Petersson | [
"NormedCommRing.toSeminormedCommRing",
"Subgroup.HasDetPlusMinusOne",
"Real",
"Complex.instNormedAddCommGroup",
"OnePoint.infty",
"Units.instTopologicalSpaceUnits",
"Matrix",
"DiscreteTopology",
"ModularFormClass",
"instDecidableEqFin",
"Complex.instNormedField",
"PseudoMetricSpace.toUniformSp... | true |
List.Vector.instLawfulTraversableFlipNat | Mathlib.Data.Vector.Basic | [
"LawfulFunctor.mk",
"Traversable.toFunctor",
"Subtype.mk.congr_simp",
"congrArg",
"LawfulTraversable.mk",
"List.map",
"List.Vector.naturality",
"List.Vector",
"Subtype.casesOn",
"List.Vector.traverse_eq_map_id",
"Function.comp",
"flip",
"id",
"Subtype",
"List.map_map",
"List.Vector.map... | true |
SymbolicDynamics.FullShift.Pattern.rec | Mathlib.Dynamics.SymbolicDynamics.Basic | [
"Inhabited.default",
"SymbolicDynamics.FullShift.Pattern.mk",
"Finset",
"Membership.mem",
"SymbolicDynamics.FullShift.Pattern",
"Finset.instSetLike",
"Inhabited",
"Eq",
"Not",
"SetLike.instMembership"
] | false |
AddSubmonoid.instInfSet._proof_2 | Mathlib.Algebra.Group.Submonoid.Basic | [
"AddSubmonoid.add_mem",
"Set.iInter",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid",
"AddSubmonoid.instInfSet._proof_1",
"instHAdd",
"AddZeroClass",
"SetLike.coe",
"HAdd.hAdd",
"AddZero.toAdd",
"AddSubmonoid.instSetLike",
"Set.instMembership",
"Set.mem_biInter",
"Set"
] | false |
PFunctor.Approx.Agree.continu | Mathlib.Data.PFunctor.Univariate.M | [
"PFunctor",
"instOfNatNat",
"PFunctor.Approx.Agree",
"PFunctor.Approx.Agree.continu",
"PFunctor.Approx.CofixA",
"Nat",
"OfNat.ofNat"
] | true |
SlashInvariantForm.constℝ._proof_1 | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | [
"Int.instAddCommGroup",
"UpperHalfPlane.glAction",
"Real.instIsOrderedRing",
"Units.val",
"NormedCommRing.toSeminormedCommRing",
"MulOne.toOne",
"Subgroup.HasDetPlusMinusOne",
"Real",
"instHSMul",
"MonoidHom.instFunLike",
"InvOneClass.toOne",
"RCLike.toNormedAlgebra",
"HMul.hMul",
"Real.la... | false |
Eq.mpr_prop | Init.SimpLemmas | [
"Eq.rec",
"Eq.symm",
"Eq"
] | true |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.congr._simp_1_1 | Mathlib.Analysis.Analytic.Basic | [
"Membership.mem",
"Insert.insert",
"Set.instInsert",
"propext",
"Or",
"Set.mem_insert_iff",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Mathlib.Data.QPF.Multivariate.Basic.0.MvQPF.mem_supp._proof_1_1 | Mathlib.Data.QPF.Multivariate.Basic | [
"False",
"eq_false",
"Lean.Grind.iff_eq",
"HEq.refl",
"Set.univ",
"Classical.byContradiction",
"Set.mem_image",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"MvFunctor.LiftP",
"MvPFunctor.A",
"And.casesOn",
"MvQPF.toMvFunctor",
"And",
"Iff",
"Exists.casesOn",
"Nat",
"True",
"eq... | false |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_6 | Mathlib.Algebra.Lie.CartanExists | [
"LieSubmodule.instSetLike",
"Submodule",
"CommRing",
"LieSubmodule.mem_mk_iff'",
"Submodule.toAddSubmonoid",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"Bracket.bracket",
"LieSubmodule",
"AddSubsemigroup.carrier",
"Membership.mem",
"AddZeroClass.to... | false |
Lean.Meta.SynthInstance.Waiter.recOn | Lean.Meta.SynthInstance | [
"Lean.Meta.SynthInstance.Waiter.consumerNode",
"Lean.Meta.SynthInstance.ConsumerNode",
"Lean.Meta.SynthInstance.Waiter",
"Lean.Meta.SynthInstance.Waiter.rec",
"Lean.Meta.SynthInstance.Waiter.root"
] | false |
LieIdeal.lcs | Mathlib.Algebra.Lie.Nilpotent | [
"CommRing",
"LieSubmodule.instTop",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Bracket.bracket",
"LieSubmodule",
"AddCommGroup",
"LieSubmodule.hasBracket",
"Nat.iterate",
"LieRing",
"CommRing.toCommSemiring",
"Nat",
"LieRingModule",
"LieIdeal",
"LieAlgebra",
"Module",
... | true |
ExteriorAlgebra.ι | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | [
"CliffordAlgebra.ι",
"CommRing",
"Semiring.toModule",
"QuadraticMap.instZero",
"Ring.toNonAssocRing",
"ExteriorAlgebra",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"instAlgebraCliffordAlgebra",
"QuadraticForm",
"AddCommGroup",
"Algebra.toModule",
"NonUnitalNonAssocRing.toNonU... | true |
AddSubmonoid.leftNeg | Mathlib.GroupTheory.Submonoid.Inverses | [
"AddSubmonoid.leftNeg._proof_1",
"AddMonoid.toAddZeroClass",
"setOf",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"Subtype",
"AddSubmonoid",
"AddSubmonoid.mk",
"AddSubsemigroup.mk",
"AddSubmonoid.leftNeg._proof_2",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"AddMonoid",
"AddZ... | true |
CategoryTheory.Bicategory.Adj.Hom.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory",
"And",
"CategoryTheory.Bicategory.Adj.Hom.mk",
"And.intro",
"eq_of_heq",
"HEq",
"CategoryTheory.Bicategory.Adj.Hom.mk.noConfusion",
"CategoryTheory.Bicategory.Adj.Ho... | true |
Matrix.projVandermonde_map | Mathlib.LinearAlgebra.Vandermonde | [
"RingHom.instRingHomClass",
"CommRing",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"Matrix",
"instDecidableEqFin",
"HSub.hSub",
"RingHom",
"RingHomClass.toMonoidWithZeroHomClass",
"instSubNat",
"NonAssocSemiring.toMulZeroOneClass",
"instOfNatNat",
"map_pow",
"MonoidWithZeroHomCl... | true |
CategoryTheory.Subobject.isoOfEqMk_inv | Mathlib.CategoryTheory.Subobject.Basic | [
"CategoryTheory.Subobject.underlying",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"Preorder.smallCategory",
"CategoryTheory.instPartialOrderSubobject",
"CategoryTheory.Subobject.isoOfEqMk._proof_3",
"CategoryTheory.Subobject.mk",
"Eq.r... | true |
Finset.noncommProd_singleton | Mathlib.Data.Finset.NoncommProd | [
"Monoid",
"Multiset.map",
"Monoid.toMulOneClass",
"Finset",
"List.map",
"Finset.noncommProd_singleton._proof_1",
"Membership.mem",
"Multiset",
"Finset.val",
"Finset.noncommProd",
"Subtype.mk",
"Multiset.instMembership",
"List.pmap._proof_1",
"mul_one",
"Finset.instSingleton",
"Singleto... | true |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.symm_mem_dilatransvections_iff._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Basic | [
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"SubNegMonoid",
"AddZeroClass.toAddZero",
"SubNegMonoid.toSub",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"SubNegMonoid.toNeg",
"AddZero.toAdd",
"SubNegMonoid.toAddMonoid",
"Eq.symm",
"Eq",
"Neg.neg"
] | false |
CategoryTheory.SimplicialObject.σ_δ₀Iter_assoc | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | [
"CategoryTheory.Category.assoc",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"instOfNatNat",
"CategoryTheory.SimplicialObject.σ_δ₀Iter._auto_3",
"LE.le",
"CategoryTheory.SimplicialObject.σ_δ₀Iter._proof_6"... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr_v_descCochain_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | [
"Lean.RArray.leaf",
"False",
"HMul.hMul",
"congrArg",
"Classical.byContradiction",
"Eq.mp",
"Lean.RArray.branch",
"Int.Linear.Expr.add",
"id",
"Lean.RArray",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Int.Linear.Poly.num",
"Int.instMul",
"Int.Linear.Poly.add",
"Int.Linear.norm_eq",
... | false |
String.Pos.instLinearOrderPackage._proof_9 | Init.Data.String.OrderInstances | [
"String",
"String.instDecidableLePos",
"Max",
"inferInstance",
"LE.le",
"Max.leftLeaningOfLE",
"Std.max_eq_if",
"LE",
"Std.instLawfulOrderLeftLeaningMax",
"DecidableLE",
"Max.max",
"String.Pos",
"String.instLEPos",
"Eq",
"ite"
] | false |
FirstOrder.Language.Theory.ModelsBoundedFormula.eq_1 | Mathlib.ModelTheory.Equivalence | [
"FirstOrder.Language.Theory.ModelType",
"FirstOrder.Language.Theory.ModelType.struc",
"FirstOrder.Language.Theory.ModelsBoundedFormula",
"FirstOrder.Language.Theory",
"FirstOrder.Language.BoundedFormula.Realize",
"Nat",
"FirstOrder.Language.Theory.ModelType.Carrier",
"Eq.refl",
"FirstOrder.Language"... | true |
ContinuousMap.mem_setOfIdeal | Mathlib.Topology.ContinuousMap.Ideals | [
"Mathlib.Tactic.Push.not_forall_eq",
"Eq.mpr",
"Semiring.toModule",
"_private.Mathlib.Topology.ContinuousMap.Ideals.0.ContinuousMap.mem_setOfIdeal._simp_1_3",
"congrArg",
"IsTopologicalSemiring",
"Compl.compl",
"ContinuousMap",
"Iff.rfl",
"setOf",
"Membership.mem",
"Exists",
"id",
"Continu... | true |
PowerSeries.idealX._proof_1 | Mathlib.RingTheory.LaurentSeries | [
"Eq.mpr",
"Semiring.toModule",
"Ideal.span_singleton_eq_bot",
"congrArg",
"CommSemiring.toSemiring",
"Field.instIsLocalRing",
"Set.instSingletonSet",
"id",
"Ne",
"Bot.bot",
"PowerSeries.X",
"Ideal",
"MvPowerSeries.instCommRing",
"ne_eq",
"Field.toSemifield",
"Field.toCommRing",
"NonU... | false |
Graph.deleteEdges_le._simp_1 | Mathlib.Combinatorics.Graph.Delete | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Graph",
"LE.le",
"Graph.deleteEdges",
"True",
"eq_true",
"Graph.instPartialOrder",
"Eq",
"Graph.deleteEdges_le",
"Set"
] | false |
Lean.Parser.Command.prefix.formatter | Lean.Parser.Syntax | [
"Lean.PrettyPrinter.Formatter",
"Lean.Parser.withCache.formatter",
"Lean.Parser.leadingNode.formatter",
"instOfNatNat",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Lean.Parser.symbol.formatter",
"Bool.true",
"Nat",
"OfNat.ofNat",
"Bool.false",
"Lean.Parser.mkAntiquot.formatter",
"L... | true |
Std.DTreeMap.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Const.modify",
"Ord.mk",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.Internal.Impl.Const.minKey?_modify_eq_minKey?",
"Std.LawfulEqCmp",
"Std.DTreeMap.wf",
"Std.DTreeMap.minKey?",
"Eq",
"Option"
] | true |
Orthonormal.exists_hilbertBasis_extension | Mathlib.Analysis.InnerProductSpace.l2Space | [
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"Submodule",
"exists_maximal_orthonormal",
"CompleteSpace",
"Orthonormal",
"congrArg",
"HilbertBasis",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Membership.mem",
"NormedField.toField",
"Exists",... | true |
RootPairing.ofBilinear._proof_4 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | [
"Subtype.mk.congr_simp",
"CommRing",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LinearMap.IsReflective",
"setOf",
"Membership.mem",
"... | false |
snd_himp | Mathlib.Order.Heyting.Basic | [
"HImp",
"Prod.instHImp",
"Prod",
"Eq",
"Prod.snd",
"rfl",
"HImp.himp"
] | true |
Bimod.AssociatorBimod.homAux._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.MonoidalCategory.whisker_exchange",
"CategoryTheory.Limits.PreservesColimitsOfSize",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"Bimod.TensorBimod.X._proof_1",
"Bimod.TensorBimod.whiskerLeft_π_actLeft",
"CategoryTheory.CategoryStruct... | false |
AddCon.mkAddHom_apply | Mathlib.GroupTheory.Congruence.Hom | [
"AddCon",
"AddHom",
"AddCon.hasAdd",
"AddHom.funLike",
"Eq.refl",
"AddCon.Quotient",
"Eq",
"DFunLike.coe",
"AddCon.toQuotient",
"AddCon.mkAddHom",
"Add"
] | true |
MulSemiringActionHom.comp._proof_4 | Mathlib.GroupTheory.GroupAction.Hom | [
"Monoid",
"MulOne.toOne",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"MulOne.toMul",
"NonAssocSemiring.toMulZeroOneClass",
"MulSemiringActionHom",
"MulZeroOneClass.toMulOneClass",
"MulSemiringActionHom.comp._proof_2",
"RingHom.comp",
"MulOneClass.toMulOne",
"OneHom.toFun",
"RingHomC... | false |
ContinuousMap.instNonUnitalNormedRing._proof_3 | Mathlib.Topology.ContinuousMap.Compact | [
"NonUnitalSeminormedRing",
"HMul.hMul",
"NonUnitalNonAssocRing.toMul",
"ContinuousMap",
"ContinuousMap.instNonUnitalSeminormedRing",
"AddMonoid.toZero",
"NonUnitalNonAssocRing.toAddCommGroup",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"NonUnitalRing.toNonUnitalNonAssocRing",
... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.