name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.PersistentArray.mapMAux._unsafe_rec | Lean.Data.PersistentArray | [
"Lean.PersistentArrayNode.node",
"Lean.PersistentArray.mapMAux._unsafe_rec",
"Monad.toApplicative",
"_private.Lean.Data.PersistentArray.0.Lean.PersistentArrayNode.isNode.match_1",
"Lean.PersistentArrayNode",
"Lean.PersistentArrayNode.leaf",
"Array",
"Applicative.toFunctor",
"Monad",
"Array.mapM",
... | false |
String.isEmpty_toSlice_iff | Init.Data.String.Lemmas.IsEmpty | [
"String.toSlice",
"congrArg",
"String",
"String.isEmpty",
"String.Slice.isEmpty",
"iff_self",
"Bool.true",
"String.isEmpty_iff._simp_1",
"Iff",
"True",
"Bool",
"of_eq_true",
"congrFun'",
"String.isEmpty_toSlice",
"Eq",
"Eq.trans"
] | true |
PiTensorProduct.instOne | Mathlib.RingTheory.PiTensorProduct | [
"PiTensorProduct.instModule",
"One",
"One.mk",
"AddCommMonoidWithOne.toAddCommMonoid",
"CommSemiring.toSemiring",
"AddCommMonoidWithOne",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"PiTensorProduct.instAddCommMonoid",
"MultilinearMap",
"PiTensorProduct.tprod",
"CommSemiring",
"AddMonoidWithOne... | true |
WeierstrassCurve.Projective.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"CommRing",
"WeierstrassCurve.Projective.Equation",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"RingHom",
"WeierstrassCurve.Projective.polynomial",
"instOfNatNat",
"WeierstrassCurve.Projective",
"MvPolynomial.... | true |
Lean.Elab.Command.Linter.rec | Lean.Elab.Command | [
"Lean.Elab.Command.Linter",
"Lean.Syntax",
"Lean.Elab.Command.Linter.mk",
"Unit",
"Lean.Name",
"Lean.Elab.Command.CommandElabM"
] | false |
ArithmeticFunction.sigma_eq_one_iff._simp_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | [
"Nat.instMulZeroClass",
"ArithmeticFunction.instFunLikeNat",
"instOfNatNat",
"ArithmeticFunction.sigma_eq_one_iff",
"Nat",
"ArithmeticFunction",
"propext",
"OfNat.ofNat",
"ArithmeticFunction.sigma",
"Eq",
"DFunLike.coe",
"MulZeroClass.toZero"
] | false |
Real.toNNReal_le_toNNReal_iff | Mathlib.Data.NNReal.Defs | [
"Real.instLE",
"Real",
"and_true",
"Real.instZero",
"congrArg",
"Real.instSemilatticeSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"_private.Mathlib.Data.NNReal.Defs.0.Real.toNNReal_le_toNNReal_iff._simp_1_1",
"NNReal",
"LE.le",
"iff_self",
"NNReal.instPartialOrder",
"And",
"Iff",
... | true |
Std.Time.TimeZone.TZif.Header.mk.noConfusion | Std.Time.Zoned.Database.TzIf | [
"Std.Time.TimeZone.TZif.Header",
"id",
"Std.Time.TimeZone.TZif.Header.noConfusion",
"Std.Time.TimeZone.TZif.Header.mk",
"UInt32",
"UInt8",
"Eq"
] | false |
Set.mem_image2_of_mem | Mathlib.Data.Set.Operations | [
"Membership.mem",
"Exists",
"And",
"Set.image2",
"And.intro",
"Exists.intro",
"Eq",
"Set.instMembership",
"rfl",
"Set"
] | true |
AddMonoid.fg_range | Mathlib.GroupTheory.Finiteness | [
"AddMonoid.FG",
"AddMonoidHom.instAddMonoidHomClass",
"AddSubmonoid.toAddMonoid",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"AddMonoidHom.mrange",
"AddSubmonoid",
"AddMonoid",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"AddSubmonoid.instSetLike",
"... | true |
Option.get_attach._proof_1 | Init.Data.Option.Attach | [
"Option.isSome_attach",
"congrArg",
"Option.some",
"Eq.mp",
"Subtype",
"Option.attach",
"Bool.true",
"Bool",
"congrFun'",
"Option.isSome",
"Eq",
"Option"
] | false |
SpectralMap.comp._proof_1 | Mathlib.Topology.Spectral.Hom | [
"SpectralMap.toFun",
"SpectralMap.spectral'",
"ContinuousMap",
"IsSpectralMap",
"Function.comp",
"IsSpectralMap.comp",
"SpectralMap",
"TopologicalSpace",
"SpectralMap.toContinuousMap",
"ContinuousMap.instFunLike",
"DFunLike.coe"
] | false |
cfcₙHomSuperset.congr_simp | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | [
"Nontrivial",
"Semiring.toModule",
"instSMulOfMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsTopologicalSemiring",
"IsScalarTower",
"ContinuousStar",
"SeparatelyContinuousMul.to_continuousSMul",
"Set.zeroOfFactMem",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAd... | true |
bddAbove_Ico._simp_1 | Mathlib.Order.Bounds.Basic | [
"Preorder.toLE",
"BddAbove",
"Set.Ico",
"True",
"eq_true",
"Eq",
"bddAbove_Ico",
"Preorder"
] | false |
Lean.PrettyPrinter.Delaborator.AppImplicitArg.canUnexpand | Lean.PrettyPrinter.Delaborator.Builtins | [
"Lean.TSyntax",
"Lean.PrettyPrinter.Delaborator.AppImplicitArg",
"Lean.Syntax.Term",
"List.cons",
"Bool.true",
"Unit",
"Bool",
"Lean.Name",
"Lean.SyntaxNodeKind",
"Bool.false",
"Lean.Name.mkStr4",
"List.nil",
"_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.... | true |
isCancelSMul_iff_eq_one_of_smul_eq | Mathlib.Algebra.Group.Action.Basic | [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"id",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"eq_comm",
"Group.toDiv... | true |
MonomialOrder.C_mul_leadingCoeff_monomial_degree | Mathlib.RingTheory.MvPolynomial.MonomialOrder | [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.instMulZeroClass",
"Semiring.toModule",
"HMul.hMul",
"AddMonoidAlgebra.addAddCommMonoid",
"congrArg",
"CommSemiring.toSemiring",
"MonomialOrder.leadingCoeff",
"AddMonoid.toAddZeroClass",
"Mv... | true |
Finset.offDiag_inter | Mathlib.Data.Finset.Prod | [
"Eq.mpr",
"instDecidableEqProd",
"congrArg",
"Finset",
"Finset.coe_offDiag",
"Set.offDiag",
"id",
"Set.instInter",
"Finset.offDiag",
"Inter.inter",
"Finset.instInter",
"Finset.coe_injective",
"SetLike.coe",
"Finset.instSetLike",
"congr",
"Set.offDiag_inter",
"Prod",
"Finset.coe_int... | true |
Std.instToStreamList | Init.Data.Stream | [
"Std.ToStream.mk",
"Std.ToStream",
"List"
] | true |
NonemptyFinLinOrd.instLargeCategory._proof_8 | Mathlib.Order.Category.NonemptyFinLinOrd | [
"Quiver.mk",
"CategoryTheory.CategoryStruct.mk",
"CategoryTheory.Category.comp_id._autoParam",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.InducedCategory.instCategory._proof_4",
"CategoryTheory.CategoryStruct.id",
"LinOrd",
"autoParam",
"LinOrd.instCategory",
"Nonemp... | false |
CategoryTheory.Triangulated.TStructure.from_truncGE_obj_ext | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"sub_self",
"_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE.0.CategoryTheory.Triangulated.TStructure.from_truncGE_obj_ext._proof_1_2",
"congrArg",
"sub_eq_zero",
"CategoryTheory.Trian... | true |
isOpen_Iio | Mathlib.Topology.Order.OrderClosed | [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Set.Ici",
"IsClosed.isOpen_compl",
"ClosedIciTopology",
"congrArg",
"Compl.compl",
"LinearOrder",
"PartialOrder.toPreorder",
"DistribLattice.toLattice",
"id",
"Set.instCompl",
"TopologicalSpace",
"Set.compl_Ici",
"IsOpen",
"SemilatticeSup.toPartia... | true |
WellFounded.fixC | Init.WFComputable | [
"Acc.wfRel",
"invImage",
"_private.Init.WFComputable.0.WellFounded.fixC._proof_1",
"Subtype",
"_private.Init.WFComputable.0.WellFounded.fixC._proof_2",
"Acc",
"WellFounded",
"WellFounded.fix",
"WellFounded.wrap"
] | true |
Nat.Linear.ExprCnstr | Init.Data.Nat.Linear | [
"Nat.Linear.ExprCnstr.mk"
] | true |
Lean.Elab.Term.Do.ToCodeBlock.Catch.mk.inj | Lean.Elab.Do.Legacy | [
"Lean.Elab.Term.Do.ToCodeBlock.Catch.mk.noConfusion",
"Lean.Syntax",
"Lean.Elab.Term.Do.CodeBlock",
"Lean.Elab.Term.Do.ToCodeBlock.Catch",
"And",
"And.intro",
"Eq",
"Lean.Elab.Term.Do.ToCodeBlock.Catch.mk"
] | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take_drop._proof_1_2 | Mathlib.Data.Seq.Basic | [
"Stream'.Seq",
"Lean.Grind.Nat.lt_eq",
"Stream'.Seq.take",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"List.drop",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Eq.substr",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"List.length"
] | false |
Lean.Meta.SynthInstance.Waiter.ctorIdx | Lean.Meta.SynthInstance | [
"Lean.Meta.SynthInstance.ConsumerNode",
"Lean.Meta.SynthInstance.Waiter",
"Lean.Meta.SynthInstance.Waiter.casesOn",
"Nat"
] | false |
BitVec.or_eq | Init.Data.BitVec.Basic | [
"instHOrOfOrOp",
"BitVec.or",
"BitVec.instOrOp",
"BitVec",
"HOr.hOr",
"Nat",
"Eq",
"rfl"
] | true |
FirstOrder.ringFunc.one.sizeOf_spec | Mathlib.ModelTheory.Algebra.Ring.Basic | [
"FirstOrder.ringFunc._sizeOf_inst",
"instOfNatNat",
"FirstOrder.ringFunc.one",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"FirstOrder.ringFunc"
] | true |
not_irrational_zero | Mathlib.NumberTheory.Real.Irrational | [
"Rat.instOfNat",
"Real",
"Real.instZero",
"Real.instRatCast",
"Rat",
"Membership.mem",
"not_not_intro",
"Rat.cast",
"Irrational",
"Real.instDivisionRing",
"Exists.intro",
"Rat.cast_zero",
"Zero.toOfNat0",
"Set.range",
"OfNat.ofNat",
"Eq",
"Set.instMembership",
"Not",
"Set"
] | true |
CategoryTheory.Over.tensorHom_left_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.pullback",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.pullback.snd",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.Over.mk",
"CategoryTheory.Limits.WidePullbackShape.cat... | true |
Std.DHashMap.Internal.AssocList.instIteratorLoopAssocListIteratorIdSigmaOfMonad | Std.Data.DHashMap.Internal.AssocList.Iterator | [
"Std.IteratorLoop",
"Id",
"Std.DHashMap.Internal.AssocList.AssocListIterator",
"Std.DHashMap.Internal.AssocList.instIteratorAssocListIteratorIdSigma",
"Std.IteratorLoop.defaultImplementation",
"Monad",
"Sigma"
] | true |
Polynomial.Chebyshev.one_le_abs_eval_T_real | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | [
"one_pow",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Int.cast",
"Units.val",
"Polynomial.eval",
"NegZeroClass.toNeg",
"_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.one_le_abs_eval_T_real._proof_1_1",
"abs_neg",
"MulOne.toOn... | true |
CategoryTheory.CommGrp.fullyFaithfulForget₂CommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | [
"CategoryTheory.CommGrp.toGrp",
"CategoryTheory.CommMon.instCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CommGrp.instCategory",
"CategoryTheory.InducedCategory.homMk",
"CategoryTheory.Grp.instCategory",
"CategoryTheory.CommGrp.forget₂CommMon",
"id",
"CategoryT... | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_7.eq_1 | Std.Data.DTreeMap.Internal.Balancing | [
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"Std.DTreeMap.Internal.Impl.BalanceLPrecond",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Eq.refl",
"Eq",
"Std.DTreeMap.Internal.Impl.balanceL.match_7",
"Std.DTreeMap.Internal.Impl"
] | true |
DiscreteMeasurableSpace.rec | Mathlib.MeasureTheory.MeasurableSpace.Defs | [
"MeasurableSet",
"DiscreteMeasurableSpace",
"DiscreteMeasurableSpace.mk",
"MeasurableSpace",
"Set"
] | false |
Lean.Grind.Nat.xor_congr | Init.Grind.Lemmas | [
"Nat.instXorOp",
"congrArg",
"instBEqOfDecidableEq",
"Bool.true",
"BEq.beq",
"Nat",
"congr",
"True",
"HXor.hXor",
"eq_self",
"Bool",
"of_eq_true",
"beq_iff_eq._simp_1",
"instDecidableEqNat",
"implies_true",
"Nat.instLawfulBEq",
"Eq",
"implies_congr_ctx",
"instHXorOfXorOp",
"Eq.... | true |
Ideal.Cotangent.lift.congr_simp | Mathlib.RingTheory.Ideal.Cotangent | [
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"NonUnitalSubringClass.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"LinearMap.inst... | true |
ClosedSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | [
"ClosedSubgroup.mk",
"Group",
"TopologicalSpace"
] | true |
instHashableUInt8 | Init.Data.Hashable | [
"UInt8.toUInt64",
"Hashable.mk",
"Hashable",
"UInt8"
] | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_278 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Aesop.RulePatternCache.noConfusion | Aesop.RulePattern.Cache | [
"Lean.Expr.instBEq",
"Lean.Expr",
"Std.HashMap",
"Aesop.RulePatternCache.Entry",
"Aesop.RulePatternCache.casesOn",
"Aesop.RulePatternCache.noConfusionType",
"Eq.ndrec",
"Eq.refl",
"Lean.Expr.instHashable",
"Eq",
"Aesop.RulePatternCache"
] | false |
String.Slice.Pos.offset | Init.Data.String.Defs | [
"String.Slice",
"String.Pos.Raw",
"String.Slice.Pos"
] | true |
_private.Mathlib.Data.Rel.0.SetRel.exists_eq_singleton_of_prod_subset_id._simp_1_3 | Mathlib.Data.Rel | [
"And",
"and_assoc",
"propext",
"Eq"
] | false |
Fin2.toFin_fs | Mathlib.Data.Fin.Fin2 | [
"Fin.succ",
"Fin2.toFin",
"instOfNatNat",
"Fin2.fs",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Fin",
"Eq",
"rfl",
"Fin2"
] | true |
Lean.Grind._simp_5 | Init.Grind.Norm | [
"Dvd.dvd",
"Int.zero_dvd",
"Int",
"Int.instDvd",
"instOfNat",
"propext",
"OfNat.ofNat",
"Eq"
] | false |
Finsupp.mapDomain_injOn | Mathlib.Data.Finsupp.Basic | [
"Finsupp.instFunLike",
"Eq.mpr",
"Finsupp.ext",
"Finset.instUnion",
"congrArg",
"Finset",
"Finsupp.mapDomain",
"Finsupp.mem_support_iff._simp_1",
"AddMonoid.toAddZeroClass",
"Finset.coe_union._simp_1",
"setOf",
"Classical.propDecidable",
"Finsupp.support",
"cast",
"Membership.mem",
"Se... | true |
CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding_obj | Mathlib.CategoryTheory.Idempotents.FunctorCategories | [
"CategoryTheory.Functor",
"CategoryTheory.Idempotents.Karoubi",
"CategoryTheory.Functor.category",
"CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding",
"CategoryTheory.Idempotents.Karoubi.instCategory",
"Eq.refl",
"CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj",
"Eq",
"Cate... | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.termS_ | Mathlib.GroupTheory.Coxeter.Inversion | [
"Lean.Name.mkNum",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.Name.anonymous",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
MvPolynomial.weightedHomogeneousComponent._proof_1 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | [
"CommSemiring.toSemiring",
"RingHomCompTriple",
"CommSemiring",
"RingHom.id",
"RingHomCompTriple.ids",
"Semiring.toNonAssocSemiring"
] | false |
CategoryTheory.AddMon.trivial_addMon_add | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategoryStruct.leftUnitor",
"CategoryTheory.AddMonObj.add",
"CategoryTheory.AddMon.trivial",
"CategoryTheory.AddMon.addMon",
"CategoryTheory.MonoidalCategoryStruct.tensorObj",
"Category... | true |
Lean.Elab.InfoTree._sizeOf_6_eq | Lean.Elab.InfoTree.Types | [
"congrArg",
"Lean.Elab.InfoTree",
"instOfNatNat",
"List.rec",
"List.cons",
"List",
"instHAdd",
"List.cons.sizeOf_spec",
"HAdd.hAdd",
"Nat",
"List._sizeOf_inst",
"Lean.Elab.InfoTree._sizeOf_inst",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Nat.add",... | false |
groupHomology.mapCycles₂_comp_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | [
"Submodule",
"Rep.V",
"groupHomology.mapCycles₂",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"Finsupp.module",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"ModuleCat",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"CategoryTheory.Conc... | true |
Field.isSeparable_sub | Mathlib.FieldTheory.SeparableDegree | [
"IntermediateField.isSeparable_of_mem_isSeparable",
"AddGroupWithOne.toAddGroup",
"HSub.hSub",
"Algebra",
"Membership.mem",
"Field.toDivisionRing",
"Set.instSingletonSet",
"Insert.insert",
"DivisionRing.toRing",
"IntermediateField.subset_adjoin",
"Field.toSemifield",
"Field.toCommRing",
"Sub... | true |
AddGroup.fg_range | Mathlib.GroupTheory.Finiteness | [
"AddGroup.fg_of_surjective",
"AddMonoidHom.rangeRestrict_surjective",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.range",
"AddSubgroup.toAddGroup",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"AddSubgroup",
"AddGroup",
"AddGroup.toSubNegMonoid",
"AddMonoidHom.rangeRestrict",
"AddSub... | true |
WithZero.instGroupWithZero._proof_5 | Mathlib.Algebra.GroupWithZero.WithZero | [
"DivInvMonoid.toInv",
"Group",
"Int",
"DivInvMonoid.zpow",
"Nat.cast",
"Group.toDivInvMonoid",
"Inv.inv",
"DivInvMonoid.zpow_neg'",
"WithZero",
"Nat",
"instNatCastInt",
"Int.negSucc",
"Nat.succ",
"Eq",
"WithZero.instDivInvMonoid"
] | false |
WellFounded.prod_gameAdd | Mathlib.Order.GameAdd | [
"WellFounded.apply",
"Prod.GameAdd",
"Acc",
"WellFounded.intro",
"Prod",
"WellFounded",
"Acc.prod_gameAdd",
"_private.Mathlib.Order.GameAdd.0.WellFounded.prod_gameAdd.match_1_1"
] | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Pure.0.Lean.Elab.Tactic.Do.ProofMode.MGoal.pureTrivial._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.Pure | [
"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 |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk | Std.Internal.Async.System | [
"String",
"Std.HashMap",
"instHashableString",
"instBEqOfDecidableEq",
"instDecidableEqString",
"Std.Internal.IO.Async.System.Environment",
"_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk"
] | true |
Units.mul_inv' | Mathlib.Algebra.GroupWithZero.Units.Basic | [
"Units.val",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"mul_inv_cancel₀",
"MulZeroClass.toMul",
"GroupWithZero",
"DivisionMonoid.toDivInvOneMonoid",
"Units",
"Units.ne_zero",
"Inv.inv",
"MonoidWith... | true |
Lean.Doc.Block.ctorElimType | Lean.DocString.Types | [
"cond",
"Lean.Doc.Block.blockquote",
"Nat.ble",
"String",
"Lean.Doc.Block",
"Lean.Doc.Block.concat",
"Lean.Doc.DescItem",
"Int",
"Lean.Doc.Block.dl",
"Lean.Doc.Block.ul",
"PULift",
"Array",
"Lean.Doc.Block.ol",
"Nat",
"Lean.Doc.Block.code",
"Lean.Doc.Block.para",
"Lean.Doc.ListItem",... | false |
sSupIndep.disjoint_sSup | Mathlib.Order.SupIndep | [
"Iff.mpr",
"sSupIndep",
"Set.mem_singleton",
"congrArg",
"PartialOrder.toPreorder",
"Set.diff_singleton_eq_self",
"Preorder.toLE",
"Disjoint",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toBoundedOrder",
"Eq.mp",
"Set.instSingletonSet",
"Insert.inse... | true |
Lean.getPPProofsThreshold | Lean.PrettyPrinter.Delaborator.Options | [
"Nat",
"Lean.Options.get",
"Lean.Option.defValue",
"Lean.KVMap.instValueNat",
"Lean.pp.proofs.threshold",
"Lean.Options",
"Lean.Option.name"
] | true |
CategoryTheory.DifferentialObject.hasZeroMorphisms._proof_4 | Mathlib.CategoryTheory.DifferentialObject | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.shiftFunctor",
"Lean.Syntax",
"CategoryTheory.DifferentialObject.Hom.f",
"CategoryTheory.DifferentialObject.instZeroHom",
"CategoryTheory.DifferentialObject.obj",
"autoPara... | false |
Module.End.instDivisionRing._proof_7 | Mathlib.RingTheory.SimpleModule.Basic | [
"Module.End.instRing",
"Semiring.toNatCast",
"Int.cast",
"Rat.castRec",
"Monoid.npow",
"Mul.mk",
"LinearEquiv.symm",
"Semigroup.toMul",
"Rat.num",
"instHDiv",
"Semigroup.mul_assoc",
"One.mk",
"AddCommGroup.toAddCommMonoid",
"Rat",
"IntCast.intCast",
"Semigroup.mk",
"Rat.den",
"AddC... | false |
Lean.Meta.Rewrite.Config.transparency | Init.Meta.Defs | [
"Lean.Meta.Rewrite.Config",
"Lean.Meta.TransparencyMode"
] | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Independent.0.AffineIndependent.vectorSpan_image_ne_of_mem_of_notMem_of_not_subsingleton._proof_1_4 | Mathlib.LinearAlgebra.AffineSpace.Independent | [
"False",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"true_or",
"Finset",
"Classical.byContradiction",
"Classical.propDecidable",
"Finset.map",
"Membership.mem",
"Eq.mp",
"Set.Elem",
"id",
"Subtype",
"Insert.insert",
"Lean.Grind.eq_true_eq",
"Finset.mem_insert",
"Finset.instInsert... | false |
Set.countable_isTop | Mathlib.Data.Set.Countable | [
"PartialOrder.toPreorder",
"setOf",
"Preorder.toLE",
"PartialOrder",
"Set.finite_isTop",
"IsTop",
"Set.Countable",
"Set.Finite.countable"
] | true |
HomogeneousLocalization.Away.val_mk._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | [
"CommRing",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"Membership.mem",
"Monoid.toPow",
"CommRing.toCommSemiring",
"HPow.hPow",
"CommMonoid.toMonoid",
"Nat",
"Submonoid.powers",
"Semiring.toMonoid",
"Exists.intro",
"Eq.refl",
"Submonoid.instSetLike",
"instHPow",
"CommRing.toCo... | false |
CategoryTheory.Limits.BinaryBiconeMorphism.mk.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | [
"CategoryTheory.Limits.BinaryBiconeMorphism.mk",
"CategoryTheory.Limits.BinaryBicone.fst",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Limits.BinaryBiconeMorphism",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.BinaryBicone.inl",
"CategoryTheory.Limits.Bi... | true |
CategoryTheory.Limits.DiagramOfCones.noConfusion | Mathlib.CategoryTheory.Limits.Fubini | [
"CategoryTheory.Limits.DiagramOfCones.noConfusionType",
"CategoryTheory.Limits.DiagramOfCones.id._autoParam",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.DiagramO... | false |
RootPairing.Hom.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Hom | [
"RootPairing.Hom.mk",
"CommRing",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"Equiv.instEquivLike",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"RootPairing.flip",
"LinearMap.instFunLike",
"RootPairing.isPerfPai... | false |
Set.Finite.iSup_biInf_of_monotone | Mathlib.Data.Set.Finite.Lattice | [
"Eq.mpr",
"Set.forall_mem_insert",
"False",
"iInf",
"Set.mem_empty_iff_false._simp_1",
"CompleteLattice.toLattice",
"Iff.of_eq",
"congrArg",
"iSup",
"PartialOrder.toPreorder",
"Monotone",
"Preorder.toLE",
"Set.Finite",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"CompleteLattice... | true |
Std.DTreeMap.Internal.Impl.insertMax!._f | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.inner",
"instOfNatNat",
"Std.DTreeMap.Internal.Impl.minView!.match_1",
"Unit",
"Std.DTreeMap.Internal.Impl.below",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Std.DTreeMap.Internal.Impl.balanceR!",
"OfNat.ofNat",
"Std.DTreeMap.Internal.Impl"
] | false |
Lean.Parser.errorAtSavedPos | Lean.Parser.Basic | [
"Lean.Parser.ParserInfo.mk",
"Lean.Parser.FirstTokens.unknown",
"Lean.Parser.Parser",
"String",
"Lean.Parser.Parser.mk",
"Lean.Parser.Token",
"id",
"List",
"Bool",
"Lean.Parser.errorAtSavedPosFn",
"Lean.Parser.SyntaxNodeKindSet"
] | true |
Std.ExtDHashMap.Const.get_map' | Std.Data.ExtDHashMap.Lemmas | [
"Std.ExtDHashMap.inner",
"Std.ExtDHashMap.instMembershipOfEquivBEqOfLawfulHashable",
"Std.DHashMap.Const.get_map'",
"Quot.pliftOn._proof_2",
"Membership.mem",
"Std.ExtDHashMap.inductionOn",
"Std.ExtDHashMap.mem_of_mem_map",
"Std.ExtDHashMap.getKey",
"Std.ExtDHashMap.mk",
"LawfulHashable",
"_priv... | true |
emultiplicity_zero_eq_zero_of_ne_zero | Mathlib.RingTheory.Multiplicity | [
"Iff.mpr",
"Dvd.dvd",
"CommSemiring.toSemiring",
"semigroupDvd",
"zero_dvd_iff",
"SemigroupWithZero.toMulZeroClass",
"SemigroupWithZero.toSemigroup",
"mt",
"emultiplicity_eq_zero",
"Ne",
"MonoidWithZero.toSemigroupWithZero",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"ENat",
"... | true |
AEMeasurable.add' | Mathlib.MeasureTheory.Group.Arithmetic | [
"MeasurableAdd₂.measurable_add",
"MeasureTheory.Measure",
"AEMeasurable",
"Prod.mk",
"Prod.fst",
"MeasurableSpace",
"instHAdd",
"Pi.instAdd",
"HAdd.hAdd",
"AEMeasurable.prodMk",
"MeasurableAdd₂",
"Measurable.comp_aemeasurable",
"Prod",
"Prod.snd",
"Add",
"Prod.instMeasurableSpace"
] | true |
MeasurableEq.recOn | Mathlib.MeasureTheory.MeasurableSpace.Constructions | [
"MeasurableSet",
"MeasurableEq",
"MeasurableEq.rec",
"MeasurableSpace",
"Set.diagonal",
"MeasurableEq.mk",
"Prod",
"Prod.instMeasurableSpace"
] | false |
_private.Lean.Util.CollectAxioms.0.Lean.ExportedAxiomsState.importedModuleEntries._default | Lean.Util.CollectAxioms | [
"id",
"List.toArray",
"Array",
"Lean.Name",
"Prod",
"List.nil"
] | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.differentiableWithinAt_comp_sub._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | [
"NegZeroClass.toNeg",
"NormedSpace",
"instVAddOfAdd",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"HSub.hSub",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"HasFDerivWithinAt",
"NormedField.toField",
"Set.vaddSet",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNeg... | false |
lt_or_eq_or_gt_or_incompRel | Mathlib.Order.Comparable | [
"Preorder.toLT",
"instReflLe",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Eq.mp",
"LE.le",
"IncompRel",
"LT.lt",
"lt_or_antisymmRel_or_gt_or_incompRel",
"congrFun'",
"AntisymmRel",
"Or",
"Eq",
"antisymmRel_iff_eq._simp_1",
"instAntisymmLe"
] | true |
_private.Lean.Environment.0.Lean.Environment.hasUnsafe.match_1 | Lean.Environment | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Lean.AsyncConstantInfo",
"Option"
] | false |
Nat.toArray_rcc_eq_singleton_append_iff | Init.Data.Range.Polymorphic.NatLemmas | [
"Array.instAppend",
"Eq.mpr",
"Nat.toArray_rcc_eq_toArray_rco",
"Std.Rcc.toArray",
"Std.Rco.toArray",
"congrArg",
"id",
"Std.PRange.instIsAlwaysFiniteNat_1",
"instOfNatNat",
"LE.le",
"and_congr_right_iff._simp_1",
"instLENat",
"List.toArray",
"List.cons",
"Array",
"Nat.toArray_rco_eq_s... | true |
QuadraticForm.equivalent_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | [
"Pi.Function.module",
"IsScalarTower.to_smulCommClass'",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"QuadraticMap.instInvertibleEndOfNat",
"CommSemiring.toSemiring",
... | true |
Mathlib.Tactic.tacticNth_grewrite_____ | Mathlib.Tactic.GRewrite.Elab | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Parser.Tactic.location",
"Lean.Parser.Tactic.optConfig",
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.Parser.Tactic.rwRuleSeq",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.co... | true |
List.mapAccumr_eq_foldr._f | Mathlib.Data.List.Lemmas | [
"congrArg",
"Prod.mk",
"_private.Mathlib.Data.List.Lemmas.0.List.mapAccumr_eq_foldr.match_1_1",
"Prod.fst",
"List.cons",
"List",
"congr",
"True",
"eq_self",
"of_eq_true",
"List.below",
"congrFun'",
"Prod",
"List.mapAccumr",
"List.foldr",
"Eq",
"Prod.snd",
"rfl",
"Eq.trans",
"Li... | false |
EuclideanGeometry.angle_le_pi_div_three_of_le_of_le | Mathlib.Geometry.Euclidean.Triangle | [
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"False",
"Mathlib.Meta.NormNum.isNat_add",
"Real.partialOrder",
"Real.instLE",
"Real",
"Mathlib.Tactic.Linarith.mul_... | true |
Module.nonempty_linearEquiv_of_finrank_eq_one | Mathlib.LinearAlgebra.Dimension.Free | [
"Pi.Function.module",
"LinearEquiv.symm",
"LinearEquiv.funUnique",
"Semiring.toModule",
"Pi.addCommMonoid",
"Unique",
"Nonempty.some",
"instOfNatNat",
"Finite.of_fintype",
"Nonempty.intro",
"AddCommMonoid",
"Module.Free",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Module.Basis.nonempty_... | true |
infIooOrderIsoIooSup._proof_4 | Mathlib.Order.ModularLattice | [
"Iff.mpr",
"Set.right_mem_Icc",
"Lattice",
"Set.Ioo_subset_Icc_self",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"Set.Elem",
"le_sup_right",
"SemilatticeInf.toMin",
"L... | false |
FractionalIdeal.spanSingleton_eq_spanSingleton | Mathlib.RingTheory.FractionalIdeal.Operations | [
"Eq.mpr",
"Submodule",
"IsDomain",
"CommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"FractionalIdeal.spanSingleton",
"CommRing.toNonUnitalCommRing",
"IsLocalization",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMono... | true |
Nat.card_image_of_injective | Mathlib.SetTheory.Cardinal.Finite | [
"Function.Injective.injOn",
"Set.Elem",
"Nat.card",
"Nat.card_image_of_injOn",
"Nat",
"Set.image",
"Function.Injective",
"Eq",
"Set"
] | true |
CategoryTheory.Subfunctor.Subpresheaf.fromPreimage | Mathlib.CategoryTheory.Subfunctor.Image | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Subfunctor.toFunctor",
"CategoryTheory.Subfunctor",
"CategoryTheory.types",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Subfunctor.preimage",
"Catego... | true |
Polynomial.normUnit_content | Mathlib.RingTheory.Polynomial.Content | [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"CommRing",
"HMul.hMul",
"GCDMonoid.toIsCancelMulZero",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"NormalizedGCDMonoid",
"NormalizationMonoid.normUnit_zero",
"MonoidWithZeroHom.funLike",
"Classical.propDecida... | true |
SubAddAction.val_vadd_of_tower._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | [
"SubAddAction.vadd'",
"AddMonoid.toAddSemigroup",
"Membership.mem",
"VAdd",
"Subtype",
"HVAdd.hVAdd",
"AddAction",
"AddAction.toAddSemigroupAction",
"SubAddAction",
"AddSemigroupAction.toVAdd",
"AddMonoid",
"instHVAdd",
"SubAddAction.val_vadd_of_tower",
"Eq.symm",
"Subtype.val",
"Eq",
... | false |
Lean.Lsp.OpenNamespace.renamed.noConfusion | Lean.Data.Lsp.Internal | [
"id",
"Lean.Lsp.OpenNamespace.renamed",
"Lean.Name",
"Lean.Lsp.OpenNamespace",
"Lean.Lsp.OpenNamespace.noConfusion",
"Eq"
] | false |
ISize.cast_toNatClampNeg | Init.Data.SInt.Lemmas | [
"Eq.mpr",
"of_decide_eq_true",
"congrArg",
"ISize.toInt.eq_1",
"Int.toNat_of_nonneg",
"instLEISize",
"ISize.le_iff_toInt_le",
"Eq.mp",
"id",
"instOfNatNat",
"Int",
"LE.le",
"Nat.cast",
"System.Platform.numBits",
"Bool.true",
"ISize.toNatClampNeg.eq_1",
"instOfNat",
"ISize.instOfNat... | true |
Int.negOnePow_def | Mathlib.Algebra.Ring.NegOnePow | [
"Int.instCommMonoid",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Additive",
"Units.instNeg",
"Units",
"Int",
"Int.instUnitsPow",
"Units.instOne",
"Int.instMonoid",
"NonUnitalNonAssocRing.toHasDistribNeg",
"HPow.hPow",
"Int.instCommRing",
"NonUnitalNon... | true |
Lean.Elab.Command.Context.currRecDepth | Lean.Elab.Command | [
"Nat",
"Lean.Elab.Command.Context"
] | true |
pi_norm_lt_iff' | Mathlib.Analysis.Normed.Group.Constructions | [
"Norm.norm",
"MulOne.toOne",
"Real",
"pseudoMetricSpacePi",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Real.instZero",
"Monoid.toMulOneClass",
"congrArg",
"SeminormedGroup",
"SeminormedGroup.toGroup",
"Real.instLT",
"SeminormedGroup.toPseudoMetricSpace",
"Group.toDivisionMonoid... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.