name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Grind.Arith.Linear.EqCnstr.brecOn.go | Lean.Meta.Tactic.Grind.Arith.Linear.Types | [
"Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofDiseqSplit",
"Lean.Meta.Grind.Arith.Linear.IneqCnstr.below",
"Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat",
"Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq",
"Lean.Meta.Grind.Arith.Linear.LinExpr",
"Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.below"... | true |
String.Slice.skipSuffix?_slice_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | [
"Eq.mpr",
"String.Slice.Pattern.Model.skipSuffix?_eq_some_iff",
"String.Slice.Pattern.Model.BackwardSliceSearcher.lawfulBackwardPatternModel",
"String.Slice.Pattern.BackwardSliceSearcher.instBackwardPattern",
"congrArg",
"String.Slice.skipSuffix?_slice_of_isEmpty",
"String",
"Iff.rfl",
"String.Slice... | true |
CommAlgCat.instMonoidalCategory | Mathlib.Algebra.Category.CommAlgCat.Monoidal | [
"CommAlgCat.instMonoidalCategory._proof_6",
"CommRing",
"CommAlgCat.ofHom",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommAlgCat.instCommRingObjForgetAlgHomCarrier",
"CommRing.toNonUnitalCommRing",
"CommAlgCat.of",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommAlgCat.instMon... | true |
SimpleGraph.Walk.mem_support_nil_iff | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | [
"False",
"congrArg",
"SimpleGraph.Walk.support",
"Membership.mem",
"List.not_mem_nil._simp_1",
"List.cons",
"SimpleGraph",
"iff_self",
"List",
"Iff",
"List.instMembership",
"List.mem_cons._simp_1",
"SimpleGraph.Walk.nil",
"True",
"of_eq_true",
"congrFun'",
"or_false",
"Or",
"Eq",... | true |
_private.Mathlib.Data.Seq.Computation.0.Computation.liftRel_bind.match_1_9 | Mathlib.Data.Seq.Computation | [
"Membership.mem",
"Exists",
"Computation",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Computation.instMembership"
] | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.inj | Lean.Server.ProtocolOverview | [
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.noConfusion",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind",
"String",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview",
"_private.Lean.Server.Proto... | true |
Lean.Doc.Inline.linebreak.noConfusion | Lean.DocString.Types | [
"String",
"id",
"heq_of_eq",
"Eq.refl",
"Eq",
"Lean.Doc.Inline.linebreak",
"Lean.Doc.Inline.noConfusion",
"Lean.Doc.Inline"
] | false |
Ordinal.CNF.coeff_zero_right | Mathlib.SetTheory.Ordinal.CantorNormalForm | [
"Finsupp.ext",
"Ordinal.CNF.coeff",
"Ordinal.CNF.coeff_zero_apply",
"Ordinal.zero",
"Zero.toOfNat0",
"Finsupp.instZero",
"OfNat.ofNat",
"Eq",
"Finsupp",
"Ordinal"
] | true |
IntervalIntegrable.comp_add_left_iff | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | [
"TopologicalSpace.PseudoMetrizableSpace",
"Eq.mpr",
"IntervalIntegrable.comp_add_left_iff._auto_1",
"Real",
"MeasureTheory.Measure",
"congrArg",
"IntervalIntegrable",
"Real.instSub",
"ENormedAddMonoid",
"MeasureTheory.MeasureSpace.toMeasurableSpace",
"HSub.hSub",
"_private.Mathlib.MeasureTheor... | true |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.sSup_eq_eqvGen._simp_1_1 | Mathlib.Data.Setoid.Basic | [
"Setoid",
"LE.le",
"Setoid.le_def",
"Setoid.instLE_mathlib",
"propext",
"Eq",
"Setoid.r"
] | false |
MulOpposite.instNonUnitalSemiring._proof_1 | Mathlib.Algebra.Ring.Opposite | [
"Semigroup.toMul",
"Semigroup.mul_assoc",
"MulOpposite.instSemigroupWithZero",
"HMul.hMul",
"MulOpposite",
"SemigroupWithZero.toSemigroup",
"NonUnitalSemiring.toSemigroupWithZero",
"NonUnitalSemiring",
"Eq",
"instHMul"
] | false |
Cardinal.ofNat_eq_toENat | Mathlib.SetTheory.Cardinal.ENat | [
"ENat.instNatCast",
"Cardinal",
"CommSemiring.toSemiring",
"Cardinal.commSemiring",
"PartialOrder.toPreorder",
"OrderRingHom.instFunLike",
"instPreorderENat",
"OrderRingHom",
"Cardinal.partialOrder",
"Iff",
"Cardinal.toENat",
"Nat",
"ENat",
"instCommSemiringENat",
"OfNat.ofNat",
"Semir... | true |
Real.toNNReal_coe | Mathlib.Data.NNReal.Defs | [
"Real.instLE",
"Real",
"Real.instZero",
"NNReal.eq",
"NNReal",
"max_eq_left",
"LE.le",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"NNReal.toReal",
"Real.linearOrder",
"Subtype.property",
"Real.toNNReal"
] | true |
AddMonoidAlgebra.commRing._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | [
"Semigroup.toMul",
"CommRing",
"HMul.hMul",
"CommSemiring.toSemiring",
"CommMonoid.mul_comm",
"AddMonoidAlgebra.commSemiring",
"AddCommMonoid",
"CommRing.toCommSemiring",
"CommMonoid.toMonoid",
"CommSemiring.toCommMonoid",
"Monoid.toSemigroup",
"AddMonoidAlgebra",
"Eq",
"instHMul"
] | false |
Int.gcd_eq_zero_iff._simp_1 | Init.Data.Int.Gcd | [
"Int.gcd",
"instOfNatNat",
"Int",
"Int.gcd_eq_zero_iff",
"And",
"instOfNat",
"Nat",
"propext",
"OfNat.ofNat",
"Eq"
] | false |
Left.one_lt_mul_of_le_of_lt | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | [
"MulOne.toOne",
"Preorder.toLT",
"HMul.hMul",
"Preorder.toLE",
"MulOne.toMul",
"LE.le",
"MulLeftStrictMono",
"MulOneClass.toMulOne",
"LT.lt",
"One.toOfNat1",
"lt_mul_of_le_of_one_lt",
"MulOneClass",
"OfNat.ofNat",
"Preorder",
"instHMul"
] | true |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.containsInOrderLower.go._unsafe_rec | Lean.Data.FuzzyMatching | [
"_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.containsInOrderLower.go._unsafe_rec",
"String",
"Char.toLower",
"instDecidableEqBool",
"instBEqOfDecidableEq",
"String.Pos.Raw",
"dite",
"Bool.true",
"BEq.beq",
"String.Pos.Raw.atEnd",
"Bool",
"String.Pos.Raw.get'",
"Char",
"String.Pos... | false |
MeasureTheory.average_neg | Mathlib.MeasureTheory.Integral.Average | [
"NegZeroClass.toNeg",
"Real",
"instHSMul",
"MeasureTheory.Measure",
"instSMulOfMul",
"NormedSpace",
"CommSemiring.toSemiring",
"Set.univ",
"MeasureTheory.integral_neg",
"MeasureTheory.Measure.instSMul",
"SubtractionMonoid.toSubNegZeroMonoid",
"ENNReal.instCommSemiring",
"MeasureTheory.averag... | true |
AlgebraicGeometry.Scheme.Pullback.diagonalCover_map._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.pullback",
"AlgebraicGeometry.Scheme.Cover.pullbackHom",
"AlgebraicGeometry.Scheme",
"CategoryTheory.PreZeroHypercover.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AlgebraicGeometry.Scheme.Pullback.diagonalCover._proof_1",
"cong... | false |
StrictConvexOn.rightDeriv_lt_slope | Mathlib.Analysis.Convex.Deriv | [
"NormedCommRing.toSeminormedCommRing",
"Real.partialOrder",
"Real",
"Set.Ioi",
"Semiring.toModule",
"instSMulOfMul",
"Real.denselyNormedField",
"PseudoMetricSpace.toUniformSpace",
"Real.instLT",
"DifferentiableWithinAt.hasDerivWithinAt",
"StrictConvexOn",
"Membership.mem",
"NormedField.toFie... | true |
Batteries.RBNode.fold | Batteries.Data.RBMap.Basic | [
"Batteries.RBNode",
"Batteries.RBNode.brecOn",
"Batteries.RBNode.fold._f"
] | true |
CategoryTheory.Subobject.Classifier.casesOn | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.IsPullback",
"CategoryTheory.Subobject.Classifier.mk",
"CategoryTheory.Subobject.Classifier.rec",
"CategoryTheory.Subobject.Classifier",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.... | false |
CategoryTheory.PreOneHypercover.noConfusionType | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.PreZeroHypercover.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreZeroHypercover.X",
"CategoryTheory.PreZeroHypercover.I₀",
"CategoryTheory.PreZeroHypercover",
"CategoryTheory.CategoryStruct.comp",
"HEq",
"CategoryTh... | false |
BoundedContinuousFunction.charAlgHom_apply | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | [
"BoundedContinuousFunction.charAlgHom",
"NormedCommRing.toNormedRing",
"Finsupp.instFunLike",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"AddMonoidAlgebra.semiring",
"Real",
"Algebra.to_smulCommClass",
"instHSMul",
"Continuous",
"MonoidHom.instFunLike",... | true |
CategoryTheory.Limits.Fan.isLimitOfIsIsoPiLift._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"CategoryTheory.Limits.limit.π",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.HasProduct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.Fan",
"CategoryTheory.Discrete.functor",
"CategoryTheory.... | false |
_private.Mathlib.Topology.Order.UpperLowerSetTopology.0.Topology.WithUpperSet.toUpperSet_specializes_toUpperSet._simp_1_1 | Mathlib.Topology.Order.UpperLowerSetTopology | [
"Specializes",
"Set.instSingletonSet",
"HasSubset.Subset",
"TopologicalSpace",
"closure",
"propext",
"Singleton.singleton",
"Eq",
"specializes_iff_closure_subset",
"Set.instHasSubset",
"Set"
] | false |
IsCoatom.Ici | Mathlib.Order.Atoms | [
"OrderDual.toDual",
"Set.Ici.orderTop",
"Equiv.instEquivLike",
"Set.Ici",
"Preorder.toLE",
"Membership.mem",
"Equiv",
"Subtype",
"LE.le",
"IsAtom.Iic",
"OrderTop",
"IsCoatom",
"Subtype.mk",
"OrderDual",
"IsCoatom.dual",
"OrderDual.instPreorder",
"Set.instMembership",
"DFunLike.coe"... | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_3 | Init.Data.UInt.Lemmas | [
"UInt16",
"Nat",
"propext",
"UInt16.toNat_inj",
"UInt16.toNat",
"Eq.symm",
"Eq"
] | false |
Lean.DeclarationRanges.noConfusionType | Lean.Data.DeclarationRange | [
"Lean.DeclarationRanges",
"Lean.DeclarationRange",
"Lean.DeclarationRanges.casesOn",
"Eq"
] | false |
Std.Internal.instIsStrictCutCompare | Std.Data.Internal.Cut | [
"Ordering.gt",
"Std.TransCmp.congr_left",
"Std.Internal.IsStrictCut",
"Ord",
"Std.OrientedCmp.gt_of_lt",
"Std.TransOrd",
"Ordering",
"Ord.compare",
"Std.Internal.IsStrictCut.mk",
"Std.OrientedCmp.lt_of_gt",
"Eq",
"Std.Internal.IsCut.mk",
"Std.TransCmp.lt_trans",
"Std.TransCmp.toOrientedCmp... | true |
_private.Mathlib.Data.Set.Prod.0.Set.prod_mono.match_1_1 | Mathlib.Data.Set.Prod | [
"Set.instSProd",
"SProd.sprod",
"Membership.mem",
"Prod.fst",
"And.casesOn",
"And.intro",
"Prod",
"Set.instMembership",
"Prod.snd",
"Set"
] | false |
TwoSidedIdeal.ext_iff | Mathlib.RingTheory.TwoSidedIdeal.Basic | [
"NonUnitalNonAssocRing",
"TwoSidedIdeal.ext",
"TwoSidedIdeal",
"HEq.refl",
"Iff.rfl",
"Membership.mem",
"Eq.casesOn",
"Iff",
"TwoSidedIdeal.setLike",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Eq",
"SetLike.instMembership"
] | true |
Int.lcm_eq_natAbs_right | Init.Data.Int.Gcd | [
"Iff.mpr",
"Int.lcm",
"Dvd.dvd",
"Int.lcm_eq_natAbs_right_iff_dvd",
"Int",
"Int.instDvd",
"Nat",
"Int.natAbs",
"Eq"
] | true |
Lean.Compiler.LCNF.LambdaLifting.visitCode | Lean.Compiler.LCNF.LambdaLifting | [
"Inhabited.default",
"Lean.Compiler.LCNF.Scope",
"instInhabitedOfMonad",
"Lean.Compiler.LCNF.LambdaLifting.State",
"Lean.Compiler.LCNF.ScopeT",
"Lean.Compiler.LCNF.LambdaLifting.Context",
"ReaderT.instMonad",
"IO.RealWorld",
"Lean.Compiler.LCNF.Purity.pure",
"Lean.Compiler.LCNF.Code",
"StateRefT... | true |
USize.le_size | Init.Data.UInt.Basic | [
"instPowNat",
"congrArg",
"instOfNatNat",
"Nat.le_refl._simp_1",
"LE.le",
"instLENat",
"Or.casesOn",
"instNatPowNat",
"Bool.true",
"USize.size_eq",
"HPow.hPow",
"eq_true_of_decide",
"Nat",
"True",
"Bool",
"of_eq_true",
"Eq.refl",
"Or.inl",
"Or",
"USize.size",
"instHPow",
"O... | true |
MvQPF.Mcongr | Mathlib.Data.QPF.Multivariate.Constructions.Cofix | [
"Exists",
"instOfNatNat",
"instHAdd",
"And",
"HAdd.hAdd",
"Nat",
"instAddNat",
"MvQPF",
"MvQPF.P",
"OfNat.ofNat",
"MvQPF.IsPrecongr",
"TypeVec",
"MvPFunctor.M"
] | true |
Lean.Elab.Tactic.Do.ProofMode.elabMIntro._regBuiltin.Lean.Elab.Tactic.Do.ProofMode.elabMIntro_1 | Lean.Elab.Tactic.Do.ProofMode.Intro | [
"Lean.Elab.Tactic.tacticElabAttribute",
"Lean.Elab.Tactic.Do.ProofMode.elabMIntro",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Name.mkStr6",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBNode.Path.ins.match_1.splitter | Batteries.Data.RBMap.Alter | [
"Batteries.RBNode",
"Batteries.RBNode.Path",
"Batteries.RBNode.Path.root",
"Batteries.RBColor.red",
"Batteries.RBColor.black",
"Batteries.RBNode.Path.ins.match_1",
"Batteries.RBNode.Path.right",
"Batteries.RBNode.Path.left"
] | true |
mdifferentiableOn_iff_differentiableOn | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | [
"chartedSpaceSelf",
"NormedSpace",
"_private.Mathlib.Geometry.Manifold.MFDeriv.FDeriv.0.mdifferentiableOn_iff_differentiableOn._simp_1_1",
"congrArg",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Membership.mem",
"MDifferentiableOn",
"iff_self",
"Iff",
"SeminormedAddCommGroup.toP... | true |
Std.Http.Response.Builder.mk.sizeOf_spec | Std.Internal.Http.Data.Response | [
"Std.Http.Response.Builder._sizeOf_inst",
"Std.Http.Extensions",
"instOfNatNat",
"Std.Http.Response.Head._sizeOf_inst",
"Std.Http.Response.Builder.mk",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Std.Http.Response.Head",
"instAddNat",
"Eq.refl",
"Std.Http.Extensions._sizeOf_inst",
"O... | true |
LeftPreLieRing.ext | Mathlib.Algebra.NonAssoc.PreLie.Basic | [
"LeftPreLieRing.toNonUnitalNonAssocRing",
"Mul.mk",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"NonUnitalNonAssocRing.toMul",
"_private.Mathlib.Algebra.NonAssoc.PreLie.Basic.0.LeftPreLieRing.ext.match_1",
"Zero.zero",
"HEq.refl",
"SubNegMonoid.mk",
"Add.mk",
"Neg.mk",
"AddMonoid.toZero",
"NonU... | true |
AlgEquiv.toRingHom_trans._simp_1 | Mathlib.Algebra.Algebra.Equiv | [
"AlgEquiv.instEquivLike",
"Algebra",
"RingHom",
"AlgEquivClass.toAlgHomClass",
"CommSemiring",
"RingHom.comp",
"AlgEquiv.trans",
"AlgEquiv.instAlgEquivClass",
"AlgEquiv",
"AlgEquiv.toRingHom_trans",
"RingHomClass.toRingHom",
"Semiring",
"AlgHomClass.toRingHomClass",
"Eq.symm",
"Semiring.... | false |
Nat.factorizationLCMRight_zero_right | Mathlib.Data.Nat.Factorization.LCM | [
"Nat.lcm",
"Finsupp.instFunLike",
"MulOne.toOne",
"Nat.factorizationLCMRight",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"Monoid.toMulOneClass",
"congrArg",
"zero_le._simp_1",
"Nat.instMonoid",
"Nat.lcm_zero_right",
"Nat.factorization_zero",
"instOfNatNat",
... | true |
PadicInt.mahlerEquiv._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | [
"Nat.Prime",
"PadicInt",
"CommSemiring.toSemiring",
"Fact",
"PadicInt.instCommRing",
"RingHomInvPair",
"CommRing.toCommSemiring",
"Nat",
"RingHomInvPair.ids",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
Lean.Server.Test.Runner.setDesynced | Lean.Server.Test.Runner | [
"Lean.Server.Test.Runner.RunnerState.versionNo",
"Lean.Lsp.Ipc.IpcM",
"modify",
"IO",
"Lean.Server.Test.Runner.RunnerState.pos",
"Lean.Server.Test.Runner.RunnerState.lastActualLineNo",
"ReaderT.instMonad",
"Lean.Server.Test.Runner.RunnerState",
"instMonadEIO",
"Lean.Server.Test.Runner.RunnerState.... | true |
Std.Roo.isSome_succMany?_of_lt_size_toArray | Init.Data.Range.Polymorphic.Lemmas | [
"Option.isSome_filter",
"GetElem?.toGetElem",
"Std.PRange.UpwardEnumerable",
"Std.Roo.upper",
"congrArg",
"Option.any",
"Std.PRange.LawfulUpwardEnumerableLT",
"Option.some",
"Std.Roo.lower",
"Eq.mp",
"instOfNatNat",
"Option.isSome_of_any",
"Std.Roo.getElem?_toArray_eq",
"Array",
"GetElem... | true |
Finset.sum_bij | Mathlib.Algebra.BigOperators.Group.Finset.Defs | [
"Multiset.sum",
"Multiset.map",
"Finset",
"Membership.mem",
"Exists",
"Multiset",
"Finset.nodup",
"Finset.val",
"AddCommMonoid",
"Multiset.map_eq_map_of_bij_of_nodup",
"congr_arg",
"Finset.instSetLike",
"Eq",
"SetLike.instMembership",
"Finset.sum"
] | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Degenerate.0.SSet.unique_nonDegenerate.map_g_op_y₂ | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | [
"Eq.mpr",
"CategoryTheory.op_comp",
"CategoryTheory.SplitEpi.id",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.opposite",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"Quiver.Hom.op",
"SSet.nonDegenerate",
"TypeCa... | true |
Std.Http.URI.EncodedString.recOn | Std.Internal.Http.Data.URI.Encoding | [
"Std.Http.URI.IsAllowedEncodedChars",
"_private.Std.Internal.Http.Data.URI.Encoding.0.Std.Http.URI.EncodedString.mk",
"Std.Http.URI.EncodedString",
"Bool",
"ByteArray",
"UInt8",
"Std.Http.URI.EncodedString.rec"
] | false |
SSet.Subcomplex.Pairing.RankFunction.casesOn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"SSet.Subcomplex.N",
"PartialOrder",
"Set.Elem",
"SSet.Subcomplex.Pairing.RankFunction.rec",
"SSet",
"SSet.Subcomplex.Pairing",
"SSet.Subcomplex.Pairing.RankFunction",
"LT.lt",
"SSet.Subcomplex.Pairing.AncestralRel",
"SSet.Subcomplex",
"SSet.Subcom... | false |
Pi.smulWithZero' | Mathlib.Algebra.GroupWithZero.Action.Pi | [
"SMulWithZero.toSMulZeroClass",
"Pi.smulWithZero'._proof_1",
"SMul",
"Pi.instZero",
"SMulZeroClass.mk",
"SMulZeroClass.toSMul",
"Pi.smul'",
"SMulWithZero",
"Pi.smulWithZero'._proof_2",
"SMulWithZero.mk",
"Zero"
] | true |
Std.DTreeMap.Internal.Unit.RicSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | [
"Std.DTreeMap.Internal.Unit.RicSliceData",
"Ord",
"HEq.refl",
"Std.DTreeMap.Internal.Unit.RicSliceData.mk",
"id",
"Std.Ric",
"heq_of_eq",
"Unit",
"Std.DTreeMap.Internal.Unit.RicSliceData.noConfusion",
"Eq.refl",
"HEq",
"Eq",
"Std.DTreeMap.Internal.Impl"
] | false |
IsLocalRing.instModuleResidueFieldCotangentSpace | Mathlib.RingTheory.Ideal.Cotangent | [
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"IsLocalRing.instModuleResidueFieldCotangentSpace._proof_5",
"Module.mk",
"IsLocalRing.maximalIdeal",
"IsLocalRing.instModuleResidueFieldCotangentSpace._proof_6",
"DistribMulAction.mk",
"Ideal.instAddCommGroupCotangent",
"IsLoc... | true |
CategoryTheory.Pseudofunctor.isoMapOfCommSq_eq._proof_1 | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"id",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory",
"CategoryTheory.CategoryStruct.comp",
"Eq.refl",
"Eq"
] | false |
Equiv.lt_def | Mathlib.Logic.Equiv.Defs | [
"Equiv.instEquivLike",
"Iff.rfl",
"Equiv",
"Equiv.lt",
"Iff",
"LT.lt",
"DFunLike.coe",
"EquivLike.toFunLike",
"LT"
] | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Path.0.SSet.spine_δ₀._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | [
"Lean.RArray.leaf",
"False",
"Classical.byContradiction",
"Nat.not_le_eq",
"id",
"False.casesOn",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.Linear.Expr.num",
"Bool.true",
"instHAdd",
"Nat.Linear.ExprCnstr.eq_false_of_isUnsat",
"HAdd.hAdd",
"Nat",
"Bool",
"Lean.Grind.intro_with_eq",
... | false |
Int.induct_roo_left | Init.Data.Range.Polymorphic.IntLemmas | [
"Nat.recAux",
"_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.induct_roo_left._proof_1_1",
"HSub.hSub",
"Int.decLe",
"instOfNatNat",
"Int",
"LE.le",
"Int.instLTInt",
"instHAdd",
"instHSub",
"instOfNat",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"Int.instAdd",
"i... | true |
Lean.DeclNameGenerator.ctorIdx | Lean.CoreM | [
"Lean.DeclNameGenerator",
"Nat"
] | false |
Int.negSucc_dvd | Init.Data.Int.DivMod.Lemmas | [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"Iff.rfl",
"id",
"instOfNatNat",
"Int",
"Nat.cast",
"Int.instDvd",
"instHAdd",
"Iff",
"HAdd.hAdd",
"Nat",
"Int.natAbs",
"propext",
"instAddNat",
"instNatCastInt",
"Int.negSucc",
"OfNat.ofNat",
"Eq.symm",
"Int.natAbs_dvd",
"Eq"
] | true |
SSet.Augmented.stdSimplex._proof_8 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | [
"CategoryTheory.Limits.hasFiniteLimits_of_hasLimits",
"Eq.mpr",
"CategoryTheory.Comma.right",
"Opposite",
"SSet.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.SimplicialObject.const",
"CategoryTheory.CommaMorph... | false |
SignType.instHasDistribNeg | Mathlib.Data.Sign.Defs | [
"HasDistribNeg.mk",
"SignType.instNeg",
"InvolutiveNeg.mk",
"SignType.instHasDistribNeg._proof_1",
"HasDistribNeg",
"SignType",
"SignType.instHasDistribNeg._proof_3",
"SignType.instMul",
"SignType.instHasDistribNeg._proof_2"
] | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_1 | Batteries.Data.List.Lemmas | [
"Lean.Grind.Nat.lt_eq",
"instOfNatNat",
"LE.le",
"instLENat",
"List.findIdxs",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Eq.substr",
"Bool",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"List.length",
"List.nil"
] | false |
Finpartition.mk_mem_sparsePairs._simp_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | [
"Preorder.toLT",
"DivisionRing.toRatCast",
"SimpleGraph.edgeDensity",
"Finset",
"LinearOrder",
"SimpleGraph.Adj",
"DecidableRel",
"PartialOrder.toPreorder",
"Membership.mem",
"Field.toDivisionRing",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Rat.cast",
"Prod.mk",
"Ne",... | false |
ConjAct.unitsSMulCommClass' | Mathlib.GroupTheory.GroupAction.ConjAct | [
"Monoid",
"instSMulOfMul",
"ConjAct.unitsSMulCommClass",
"Monoid.toMulOneClass",
"IsScalarTower",
"SMul",
"ConjAct.unitsScalar",
"Units",
"MulOne.toMul",
"SMulCommClass.symm",
"MulOneClass.toMulOne",
"ConjAct",
"SMulCommClass"
] | true |
FractionRing.instNontrivial | Mathlib.RingTheory.Localization.FractionRing | [
"Nontrivial",
"CommRing",
"OreLocalization.nontrivial",
"CommSemiring.toSemiring",
"FractionRing",
"nonZeroDivisors",
"inferInstance",
"CommRing.toCommSemiring",
"OreLocalization.oreSetComm",
"CommRing.toCommMonoid",
"Semiring.toMonoidWithZero"
] | true |
CategoryTheory.CostructuredArrow.essentiallySmall | Mathlib.CategoryTheory.Comma.StructuredArrow.Small | [
"Eq.mpr",
"CategoryTheory.Equivalence.isEquivalence_inverse",
"CategoryTheory.Functor",
"CategoryTheory.CostructuredArrow.isEquivalence_pre",
"congrArg",
"CategoryTheory.LocallySmall",
"CategoryTheory.Functor.comp",
"CategoryTheory.essentiallySmall_of_small_of_locallySmall",
"id",
"CategoryTheory.... | true |
Complex.liftAux | Mathlib.LinearAlgebra.Complex.Module | [
"Complex.imLm",
"NegZeroClass.toNeg",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"Complex.commRing",
"Ring.toNonAssocRing",
"Complex.reLm",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.ofLinearMap",
"AddGroupWi... | true |
AddSubmonoid.toAddMonoid | Mathlib.Algebra.Group.Submonoid.Defs | [
"AddSubmonoid.toAddMonoid._proof_1",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"Subtype",
"AddSubmonoid",
"AddMonoid",
"AddSubmonoidClass.toAddMonoid",
"AddSubmonoid.instSetLike",
"SetLike.instMembership"
] | true |
TopModuleCat.mk._flat_ctor | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | [
"_private.Mathlib.Algebra.Category.ModuleCat.Basic.0.ModuleCat.mk",
"ContinuousSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"AddCommGroup",
"DistribSMul.toSMulZeroClass",
"TopologicalSpace"... | false |
quadraticChar._proof_1 | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Fintype.IsSquare.decidablePred",
"congrArg",
"Ne.isUnit",
"IsUnit",
"DivisionSemiring.toGroupWithZero",
"CommSemiring.toCommMonoidWithZero",
"mt",
"id",
"Int",
"CommMonoidWithZero.toMonoidWithZero",
"Field.toSemifield",
"Field.toCommRing",
"in... | false |
CategoryTheory.Limits.Types.instHasColimitConstPUnitFunctor | Mathlib.CategoryTheory.Limits.IsConnected | [
"CategoryTheory.Limits.Types.isColimitPUnitCocone",
"Nonempty.intro",
"CategoryTheory.Limits.HasColimit.mk'",
"CategoryTheory.Limits.ColimitCocone.mk",
"CategoryTheory.Limits.Types.pUnitCocone",
"CategoryTheory.types",
"CategoryTheory.IsConnected",
"CategoryTheory.Limits.HasColimit",
"CategoryTheory... | true |
_private.Mathlib.Analysis.CStarAlgebra.Module.Defs.0.CStarModule.inner_zero_right._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Module.Defs | [
"CStarModule.innerₛₗ_apply",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Complex.commRing",
"Inner.inner",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"SMul",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGroup",
"LinearMap.instFunLike",
"CStarModule.inn... | false |
Set.prod_image_right | Mathlib.Data.Set.Operations | [
"Set.instSProd",
"Set.ext",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"Set.mem_prod._simp_1",
"Set.mem_image._simp_1",
"Prod.exists._simp_1",
"Membership.mem",
"Exists",
"id",
"Prod.mk",
"Prod.fst",
"And.casesOn",
"funext",
"And",
"Iff",
"Exists.casesOn",
"Prod.mk.injEq",
"And.intro... | true |
Int64.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | [
"Int64.toInt",
"BitVec",
"BitVec.le_toInt",
"instOfNatNat",
"Int",
"LE.le",
"Int64.minValue",
"Nat",
"BitVec.toInt",
"OfNat.ofNat",
"Int.instLEInt"
] | false |
_private.Mathlib.Topology.Instances.Matrix.0.Continuous.matrix_blockDiagonal.match_1_1 | Mathlib.Topology.Instances.Matrix | [
"Prod.mk",
"Prod",
"Prod.casesOn"
] | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs._proof_1 | Batteries.Data.List.Lemmas | [
"List.countP",
"Lean.Grind.CommRing.le_norm_expr",
"Lean.Grind.instOrderedRingInt",
"Lean.RArray.leaf",
"False",
"Lean.Grind.CommRing.Expr.var",
"congrArg",
"Std.IsLinearPreorder.toIsPreorder",
"Classical.byContradiction",
"Lean.Grind.instIsLinearOrderInt",
"Nat.not_le_eq",
"Nat.ToInt.add_cong... | false |
Finset.Nat.prod_antidiagonal_eq_prod_range_succ | Mathlib.Algebra.BigOperators.NatAntidiagonal | [
"HSub.hSub",
"Nat.instAddMonoid",
"instSubNat",
"Prod.fst",
"Finset.prod",
"Finset.range",
"Finset.Nat.prod_antidiagonal_eq_prod_range_succ_mk",
"Finset.Nat.instHasAntidiagonal",
"instHSub",
"Nat",
"Prod",
"Nat.succ",
"Eq",
"CommMonoid",
"Prod.snd",
"Finset.HasAntidiagonal.antidiagonal... | true |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Finset.prod_le_prod_of_subset_of_one_le'._simp_1_1 | Mathlib.Algebra.Order.BigOperators.Group.Finset | [
"Finset",
"Finset.instSDiff",
"Membership.mem",
"Finset.mem_sdiff",
"SDiff.sdiff",
"And",
"Finset.instSetLike",
"propext",
"Eq",
"Not",
"SetLike.instMembership",
"DecidableEq"
] | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.invariantCardinalRank_of_finitary.match_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | [
"Membership.mem",
"Exists",
"Set.instUnion",
"Matroid.Indep",
"Insert.insert",
"Set.instInter",
"Inter.inter",
"And.casesOn",
"SDiff.sdiff",
"And",
"Exists.casesOn",
"Set.instInsert",
"And.intro",
"Exists.intro",
"Union.union",
"Set.instMembership",
"Matroid",
"Set.instSDiff",
"S... | false |
intervalIntegral.integrableOn_deriv_of_nonneg | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | [
"IsModuleTopology.toContinuousSMul",
"Set.Ioc",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"HasDerivAt.hasDerivWithinAt",
"Real.instLE",
"Real",
"Set.Ioi",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"IsTopologicalRing.toIsTopologicalSemir... | true |
CategoryTheory.CommMon.mkIso | Mathlib.CategoryTheory.Monoidal.CommMon_ | [
"CategoryTheory.CommMon.instCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.IsMonHom",
"CategoryTheory.Iso",
"autoParam",
"CategoryTheory.BraidedCategory",
"CategoryTheory.MonObj.one",
"CategoryTheory.CommMon.mkIso._proof_1",
... | true |
_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.addEqStep.updateRoots.match_1 | Lean.Meta.Tactic.Grind.Core | [
"Lean.Meta.Grind.Goal",
"Option.ctorIdx",
"Lean.Meta.Grind.CongrKey.mk",
"Option.some",
"Lean.Meta.Grind.CongrKey",
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Meta.Grind.GoalState.enodeMap",
"Lean.Meta.Grind.Goal.toGoalState",
"_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.invertTrans.go._sparse... | false |
ConditionallyCompleteLinearOrderedField.ratCast._inherited_default | Mathlib.Algebra.Order.CompleteField | [
"Rat.castRec",
"Rat",
"id",
"Int",
"Div.mk",
"Nat",
"NatCast.mk",
"IntCast.mk"
] | false |
CategoryTheory.PreOneHypercover.sieve₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.PreOneHypercover.sieve₁._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"Exists",
"CategoryTheory.PreZeroHypercover.X",
"CategoryTheory.S... | true |
CommGroupWithZero.instNormalizedGCDMonoid._proof_15 | Mathlib.Algebra.GCDMonoid.Basic | [
"GroupWithZero.toMonoidWithZero",
"InvOneClass.toOne",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"DivisionMonoid.toDivInvOneMonoid",
"CommMonoidWithZero.toMonoidWithZero",
"if_pos",
"MonoidWithZero.toMulZeroOneClass",
"CommGroupWithZero",
"One.toOfNat1",
"Zero.toOfN... | false |
LowerSet.coe_iSup | Mathlib.Order.UpperLower.CompleteLattice | [
"Set.mem_range",
"Iff.of_eq",
"congrArg",
"iSup",
"Membership.mem",
"Exists",
"LE",
"funext",
"LowerSet.instSupSet",
"SetLike.coe",
"True",
"eq_self",
"propext",
"Set.iUnion_exists",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Set.range",
"Set.iUnion_congr_Prop",
"LowerSet",
"Eq",... | true |
_private.Mathlib.Algebra.Group.Opposite.0.MulOpposite.semiconjBy_op._simp_1_2 | Mathlib.Algebra.Group.Opposite | [
"MulOpposite",
"MulOpposite.op_inj",
"propext",
"Eq",
"MulOpposite.op"
] | false |
Int8._sizeOf_1 | Init.Data.SInt.Basic | [
"Int8",
"UInt8._sizeOf_inst",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"OfNat.ofNat",
"UInt8",
"Int8.rec"
] | false |
_private.Mathlib.Algebra.Order.Group.MinMax.0.max_sub_max_le_max._proof_1_1 | Mathlib.Algebra.Order.Group.MinMax | [
"instLawfulOrderLT_mathlib",
"Lean.Grind.Linarith.Expr",
"Lean.RArray.leaf",
"False",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"eq_false",
"Lean.Grind.Linarith.le_norm",
"congrArg",
"Lean.Grind.Order.le_of_eq_1",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"Classical.byContradiction",... | false |
Aesop.Safety.safe.elim | Aesop.Rule | [
"PULift.up",
"Aesop.Safety.safe",
"Aesop.Safety",
"Aesop.Safety.ctorIdx",
"Aesop.Safety.ctorElim",
"Nat",
"Eq.symm",
"Eq"
] | false |
tendsto_integral_mul_one_add_inv_smul_sq_pow | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSqIntegral | [
"mul_self_nonneg",
"MeasureTheory.ae",
"Iff.mpr",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Norm.norm",
"Mathlib.Tactic.Ring.Common.neg_zero",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"InnerProductSpace.toNormedSpa... | true |
USize.fromExpr | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | [
"Pure.pure",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"Option.some",
"Lean.Meta.Simp.MethodsRef",
"ReaderT.instMonad",
"USize.ofNat",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"liftM",
"ReaderT.instMonadLift",
"Applicative.toPure",
"Option.none",
"Lean.Meta.Simp.SimpM",
... | true |
Nat._aux_Mathlib_Data_Nat_Totient___macroRules_Nat_termφ_1 | Mathlib.Data.Nat.Totient | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.instMonad",
"Lean.TSyntax.... | false |
Std.ExtDHashMap.size_add_size_eq_size_union_add_size_inter | Std.Data.ExtDHashMap.Lemmas | [
"Std.DHashMap.size_add_size_eq_size_union_add_size_inter",
"Std.ExtDHashMap.inductionOn₂",
"LawfulHashable",
"Inter.inter",
"Std.ExtDHashMap.instInterOfEquivBEqOfLawfulHashable",
"Std.ExtDHashMap.instUnionOfEquivBEqOfLawfulHashable",
"instHAdd",
"EquivBEq",
"HAdd.hAdd",
"Std.ExtDHashMap.size",
"... | true |
CategoryTheory.Endofunctor.Algebra.Initial.left_inv | Mathlib.CategoryTheory.Endofunctor.Algebra | [
"CategoryTheory.Functor",
"CategoryTheory.Endofunctor.Algebra.instCategoryStruct",
"CategoryTheory.Endofunctor.Algebra",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Endofunctor.Algebra.Hom",
"CategoryTheory.Endofunctor.Algebra.Hom.mk",
"CategoryTheory.Endofunctor.Algebra.st... | true |
Lean.PrettyPrinter.Delaborator.annotateTermInfo | Lean.PrettyPrinter.Delaborator.Basic | [
"Pure.pure",
"Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM",
"Lean.PrettyPrinter.Delaborator.Context",
"Lean.PrettyPrinter.Delaborator.Delab",
"ReaderT.instMonad",
"Lean.TSyntax.raw",
"Lean.PrettyPrinter.Delaborator.DelabM",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.takeUntil_eq_take._proof_1_12 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | [
"congrArg",
"SimpleGraph.Adj",
"SimpleGraph.Walk.support",
"SimpleGraph.Walk",
"Membership.mem",
"instBEqOfDecidableEq",
"SimpleGraph",
"SimpleGraph.Walk.cons",
"List",
"List.instMembership",
"_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.takeUntil_eq_take._proof_1_10... | false |
Isometry.euclideanHausdorffMeasure_preimage | Mathlib.Geometry.Euclidean.Volume.Measure | [
"MeasureTheory.Measure.IsAddHaarMeasure.toIsFiniteMeasureOnCompacts",
"Real.instIsOrderedRing",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real.partialOrder",
"Real.instLE",
"Real",
"instHSMul",
"MeasureTheory.Measure",
"WithLp.instModuleFinite",
"inst... | true |
Lean.Omega.Constraint.combo | Init.Omega.Constraint | [
"Lean.Omega.Constraint.add",
"Int",
"Lean.Omega.Constraint.scale",
"Lean.Omega.Constraint"
] | true |
Nat.bitwise_eq_binaryRec | Mathlib.Data.Nat.Bitwise | [
"cond",
"Nat.bit",
"Eq.mpr",
"Nat.bodd_bit",
"instHDiv",
"Nat.div2_bit",
"congrArg",
"Nat.bitwise_of_ne_zero",
"Nat.bit_bodd_div2",
"Eq.rec",
"Eq.mp",
"id",
"Nat.binaryRec'",
"HDiv.hDiv",
"instDecidableEqBool",
"Nat.div2",
"Ne",
"instOfNatNat",
"Bool.true",
"funext",
"Nat.bit... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.