name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go.eq_def | Lean.Util.Diff | [
"_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix._proof_2",
"Subarray",
"Std.Slice.toArray",
"InvImage",
"HSub.hSub",
"WellFounded.Nat.fix",
"WellFounded.Nat.fix_eq",
"_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._proof_2",
"id",
"_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix.go._proof_3",... | true |
InformationTheory.klDiv_def | Mathlib.InformationTheory.KullbackLeibler.Basic | [
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"InformationTheory.definition._@.Mathlib.InformationTheory.KullbackLeibler.Basic.2839050664._hygCtx._hyg.8",
"ENNReal.ofReal",
"Real.instRCLike",
"congrArg",
"Real.instSub",
"Set.... | true |
Std.DTreeMap.Equiv.of_forall_constGet?_eq | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Ord.mk",
"Ordering",
"Std.DTreeMap.Const.get?",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.Internal.Impl.Equiv.of_forall_constGet?_eq",
"Std.LawfulEqCmp",
"Std.DTreeMap.wf",
"Std.DTreeMap.Equiv",
"Eq",
"Std.DTreeMap.Equiv.mk",
"Option"
] | true |
IsUnit.isStrictlyPositive | Mathlib.Algebra.Algebra.StrictPositivity | [
"Iff.mpr",
"Monoid",
"IsUnit",
"LE.le",
"LE",
"IsStrictlyPositive.iff_of_unital",
"And",
"And.intro",
"Zero.toOfNat0",
"OfNat.ofNat",
"IsStrictlyPositive",
"Zero"
] | true |
Submodule.sub_mem | Mathlib.Algebra.Module.Submodule.Defs | [
"Submodule",
"Submodule.addSubgroupClass",
"AddCommGroup.toAddCommMonoid",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddCommGroup",
"sub_mem",
"SubNegMonoid.toSub",
"instHSub",
"AddGroup.toSubNegMonoid",
"Submodule.setLike",
"Module",
"Ring.toSemiring",
"Ring",
"SetLik... | true |
ENNReal.log_lt_zero_iff._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | [
"ENNReal.log_lt_zero_iff",
"Preorder.toLT",
"PartialOrder.toPreorder",
"EReal",
"ENNReal.log",
"instZeroEReal",
"LT.lt",
"ENNReal",
"propext",
"instPartialOrderEReal",
"One.toOfNat1",
"ENNReal.instPartialOrder",
"Zero.toOfNat0",
"ENNReal.instOne",
"OfNat.ofNat",
"Eq"
] | false |
CategoryTheory.IsCofilteredOrEmpty.cone_maps | Mathlib.CategoryTheory.Filtered.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Exists",
"CategoryTheory.IsCofilteredOrEmpty",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Category"
] | true |
CategoryTheory.Sieve.coverByImage._proof_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Presieve.CoverByImageStructure",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Nonempty.intro",
"CategoryTheory.Sieve.coverByImage._proof_3",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Presiev... | false |
_private.Init.WFExtrinsicFix.0.WellFounded.partialExtrinsicFix₂._proof_1 | Init.WFExtrinsicFix | [
"Subtype",
"Relation.TransGen",
"PSigma.mk",
"Nonempty",
"Or",
"Subtype.val",
"PSigma",
"Eq"
] | false |
Lean.Elab.Term.ToDepElimPattern.normalize | Lean.Elab.Match | [
"Inhabited.default",
"Lean.Elab.Term.ToDepElimPattern.Context",
"instInhabitedOfMonad",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.Elab.Term.ToDepElimPattern.M",
"Lean.Expr",
"IO.RealWorld",
"StateRefT'",
"StateRefT'.instMonad",
"Lean.Elab.Term.TermElabM",
"Inhabited",
"instInhabitedReaderT",
... | true |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.LinearOrderedAddCommGroup.discrete_iff_not_denselyOrdered._simp_1_1 | Mathlib.GroupTheory.ArchimedeanDensely | [
"IsEmpty",
"not_nonempty_iff",
"propext",
"Nonempty",
"Eq",
"Not"
] | false |
Ordinal.IsNormal.bsup_eq | Mathlib.SetTheory.Ordinal.Family | [
"Eq.mpr",
"Ordinal.instLinearOrder",
"Order.IsSuccLimit.ne_bot",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.instOrderBot",
"PartialOrder.toPreorder",
"Ordinal.bsup",
"Order.IsSuccLimit",
"id",
"Ordinal.instSuccOrder",
"Order.IsSuccLimit.succ_lt",
"Ordinal.IsNormal.bsup",... | true |
AddAction.IsBlock.eq_1 | Mathlib.GroupTheory.GroupAction.Blocks | [
"ChainCompletePartialOrder.instOfCompleteLattice",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"Disjoint",
"Set.vaddSet",
"VAdd",
"Ne",
"ChainCompletePartialOrder.toPartialOrder",
"HVAdd.hVAdd",
"instHVAdd",
"CompleteDistribLattice.toFrame",
"CompleteBooleanAlgebra.toCompleteLattice",
"... | true |
PiToModule.fromMatrix | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | [
"Pi.Function.module",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"instSMulOfMul",
"Pi.addCommMonoid",
"CommRing.toNonUnitalCommRing",
"Matrix.module",
"AlgEquiv.symm",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Matrix",
"Module.End.inst... | true |
CategoryTheory.NonPreadditiveAbelian.epi_r | Mathlib.CategoryTheory.Abelian.NonPreadditive | [
"CategoryTheory.NormalMonoCategory.epi_of_zero_cancel",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.CokernelCofork.IsColimit.desc'",
"CategoryTheory.Limits.KernelFork.ofι",
"CategoryTheory.Epi",
"CategoryTheory.CategoryS... | true |
CochainComplex.HomComplex.Cocycle.leftUnshift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | [
"HomologicalComplex.instCategory",
"CochainComplex.HomComplex.Cocycle.leftUnshift._proof_1",
"CochainComplex.HomComplex.instAddCommGroupCochain",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemigroup",
"CochainComplex.instHasShiftInt",
"AddCancelMonoid.toAddRightCancelMonoid",
... | true |
CategoryTheory.Adjunction.unit_rightAdjointUniq_hom_app | Mathlib.CategoryTheory.Adjunction.Unique | [
"Eq.mpr",
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.conjugateEquiv_apply_app",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id... | true |
Std.Iterators.Types.Zip.instProductive | Std.Data.Iterators.Combinators.Monadic.Zip | [
"Std.Iterators.Types.Zip.instProductivenessRelation",
"Std.Iterator",
"Std.Iterators.Productive",
"Std.Iterators.Types.Zip.instIterator",
"Std.Iterators.Productive.of_productivenessRelation",
"Std.Iterators.Types.Zip",
"Prod",
"Monad"
] | true |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.ctorElim | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | [
"Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.ctorElimType",
"Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval",
"Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.ci",
"Nat",
"Lean.Meta.Grind.Arith.Cutsat.SymbolicBound",
"Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.co",
"Lean.Meta.Grind.Arith.C... | false |
Lean.Parser.Term.matchAltsWhereDecls._regBuiltin.Lean.Parser.Term.matchAltsWhereDecls.formatter_3 | Lean.Parser.Term | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"Lean.Parser.Term.matchAltsWhereDecls.formatter",
"IO",
"Unit",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
Finset.le_prod_of_submultiplicative_of_nonneg | Mathlib.Algebra.Order.BigOperators.Ring.Finset | [
"CommMonoidWithZero.toCommMonoid",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"IsOrderedRing.toPosMulMono",
"HMul.hMul",
"Multiset.map",
"Monoid.toMulOneClass",
"IsOrderedRing",
"instReflLe",
"congrArg",
"CommSemiring.toSemiring",
"Finset",
"Multiset.prod",
"PartialOrder.to... | true |
_private.Std.Do.Triple.SpecLemmas.0.List.forIn'_cons.match_1.eq_2 | Std.Do.Triple.SpecLemmas | [
"ForInStep.done",
"ForInStep",
"List.forIn'_cons.match_1",
"Eq.refl",
"Eq",
"ForInStep.yield"
] | true |
Std.DHashMap.Internal.Raw.fold_cons | Std.Data.DHashMap.Internal.WF | [
"congrArg",
"List.map",
"Std.DHashMap.Raw",
"id",
"Std.DHashMap.Raw.fold",
"Sigma.fst",
"Std.DHashMap.Internal.Raw.fold_cons_apply",
"List.cons",
"instHAppendOfAppend",
"List.map_id_fun'",
"List",
"congrFun",
"List.map_reverse",
"Std.DHashMap.Raw.buckets",
"True",
"eq_self",
"Std.DHa... | true |
Fin.div._proof_1 | Init.Data.Fin.Basic | [
"instHDiv",
"Nat.lt_of_le_of_lt",
"HDiv.hDiv",
"Nat.div_le_self",
"Nat",
"LT.lt",
"Nat.instDiv",
"instLTNat"
] | false |
instSubsingletonLieAlgebraRat | Mathlib.Algebra.Lie.Basic | [
"LieAlgebra.toModule",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Function.Injective.subsingleton",
"Rat",
"subsingleton_rat_module",
"LieAlgebra.toModule_injective",
"LieRing",
"CommRing.toCommSemiring",
"Subsingleton",
"LieAlgebra",
"Module",
"R... | true |
Matrix.IsSymm.sub._simp_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | [
"Matrix",
"HSub.hSub",
"instHSub",
"Matrix.sub",
"True",
"Matrix.IsSymm",
"eq_true",
"Matrix.IsSymm.sub",
"Eq",
"Sub"
] | false |
Lean.Firefox.Thread.processType | Lean.Util.Profiler | [
"String",
"Lean.Firefox.Thread"
] | true |
_private.Mathlib.GroupTheory.DivisibleHull.0.DivisibleHull.archimedeanClassOrderHom.eq_1 | Mathlib.GroupTheory.DivisibleHull | [
"DivisibleHull.coeOrderAddMonoidHom._proof_2",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"DivisibleHull.instLinearOrder",
"LinearOrder",
"ArchimedeanClass.orderHom",
"ArchimedeanClass.instLinearOrder",
"OreLocalization.instAddCommGroup",
"PartialOrder.toPreorder",
"DivisibleHull",... | true |
Lean.Doc.instOrdBlock.ord | Lean.DocString.Types | [
"Inhabited.default",
"instInhabitedOrdering",
"Ord",
"Lean.Doc.Block",
"Ordering"
] | true |
BitVec.instCommutativeHXor | Init.Data.BitVec.Lemmas | [
"Std.Commutative",
"BitVec.instXorOp",
"BitVec",
"BitVec.xor_comm",
"Nat",
"HXor.hXor",
"Std.Commutative.mk",
"instHXorOfXorOp"
] | true |
_private.Std.Data.DHashMap.Raw.0.Std.DHashMap.Raw.containsThenInsert.eq_1 | Std.Data.DHashMap.Raw | [
"Std.DHashMap.Raw",
"Std.DHashMap.Internal.Raw₀.containsThenInsert",
"Prod.mk",
"instOfNatNat",
"Std.DHashMap.Raw.containsThenInsert",
"dite",
"Subtype.mk",
"_private.Std.Data.DHashMap.Raw.0.Std.DHashMap.Raw.containsThenInsert.match_1",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Bool",
"Na... | true |
DomAddAct.instNonUnitalSemiringOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | [
"AddOpposite",
"DomAddAct",
"NonUnitalSemiring"
] | true |
_private.Init.Data.Option.Lemmas.0.Option.get_eq_get!.match_1_1 | Init.Data.Option.Lemmas | [
"False",
"HEq.refl",
"False.elim",
"Option.casesOn",
"noConfusion_of_Nat",
"Option.some",
"Eq.casesOn",
"Bool.ctorIdx",
"Bool.true",
"Option.none",
"Bool",
"Eq.refl",
"HEq",
"Option.isSome",
"Bool.false",
"Eq",
"Option"
] | false |
Lean.Firefox.ResourceTable.mk.injEq | Lean.Util.Profiler | [
"Lean.Json",
"Eq.propIntro",
"Lean.Firefox.ResourceTable.mk.inj",
"Lean.injEq_helper",
"Lean.Firefox.ResourceTable.mk",
"Array",
"And",
"Nat",
"Lean.Firefox.ResourceTable",
"Eq.ndrec",
"Eq.refl",
"Eq"
] | true |
Std.DHashMap.contains_emptyWithCapacity | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.Internal.Raw₀.contains_emptyWithCapacity",
"Std.DHashMap.contains",
"Nat",
"Bool",
"Hashable",
"Std.DHashMap.emptyWithCapacity",
"Bool.false",
"BEq",
"Eq"
] | true |
CategoryTheory.StrongEpi.recOn | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | [
"CategoryTheory.HasLiftingProperty",
"CategoryTheory.Epi",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.StrongEpi.mk",
"CategoryTheory.StrongEpi.rec",
"CategoryTheory.StrongEpi",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"... | false |
Set.nonempty_uIcc._simp_1 | Mathlib.Order.Interval.Set.UnorderedInterval | [
"Lattice",
"Set.Nonempty",
"True",
"eq_true",
"Set.nonempty_uIcc",
"Eq",
"Set.uIcc"
] | false |
OpenPartialHomeomorph.IsImage.restr._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.IsImage | [
"Set.inter_subset_left",
"OpenPartialHomeomorph.toFun'",
"OpenPartialHomeomorph.IsImage",
"TopologicalSpace",
"OpenPartialHomeomorph.continuousOn",
"OpenPartialHomeomorph.IsImage.toPartialEquiv",
"PartialEquiv.source",
"ContinuousOn.mono",
"ContinuousOn",
"OpenPartialHomeomorph.toPartialEquiv",
... | false |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.instOrderBot._simp_1 | Mathlib.Algebra.Module.Submodule.Lattice | [
"SetLike",
"outParam",
"Membership.mem",
"ZeroMemClass",
"True",
"eq_true",
"Zero.toOfNat0",
"ZeroMemClass.zero_mem",
"OfNat.ofNat",
"Eq",
"SetLike.instMembership",
"Zero"
] | false |
StarOrderedRing.toIsOrderedRing | Mathlib.Algebra.Order.Ring.Star | [
"IsOrderedModule.toPosSMulMono",
"smul_le_smul_of_nonneg_right",
"Semiring.toModule",
"instSMulOfMul",
"IsOrderedRing",
"CommSemiring.toNonUnitalCommSemiring",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsOrderedModule.toSMulPosMono",
"AddMonoid.toAddZeroClass",
"PartialOrder.... | true |
Std.DHashMap.Raw.Const.mem_ofList._simp_1 | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Std.DHashMap.Raw.Const.ofList",
"List.map",
"List.contains",
"Std.DHashMap.Raw",
"Membership.mem",
"LawfulHashable",
"Prod.fst",
"Bool.true",
"List",
"EquivBEq",
"Std.DHashMap.Raw.Const.mem_ofList",
"propext",
"Bool",
"Hashable",
"Prod... | false |
CommAlgCat.isoEquivAlgEquiv._proof_2 | Mathlib.Algebra.Category.CommAlgCat.Basic | [
"CommAlgCat.algEquivOfIso",
"CommRing",
"CommAlgCat.of",
"CommSemiring.toSemiring",
"Algebra",
"CategoryTheory.Iso",
"CommAlgCat.instCategory",
"CommRing.toCommSemiring",
"AlgEquiv",
"Function.RightInverse",
"CommAlgCat",
"Eq.refl",
"CommAlgCat.isoMk"
] | false |
Lean.Meta.MatcherApp.ctorIdx | Lean.Meta.Match.MatcherApp.Basic | [
"Lean.Meta.MatcherApp",
"Nat"
] | false |
ssubset_of_subset_of_ne | Mathlib.Order.RelClasses | [
"HasSSubset",
"Std.Antisymm",
"HasSSubset.SSubset",
"mt",
"HasSubset.Subset.ssubset_of_not_subset",
"HasSubset.Subset",
"Ne",
"HasSubset.Subset.antisymm",
"HasSubset",
"Eq",
"IsNonstrictStrictOrder"
] | true |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Subcanonical.0.CategoryTheory.Precoverage.ZeroHypercover.isPullback_of_forall_isPullback._simp_1_2 | Mathlib.CategoryTheory.Sites.Hypercover.Subcanonical | [
"CategoryTheory.IsIso",
"CategoryTheory.MorphismProperty.isomorphisms.iff",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.isomorphisms",
"propext",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Category"
] | false |
NNRealRMK.rieszMeasure_integralLinearMap | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.NNReal | [
"NNReal.instTopologicalSpace",
"Real.instLE",
"MeasureTheory.Measure.ext_of_integral_eq_on_compactlySupported_nnreal",
"Real",
"MeasureTheory.Measure",
"Semiring.toModule",
"Real.instZero",
"congrArg",
"CompactlySupportedContinuousMap",
"SeparatelyContinuousMul.to_continuousSMul",
"CompactlySupp... | true |
UInt16.reduceSub | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | [
"HSub.hSub",
"instOfNatNat",
"UInt16",
"instHSub",
"Nat",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"instSubUInt16",
"OfNat.ofNat",
"UInt16.reduceBin._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.3"
] | true |
_private.Mathlib.Data.Set.Equitable.0.Finset.equitableOn_iff._simp_1_2 | Mathlib.Data.Set.Equitable | [
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"And",
"HAdd.hAdd",
"Nat",
"propext",
"instAddNat",
"Nat.le_and_le_add_one_iff",
"Or",
"OfNat.ofNat",
"Eq"
] | false |
ContinuousLinearEquiv.comp_hasFDerivWithinAt_iff' | Mathlib.Analysis.Calculus.FDeriv.Equiv | [
"ContinuousLinearMap.comp",
"Eq.mpr",
"ContinuousLinearEquiv.symm",
"ContinuousLinearEquiv.coe_comp_coe_symm",
"NormedSpace",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"Iff.rfl",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"HasFDerivWithinAt",
"NormedField.... | true |
Finset.prod_inv_distrib | Mathlib.Algebra.BigOperators.Group.Finset.Defs | [
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Finset",
"DivisionCommMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"DivisionCommMonoid.toCommMonoid",
"Finset.val",
"Finset.prod",
"Inv.inv",
"InvOneClass.toInv",
"Eq",
"Multiset.prod_map_inv"
] | true |
Lean.Lsp.instFromJsonResolvableCompletionItem.fromJson | Lean.Data.Lsp.LanguageFeatures | [
"Pure.pure",
"Lean.Json",
"Lean.instFromJsonString",
"Monad.toApplicative",
"String",
"Lean.Lsp.CompletionItemTag",
"Lean.instFromJsonOption",
"Lean.Name.mkStr3",
"Lean.Json.getObjValAs?",
"Lean.Lsp.instFromJsonResolvableCompletionItemData",
"Lean.Lsp.MarkupContent",
"Lean.instFromJsonArray",
... | true |
ENNReal.inv_eq_top | Mathlib.Data.ENNReal.Inv | [
"Eq.rec",
"ENNReal.inv_zero",
"Iff",
"inv_inj",
"Inv.inv",
"ENNReal.instInvolutiveInv",
"ENNReal",
"Zero.toOfNat0",
"ENNReal.instInv",
"ENNReal.instTop",
"ENNReal.instZero",
"Top.top",
"OfNat.ofNat",
"Eq"
] | true |
_private.Mathlib.NumberTheory.FLT.Four.0.Fermat42.mul._proof_1_1 | Mathlib.NumberTheory.FLT.Four | [
"instPowNat",
"Lean.RArray.leaf",
"False",
"Int.instIsStrictOrderedRing",
"Lean.Grind.CommRing.Mon.mult",
"Lean.Grind.not_not",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"HMul.hMul",
"Lean.Grind.CommRing.Expr.mul",
"Lean.Grind.not_and",
"eq_false",
"Lean.Grind.iff_eq",
"Lean.... | false |
Module.Finite.iff_cofg_bot | Mathlib.RingTheory.Finiteness.Cofinite | [
"Submodule",
"Submodule.Quotient.addCommMonoid",
"AddCommGroup.toAddCommMonoid",
"Submodule.hasQuotient",
"AddCommGroup",
"Submodule.quotEquivOfEqBot",
"Bot.bot",
"Submodule.Quotient.module",
"Submodule.instBot",
"HasQuotient.Quotient",
"Submodule.CoFG",
"Iff",
"Submodule.CoFG.of_finite",
... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.mkRingContext.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Nat",
"_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.getVarOf._sparseCasesOn_1",
"Option"
] | false |
Int64.ofNat_int8ToNatClampNeg | Init.Data.SInt.Lemmas | [
"instPowNat",
"Eq.mpr",
"of_decide_eq_true",
"Int64.toInt",
"congrArg",
"Int8.toInt_toInt64",
"Int8.toInt64",
"Int8",
"Int8.toInt",
"id",
"Int64",
"instOfNatNat",
"Int",
"LE.le",
"instLENat",
"Nat.cast",
"instNatPowNat",
"Bool.true",
"HPow.hPow",
"Int8.toNatClampNeg",
"Nat",
... | true |
CategoryTheory.ShortComplex.exact_iff_epi_imageToKernel | Mathlib.CategoryTheory.Abelian.Exact | [
"CategoryTheory.Abelian.toPreadditive",
"Eq.mpr",
"CategoryTheory.Limits.HasImages.has_image",
"CategoryTheory.Subobject.underlying",
"imageToKernel'_kernelSubobjectIso",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.imageSubobject... | true |
FirstOrder.Language.Substructure.map_iInf_comap_of_surjective | Mathlib.ModelTheory.Substructures | [
"iInf",
"FirstOrder.Language.Substructure.instInfSet",
"FirstOrder.Language.Hom",
"GaloisInsertion.l_iInf_u",
"FirstOrder.Language.Substructure",
"FirstOrder.Language.Structure",
"FirstOrder.Language.Substructure.giMapComap",
"FirstOrder.Language",
"FirstOrder.Language.Substructure.instCompleteLatti... | true |
CategoryTheory.Functor.OplaxMonoidal.recOn | Mathlib.CategoryTheory.Monoidal.Functor | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategoryStruct.rightUnitor",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategoryStruct.leftUnitor",
"CategoryTheory.Functor.map... | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.partialTraj_const_restrict₂._proof_1_1 | Mathlib.Probability.ProductMeasure | [
"Finset.Ioc_subset_Iic_self",
"Finset",
"Nat.instLocallyFiniteOrder",
"LocallyFiniteOrder.toLocallyFiniteOrderBot",
"HasSubset.Subset",
"Nat.instPreorder",
"Nat",
"Finset.instHasSubset",
"Finset.Iic",
"Nat.instOrderBot",
"Finset.Ioc"
] | false |
String.Legacy.Iterator.ValidFor.prevn | Batteries.Data.String.Lemmas | [
"List.brecOn",
"String.Legacy.Iterator.ValidFor.prevn._f",
"LE.le",
"instLENat",
"instHAppendOfAppend",
"List",
"List.drop",
"Nat",
"List.reverse",
"String.Legacy.Iterator",
"Char",
"String.Legacy.Iterator.ValidFor",
"List.instAppend",
"List.take",
"List.length",
"HAppend.hAppend",
"... | true |
not_isOfFinAddOrder_of_isAddTorsionFree | Mathlib.GroupTheory.OrderOfElement | [
"Eq.mpr",
"False",
"instHSMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Exists",
"AddZeroClass.toAddZero",
"Eq.mp",
"nsmul_zero",
"id",
"Ne",
"instOfNatNat",
"IsAddTorsionFree",
"And.casesOn",
"LT.lt.ne'",
"IsOfFinAddOrder",
"AddZero.toZero",
"And",
"Exist... | true |
Lean.Omega.LinearCombo.smul_eval | Init.Omega.LinearCombo | [
"HMul.hMul",
"Lean.Omega.LinearCombo.coeffs",
"congrArg",
"Lean.Omega.LinearCombo.eval",
"Int",
"Lean.Omega.LinearCombo",
"Int.instMul",
"instHAdd",
"HAdd.hAdd",
"Lean.Omega.Coeffs",
"Lean.Omega.LinearCombo.mk",
"Lean.Omega.LinearCombo.instHMulInt",
"congr",
"True",
"eq_self",
"of_eq_t... | true |
Lean.Lsp.CreateFile.instFromJsonOptions | Lean.Data.Lsp.Basic | [
"Lean.Lsp.CreateFile.instFromJsonOptions.fromJson",
"Lean.FromJson",
"Lean.Lsp.CreateFile.Options",
"Lean.FromJson.mk"
] | true |
codisjoint_inf_left._simp_1 | Mathlib.Order.Disjoint | [
"Codisjoint",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"SemilatticeInf.toMin",
"OrderTop",
"DistribLattice",
"And",
"propext",
"codisjoint_inf_left",
"Eq",
"Min.min",
"Lattice.toSemilatticeInf"
] | false |
instChartedSpaceEuclideanSpaceRealFinElemHAddNatOfNatSphere | Mathlib.Geometry.Manifold.Instances.Sphere | [
"NormedCommRing.toNormedRing",
"Pi.Function.module",
"Real",
"Semiring.toModule",
"fact_one_le_two_ennreal",
"NormedRing.toRing",
"Real.instRCLike",
"AddCommGroup.toAddCommMonoid",
"PseudoMetricSpace.toUniformSpace",
"PiLp.instPseudoMetricSpace",
"WithLp.instAddCommGroup",
"Membership.mem",
... | true |
AddSubgroup.leftTransversals.diff.eq_1 | Mathlib.GroupTheory.Transfer | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"AddSubgroup.fintypeQuotientOfFiniteIndex",
"AddSubgroup.FiniteIndex",
"Equiv.instEquivLike",
"AddSubgroup.leftTransversals.diff._proof_1",
"Finset.univ",
"AddSubgroup.leftTransversals.diff._proof_2",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.... | true |
VectorBundleCore.toTopologicalSpace._proof_2 | Mathlib.Topology.VectorBundle.Basic | [
"NormedSpace",
"TopologicalSpace.GenerateOpen.inter",
"FiberBundleCore.Fiber",
"PseudoMetricSpace.toUniformSpace",
"instTopologicalSpaceProd",
"Set.instSingletonSet",
"FiberBundleCore.TotalSpace",
"Set.instInter",
"VectorBundleCore.toFiberBundleCore",
"Inter.inter",
"TopologicalSpace",
"Vector... | false |
_private.Init.Data.Nat.Fold.0.Nat.all.eq_def | Init.Data.Nat.Fold | [
"Eq.mpr",
"_private.Init.Data.Nat.Fold.0.Nat.fold._proof_4",
"Nat.all._f",
"congrArg",
"HEq.refl",
"Nat.brecOn.go",
"Nat.rec",
"Nat.brecOn",
"Nat.brecOn.eq",
"id",
"Bool.and",
"_private.Init.Data.Nat.Fold.0.Nat.any.match_1",
"instOfNatNat",
"Nat.all",
"_private.Init.Data.Nat.Fold.0.Nat.f... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.min?_keys._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"Membership.mem",
"Bool.true",
"Std.DTreeMap.Internal.Impl.contains",
"propext",
"Bool",
"Std.DTreeMap.Internal.Impl.mem_iff_contains",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Std.DTreeMap.Internal.Impl.instMembershipOfOrd"
] | false |
Lean.Widget.GetWidgetSourceParams.mk.noConfusion | Lean.Widget.UserWidget | [
"UInt64",
"id",
"Lean.Lsp.Position",
"Eq",
"Lean.Widget.GetWidgetSourceParams",
"Lean.Widget.GetWidgetSourceParams.mk",
"Lean.Widget.GetWidgetSourceParams.noConfusion"
] | false |
Lean.Grind.CommRing.instBEqExpr.beq._sparseCasesOn_9 | Init.Grind.Ring.CommSolver | [
"Lean.Grind.CommRing.Expr",
"Lean.Grind.CommRing.Expr.mul",
"Nat.ne_of_beq_eq_false",
"Lean.Grind.CommRing.Expr.var",
"Nat.shiftRight",
"Lean.Grind.CommRing.Expr.sub",
"Lean.Grind.CommRing.Expr.ctorIdx",
"Lean.Grind.CommRing.Expr.natCast",
"Lean.Grind.CommRing.Expr.neg",
"Nat.hasNotBit",
"instOf... | false |
ZSpan.vadd_mem_fundamentalDomain | Mathlib.Algebra.Module.ZLattice.Basic | [
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Submodule.vadd_def",
"NegZeroClass.toNeg",
"Submodule",
"Submodule.addSubgroupClass",
"NormedRing.toRing",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"NormedSpace",
"instVAddOfAdd",
"congrArg",
"AddCommGroup.toAddComm... | true |
Array.zipIdx_eq_map_add | Init.Data.Array.Range | [
"Eq.mpr",
"Array.zipIdx_toArray",
"congrArg",
"List.map",
"List.map_toArray",
"Array.map",
"Array.casesOn",
"id",
"Prod.mk",
"instOfNatNat",
"Prod.fst",
"List.toArray",
"Array.zipIdx",
"Array",
"List",
"instHAdd",
"Array.mk.injEq",
"List.zipIdx_eq_map_add",
"HAdd.hAdd",
"Nat",
... | true |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mk | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | [
"Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality",
"Mathlib.Tactic.BicategoryLike.NormalizedHom",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso",
"Lean.Expr",
"Mathlib.Tactic.BicategoryLike.Mor₁",
"Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mk"
] | true |
_private.Lean.Meta.Check.0.Lean.Meta.throwLetTypeMismatchMessage._sparseCasesOn_1 | Lean.Meta.Check | [
"Lean.LocalDecl.cdecl",
"Lean.LocalDecl.ldecl",
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Lean.LocalDeclKind",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.LocalDecl.ctorIdx",
"Nat.land",
"Nat",
"Lean.LocalDecl.rec",
"Bool",
"Lean.Name",
"Eq.refl",
"Lean.Loca... | false |
CategoryTheory.regularOfIsPullbackFstOfRegular._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq.symm",
"Eq",
"CategoryTheory.Category"
] | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffWithinAt_nat.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | [
"Filter.instMembership",
"NormedCommRing.toSeminormedCommRing",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ENat.instNatCast",
"FormalMultilinearSeries",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"nhdsWithin",
"Norme... | false |
List.findFinIdx?_singleton._proof_1 | Init.Data.List.Find | [
"congrArg",
"instOfNatNat",
"Nat.lt_add_one._simp_1",
"List.cons",
"Nat",
"LT.lt",
"True",
"of_eq_true",
"instLTNat",
"Nat.zero_add",
"OfNat.ofNat",
"List.length",
"Eq.trans",
"List.nil"
] | false |
BitVec.ofBool_xor_ofBool | Init.Data.BitVec.Lemmas | [
"BitVec.instXorOp",
"BitVec",
"instOfNatNat",
"Bool.true",
"Bool.casesOn",
"Bool.xor",
"Nat",
"HXor.hXor",
"Bool",
"Eq.ndrec",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Bool.false",
"Eq",
"instHXorOfXorOp",
"BitVec.ofBool"
] | true |
_private.Mathlib.Algebra.Module.Submodule.Map.0.LinearMap.iInf_invariant._simp_1_1 | Mathlib.Algebra.Module.Submodule.Map | [
"Submodule",
"iInf",
"Submodule.mem_iInf",
"Membership.mem",
"AddCommMonoid",
"Submodule.setLike",
"propext",
"Semiring",
"Module",
"Eq",
"SetLike.instMembership",
"Submodule.instInfSet"
] | false |
Algebra.Extension.Cotangent.map._proof_2 | Mathlib.RingTheory.Extension.Basic | [
"Eq.mpr",
"Submodule",
"CommRing",
"instHSMul",
"Algebra.Extension.commRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"AlgHom.algHomClass",
"Algebra.Extension.Hom.toRingHom",
"HMul.hMul",
"Algebra.Extension.instModuleCotangent",
"IsScalarTower.right",
"CommRing.... | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unsafe_rec | Init.Data.Array.BinSearch | [
"Pure.pure",
"Unit.unit",
"_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_6",
"False",
"Array.insertIdx",
"instHDiv",
"_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_3",
"congrArg",
"Monad.toApplicative",
"Std.IsLinearPreorder.toIsPreorder",
"False.elim",
"_priv... | false |
LinearMap.trace_transpose | Mathlib.LinearAlgebra.Trace | [
"dualTensorHomEquiv",
"LinearMap.trace",
"CommRing",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"IsScalarTower.right",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"TensorProduct.addCommMonoid",
"LinearMap.add... | true |
AlgebraicGeometry.Scheme.Opens.toSpecΓ_preimage_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | [
"AlgebraicGeometry.Scheme.Hom.opensFunctor",
"Eq.mpr",
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"Lattice.toSemilatticeSup",
"Opposite",
"CommRingCat.carrier",
"Quiver.opposite",
"AlgebraicGeometry.PresheafedSpace.car... | true |
Turing.TM2to1.StAct | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"Turing.TM2to1.StAct.pop",
"Turing.TM2to1.StAct.peek",
"Turing.TM2to1.StAct.push"
] | true |
_private.Mathlib.Probability.UniformOn.0.ProbabilityTheory.uniformOn_univ._simp_1_2 | Mathlib.Probability.UniformOn | [
"instHDiv",
"HMul.hMul",
"CommSemiring.toSemiring",
"HDiv.hDiv",
"ENNReal.instCommSemiring",
"instDistribOfSemiring",
"Inv.inv",
"Distrib.toMul",
"ENNReal",
"ENNReal.instDivInvMonoid",
"DivInvMonoid.toDiv",
"ENNReal.instInv",
"Eq.symm",
"Eq",
"ENNReal.div_eq_inv_mul",
"instHMul"
] | false |
Finset.exists_notMem | Mathlib.Data.Set.Finite.Basic | [
"Finset",
"Membership.mem",
"Exists",
"Set.Finite.exists_notMem",
"SetLike.coe",
"Finset.instSetLike",
"Finset.finite_toSet",
"Infinite",
"Not",
"SetLike.instMembership"
] | true |
le_or_lt_of_add_le_add | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | [
"not_le",
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"LinearOrder",
"PartialOrder.toPreorder",
"AddRightStrictMono",
"AddLeftMono",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"id",
"LE.le",
"not_or",
"Mathlib.Tactic.Contrapose.contrapose₁",
"instHAdd",
... | true |
AddSubsemigroup.map_surjective_of_surjective | Mathlib.Algebra.Group.Subsemigroup.Operations | [
"AddSubsemigroup.giMapComap",
"AddHom",
"PartialOrder.toPreorder",
"AddSubsemigroup.comap",
"AddHom.funLike",
"AddSubsemigroup.instPartialOrder",
"AddSubsemigroup",
"GaloisInsertion.l_surjective",
"DFunLike.coe",
"Function.Surjective",
"Add",
"AddSubsemigroup.map"
] | true |
FirstOrder.Field.eqZero | Mathlib.ModelTheory.Algebra.Field.CharP | [
"FirstOrder.Language.ring",
"FreeCommRing",
"AddGroupWithOne.toAddMonoidWithOne",
"instCommRingFreeCommRing",
"FirstOrder.Language.Term",
"FirstOrder.Language.Term.equal",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"Empty",
"FirstOrder.Ring.instZeroTermRing",
"Nat",
"Zero.toOfNat0",
"FirstOrd... | true |
add_neg_nonpos_iff_le | Mathlib.Algebra.Order.Group.Unbundled.Basic | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"AddRightMono",
"AddZeroClass.toAddZero",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNegZeroMonoid.toNegZeroClass",
"zero_add",
"LE",
"AddZero.toZero",
"in... | true |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsLittleO.comp_fst._simp_1_1 | Mathlib.Analysis.Asymptotics.Defs | [
"Norm.norm",
"Real.instLE",
"Real",
"HMul.hMul",
"Real.instZero",
"Filter.Eventually",
"Real.instLT",
"Norm",
"LE.le",
"Real.instMul",
"LT.lt",
"propext",
"Zero.toOfNat0",
"Asymptotics.IsLittleO",
"Asymptotics.isLittleO_iff",
"OfNat.ofNat",
"Eq",
"Filter",
"instHMul"
] | false |
_private.Mathlib.Data.ENat.Basic.0.ENat.top_ne_ofNat.match_1_1 | Mathlib.Data.ENat.Basic | [
"False",
"ENat.instNatCast",
"instTopENat",
"Option.ctorIdx",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Option.some",
"Eq.casesOn",
"Option.none",
"Nat",
"ENat",
"Eq.refl",
"HEq",
"Top.top",
"OfNat.ofNat",
"Eq",
"instOfNatAtLeastTwo",
"Nat.AtLeastTwo",
"Option"
] | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.LFunction.0.ArithmeticFunction.tendsTo_eulerProduct_of_tendsTo._simp_1_5 | Mathlib.NumberTheory.ArithmeticFunction.LFunction | [
"Filter.Eventually",
"Membership.mem",
"Filter.tendsto_principal",
"Filter.Tendsto",
"propext",
"Filter.principal",
"Eq",
"Set.instMembership",
"Filter",
"Set"
] | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.toBitVec_eq_of_parseFirstByte_eq_twoMore | Init.Data.String.Decode | [
"ByteArray.utf8DecodeChar?.parseFirstByte",
"BitVec.setWidth",
"BitVec.extractLsb'",
"BitVec.instHAppendHAddNat",
"BitVec",
"ByteArray.utf8DecodeChar?.FirstByte.twoMore",
"_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_twoMore_iff_toBitVec",
"_private.Init.Data.String.D... | true |
lp.coeFn_sub | Mathlib.Analysis.Normed.Lp.lpSpace | [
"HSub.hSub",
"instAddCommGroupPreLp",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddSubgroup.sub",
"Subtype",
"AddSubgroup",
"SubNegMonoid.toSub",
"instHSub",
"lp",
"AddGroup.toSubNegMonoid",
"AddSubgroup.instSetLike",
"ENNReal",
"PreLp",
"NormedAddCommGroup.toAddCommGroup",
"Pi.ins... | true |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_20 | Mathlib.Data.List.Chain | [
"Lean.Grind.nestedProof",
"congrArg",
"HEq.refl",
"cast",
"Membership.mem",
"Eq.rec",
"List.cons",
"List",
"List.instMembership",
"eq_of_heq",
"HEq",
"List.mem_cons_self",
"Eq",
"Lean.Grind.abstractFn",
"_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_2"
] | false |
bex_def | Mathlib.Logic.Basic | [
"Exists",
"_private.Mathlib.Logic.Basic.0.bex_def.match_1_3",
"And",
"Iff",
"_private.Mathlib.Logic.Basic.0.bex_def.match_1_1",
"And.intro",
"Iff.intro",
"Exists.intro"
] | true |
Semiring.toGrindSemiring._proof_8 | Mathlib.Algebra.Ring.GrindInstances | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instNeZeroNatHAdd_1",
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
"inferInstance",
"Semiring.toGrindSemiring.match_1",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"po... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.