name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
AffineSubspace.subtypeA_toAffineMap | Mathlib.Topology.Algebra.AffineSubspace | [
"Submodule",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddCommGroup",
"Subtype",
"Submodule.module",
"AffineMap",
"AffineSubspace.toAddTorsor",
"AffineSubspace.subtypeA",
"AffineSubspace.instSetLike",
"TopologicalSpace",
"AffineSubspace.subtype",
"Submod... | true |
Lean.Parser.Term.ident._regBuiltin.Lean.Parser.Term.ident_1 | Lean.Parser.Term | [
"IO",
"Unit",
"Lean.Parser.addBuiltinLeadingParser",
"Lean.Parser.Term.ident",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | false |
Std.Iterators.Types.StepSizeIterator.instIterator._proof_2 | Std.Data.Iterators.Combinators.Monadic.StepSize | [
"Std.IterM.IsPlausibleNthOutputStep",
"Std.IterStep",
"Std.PlausibleIterStep",
"Function.comp",
"Std.Iterators.Types.StepSizeIterator.nextIdx",
"Std.IterStep.mapIterator",
"Std.Iterators.Types.StepSizeIterator.instIterator._proof_3",
"Std.IterM.mk",
"Std.IterM.internalState",
"Std.Iterator",
"St... | false |
Std.DTreeMap.Internal.Impl.alter.match_1 | Std.Data.DTreeMap.Internal.Operations | [
"HSub.hSub",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"instHSub",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.casesOn",
"HAdd.hAdd",
"Nat",
"in... | false |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.toExprCore._sunfold | Lean.Elab.Extra | [
"Pure.pure",
"_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.mkUnOp",
"Lean.Elab.InfoState.mk",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.mkBinOp",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.Elab.InfoState",
"instMonadControlTOfPure",
"Lean.Meta.Sta... | false |
Lean.Compiler.LCNF.Simp.instReprFunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfo | [
"Lean.Compiler.LCNF.Simp.FunDeclInfo",
"Repr.mk",
"Lean.Compiler.LCNF.Simp.instReprFunDeclInfo.repr",
"Repr"
] | true |
_private.Std.Data.ByteSlice.0.ByteSlice.forM.loop.eq_def | Std.Data.ByteSlice | [
"Pure.pure",
"ByteSlice",
"Monad.toApplicative",
"InvImage",
"HSub.hSub",
"_private.Std.Data.ByteSlice.0.ByteSlice.forM.loop",
"_private.Std.Data.ByteSlice.0.ByteSlice.forM.loop._proof_1",
"WellFounded.Nat.fix",
"WellFounded.Nat.fix_eq",
"ByteSlice.size",
"id",
"instSubNat",
"ByteSlice.instG... | true |
instIsPreorderLe | Mathlib.Order.RelClasses | [
"instReflLe",
"Preorder.toLE",
"LE.le",
"instIsTransLe",
"IsPreorder.mk",
"IsPreorder",
"Preorder"
] | true |
SimpleGraph.IsPathGraph3Compl.fst_ne_snd | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | [
"SimpleGraph.Adj.ne",
"SimpleGraph.IsPathGraph3Compl",
"Ne",
"SimpleGraph",
"SimpleGraph.IsPathGraph3Compl.adj"
] | true |
BitVec.toInt_sdiv | Init.Data.BitVec.Bitblast | [
"BitVec.neg_zero",
"Int.tdiv_neg",
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"HSub.hSub",
"Int.decLe",
"BitVec.neg_one_eq_allOnes",
"_private.Init.Data.BitVec.Bitblast.0.BitVec.toInt_sdiv._proof_1_1",
"BitVec.allOnes",
"BitVec",
"Eq.rec",
"Eq.mp",
"BitVec.toInt_intMin_of_pos",
"... | true |
Module.Relations.instAddCommGroupQuotient._proof_7 | Mathlib.Algebra.Module.Presentation.Basic | [
"Semiring.toModule",
"Finsupp.module",
"Ring.toNonAssocRing",
"Module.Relations.Quotient",
"Add.mk",
"Module.Relations.instAddCommGroupQuotient._aux_1",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Module.Relations.relation",
"AddSemigroup.mk",
"Module.Relations.instAddCommGroupQuotient._... | false |
smoothPresheafRing._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | [
"RingCat.ofHom",
"RingCat.of",
"instRingObjOppositeOpensCarrierOfPresheafSmoothSheaf",
"Opposite",
"NormedSpace",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"instTopENat",
"TopologicalSpace.Opens.instPartialOrder",
"PartialOrder.toPreorder",
"ContMDiffMap.restrictRingHom",
"Quiver... | false |
CategoryTheory.Pseudofunctor.isStackFor_ofArrows_iff | Mathlib.CategoryTheory.Sites.Descent.DescentData | [
"Eq.mpr",
"CategoryTheory.Over",
"CategoryTheory.Sieve.ofArrows_category'",
"Opposite",
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pseudofunctor.IsStackFor",
"congrArg",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.... | true |
Lean.Meta.InjectionResult.rec | Lean.Meta.Tactic.Injection | [
"Lean.MVarId",
"Lean.FVarId",
"Array",
"List",
"Lean.Meta.InjectionResult.subgoal",
"Lean.Meta.InjectionResult.solved",
"Lean.Name",
"Lean.Meta.InjectionResult"
] | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk | Lean.Server.ProtocolOverview | [
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind",
"String",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk",
"Array",
"Lean.JsonRpc.MessageDirecti... | true |
Lean.Lsp.Ipc.waitForExit | Lean.Data.Lsp.Ipc | [
"Lean.Lsp.Ipc.IpcM",
"instMonadReaderOfReaderTOfMonad",
"ReaderT",
"instMonadLiftT",
"IO",
"MonadReader.read",
"IO.Process.Child.wait",
"ReaderT.instMonad",
"EIO",
"liftM",
"instMonadEIO",
"ReaderT.instMonadLift",
"IO.Process.Child",
"Lean.Lsp.Ipc.ipcStdioConfig",
"instMonadReaderOfMonad... | true |
Monoid.CoprodI.Word.Pair.tail | Mathlib.GroupTheory.CoprodI | [
"Monoid",
"Monoid.CoprodI.Word",
"Monoid.CoprodI.Word.Pair"
] | true |
AddAction.BlockMem.instBoundedOrder._proof_2 | Mathlib.GroupTheory.GroupAction.Blocks | [
"AddMonoid.toAddSemigroup",
"Set.subset_univ",
"Set.univ",
"Subtype.casesOn",
"Membership.mem",
"Subtype",
"HasSubset.Subset",
"LE.le",
"Subtype.mk",
"And.casesOn",
"AddAction",
"AddAction.toAddSemigroupAction",
"And",
"AddGroup",
"AddSemigroupAction.toVAdd",
"AddGroup.toSubNegMonoid",... | false |
torusMap.eq_1 | Mathlib.MeasureTheory.Integral.TorusIntegral | [
"Real",
"HMul.hMul",
"torusMap",
"Complex.instMul",
"Complex.ofReal",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Complex.exp",
"Eq.refl",
"Complex.instAdd",
"Complex",
"Fin",
"Eq",
"instHMul",
"Complex.I"
] | true |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT_hom_app_fac_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | [
"WithBot.instPreorder",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"WithTop.instPreorder",
"congrArg",
"CategoryTheory.Functor.Additive",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.... | true |
FinBddDistLat.Iso.mk._proof_11 | Mathlib.Order.Category.FinBddDistLat | [
"Lattice.toSemilatticeSup",
"BddDistLat.isBoundedOrder",
"SupHom.toFun",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"FinBddDistLat.instDistribLatticeCarrier",
"SemilatticeSup.toMax",
"DistLat.str",
"DistribLattice.toLattice",
"OrderIso",
"FinBddDistLat.Iso.mk.... | false |
Lean.IR.UnboxResult.initFn._@.Lean.Compiler.IR.UnboxResult.1925234477._hygCtx._hyg.2 | Lean.Compiler.IR.UnboxResult | [
"Pure.pure",
"Lean.getConstInfo",
"Lean.MessageData",
"Lean.MonadError.mk",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Core.instMonadRefCoreM",
"Lean.AttrM",
"String",
"Lean.Core.instMonadEnvCoreM",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMonad",
"IO",
"Lean.Mess... | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_eq_of_size_le_stop._proof_1_2 | Batteries.Data.Array.Lemmas | [
"Lean.Grind.Nat.lt_eq",
"instOfNatNat",
"LE.le",
"instLENat",
"Array.extract",
"Array",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Eq.substr",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"Array.size"
] | false |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.revMatchesAt_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Pred | [
"String.Slice.Pos.prev",
"String.Slice.Pattern.Model.CharPred.Decidable.instPatternModelForallCharPropOfDecidablePred",
"String.Slice.Pattern.Model.CharPred.Decidable.isLongestRevMatchAt_iff",
"String.Slice.Pattern.Model.CharPred.isLongestRevMatchAt_iff._proof_1",
"String.Slice",
"Exists",
"Ne",
"Stri... | false |
Std.Tactic.BVDecide.BoolExpr._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | [
"Std.Tactic.BVDecide.BoolExpr",
"Std.Tactic.BVDecide.BoolExpr._sizeOf_1",
"SizeOf.mk",
"SizeOf"
] | false |
AffineSubspace.direction_mk' | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | [
"AffineSubspace.self_mem_mk'",
"Eq.mpr",
"Submodule",
"AffineSubspace.vadd_mem_mk'",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"AffineSubspace.mk'",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"AddCommGroup",
"AffineSubspace.mem_directi... | true |
Aesop.RuleBuilderOptions.casesOn | Aesop.Builder.Basic | [
"Aesop.IndexingMode",
"Aesop.RuleBuilderOptions",
"Aesop.RuleBuilderOptions.mk",
"Lean.Syntax.Term",
"Aesop.RuleBuilderOptions.rec",
"Lean.Meta.TransparencyMode",
"Array",
"Aesop.CasesPattern",
"Lean.Name",
"Option"
] | false |
_private.Lean.Util.SCC.0.Lean.SCC.updateLowLinkOf | Lean.Util.SCC | [
"Lean.SCC.Data.onStack",
"Option.some",
"Lean.SCC.Data.mk",
"_private.Lean.Util.SCC.0.Lean.SCC.modifyDataOf",
"Unit",
"Nat",
"LT.lt",
"Nat.decLt",
"Lean.SCC.Data.index?",
"Hashable",
"instLTNat",
"Lean.SCC.Data",
"BEq",
"_private.Lean.Util.SCC.0.Lean.SCC.updateLowLinkOf.match_1",
"Lean.S... | true |
instLinearOrderedAddCommGroupWithTopOrderDualAdditive._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | [
"CommMonoidWithZero.toCommMonoid",
"OrderDual.instLE",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Additive.orderBot",
"Additive.linearOrder",
"AddMonoid.toAddSemigroup",
"congrArg",
"LinearOrderedCommMonoidWithZero.toOrderBot",
"Additive",
"PartialOrder.toPreorder",
"Li... | false |
_private.Mathlib.Data.List.Pairwise.0.List.Pairwise.rel_head_of_rel_head_head._proof_1_4 | Mathlib.Data.List.Pairwise | [
"False",
"Lean.Grind.nestedProof",
"eq_false",
"False.elim",
"noConfusion_of_Nat",
"cast",
"Membership.mem",
"List.ne_nil_of_mem",
"Lean.Grind.not_eq_of_eq_false",
"List.cons",
"List",
"List.instMembership",
"True",
"eq_true",
"Eq.symm",
"Eq",
"List.ctorIdx",
"Not",
"Eq.trans",
... | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_add_eq_toReal_add_toReal._simp_1_9 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | [
"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 |
Aesop.MVarClusterData.ctorIdx | Aesop.Tree.Data | [
"Aesop.MVarClusterData",
"Nat"
] | false |
Finset.powersetCard_nonempty_of_le | Mathlib.Data.Finset.Powerset | [
"Iff.mpr",
"Finset",
"LE.le",
"instLENat",
"Finset.powersetCard",
"Nat",
"Finset.Nonempty",
"Finset.powersetCard_nonempty",
"Finset.card"
] | true |
Nat.divisorsAntidiagonal_eq_prod_filter_of_le | Mathlib.NumberTheory.Divisors | [
"Eq.mpr",
"MulOne.toOne",
"le_refl",
"Nat.instMulZeroClass",
"Preorder.toLT",
"IsOrderedRing.toPosMulMono",
"HMul.hMul",
"Nat.divisorsAntidiagonal",
"and_true",
"IsStrictOrderedRing.toMulPosStrictMono",
"SProd.sprod",
"congrArg",
"Finset",
"_private.Mathlib.NumberTheory.Divisors.0.Nat.divi... | true |
LipschitzWith.hasFDerivAt_of_hasLineDerivAt_of_closure | Mathlib.Analysis.Calculus.Rademacher | [
"Filter.instMembership",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Iff.mpr",
"HasFDerivAt",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NormedCommRing.toSeminormedCommRing",
"NonAssocSemiring.... | true |
Lean.Grind.Ring.OfSemiring.toQ_inj | Init.Grind.Ring.Envelope | [
"Lean.Grind.AddRightCancel.add_right_cancel",
"Lean.Grind.AddRightCancel",
"congrArg",
"Lean.Grind.Ring.OfSemiring.r",
"Lean.Grind.AddCommMonoid.zero_add",
"Lean.Grind.Ring.OfSemiring.toQ",
"Exists",
"Lean.Grind.Semiring.toAdd",
"Eq.mp",
"id",
"Lean.Grind.AddCommMonoid.toZero",
"Prod.mk",
"L... | true |
IsAddUnit.of_leftInverse | Mathlib.Algebra.Group.Units.Hom | [
"Function.LeftInverse",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"Eq.mp",
"AddMonoidHomClass",
"IsAddUnit",
"IsAddUnit.map",
"AddMonoid",
"DFunLike.coe",
"FunLike"
] | true |
Filter.instNSMul.eq_1 | Mathlib.Order.Filter.Pointwise | [
"Filter.instAdd",
"SMul",
"Filter.instNSMul",
"SMul.mk",
"Filter.instZero",
"nsmulRec",
"Nat",
"Eq.refl",
"Eq",
"Filter",
"Add",
"Zero"
] | true |
CategoryTheory.FreeBicategory.normalize._proof_8 | Mathlib.CategoryTheory.Bicategory.Coherence | [
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Path.nil",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.Paths.categoryPaths",
"CategoryTheory.Paths",
"CategoryTheory.eqToIso",
"CategoryTheor... | false |
Array.findSome?_eq_none_iff._simp_1 | Init.Data.Array.Find | [
"Array.instMembership",
"Membership.mem",
"Array",
"Option.none",
"Array.findSome?",
"propext",
"Array.findSome?_eq_none_iff",
"Eq",
"Option"
] | false |
GradedRingHom.one_def | Mathlib.RingTheory.GradedAlgebra.RingHom | [
"SetLike",
"GradedRingHom",
"GradedRingHom.instOne",
"Semiring",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"GradedRingHom.id",
"rfl"
] | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnLE._proof_1_6 | Batteries.Data.BitVec.Lemmas | [
"Int.Linear.not_eq_norm_expr",
"instDecidableNot",
"BitVec.msb_eq_getMsbD_zero",
"of_eq_false",
"Lean.Grind.CommRing.le_norm_expr",
"Lean.Grind.instOrderedRingInt",
"Lean.RArray.leaf",
"False",
"dite_congr",
"HMul.hMul",
"Lean.Grind.CommRing.Expr.mul",
"Int.Linear.norm_le",
"Lean.Grind.neste... | false |
CategoryTheory.RepresentablyFlat.mk._flat_ctor | Mathlib.CategoryTheory.Functor.Flat | [
"CategoryTheory.Functor",
"CategoryTheory.IsCofiltered",
"CategoryTheory.RepresentablyFlat",
"CategoryTheory.instCategoryStructuredArrow",
"CategoryTheory.RepresentablyFlat.mk",
"CategoryTheory.StructuredArrow",
"CategoryTheory.Category"
] | false |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiFst | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | [
"CategoryTheory.Limits.BinaryBicone.fst",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Limits.BinaryBicone.retract_left",
"CategoryTheory.Limits.BinaryBicone.pt",
"CategoryTheory.IsSplitEpi",
"CategoryTheory.Limits.BinaryBicone",
"CategoryTheory.Retract.instIsSplitEpiR",
"CategoryTheory.C... | true |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsClosure.0.CategoryTheory.ObjectProperty.strictLimitsClosureStep_strictLimitsClosureIter_eq_self._simp_1_2 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | [
"iSup",
"Prop.instCompleteLattice",
"Exists",
"propext",
"CompleteSemilatticeSup.toSupSet",
"CategoryTheory.Category.toCategoryStruct",
"CompleteLattice.toCompleteSemilatticeSup",
"Eq",
"Pi.supSet",
"CategoryTheory.ObjectProperty",
"CategoryTheory.Category",
"CategoryTheory.ObjectProperty.prop... | false |
CategoryTheory.EnrichedOrdinaryCategory.homEquiv_comp._autoParam | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Filter.coprod_cocompact | Mathlib.Topology.Compactness.Compact | [
"Filter.instMembership",
"Iff.mpr",
"Set.instSProd",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"SProd.sprod",
"congrArg",
"Compl.compl",
"IsCompact.prod",
"Filter.instCompleteLatticeFilter",
"Set.univ",
"IsCompact.compl_mem_cocompact",
"PartialOrder.toPreorder",
"Set.univ_prod",
"instTopolog... | true |
UnitAddTorus.mFourierBasis | Mathlib.Analysis.Fourier.AddCircleMulti | [
"MeasureTheory.L2.innerProductSpace",
"fact_one_le_two_ennreal",
"Complex.instNormedAddCommGroup",
"UnitAddTorus.mFourierBasis._proof_3",
"HilbertBasis",
"HilbertBasis.mk",
"MeasureTheory.MeasureSpace.toMeasurableSpace",
"Nat.instAtLeastTwoHAddOfNat",
"PseudoMetricSpace.toUniformSpace",
"AddCommGr... | true |
Int8.and_self | Init.Data.SInt.Bitwise | [
"Int8",
"BitVec",
"Int8.toBitVec_inj",
"instOfNatNat",
"Nat",
"Iff.mp",
"Int8.toBitVec",
"HAnd.hAnd",
"OfNat.ofNat",
"Eq",
"instHAndOfAndOp",
"instAndOpInt8",
"BitVec.and_self"
] | true |
Real.rpowIntegrand₀₁_le_rpow_sub_two_mul_self | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Real.instIsOrderedRing",
"div_le_div₀",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"mul_nonneg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"Mathlib.Tactic.Ring.Common.div_congr",
"le_ref... | true |
StandardEtalePair.mk | Mathlib.RingTheory.Etale.StandardEtale | [
"Polynomial.derivative",
"CommRing",
"Semiring.toModule",
"HMul.hMul",
"CommSemiring.toSemiring",
"LinearMap.instFunLike",
"Exists",
"StandardEtalePair.mk",
"Polynomial.instAdd",
"LinearMap",
"Polynomial",
"Monoid.toPow",
"Polynomial.Monic",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"... | true |
Std.DTreeMap.Internal.Impl.getKeyLE? | Std.Data.DTreeMap.Internal.Queries | [
"Ord",
"Std.DTreeMap.Internal.Impl.getKeyLE?.go",
"Option.none",
"Std.DTreeMap.Internal.Impl",
"Option"
] | true |
CategoryTheory.Limits.CokernelCofork.IsColimit.ofπOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Kernels | [
"CategoryTheory.Limits.HasZeroMorphisms",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"Quiver.Hom.op_inj",
"Quiver.Hom.unop",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"Opposite.op",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.oppo... | false |
IsometryEquiv.image_closedBall | Mathlib.Topology.MetricSpace.Isometry | [
"Eq.mpr",
"Real",
"IsometryEquiv.instEquivLike",
"congrArg",
"id",
"IsometryEquiv.symm",
"PseudoMetricSpace",
"IsometryEquiv.symm_symm",
"Set.preimage",
"Eq.refl",
"Set.image",
"Metric.closedBall",
"Eq.symm",
"Eq",
"DFunLike.coe",
"IsometryEquiv",
"IsometryEquiv.preimage_symm",
"Is... | true |
_private.Mathlib.NumberTheory.RamificationInertia.Ramification.0.Ideal.ramificationIdx_comap_eq._simp_1_1 | Mathlib.NumberTheory.RamificationInertia.Ramification | [
"Semiring.toModule",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Ideal.map",
"Submodule.instPartialOrder",
"LE.le",
"Ideal",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Ideal.map_le_iff_le_comap",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Ideal.comap",
"propext",
"Semiring",
"Sem... | false |
IsAlgClosure.isGalois | Mathlib.FieldTheory.Galois.Basic | [
"instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddGroupWithOne.toAddMonoidWithOne",
"Algebra",
"DivisionSemiring.toGroupWithZero",
"Field.toDivisionRing",
"Algebra.toModule",
"IsGalois",
"DivisionRing.toRing",
"SubtractionMonoid.toS... | true |
CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | [
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.Limits.HasLimitsOfShape",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.HasLimit",
"CategoryTheory.Limits.lim",
"CategoryTheory.Limits.hasLimitOfHasLimitsOfShape",
"CategoryTheory.Cate... | false |
InfTopHom.mk | Mathlib.Order.Hom.BoundedLattice | [
"InfHom.toFun",
"InfHom",
"Min",
"InfTopHom.mk",
"InfTopHom",
"Top.top",
"Eq",
"Top"
] | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.Slice.intercalate.go.eq_def | Init.Data.String.Lemmas.Intercalate | [
"List.brecOn",
"Eq.mpr",
"List.brecOn.go",
"List.brecOn.eq",
"congrArg",
"String",
"_private.Init.Data.String.Slice.0.String.Slice.intercalate.go",
"String.Slice",
"_private.Init.Data.String.Slice.0.String.Slice.intercalate.go._f",
"id",
"_private.Init.Data.String.Lemmas.Intercalate.0.String.Sli... | true |
IsAddUnit.add_iff | Mathlib.Algebra.Group.Units.Defs | [
"AddMonoid.toAddZeroClass",
"IsAddUnit.add",
"AddZeroClass.toAddZero",
"isAddUnit_of_add_isAddUnit_left",
"IsAddUnit",
"instHAdd",
"And",
"Iff",
"And.right",
"And.left",
"HAdd.hAdd",
"And.intro",
"Iff.intro",
"AddMonoid",
"AddZero.toAdd",
"isAddUnit_of_add_isAddUnit_right",
"IsDedeki... | true |
Aesop.RulePatternIndex.get | Aesop.Index.RulePattern | [
"Aesop.BaseM",
"Aesop.RuleName",
"StateRefT'.instAlternativeOfMonad",
"Aesop.RulePatternIndex",
"Lean.Expr",
"Aesop.Substitution",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Array",
"Aesop.RulePatternSubstMap.ofArray",
"Lean.Meta.instMonadMetaM",
"Aesop.BaseM.State",
"Aesop.RulePatternSubstMap",
... | true |
WithTop.coe_wcovBy_top._simp_2 | Mathlib.Order.Cover | [
"WithTop.instPreorder",
"Preorder.toLE",
"WithTop.some",
"WithTop.coe_wcovBy_top",
"WithTop.top",
"WCovBy",
"propext",
"Top.top",
"Eq",
"Preorder",
"IsMax",
"WithTop"
] | false |
Lean.Compiler.LCNF.CompilerM.State.mk | Lean.Compiler.LCNF.CompilerM | [
"Lean.Compiler.LCNF.CompilerM.State",
"Nat",
"Lean.Compiler.LCNF.CompilerM.State.mk",
"Lean.Compiler.LCNF.LCtx"
] | true |
List.Mem.tail | Init.Data.List.Basic | [
"List.Mem.tail",
"List.cons",
"List",
"List.Mem"
] | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Model.0.Lean.Meta.Grind.Arith.Cutsat.getCutsatAssignment?.match_4 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Model | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Model.0.Lean.Meta.Grind.Arith.Cutsat.getCutsatAssignment?._sparseCasesOn_1",
"Option"
] | false |
UInt8.ofNatLT_shiftLeft._proof_1 | Init.Data.UInt.Bitwise | [
"of_decide_eq_true",
"UInt8.size",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Decidable.decide",
"Eq"
] | false |
ZMod.smul_mem | Mathlib.Algebra.Module.ZMod | [
"SetLike",
"Int.cast",
"Eq.mpr",
"instHSMul",
"zsmul_mem",
"ZMod.cast",
"ZMod.commRing",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddZeroClass.toAddZe... | true |
CategoryTheory.skeleton_skeletal | Mathlib.CategoryTheory.Skeletal | [
"congrArg",
"CategoryTheory.IsIsomorphic",
"Eq.mp",
"CategoryTheory.Iso",
"CategoryTheory.isIsomorphicSetoid",
"Quotient.out",
"Nonempty.intro",
"Quotient.mk",
"CategoryTheory.Skeletal",
"Quotient",
"HasEquiv.Equiv",
"CategoryTheory.fromSkeleton",
"Nonempty.casesOn",
"congr",
"CategoryTh... | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.glue.match_1.splitter | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"Std.DTreeMap.Internal.Impl.BalancedAtRoot",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Std.DTreeMap.Internal.Impl.glue.match_1",
"Std.DTreeMap.Internal.Impl"
] | true |
Pi.instNeg.eq_1 | Mathlib.Algebra.Notation.Pi.Defs | [
"Pi.instNeg",
"Neg.mk",
"Neg",
"Eq.refl",
"Eq",
"Neg.neg"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hamiltonian.0.SimpleGraph.Walk.isHamiltonianCycle_isCycle_and_isHamiltonian_tail.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | [
"SimpleGraph.Walk.IsHamiltonianCycle.casesOn",
"SimpleGraph.Walk.IsCycle",
"SimpleGraph.Walk",
"SimpleGraph.Walk.IsHamiltonianCycle.mk",
"SimpleGraph",
"SimpleGraph.Walk.IsHamiltonianCycle",
"SimpleGraph.Walk.tail",
"SimpleGraph.Walk.IsHamiltonian",
"SimpleGraph.Walk.snd",
"DecidableEq"
] | false |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToCodeBlock.expandLiftMethodAux.match_3 | Lean.Elab.Do.Legacy | [
"Lean.Syntax.node",
"Lean.Syntax.ctorIdx",
"Lean.SourceInfo",
"Lean.Syntax",
"namedPattern",
"Nat.hasNotBit",
"Array",
"_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.hasLiftMethod._sparseCasesOn_1",
"Eq.refl",
"Lean.SyntaxNodeKind",
"Eq"
] | false |
RingHom.compLeft._proof_1 | Mathlib.Algebra.Ring.Pi | [
"MulOne.toOne",
"RingHom",
"NonAssocSemiring.toMulZeroOneClass",
"MonoidHom.compLeft",
"Pi.mulOneClass",
"MulZeroOneClass.toMulOneClass",
"MulOneClass.toMulOne",
"NonAssocSemiring",
"OneHom.toFun",
"OneHom.map_one'",
"MonoidHom.toOneHom",
"One.toOfNat1",
"RingHom.toMonoidHom",
"OfNat.ofNat... | false |
Function.isFixedPt_piMap._simp_1 | Mathlib.Dynamics.PeriodicPts.Defs | [
"Pi.map",
"propext",
"Function.isFixedPt_piMap",
"Function.IsFixedPt",
"Eq"
] | false |
CategoryTheory.Localization.functor_additive | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | [
"CategoryTheory.MorphismProperty.HasLeftCalculusOfFractions",
"CategoryTheory.MorphismProperty",
"CategoryTheory.Localization.preadditive",
"CategoryTheory.Functor",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Preadditive",
"CategoryTheory.Functor.IsLocalization",
"CategoryTheory.Functor.Additi... | true |
Ideal.idealProdEquiv | Mathlib.RingTheory.Ideal.Prod | [
"Semiring.toModule",
"RelIso.mk",
"Prod.instLE_mathlib",
"PartialOrder.toPreorder",
"Preorder.toLE",
"RingHom",
"Ideal.idealProdEquiv._proof_5",
"Equiv.mk",
"Ideal.map",
"Prod.instSemiring",
"OrderIso",
"Prod.mk",
"Submodule.instPartialOrder",
"LE.le",
"Ideal",
"Prod.fst",
"RingHom.s... | true |
CategoryTheory.Comon.mkIso._auto_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
BitVec.and_or_distrib_left | Init.Data.BitVec.Lemmas | [
"instHOrOfOrOp",
"BitVec.instAndOp",
"BitVec.getElem_or",
"congrArg",
"BitVec.getElem_and",
"BitVec.instOrOp",
"BitVec",
"Bool.and",
"GetElem.getElem",
"HOr.hOr",
"Bool.and_or_distrib_left",
"Nat",
"congr",
"LT.lt",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Bool.or",
"BitVec.in... | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.packingNumber_two_mul_le_externalCoveringNumber._simp_1_3 | Mathlib.Topology.MetricSpace.CoveringNumbers | [
"iInf",
"PartialOrder.toPreorder",
"Preorder.toLE",
"le_iInf_iff",
"LE.le",
"CompleteLattice.toCompleteSemilatticeInf",
"propext",
"CompleteLattice.toCompleteSemilatticeSup",
"CompleteSemilatticeInf.toInfSet",
"CompleteSemilatticeSup.toPartialOrder",
"CompleteLattice",
"Eq"
] | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.neg_φH | Mathlib.Algebra.Homology.ShortComplex.Preadditive | [
"CategoryTheory.ShortComplex.LeftHomologyMapData.neg",
"NegZeroClass.toNeg",
"CategoryTheory.ShortComplex.LeftHomologyMapData",
"CategoryTheory.ShortComplex.LeftHomologyData",
"CategoryTheory.ShortComplex.instNegHom",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex... | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.not_nontrivial_singleton.match_1_1 | Mathlib.Data.Set.Subsingleton | [
"Membership.mem",
"Exists",
"Set.instSingletonSet",
"Ne",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Singleton.singleton",
"Set.instMembership",
"Set"
] | false |
Matroid.eRk_union_le_encard_add_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | [
"le_refl",
"Set.encard",
"instCompleteLinearOrderENat",
"ChainCompletePartialOrder.instOfCompleteLattice",
"CommSemiring.toSemiring",
"CompletelyDistribLattice.toCompleteLattice",
"covariant_swap_add_of_covariant_add",
"Preorder.toLE",
"Set.instUnion",
"instAddENat",
"instPreorderENat",
"add_l... | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.isMulTorsionFree_iff_not_isOfFinOrder._simp_1_2 | Mathlib.GroupTheory.OrderOfElement | [
"Monoid",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Exists",
"instOfNatNat",
"Monoid.toPow",
"MulOneClass.toMulOne",
"And",
"HPow.hPow",
"Nat",
"LT.lt",
"propext",
"One.toOfNat1",
"instHPow",
"instLTNat",
"OfNat.ofNat",
"isOfFinOrder_iff_pow_eq_one",
"Eq",
"IsOfFinOrder"
] | false |
MeasureTheory.Lp.instModule._proof_4 | Mathlib.MeasureTheory.Function.LpSpace.Basic | [
"Submodule",
"Submodule.module._proof_1",
"instHSMul",
"MeasureTheory.Measure",
"instSMulOfMul",
"NormedRing.toRing",
"MeasureTheory.Lp.LpSubmodule",
"UniformContinuousConstSMul.to_continuousConstSMul",
"AddMonoid.toAddSemigroup",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",... | false |
Int.mem_divisors_self | Mathlib.NumberTheory.Divisors | [
"Int.divisors",
"Iff.mpr",
"Dvd.dvd",
"Finset",
"Membership.mem",
"Ne",
"Int",
"Int.mem_divisors",
"Int.instDvd",
"Int.instMonoid",
"And",
"instOfNat",
"Finset.instSetLike",
"And.intro",
"dvd_rfl",
"OfNat.ofNat",
"SetLike.instMembership"
] | true |
centralBinom_factorization_small | Mathlib.NumberTheory.Bertrand | [
"not_le",
"instPowNat",
"Finsupp.instFunLike",
"Eq.mpr",
"MulOne.toOne",
"three_pos",
"False",
"Nat.instMulZeroClass",
"Nat.Prime",
"Preorder.toLT",
"instHDiv",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"eq_false",
"Finset.instIsTransSubset",
"Monoid.toMulOneClass",
"CommSemiring.to... | true |
Lean.Lsp.Ipc.readRequestAs | Lean.Data.Lsp.Ipc | [
"Lean.Lsp.Ipc.IpcM",
"ReaderT",
"String",
"instMonadLiftT",
"IO",
"IO.FS.Stream.readLspRequestAs",
"ReaderT.instMonad",
"Lean.Lsp.Ipc.stdout",
"EIO",
"liftM",
"instMonadEIO",
"ReaderT.instMonadLift",
"IO.Process.Child",
"Lean.Lsp.Ipc.ipcStdioConfig",
"Lean.FromJson",
"Monad.toBind",
... | true |
CategoryTheory.Oplax.StrongTrans.homCategory._proof_6 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Oplax.StrongTrans.Hom.of.injEq",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Oplax.StrongTrans.Modification.ext",
"CategoryTheory.OplaxFunctor.toPrelaxFunctor",
"CategoryTheory.Oplax.StrongTrans.Hom.as... | false |
StarMonoidHom.instFunLike._proof_2 | Mathlib.Algebra.Star.MonoidHom | [
"Monoid",
"MulOne.toOne",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Eq.mp",
"id",
"MulOneClass.toMulOne",
"OneHom.toFun",
"Star",
"StarMonoidHom",
"StarMonoidHom.toMonoidHom",
"True",
"eq_self",
"StarMonoidHom.mk",
"StarMonoidHom.casesOn",
"MonoidHo... | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorElim | Mathlib.Tactic.TacticAnalysis.Declarations | [
"_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome",
"Lean.TSyntax",
"Lean.MessageData",
"_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success",
"_private.Mathlib.Tactic.TacticAnalysis.Declaratio... | false |
CategoryTheory.Endofunctor.Adjunction.Algebra.toCoalgebraOf._proof_1 | Mathlib.CategoryTheory.Endofunctor.Algebra | [
"CategoryTheory.Functor",
"CategoryTheory.Endofunctor.Coalgebra.mk",
"CategoryTheory.Endofunctor.Coalgebra.instCategory",
"CategoryTheory.Endofunctor.Algebra",
"CategoryTheory.Endofunctor.Adjunction.Algebra.homEquiv_naturality_str",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheo... | false |
Std.HashMap.isEmpty_insertMany_list | Std.Data.HashMap.Lemmas | [
"instForInOfForIn'",
"Std.DHashMap.Const.isEmpty_insertMany_list",
"inferInstance",
"Bool.and",
"Std.HashMap",
"Id",
"Membership",
"LawfulHashable",
"List",
"Std.HashMap.insertMany",
"EquivBEq",
"List.instMembership",
"Std.HashMap.isEmpty",
"List.isEmpty",
"Bool",
"Id.instMonad",
"Ha... | true |
Char.reduceOfNatAux._regBuiltin.Char.reduceOfNatAux.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.1314572429._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | [
"Char.reduceOfNatAux",
"IO",
"Bool.true",
"Unit",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.addSimprocBuiltinAttr",
"Lean.Meta.Simp.Simproc"
] | false |
Std.DTreeMap.Internal.Impl.ordered_updateCell | Std.Data.DTreeMap.Internal.WF.Lemmas | [
"Ordering.gt",
"Std.DTreeMap.Internal.List.findCell",
"Eq.mpr",
"instDecidableEqOrdering",
"instLawfulBEq",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"List.Pairwise",
"Ord",
"congrArg",
"Option.toList",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.Ordered",
"HSub.hSub",
"List.fin... | true |
Lean.getDelayedMVarRoot | Lean.MetavarContext | [
"Inhabited.default",
"instInhabitedOfMonad",
"Lean.MVarId",
"Inhabited",
"Monad",
"Lean.MonadMCtx",
"Inhabited.mk"
] | true |
Ctop.ctorIdx | Mathlib.Data.Analysis.Topology | [
"Ctop",
"Nat"
] | false |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.Prod.upAddHom.eq_1 | Mathlib.Algebra.Group.UniqueProds.Basic | [
"Prod.instAdd",
"AddHom",
"_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.Prod.upAddHom._proof_1",
"Prod.fst",
"Pi.instAdd",
"_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.I",
"Bool.rec",
"Bool",
"_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.Prod.upAddHom",
"Eq.refl",
"AddHom.mk",... | true |
StarAlgEquiv.rec | Mathlib.Algebra.Star.StarAlgHom | [
"RingEquiv.toEquiv",
"StarRingEquiv.toRingEquiv",
"instHSMul",
"SMul",
"Mul",
"StarAlgEquiv",
"Equiv.toFun",
"Star",
"HSMul.hSMul",
"Eq",
"StarAlgEquiv.mk",
"StarRingEquiv",
"Add"
] | false |
_private.Mathlib.Algebra.Group.Subgroup.Lattice.0.Subgroup.mem_iSup_of_directed._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Lattice | [
"Exists",
"PLift",
"PLift.up",
"propext",
"Eq",
"PLift.exists"
] | false |
CategoryTheory.MorphismProperty.LeftFraction₂.mk._flat_ctor | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.LeftFraction₂",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.MorphismProperty.LeftFraction₂.mk",
"CategoryTheory.Category"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.