name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
AffineIsometryEquiv.coe_vaddConst' | Mathlib.Analysis.Normed.Affine.Isometry | [
"NormedCommRing.toNormedRing",
"SeminormedAddCommGroup",
"NormedRing.toRing",
"NormedSpace",
"AddMonoid.toAddSemigroup",
"AffineEquiv.vaddConst",
"NormedSpace.toModule",
"AffineEquiv.equivLike",
"AddCommGroup.toAddGroup",
"addGroupIsAddTorsor",
"NormedField",
"HVAdd.hVAdd",
"AddAction.toAddS... | true |
_private.Mathlib.Algebra.FreeAlgebra.0.FreeAlgebra.mk_mul | Mathlib.Algebra.FreeAlgebra | [
"HMul.hMul",
"FreeAlgebra.instMul",
"FreeAlgebra.Pre",
"FreeAlgebra",
"CommSemiring",
"Quot",
"FreeAlgebra.Rel",
"FreeAlgebra.Pre.hasMul",
"Eq",
"rfl",
"Quot.mk",
"instHMul"
] | true |
Std.DTreeMap.Const.get_erase | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Ord.mk",
"Membership.mem",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Std.DTreeMap.Internal.Impl.Const.get_erase",
"Std.DTreeMap.Const.get",
"Std.DTreeMap.wf",
"Std.DTreeMap.mem_of_mem_erase",
"Eq",
"Std.DTreeMap.erase"
] | true |
LinearEquiv.ofEq._proof_5 | Mathlib.Algebra.Module.Submodule.Equiv | [
"Submodule",
"Equiv.right_inv",
"Equiv.setCongr",
"Set.Elem",
"Equiv.toFun",
"AddCommMonoid",
"SetLike.coe",
"Submodule.setLike",
"Function.RightInverse",
"Semiring",
"LinearEquiv.ofEq._proof_1",
"Module",
"Eq",
"Equiv.invFun"
] | false |
Pi.inv_def | Mathlib.Algebra.Notation.Pi.Defs | [
"Inv",
"Pi.instInv",
"Inv.inv",
"Eq",
"rfl"
] | true |
Lean.Parser.Command.quot | Lean.Parser.Command | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Lean.Parser.commandParser",
"Nat",
"Lean.Parser.withCache",
"Lean.Parser.incQuotDepth",
"OfNat.ofNat",
"L... | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.isComplement_subgroup_left_iff_existsUnique_quotientMk''._simp_1_2 | Mathlib.GroupTheory.Complement | [
"SetLike",
"Membership.mem",
"SetLike.coe",
"SetLike.mem_coe",
"propext",
"Eq",
"Set.instMembership",
"SetLike.instMembership",
"Set"
] | false |
_private.Mathlib.Logic.Encodable.Basic.0.Encodable.decodeSum.match_1.splitter | Mathlib.Logic.Encodable.Basic | [
"False",
"_private.Mathlib.Logic.Encodable.Basic.0.Encodable.decodeSum.match_1.splitter._sparseCasesOn_2",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.ctorIdx",
"Bool.true",
"Nat.land",
"absurd",
"Nat",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"OfNat.ofNat",
... | true |
Lean.Meta.Grind.Filter.const.sizeOf_spec | Lean.Meta.Tactic.Grind.Filter | [
"Lean.Meta.Grind.Filter",
"Lean.Meta.Grind.Filter._sizeOf_inst",
"instOfNatNat",
"Lean.Meta.Grind.Filter.const",
"instHAdd",
"HAdd.hAdd",
"Lean.instSizeOfName",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Eq"
] | true |
FormalGroup.𝔾ₐ._proof_2 | Mathlib.RingTheory.FormalGroup.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.instMulZeroClass",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Fin.instNonUnitalCommRing",
"Fin.instNeZeroHAddNatOfNat_mathlib_1",... | false |
CategoryTheory.Functor.triangle | Mathlib.CategoryTheory.Whiskering | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.rightUnitor",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"... | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | [
"Mathlib.Tactic.BicategoryLike.WhiskerLeft.of",
"Mathlib.Tactic.BicategoryLike.Mor₂",
"Mathlib.Tactic.BicategoryLike.Atom₁",
"Mathlib.Tactic.BicategoryLike.WhiskerLeft",
"Mathlib.Tactic.BicategoryLike.WhiskerLeft.whisker",
"Mathlib.Tactic.BicategoryLike.HorizontalComp"
] | false |
Std.DTreeMap.modify._proof_1 | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"Ord.mk",
"Ordering",
"Std.DTreeMap.Internal.Impl.WF.modify",
"Std.DTreeMap.inner",
"Std.DTreeMap.Internal.Impl.WF",
"Std.LawfulEqCmp",
"Std.DTreeMap.wf",
"Std.DTreeMap.Internal.Impl.modify"
] | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.cellFrontier_one_eq._simp_1_3 | Mathlib.Topology.CWComplex.Classical.Basic | [
"Membership.mem",
"Insert.insert",
"Set.instInsert",
"propext",
"Or",
"Set.mem_insert_iff",
"Eq",
"Set.instMembership",
"Set"
] | false |
Lean.Meta.SynthInstance.State.rec | Lean.Meta.SynthInstance | [
"Lean.Meta.SynthInstance.Answer",
"Lean.Meta.SynthInstance.ConsumerNode",
"Lean.Expr.instBEq",
"Lean.Meta.AbstractMVarsResult",
"Lean.Expr",
"Std.HashMap",
"Array",
"Lean.Meta.SynthInstance.GeneratorNode",
"Lean.Meta.SynthInstance.TableEntry",
"Lean.Meta.SynthInstance.State.mk",
"Lean.Expr.instH... | false |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.comap_comap_center._simp_1_1 | Mathlib.GroupTheory.QuotientGroup.Basic | [
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Group",
"Membership.mem",
"DivInvMonoid.toMonoid",
"Subgroup",
"Subgroup.mem_comap",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"propext",
"Eq",
"DFunLike.coe",
"Subgroup.comap",
"SetLike.instMembership",
"Subgroup.ins... | false |
IsMaxOn.norm_add_self | Mathlib.Analysis.Normed.Module.Extr | [
"Norm.norm",
"Real",
"SeminormedAddCommGroup",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"IsMaxOn",
"Function.comp",
"SeminormedAddCommGroup.toNorm",
"instHAdd",
"HAdd.hAdd",
"SeminormedAddCommGroup.toAddCommGroup",
"Filter.principal",
"Real.normedField",
"AddCommSemigroup.toAddCommMa... | true |
Batteries.BinomialHeap.Imp.HeapNode.toHeap.go._f | Batteries.Data.BinomialHeap.Basic | [
"Batteries.BinomialHeap.Imp.HeapNode.node",
"Batteries.BinomialHeap.Imp.Heap",
"Batteries.BinomialHeap.Imp.HeapNode",
"HSub.hSub",
"Batteries.BinomialHeap.Imp.HeapNode.toHeap.go.match_1",
"instSubNat",
"instOfNatNat",
"Batteries.BinomialHeap.Imp.Heap.cons",
"Batteries.BinomialHeap.Imp.HeapNode.nil",... | false |
IsLocalRing.instOrderTopPrimeSpectrum | Mathlib.RingTheory.Spectrum.Prime.Topology | [
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"IsLocalRing.instOrderTopPrimeSpectrum._proof_1",
"Top.mk",
"IsLocalRing",
"OrderTop.mk",
"OrderTop",
"CommSemiring",
"PrimeSpectrum.instPartialOrder",
"IsLocalRing.closedPoint",
"PrimeSpectrum"
] | true |
Module.End.instDivisionRing._proof_6 | Mathlib.RingTheory.SimpleModule.Basic | [
"Module.End.instRing",
"Semiring.toNatCast",
"Monoid.npow",
"NNRat.castRec",
"Mul.mk",
"LinearEquiv.symm",
"Semigroup.toMul",
"instHDiv",
"Semigroup.mul_assoc",
"One.mk",
"AddCommGroup.toAddCommMonoid",
"Semigroup.mk",
"AddCommGroup",
"NNRatCast.mk",
"HDiv.hDiv",
"IsSimpleModule",
"N... | false |
NNReal.rpow_inv_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"Real",
"DivInvMonoid.toInv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"MulZeroClass.toMul",
"Real.instZero",
"congrArg",
"Real.instInv",
"DivisionSemiring.toGroupWithZero",
"NNReal.rpow_mul",
"id",
"NNReal",
"Ne",
"Fiel... | true |
Int64.shiftRight_xor | Init.Data.SInt.Bitwise | [
"BitVec.instXorOp",
"BitVec.instOfNat",
"Int64.toBitVec_shiftRight",
"congrArg",
"Int64.toBitVec_xor",
"BitVec",
"Int64",
"instOfNatNat",
"BitVec.toNat",
"BitVec.sshiftRight'",
"BitVec.ofNat",
"instHShiftRightOfShiftRight",
"BitVec.sshiftRight",
"instXorOpInt64",
"HShiftRight.hShiftRight... | true |
AddMemClass.toAddCommSemigroup._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | [
"SetLike",
"Membership.mem",
"AddCommMagma.add_comm",
"Subtype",
"AddCommSemigroup.toAddSemigroup",
"Subtype.coe_injective",
"Function.Injective.addCommMagma",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"AddMemClass",
"AddCommSemigroup.toAddCommMagma",
"AddCommSemigroup",
"Subtype.val"... | false |
Std.Format.defIndent | Init.Data.Format.Basic | [
"instOfNatNat",
"Nat",
"OfNat.ofNat"
] | true |
Valuation.restrict_le_iff | Mathlib.RingTheory.Valuation.Basic | [
"Units.val",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"False",
"WithZero.instIsBotZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"eq_false",
"LinearOrder.toDecidableEq",
"ValuationClass.toMonoidWithZeroHomClass... | true |
ProbabilityTheory.Kernel.indepFun_const_right | Mathlib.Probability.Independence.Kernel.IndepFun | [
"MeasureTheory.Measure",
"ProbabilityTheory.IsZeroOrMarkovKernel",
"ProbabilityTheory.Kernel.indepFun_const_left",
"ProbabilityTheory.Kernel.IndepFun",
"MeasurableSpace",
"ProbabilityTheory.Kernel.IndepFun.symm",
"ProbabilityTheory.Kernel"
] | true |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_some._simp_1_4 | Std.Sat.CNF.RelabelFin | [
"Exists",
"forall_exists_index",
"propext",
"Exists.intro",
"Eq"
] | false |
CategoryTheory.SplitEpi.map_section_ | Mathlib.CategoryTheory.EpiMono | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.SplitEpi.section_",
"CategoryTheory.Functor.map",
"Eq.refl",
"CategoryTheory.SplitEpi.map",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.SplitEpi",
"Eq",
"CategoryTheory.Functor.obj",... | true |
CoheytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | [
"CoheytingAlgebra",
"Nat"
] | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs._proof_3 | Batteries.Data.List.Lemmas | [
"Lean.Grind.Nat.lt_eq",
"instOfNatNat",
"LE.le",
"instLENat",
"List.findIdxs",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Eq.substr",
"Bool",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"List.length"
] | false |
Cardinal.ord_lt_omega0 | Mathlib.SetTheory.Ordinal.Basic | [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.omega0",
"Ordinal.partialOrder",
"Cardinal",
"PartialOrder.toPreorder",
"le_iff_le_iff_lt_iff_lt",
"Preorder.toLE",
"Cardinal.aleph0",
"LE.le",
"Cardinal.omega0_le_ord",
"Cardinal.ord",
"Cardinal.partialOrder",
"Iff",
"LT.lt",
"Iff.m... | true |
Commute.zpow_zpow_self₀ | Mathlib.Algebra.GroupWithZero.Semiconj | [
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivInvMonoid",
"MulZeroClass.toMul",
"GroupWithZero",
"DivInvMonoid.toZPow",
"Commute",
"Int",
"Commute.refl",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"Commute.zpow_zpow₀"
] | true |
ULift.normedAddGroup | Mathlib.Analysis.Normed.Group.Constructions | [
"ULift.addZeroClass",
"ULift.normedAddGroup._proof_1",
"ULift.addGroup",
"AddMonoid.toAddZeroClass",
"ULift",
"ULift.normedAddGroup._proof_2",
"AddZeroClass.toAddZero",
"AddMonoidHom.mk",
"NormedAddGroup.toAddGroup",
"NormedAddGroup.induced",
"ZeroHom.mk",
"ULift.normedAddGroup._proof_3",
"A... | true |
HurwitzZeta.evenKernel_undef | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | [
"Complex.mul_im",
"Eq.mpr",
"Real.instLE",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Real.pi",
"HMul.hMul",
"HurwitzZeta.evenKernel_def",
"Real.instZero",
"Real.instAddMonoid",
"congrArg",
"Complex.im",
"AddMonoid.toAddZeroClass",
"Complex.instNormedField",
"Complex.instZ... | true |
Prod.instCompletelyDistribLattice._proof_3 | Mathlib.Order.CompleteBooleanAlgebra | [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompletelyDistribLattice",
"LE.le",
"Order.Frame.toCompleteLattice",
"CompletelyDistribLattice.toCompleteDistribLattice",
"CompleteDistribLattice.toFrame",
"Lattice.inf",
"SemilatticeSup.toParti... | false |
Set.ordConnected_empty | Mathlib.Order.Interval.Set.OrdConnected | [
"False.elim",
"Membership.mem",
"HasSubset.Subset",
"Set.Icc",
"Set.OrdConnected.mk",
"Set.instEmptyCollection",
"Set.OrdConnected",
"EmptyCollection.emptyCollection",
"Set.instMembership",
"Preorder",
"Set.instHasSubset",
"Set"
] | true |
ModuleCat.ihom_map_apply | Mathlib.Algebra.Category.ModuleCat.Monoidal.Closed | [
"CommRing",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"CommSemiring.toSemiring",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"ModuleCat.instAddCommGroupHom",
"LinearMap.instFunLike",
"ModuleCat.Hom.instModule",
"ModuleCat.instConcreteCategory... | true |
AffineEquiv.toEquiv_pointReflection | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | [
"AddCommGroup.toAddCommMonoid",
"Equiv.pointReflection",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Equiv",
"AddTorsor",
"AffineEquiv.toEquiv",
"Module",
"Ring.toSemiring",
"Eq",
"Ring",
"rfl",
"AffineEquiv.pointReflection"
] | true |
AlgebraicGeometry.morphismRestrictRestrictBasicOpen | Mathlib.AlgebraicGeometry.Restrict | [
"AlgebraicGeometry.Scheme.Hom.opensFunctor",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"Lattice.toSemilatticeSup",
"AlgebraicGeometry.morphismRestrictRestrictBasicOpen._proof_2",
"Opposite",
"CommRingCat.carrier",
"AlgebraicGeometry.PresheafedSpac... | true |
Std.ExtDTreeMap.getEntryGT._proof_3 | Std.Data.ExtDTreeMap.Basic | [
"Ordering.gt",
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Std.DTreeMap.getEntryGT",
"Membership.mem",
"Exists",
"Ordering",
"Std.ExtDTreeMap.getEntryGT._proof_1",
"Eq.rec",
"Std.TransCmp",
"And",
"Std.ExtDTreeMap",
"Std.ExtDTreeMap.getEntryGT._proof_2",
"Std.DTreeMap.Equiv",
"Std.DTreeMap.Eq... | false |
_private.Lean.Elab.PreDefinition.MkInhabitant.0.Lean.Elab.mkInhabitantForAux?._sparseCasesOn_1 | Lean.Elab.PreDefinition.MkInhabitant | [
"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 |
_private.Mathlib.RepresentationTheory.Coinvariants.0.Representation.Coinvariants.lift._simp_4 | Mathlib.RepresentationTheory.Coinvariants | [
"Submodule",
"AddMonoid.toAddZeroClass",
"LinearMap.ker",
"LinearMap.instFunLike",
"RingHom",
"Membership.mem",
"AddZeroClass.toAddZero",
"LinearMap",
"AddCommMonoid",
"LinearMap.mem_ker",
"AddZero.toZero",
"Submodule.setLike",
"propext",
"Semiring",
"Zero.toOfNat0",
"AddCommMonoid.toA... | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.measurableSet_eq_of_countable_range._simp_1_7 | Mathlib.Probability.Process.Stopping | [
"Preorder.toLT",
"lt_iff_le_not_ge",
"Preorder.toLE",
"LE.le",
"And",
"LT.lt",
"propext",
"Eq",
"Not",
"Preorder"
] | false |
FreeAlgebra.Rel.add_compat_right | Mathlib.Algebra.FreeAlgebra | [
"FreeAlgebra.Rel.add_compat_right",
"FreeAlgebra.Pre.hasAdd",
"FreeAlgebra.Pre",
"CommSemiring",
"instHAdd",
"HAdd.hAdd",
"FreeAlgebra.Rel"
] | true |
Finsupp.extendDomain_toFun | Mathlib.Data.Finsupp.Basic | [
"Finsupp.instFunLike",
"Subtype",
"dite",
"Subtype.mk",
"DecidablePred",
"Zero.toOfNat0",
"Finsupp.extendDomain_apply",
"OfNat.ofNat",
"Eq",
"Finsupp.extendDomain",
"DFunLike.coe",
"Not",
"Finsupp",
"Zero"
] | true |
Aesop.Hyp.mk.inj | Aesop.Forward.State | [
"Aesop.Hyp.mk",
"Aesop.Substitution",
"Lean.FVarId",
"And",
"And.intro",
"Aesop.Hyp.mk.noConfusion",
"Aesop.Hyp",
"Eq",
"Option"
] | true |
Seminorm.comp._proof_2 | Mathlib.Analysis.Seminorm | [
"LinearMap.toAddMonoidHom",
"AddGroup.toSubtractionMonoid",
"Real",
"Real.instZero",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddGroupSeminorm.comp",
"AddMonoid.toAddZeroClass",
"SeminormedRing.toRing",
"AddCommGroup.toAddGroup",
"RingHom",
"AddZeroClass.toAddZero",
... | false |
IsDedekindDomainInv.commGroupWithZero._proof_1 | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | [
"IsDomain",
"CommRing",
"HMul.hMul",
"CommSemiring.toSemiring",
"IsFractionRing",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Algebra",
"Preorder.toLE",
"nonZeroDivisors",
"FractionalIdeal.instInvNonZeroDivisors",
"Ne",
"Bot.bot",
"FractionalIdeal.instMul",
"Field.toSemifield",
"Fiel... | false |
AddCommute.sub_sub_sub_comm | Mathlib.Algebra.Group.Commute.Basic | [
"neg_add_rev",
"Eq.mpr",
"NegZeroClass.toNeg",
"SubtractionMonoid.toInvolutiveNeg",
"AddMonoid.toAddSemigroup",
"AddCommute.symm",
"congrArg",
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"AddZeroClass.toAddZero",
"neg_neg",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"Su... | true |
IntermediateField.relfinrank_comap | Mathlib.FieldTheory.Relrank | [
"Nat.instMulZeroOneClass",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"IntermediateField",
"IntermediateField.relfinrank",
"AlgHom",
"Cardinal.commSemiring",
"Cardinal.toNat",
"MonoidWithZeroHom.funLike",
"Cardinal.lift",
"Algebra",
"Eq.mp",
"id",
"IntermediateField.lift_relrank_... | true |
Std.DTreeMap.Const.get?_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap.instUnion",
"Std.DTreeMap",
"congrArg",
"Ord.mk",
"Membership.mem",
"Ordering",
"Eq.mp",
"Std.DTreeMap.Const.get?",
"Std.DTreeMap.contains_eq_false_iff_not_mem",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Std.DTreeMap.Internal.Impl.Const.get?_union_of... | true |
Submodule.mem_mk._simp_1 | Mathlib.Algebra.Module.Submodule.Defs | [
"Submodule",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"Membership.mem",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddSubmonoid.toAddSubsemigroup",
"AddSubmonoid",
"AddCommMonoid",
"AddZero.toZero",
"Submodule.setLik... | false |
AddActionHom.prodMap._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | [
"CompTriple.instIsIdId",
"id",
"CompTriple",
"CompTriple.instComp_id"
] | false |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.RxoIterator.toList_rxoIter._unary | Std.Data.DTreeMap.Internal.Zipper | [
"Std.IterM.toList_eq_match_step",
"Pure.pure",
"Eq.mpr",
"Std.DTreeMap.Internal.RxoIterator.step",
"False",
"List.takeWhile_cons_of_neg",
"Std.IterStep",
"List.takeWhile_cons_of_pos",
"Ord",
"Std.Iter.toList_eq_toList_toIterM",
"congrArg",
"Std.Shrink",
"_private.Std.Data.DTreeMap.Internal.Z... | false |
CategoryTheory.Pseudofunctor.DescentData.subtypeCompatibleHomEquiv._proof_9 | Mathlib.CategoryTheory.Sites.Descent.DescentData | [
"CategoryTheory.Over",
"Opposite",
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.Pseudofunctor.DescentData.Hom.hom",
"CategoryTheory.Over.mk",
"CategoryTheory.Cat.str",
"CategoryTheory.Catego... | false |
IO.FileRight.casesOn | Init.System.IO | [
"IO.FileRight",
"IO.AccessRight",
"IO.FileRight.mk",
"IO.FileRight.rec"
] | false |
NonUnitalSubsemiring.centralizer._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | [
"Membership.mem",
"Distrib.toAdd",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"Set.centralizer",
"instHAdd",
"Set.add_mem_centralizer",
"Distrib.toMul",
"HAdd.hAdd",
"NonUnitalSemiring",
"NonUnitalNonAssocSemiring.toDistrib",
"Set.instMembership",
"Set"
] | false |
DihedralGroup.orderOf_r_one | Mathlib.GroupTheory.SpecificGroups.Dihedral | [
"Eq.mpr",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Preorder.toLT",
"InvOneClass.toOne",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"ZMod.commRing",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"CancelMonoid.toLeftCancelMono... | true |
Lean.Lsp.Ipc.instFromJsonCallHierarchy | Lean.Data.Lsp.Ipc | [
"Lean.Lsp.Ipc.CallHierarchy",
"Lean.FromJson",
"Lean.FromJson.mk",
"Lean.Lsp.Ipc.instFromJsonCallHierarchy.fromJson"
] | true |
Bool.le_and | Mathlib.Data.Bool.Basic | [
"Bool.instDecidableForallOfDecidablePred",
"of_decide_eq_true",
"id",
"Bool.and",
"forall_prop_decidable",
"LE.le",
"Bool.true",
"Bool.instLE",
"Bool",
"Eq.refl",
"Bool.instDecidableLe",
"Decidable.decide",
"Eq"
] | true |
instInhabitedAntisymmetrization._aux_1 | Mathlib.Order.Antisymmetrization | [
"Inhabited.default",
"AntisymmRel.setoid",
"Quotient.mk",
"Antisymmetrization",
"Inhabited",
"IsPreorder"
] | false |
CStarModule.inner_self_nonneg | Mathlib.Analysis.CStarAlgebra.Module.Defs | [
"Inner.inner",
"AddCommGroup.toAddCommMonoid",
"SMul",
"PartialOrder.toPreorder",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Preorder.toLE",
"CStarModule",
"PartialOrder",
"AddCommGroup",
"Norm",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"LE.le",
"CStarModule.toInner",
"NonUnitalN... | true |
Units.instFaithfulSMul | Mathlib.Algebra.Group.Action.Units | [
"Monoid",
"Units.val",
"instHSMul",
"FaithfulSMul.eq_of_smul_eq_smul",
"SMul",
"Units.instSMul",
"Units",
"Units.ext",
"FaithfulSMul",
"FaithfulSMul.mk",
"HSMul.hSMul",
"Eq"
] | true |
Module.Relations.Solution.mk.sizeOf_spec | Mathlib.Algebra.Module.Presentation.Basic | [
"Semiring.toModule",
"Finsupp.module",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"AddCommGroup",
"Module.Relations.Solution",
"Module.Relations.relation",
"SubtractionMonoid.toSubNegZeroMonoid",
"instOfNatNat",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractio... | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapWithPostcondition.match_3.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Std.IterStep",
"Std.IterM.step_filterMapWithPostcondition.match_3",
"Std.IterM.IsPlausibleStep",
"Std.IterStep.skip",
"Std.Iterator",
"Subtype.mk",
"Std.IterStep.yield",
"Std.IterM.Step",
"Std.IterStep.done",
"Eq.refl",
"Std.IterM",
"Eq"
] | true |
Topology.RelCWComplex.isClosed_cellFrontier | Mathlib.Topology.CWComplex.Classical.Basic | [
"Topology.RelCWComplex",
"Topology.RelCWComplex.isCompact_cellFrontier",
"Topology.RelCWComplex.cellFrontier",
"IsClosed",
"TopologicalSpace",
"Nat",
"Topology.RelCWComplex.cell",
"T2Space",
"IsCompact.isClosed",
"Set"
] | true |
Lean.Meta.Grind.AC.EqCnstrProof.simp_ac.elim | Lean.Meta.Tactic.Grind.AC.Types | [
"PULift.up",
"Lean.Meta.Grind.AC.EqCnstrProof.ctorIdx",
"Lean.Meta.Grind.AC.EqCnstr",
"Lean.Meta.Grind.AC.EqCnstrProof.simp_ac",
"Lean.Meta.Grind.AC.EqCnstrProof",
"Lean.Meta.Grind.AC.EqCnstrProof.ctorElim",
"Nat",
"Bool",
"Lean.Grind.AC.Seq",
"Eq.symm",
"Eq"
] | false |
MeasurableSpace.DynkinSystem.GenerateHas.recOn | Mathlib.MeasureTheory.PiSystem | [
"MeasurableSpace.DynkinSystem.GenerateHas.empty",
"Function.onFun",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"Compl.compl",
"Disjoint",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"Set.instCompl",
"MeasurableSpace.DynkinSystem.GenerateHas.rec",
"MeasurableSpace.Dy... | false |
Std.IterM.any_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Pure.pure",
"Eq.mpr",
"bind_congr",
"Std.IterStep",
"congrArg",
"Std.Shrink",
"Std.IterM.length_eq_match_step.match_1",
"Monad.toApplicative",
"ULift",
"Std.IteratorLoop",
"Std.IterM.IsPlausibleStep",
"Std.Iterators.Finite",
"Std.IterStep.skip",
"id",
"instDecidableEqBool",
"Std.IterM... | true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.disjoint_conj._simp_1_1 | Mathlib.GroupTheory.Perm.Support | [
"Equiv.instEquivLike",
"Equiv.Perm.instInv",
"Inv.inv",
"Equiv.Perm",
"propext",
"Equiv.Perm.eq_inv_iff_eq",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk.injEq | Lean.Meta.Tactic.Simp.Types | [
"Lean.Meta.SimpCongrTheorems",
"Lean.Meta.Simp.Config",
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Expr",
"And",
"Nat",
"_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk",
"Lean.Meta.ConfigWithKey",
"Bool",
"Eq.ndrec",
"Lean.Meta.Simp.Context",
"UInt32",
"Eq.refl",
"Lean.... | true |
Lean.Meta.Grind.Order.Weight.strict | Lean.Meta.Tactic.Grind.Order.Types | [
"Lean.Meta.Grind.Order.Weight",
"Bool"
] | true |
Lean.Meta.Grind.instCoeFunVarRenameForallVar | Lean.Meta.Tactic.Grind.VarRename | [
"Option.getD",
"Membership.mem",
"CoeFun.mk",
"instOfNatNat",
"Std.HashMap",
"instHashableNat",
"instBEqOfDecidableEq",
"Lean.Meta.Grind.VarRename.map",
"Lean.Meta.Grind.Var",
"Lean.Meta.Grind.VarRename",
"instDecidableEqNat",
"GetElem?.getElem?",
"Std.HashMap.instGetElem?Mem",
"OfNat.ofNa... | true |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.exists_algHom_adjoin_of_splits'._simp_1_2 | Mathlib.FieldTheory.Extension | [
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IntermediateField",
"Algebra",
"RingHom",
"HasSubset.Subset",
"Field.toSemifield",
"And",
"RingHom.instFunLike",
"Semifield.toDivisionSemiring",
"SetLike.coe",
"IntermediateField.adjoin",
"propext",
"DivisionSemiring.toSemiring",
"Interme... | false |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.getRel._sparseCasesOn_2 | Mathlib.Tactic.GCongr.Core | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... | false |
_private.Init.Data.List.Nat.Basic.0.List.dropLast.match_1.splitter._sparseCasesOn_4 | Init.Data.List.Nat.Basic | [
"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 |
CommAlgCat.instConcreteCategoryAlgHomCarrier._proof_3 | Mathlib.Algebra.Category.CommAlgCat.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"CategoryTheory.CategoryStruct.id",
"CommAlgCat.commRing",
"id",
"CommAlgCat.Hom.hom'",
"CommAlgCat.instCategory",
"CommAlgCat.carrier",
"CommRing.toCommSemiring",
"CommAlgCat.algebra",
"CommAlgCat",
"Eq.refl",
"CategoryT... | false |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.posFittingComp_map_incl_sup_of_codisjoint._simp_1_3 | Mathlib.Algebra.Lie.Weights.Basic | [
"LieSubmodule.lcs_sup",
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieSubmodule",
"AddCommGroup",
"LieSubmodule.lcs",
"LieRing",
"CommRing.toCommSemiring",
"Max.max",
"Nat",
"LieRingModule",
"LieSubmodule.instMax",
"LieAlgebra",
"Module",
"Eq.symm",
"Eq"
... | false |
Subarray.toList_mkSlice_roo | Init.Data.Slice.Array.Lemmas | [
"Std.Slice.toList",
"Std.Rco.Sliceable.mkSlice",
"Subarray",
"congrArg",
"instOfNatNat",
"SubarrayIterator",
"List",
"instHAdd",
"instSliceableSubarrayNat_4",
"List.drop",
"HAdd.hAdd",
"Std.Slice.Internal.SubarrayData",
"Nat",
"Subarray.toList_mkSlice_rco",
"instSliceableSubarrayNat_1",
... | true |
AddCon.addConGen_le | Mathlib.GroupTheory.Congruence.Defs | [
"AddCon.instFunLikeForallProp",
"AddCon",
"Eq.mpr",
"addConGen",
"congrArg",
"setOf",
"id",
"AddCon.instLE",
"LE.le",
"AddCon.instCompleteLattice",
"CompleteLattice.toCompleteSemilatticeInf",
"sInf_le",
"AddCon.addConGen_eq",
"Eq",
"DFunLike.coe",
"InfSet.sInf",
"Add",
"AddCon.inst... | true |
Set.mem_Ici_Ioi_of_subset_of_subset | Mathlib.Order.Interval.Set.Basic | [
"Set.Subset.antisymm",
"Set.singleton_subset_iff",
"Eq.mpr",
"Set.Ioi",
"Set.Ici",
"congrArg",
"and_self",
"Set.union_subset_iff",
"PartialOrder.toPreorder",
"by_cases",
"Membership.mem",
"Set.instUnion",
"Eq.rec",
"PartialOrder",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Has... | true |
List.sublist_cons_of_sublist | Mathlib.Data.List.Basic | [
"List.cons",
"List",
"List.Sublist",
"List.Sublist.cons"
] | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_24 | Mathlib.RingTheory.Polynomial.Resultant.Basic | [
"Lean.RArray.leaf",
"_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_16",
"Eq.rec",
"Lean.RArray.branch",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"Fin.val",
"Bool.true",
"instHAdd",
"Nat.Linear.Expr.eq_of_toNormPoly_eq",
"HAdd... | false |
Polynomial.IsMonicOfDegree.eq_isMonicOfDegree_two_mul_isMonicOfDegree | Mathlib.Analysis.Polynomial.Factorization | [
"Semigroup.toMul",
"Real",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"mul_assoc",
"NonUnitalCommSemiring.toCommSemigroup",
"Exists",
"SemigroupWithZero.toSemigroup",
"Eq.rec",
"Real.semiring",
"Eq.mp",
"Polynomial.IsMonicOfDegree.mul",
"CommMagma.toMul",
"instOfNatNat",
... | true |
Algebra.IsCentral.baseField_essentially_unique | Mathlib.Algebra.Central.Basic | [
"Subalgebra.instSetLike",
"Nontrivial",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Algebra.IsCentral",
"instHSMul",
"Lattice.toSemilatticeSup",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Field.isDomain",
"CommRing.toNonUnitalCommRing",
"smul_assoc",
"Algebra.algebraMap",
"Ring.toNonAss... | true |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toLower_eq_of_isUpper._proof_1_4 | Batteries.Data.Char.AsciiCasing | [
"Lean.Grind.CommRing.le_norm_expr",
"Lean.Grind.instOrderedRingInt",
"Lean.RArray.leaf",
"False",
"Nat.Simproc.le_add_ge",
"of_decide_eq_true",
"Lean.Grind.not_and",
"Lean.Grind.CommRing.Expr.var",
"congrArg",
"Lean.Grind.not_or",
"Std.IsLinearPreorder.toIsPreorder",
"False.elim",
"Classical... | false |
Stream'.take | Mathlib.Data.Stream.Defs | [
"Nat.brecOn",
"Stream'.take._f",
"Stream'",
"List",
"Nat"
] | true |
OrderAddMonoidIso.coe_addEquiv | Mathlib.Algebra.Order.Hom.Monoid | [
"OrderAddMonoidIso",
"OrderAddMonoidIso.instEquivLike",
"AddEquivClass.toAddEquiv",
"OrderAddMonoidIso.instAddEquivClass",
"AddEquiv",
"AddEquiv.instEquivLike",
"Eq",
"DFunLike.coe",
"Add",
"rfl",
"Preorder",
"EquivLike.toFunLike"
] | true |
Aesop.Script.Tactic.recOn | Aesop.Script.Tactic | [
"Aesop.Script.Tactic.mk",
"Aesop.Script.STactic",
"Aesop.Script.Tactic",
"Aesop.Script.UTactic",
"Aesop.Script.Tactic.rec",
"Option"
] | false |
CategoryTheory.nerveFunctor._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | [
"CategoryTheory.nerveMap",
"CategoryTheory.Cat.category",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Cat.str",
"id",
"SSet",
"CategoryTheory.Cat",
"CategoryTheory.Bundled.α",
"CategoryTheory.types",
"CategoryTheory.C... | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.add._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | [
"Lean.RArray.leaf",
"False",
"CommRing",
"HMul.hMul",
"Int.Linear.norm_le",
"congrArg",
"CommSemiring.toSemiring",
"Int.Linear.le_unsat",
"RootPairing.Base",
"AddCommGroup.toAddCommMonoid",
"Classical.byContradiction",
"RootPairing.Base.height",
"AddGroupWithOne.toAddMonoidWithOne",
"Int.n... | false |
Antivary.antivaryOn | Mathlib.Order.Monotone.Monovary | [
"Preorder.toLT",
"Antivary",
"Membership.mem",
"AntivaryOn",
"LT.lt",
"Set.instMembership",
"Preorder",
"Set"
] | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceCastLE.declare_181._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.3994795301._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | [
"IO",
"Lean.Meta.DiscrTree.Key.star",
"Lean.Meta.DiscrTree.Key",
"instOfNatNat",
"List.toArray",
"List.cons",
"Unit",
"Nat",
"Lean.Meta.Simp.registerBuiltinDSimproc",
"Lean.Name.mkStr2",
"Fin.reduceCastLE",
"OfNat.ofNat",
"Lean.Meta.DiscrTree.Key.const",
"List.nil"
] | false |
Filter.frequently_neg_filter | Mathlib.Order.Filter.Pointwise | [
"VAdd",
"Filter.frequently_map",
"Filter.Frequently",
"HVAdd.hVAdd",
"Filter.instVAddFilter",
"Iff",
"instHVAdd",
"Filter"
] | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.injEq | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | [
"Eq.propIntro",
"Lean.injEq_helper",
"Mathlib.Tactic.BicategoryLike.StructuralAtom.id.inj",
"Lean.Expr",
"Mathlib.Tactic.BicategoryLike.StructuralAtom",
"Mathlib.Tactic.BicategoryLike.Mor₁",
"And",
"Mathlib.Tactic.BicategoryLike.StructuralAtom.id",
"Eq.ndrec",
"Eq.refl",
"Eq"
] | true |
Ideal.span_pair_eq_span_right_iff_dvd._simp_1 | Mathlib.RingTheory.Ideal.Span | [
"Ideal.span_pair_eq_span_right_iff_dvd",
"Dvd.dvd",
"CommSemiring.toNonUnitalCommSemiring",
"CommSemiring.toSemiring",
"semigroupDvd",
"SemigroupWithZero.toSemigroup",
"Set.instSingletonSet",
"Insert.insert",
"NonUnitalSemiring.toSemigroupWithZero",
"Ideal",
"NonUnitalCommSemiring.toNonUnitalSem... | false |
_private.Mathlib.Order.SuccPred.Tree.0.IsPredArchimedean.pred_findAtom._simp_1_1 | Mathlib.Order.SuccPred.Tree | [
"Function.iterate_succ_apply'",
"Nat.iterate",
"Nat",
"Eq.symm",
"Nat.succ",
"Eq"
] | false |
Lean.Lsp.CompletionClientCapabilities._sizeOf_1 | Lean.Data.Lsp.Capabilities | [
"Option._sizeOf_inst",
"Lean.Lsp.CompletionClientCapabilities.rec",
"instOfNatNat",
"Lean.Lsp.CompletionItemCapabilities._sizeOf_inst",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Lean.Lsp.CompletionClientCapabilities",
"OfNat.ofNat",
"Lean.Lsp.CompletionItemCapabilities",
... | false |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.unitLattice_span_eq_top.match_1_1 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | [
"Real",
"Membership.mem",
"Subtype",
"Ne",
"NumberField.Units.dirichletUnitTheorem.w₀",
"Exists.casesOn",
"Exists.intro",
"NumberField.InfinitePlace",
"NumberField.Units.dirichletUnitTheorem.logSpace",
"Set.range",
"Eq",
"Set.instMembership",
"Field",
"NumberField",
"Set"
] | false |
DirectLimit.instMulOneClassOfMonoidHomClass.eq_1 | Mathlib.Algebra.Colimit.DirectLimit | [
"DirectLimit.instMulOneClassOfMonoidHomClass",
"MulOne.toOne",
"DirectLimit.instMul",
"Preorder.toLE",
"MulOne.mk",
"MulOne.toMul",
"LE.le",
"DirectLimit",
"DirectLimit.instMulOneClassOfMonoidHomClass._proof_3",
"DirectLimit.instMulOneClassOfMonoidHomClass._proof_4",
"MulOneClass.toMulOne",
"I... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.