name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"beqOfOrd",
"Ordering",
"Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false",
"Ordering.eq",
"Ne",
"Ord.compare",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"Eq"
] | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._proof_1_7 | Mathlib.Topology.Sets.VietorisTopology | [
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"eq_false",
"Lean.Grind.iff_eq",
"Set.subset_def",
"Set.mem_powerset_iff",
"Set.mem_inter_iff",
"Classical.byContradiction",
"Lean.Grind.eq_false_of_imp_eq_true",
"setOf",
"Set.sUnion",
"Set.powerset",
"Membership.mem",
"Exists",
"Eq.mp",
... | false |
Alexandrov.principals | Mathlib.Topology.Sheaves.Alexandrov | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopologicalSpace.Opens.instPartialOrder",
"Quiver.Hom.op",
"Topology.IsUpperSet",
"CategoryTheory.Functor.mk",
"PartialOrder.toPreorder",
"TopologicalSpace.Opens",
"Preorder.smallCategory",
"LE.le.ho... | true |
ComplexShape.σ_symm | Mathlib.Algebra.Homology.ComplexShapeSigns | [
"TotalComplexShapeSymmetrySymmetry.σ_symm",
"Units",
"Int",
"ComplexShape",
"TotalComplexShapeSymmetry",
"Int.instMonoid",
"TotalComplexShape",
"ComplexShape.σ",
"Eq",
"TotalComplexShapeSymmetrySymmetry"
] | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_3 | Mathlib.Tactic.NormNum.Ineq | [
"Mathlib.Meta.NormNum.Result'.ctorIdx",
"Mathlib.Meta.NormNum.Result'.isNNRat",
"Lean.Expr.const",
"Rat",
"Mathlib.Meta.NormNum.Result'.isNat",
"Mathlib.Meta.NormNum.Result'.isBool",
"_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core._sparseCasesOn_3",
"Lean.Expr",
"Nat.hasNotB... | false |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew._sparseCasesOn_3 | Mathlib.Util.WhatsNew | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
NonUnitalSubsemiring.instBot._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | [
"congrArg",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Eq.mp",
"Set.instSingletonSet",
"id",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"congr",
"True",
"eq_self",
"of_eq_true",
"AddZero.toAdd",
"Zero.toOfNat0... | false |
_private.Lean.Compiler.LCNF.DependsOn.0.Lean.Compiler.LCNF.LetDecl.depOn | Lean.Compiler.LCNF.DependsOn | [
"_private.Lean.Compiler.LCNF.DependsOn.0.Lean.Compiler.LCNF.typeDepOn",
"ReaderT.instMonad",
"Lean.Compiler.LCNF.Purity",
"Lean.Compiler.LCNF.LetDecl.value",
"Id",
"instToBoolBool",
"Lean.Compiler.LCNF.LetDecl.type",
"_private.Lean.Compiler.LCNF.DependsOn.0.Lean.Compiler.LCNF.letValueDepOn",
"Bool",... | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getPolyConst.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | [
"Lean.Grind.CommRing.Poly",
"Nat.hasNotBit",
"Int",
"_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getPolyConst._sparseCasesOn_1",
"Lean.Grind.CommRing.Poly.ctorIdx",
"Lean.Grind.CommRing.Poly.num"
] | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.cRk_map_image_lift._simp_1_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | [
"Subtype.forall",
"Subtype",
"Subtype.mk",
"propext",
"Eq"
] | false |
FreeAddSemigroup.rec._@.Mathlib.Algebra.Free.2508704951._hygCtx._hyg.3 | Mathlib.Algebra.Free | [
"FreeAddSemigroup.mk",
"List",
"FreeAddSemigroup"
] | false |
Lean.Grind.CommRing.Mon.concat.eq_1 | Init.Grind.Ring.CommSolver | [
"Lean.Grind.CommRing.Mon.concat",
"Eq.refl",
"Eq",
"Lean.Grind.CommRing.Mon",
"Lean.Grind.CommRing.Mon.unit"
] | true |
EmbeddingLike.casesOn | Mathlib.Data.FunLike.Embedding | [
"EmbeddingLike.rec",
"EmbeddingLike",
"EmbeddingLike.mk",
"Function.Injective",
"DFunLike.coe",
"FunLike"
] | false |
Substring.Raw.Valid.validFor | Batteries.Data.String.Lemmas | [
"Iff.mpr",
"Eq.mpr",
"_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.validFor._simp_1_4",
"Substring.Raw.str",
"String.toByteArray_ofList",
"List.append_assoc",
"congrArg",
"and_self",
"Substring.Raw.mk",
"HEq.refl",
"String",
"_private.Batteries.Data.String.Lemmas.0.Substring.Raw... | true |
LinearIsometry.rTensor_apply | Mathlib.Analysis.InnerProductSpace.TensorProduct | [
"LinearIsometry",
"InnerProductSpace.toNormedSpace",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"TensorProduct.addCommMonoid",
"NormedSpace.toModule",
"LinearMap.instFunLike",
"PseudoMetricSpace.toUniformSpace",
"LinearIsometry.instFunLike",
"NormedField.toField",
"TensorProduct.... | true |
ArchimedeanClass.stdPart_sub_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | [
"Eq.mpr",
"Real",
"IsDomain.to_noZeroDivisors",
"Preorder.toLT",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"IsOrderedRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"LinearOrder",
"ArchimedeanClass.instLinearOrder",
"AddMonoid.toAddZeroClass",
"Partial... | true |
Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause.beq._proof_4 | Std.Tactic.BVDecide.LRAT.Internal.Clause | [
"instLawfulBEq",
"HEq.refl",
"Std.Tactic.BVDecide.LRAT.Internal.instBEqDefaultClause.beq._proof_1",
"instLawfulBEqBool",
"instDecidableEqBool",
"Prod.instLawfulBEq",
"instBEqOfDecidableEq",
"Bool.true",
"BEq.beq",
"instBEqProd",
"Nat",
"Std.Sat.CNF.Clause",
"Bool",
"HEq",
"List.instBEq",... | false |
Lean.Elab.Command.elabElabRules._regBuiltin.Lean.Elab.Command.elabElabRules.declRange_3 | Lean.Elab.ElabRules | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
Mathlib.Tactic.RingNF.Config | Mathlib.Tactic.Ring.RingNF | [
"Mathlib.Tactic.RingNF.Config.mk"
] | true |
_private.Mathlib.Order.Defs.Unbundled.0.of_eq.match_1_1 | Mathlib.Order.Defs.Unbundled | [
"HEq.refl",
"Eq.casesOn",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Eq"
] | false |
AlgebraicGeometry.Scheme.Cover.glueMorphisms._proof_2 | Mathlib.AlgebraicGeometry.Gluing | [
"AlgebraicGeometry.Scheme",
"CategoryTheory.IsIso",
"AlgebraicGeometry.Scheme.Cover.instIsIsoFromGlued",
"AlgebraicGeometry.Scheme.OpenCover",
"AlgebraicGeometry.Scheme.Cover.fromGlued",
"AlgebraicGeometry.IsOpenImmersion",
"AlgebraicGeometry.Scheme.Cover.gluedCover",
"AlgebraicGeometry.Scheme.instCat... | false |
MonadShareCommon.mk._flat_ctor | Init.ShareCommon | [
"MonadShareCommon.mk",
"MonadShareCommon"
] | false |
ContinuousMap.norm_eq_iSup_norm | Mathlib.Topology.ContinuousMap.Compact | [
"Norm.norm",
"Real",
"SeminormedAddCommGroup",
"ContinuousMap.instNorm",
"iSup",
"ContinuousMap",
"PseudoMetricSpace.toUniformSpace",
"Real.instSupSet",
"BoundedContinuousFunction.mkOfCompact",
"CompactSpace",
"TopologicalSpace",
"SeminormedAddCommGroup.toNorm",
"SeminormedAddCommGroup.toPse... | true |
LinearMap.smulRightₗ | Mathlib.Algebra.Module.LinearMap.End | [
"LinearMap.smulRightₗ._proof_1",
"Semiring.toModule",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"LinearMap.instSMulCommClass",
"LinearMap.smulRightₗ._proof_4",
"LinearMap.module",
"LinearMap",
"LinearMap.smulRightₗ._proof_3",
"smulCommClass_self",
"AddCommMonoid",
"CommSemir... | true |
StrictMono.wellFoundedLT | Mathlib.Order.Monotone.Basic | [
"instIsWellFoundedInvImage",
"Preorder.toLT",
"StrictMono",
"InvImage",
"WellFoundedLT",
"StrictMono.imp",
"LT.lt",
"Preorder",
"Subrelation.isWellFounded"
] | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.exists_eq_add_of_lt._simp_1_3 | Mathlib.Data.Fin.Basic | [
"Int.ofNat_lt",
"Int",
"Nat.cast",
"Int.instLTInt",
"Nat",
"LT.lt",
"propext",
"instNatCastInt",
"instLTNat",
"Eq.symm",
"Eq"
] | false |
Set.mem_smul | Mathlib.Algebra.Group.Pointwise.Set.Scalar | [
"instHSMul",
"SMul",
"Iff.rfl",
"Set.smul",
"Membership.mem",
"Exists",
"And",
"Iff",
"HSMul.hSMul",
"Eq",
"Set.instMembership",
"Set"
] | true |
Append.mk.noConfusion | Init.Prelude | [
"Append.noConfusion",
"Append",
"id",
"heq_of_eq",
"Append.mk",
"Eq.refl",
"HEq",
"Eq"
] | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Comma.0.CategoryTheory.MorphismProperty.instIsClosedUnderIsomorphismsOverOverObjOfRespectsIso._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Over",
"CategoryTheory.Functor.id",
"CategoryTheory.MorphismProperty.overObj",
"CategoryTheory.instCategoryOver",
"CategoryTheory.MorphismProperty.RespectsIso",
"CategoryTheory.discreteCategory",
"PUnit",
"CategoryTheory.Category.toCategoryStruct",
... | false |
MeasureTheory.SimpleFunc.integral_smul | Mathlib.MeasureTheory.Integral.Bochner.L1 | [
"Real",
"instHSMul",
"MeasureTheory.Measure",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"MeasureTheory.Integrable",
"MeasureTheory.SimpleFunc",
"AddZeroClass.toAddZero",
"Real.semiring",
"Seminorme... | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.go._unsafe_rec | Lean.Compiler.LCNF.Types | [
"Pure.pure",
"Lean.LocalDeclKind.default",
"Lean.Meta.isProp",
"_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.go._unsafe_rec",
"instMonadControlTOfPure",
"Lean.Compiler.LCNF.erasedExpr",
"Lean.Meta.State",
"_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.whnfEta",... | false |
Finpartition.map | Mathlib.Order.Partition.Finpartition | [
"Lattice",
"Lattice.toSemilatticeSup",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Finset.map",
"OrderBot",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Finpartition.mk",
"id",
"OrderIso",
"HasSubset.Subset",
"OrderIso.instEquivLike",
"LE.le",
"Finpartition.parts",
... | true |
Graph.not_isLink_of_notMem_edgeSet | Mathlib.Combinatorics.Graph.Basic | [
"Graph.IsLink.edge_mem",
"Membership.mem",
"mt",
"Graph",
"Graph.IsLink",
"Graph.edgeSet",
"Set.instMembership",
"Not",
"Set"
] | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks.0.CategoryTheory.Limits.PreservesPullback.iso_inv_fst._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Iso.inv_comp_eq",
"CategoryTheory.Iso",
"propext",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Iso.hom",
"Eq",
"CategoryTheory.Iso.inv",
"CategoryTheory.Category"
] | false |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.instLawfulSliceSizeTakeListIteratorIdListSliceData._simp_1 | Init.Data.Slice.List.Lemmas | [
"Std.Slice.Internal.ListSliceData",
"ListSlice.instToIterator",
"Std.Iterators.Types.ListIterator",
"Monad.toApplicative",
"Std.ToIterator.iter",
"Std.Iterators.Types.Take",
"Id",
"Applicative.toPure",
"_private.Init.Data.Slice.List.Lemmas.0.ListSlice.internalIter_eq_toIteratorIter",
"Std.Iter",
... | false |
NonUnitalStarAlgebra.adjoinNonUnitalCommSemiringOfComm.match_1 | Mathlib.Algebra.Star.NonUnitalSubalgebra | [
"NonUnitalStarAlgebra.adjoin",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"instDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Subtype.casesOn",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"DistribSMul.toSMulZeroClass",
"NonUnitalSemiring.toNonUnitalNon... | false |
AddMonoidAlgebra.of'_mul_divOf | Mathlib.Algebra.MonoidAlgebra.Division | [
"Finsupp.instFunLike",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMul",
"AddMonoidAlgebra.divOf",
"congrArg",
"Finset",
"AddMonoidAlgebra.divOf_apply",
"IsCancelAdd.toIsLeftCancelAdd",
"AddMonoidAlgebra.ext",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Finsu... | true |
CategoryTheory.Sheaf.ΓNatIsoLim | Mathlib.CategoryTheory.Sites.GlobalSections | [
"CategoryTheory.Functor",
"CategoryTheory.constantSheaf",
"Opposite",
"CategoryTheory.Limits.HasLimitsOfShape",
"CategoryTheory.Functor.category",
"CategoryTheory.hasGlobalSectionsFunctor_of_hasLimitsOfShape",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.lim",
"CategoryTheory.Iso",
"Categ... | true |
ISize.add_assoc | Init.Data.SInt.Lemmas | [
"instAddISize",
"BitVec.add_assoc",
"ISize.toBitVec_inj",
"BitVec",
"System.Platform.numBits",
"instHAdd",
"HAdd.hAdd",
"ISize.toBitVec",
"Iff.mp",
"ISize",
"Eq"
] | true |
PolynomialModule.eval_smul | Mathlib.Algebra.Polynomial.Module.Basic | [
"Eq.mpr",
"Mathlib.Tactic.Module.NF.eval_algebraMap",
"Polynomial.eval",
"Mathlib.Tactic.Module.NF.eq_cons_cons",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"Mathlib.Tactic.Ring.single_pow",
"Mathlib.Tactic.Module.NF.atom_eq_eval",
"CommRing",
"instHSMul",
"Semiring.t... | true |
_private.Std.Sync.Barrier.0.Std.BarrierState.mk._flat_ctor | Std.Sync.Barrier | [
"_private.Std.Sync.Barrier.0.Std.BarrierState",
"_private.Std.Sync.Barrier.0.Std.BarrierState.mk",
"Nat"
] | false |
Std.Time.TimeZone.TZif.instInhabitedTZif | Std.Time.Zoned.Database.TzIf | [
"Inhabited",
"Std.Time.TimeZone.TZif.TZif",
"Inhabited.mk",
"Std.Time.TimeZone.TZif.instInhabitedTZif.default"
] | true |
_private.LeanSearchClient.Syntax.0.LeanSearchClient.checkTactic.match_1 | LeanSearchClient.Syntax | [
"Lean.MVarId",
"Prod.mk",
"List",
"Lean.Elab.Term.State",
"Prod",
"Prod.casesOn"
] | false |
Lean.Compiler.LCNF.isClass? | Lean.Compiler.LCNF.Types | [
"Pure.pure",
"Lean.Core.instMonadEnvCoreM",
"Option.some",
"Lean.Expr",
"IO.RealWorld",
"EIO",
"instDecidableEqBool",
"Lean.Level",
"instMonadEIO",
"Applicative.toPure",
"Bool.true",
"_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.isClass?.match_1",
"Option.none",
"List",
"Lean.C... | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers.0.CategoryTheory.NormalMonoCategory.pullback_of_mono.match_1_3 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Limits.KernelFork.ofι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"Subtype.casesOn",
"CategoryTheory.Limits.kernel",
"CategoryTheory.Limits.walkingParallelPairHomCategory",
"Subtype",... | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.withSynthesizeImp.match_1 | Lean.Elab.SyntheticMVars | [
"DoResultPR",
"DoResultPR.return",
"PUnit",
"DoResultPR.casesOn",
"DoResultPR.pure"
] | false |
PresheafOfModules.Sheafify.SMulCandidate.casesOn | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | [
"CategoryTheory.Functor",
"instHSMul",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"Cate... | false |
Vector.insertIdx | Init.Data.Vector.Basic | [
"Array.insertIdx",
"Vector",
"instOfNatNat",
"LE.le",
"instLENat",
"autoParam",
"instHAdd",
"Vector.insertIdx._auto_1",
"HAdd.hAdd",
"Vector.mk",
"Nat",
"Vector.insertIdx._proof_2",
"Vector.insertIdx._proof_1",
"instAddNat",
"OfNat.ofNat",
"Vector.toArray"
] | true |
MulOpposite.op_ne_zero_iff | Mathlib.Algebra.Opposites | [
"MulOpposite.op_eq_zero_iff",
"MulOpposite",
"Ne",
"MulOpposite.instZero",
"Iff",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"not_congr",
"MulOpposite.op",
"Zero"
] | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvLetValue._sparseCasesOn_15 | Lean.Compiler.LCNF.AlphaEqv | [
"Lean.Compiler.LCNF.LetValue.reuse",
"Lean.Compiler.LCNF.Arg",
"Lean.Compiler.LCNF.LetValue.pap",
"Nat.ne_of_beq_eq_false",
"Lean.Compiler.LCNF.LitValue",
"Lean.Compiler.LCNF.LetValue.oproj",
"Lean.Compiler.LCNF.LetValue.rec",
"Lean.Compiler.LCNF.LetValue",
"Nat.shiftRight",
"Lean.Compiler.LCNF.Le... | false |
Class._aux_Mathlib_SetTheory_ZFC_Class___unexpand_Class_sUnion_1 | Mathlib.SetTheory.ZFC.Class | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | [
"Nat.instMulZeroClass",
"Composition.mk",
"List.sum",
"Membership.mem",
"instOfNatNat",
"Composition",
"List",
"List.instMembership",
"Nat",
"LT.lt",
"instAddNat",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Composition.recOnSingleAppend.match_3",
"Eq",
"MulZeroClass.toZero"
] | true |
ProbabilityTheory.exponentialPDF_of_nonneg | Mathlib.Probability.Distributions.Exponential | [
"Real.instLE",
"Real",
"HMul.hMul",
"Real.instZero",
"ENNReal.ofReal",
"congrArg",
"ProbabilityTheory.exponentialPDF",
"Decidable",
"ProbabilityTheory.exponentialPDF_eq",
"LE.le",
"Real.exp",
"if_pos",
"Real.instMul",
"True",
"Real.instNeg",
"eq_self",
"ENNReal",
"of_eq_true",
"Z... | true |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_snd | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"Std.DTreeMap.Internal.Impl.insert!",
"Std.Internal.List.containsKey_eq_isSome_getValue?",
"Std.DTreeMap.Internal.Impl.contains_eq_containsKey",
"beqOfOrd",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?.match_1",
"Optio... | true |
LLVM.AttributeIndex.ctorIdx | Lean.Compiler.IR.LLVMBindings | [
"Nat",
"LLVM.AttributeIndex"
] | false |
_private.Mathlib.MeasureTheory.Integral.DominatedConvergence.0.MeasureTheory.integral_tsum._simp_1_2 | Mathlib.MeasureTheory.Integral.DominatedConvergence | [
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Real",
"SeminormedAddGroup.toNNNorm",
"NNNorm.nnnorm",
"SeminormedAddGroup",
"coe_nnnorm",
"Eq.symm",
"Eq",
"NNReal.toReal"
] | false |
HasFPowerSeriesAt.hasFDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | [
"LinearIsometryEquiv.instEquivLike",
"HasFDerivAt",
"NormedCommRing.toSeminormedCommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"FormalMultilinearSeries",
"DistribMulAction.toDistribSMul",
... | true |
LaurentSeries.ratfuncAdicComplRingEquiv._proof_3 | Mathlib.RingTheory.LaurentSeries | [
"Int.instAddCommGroup",
"Eq.mpr",
"LaurentSeries.extensionAsRingHom",
"Int.instAddCommMonoid",
"Multiplicative.linearOrder",
"Int.instIsStrictOrderedRing",
"RatFunc.polynomialValuationX._proof_1",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Equiv.instEquivLike",
"HMul.hMul",
"CommRing.toNo... | false |
Finset.cons.congr_simp | Mathlib.Data.Finset.Insert | [
"Finset.cons",
"Finset",
"Membership.mem",
"Eq.rec",
"Finset.instSetLike",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Not",
"SetLike.instMembership"
] | true |
Fintype.card_lt_of_injective_of_notMem | Mathlib.Data.Fintype.Card | [
"Eq.mpr",
"Set.image_univ",
"Trans.trans",
"Finset.univ",
"Finset.coe_univ",
"congrArg",
"Finset",
"Set.univ",
"Finset.card_map",
"Finset.map",
"Membership.mem",
"Function.Embedding.mk",
"Fintype.card",
"id",
"Function.Embedding",
"instTransEq",
"Finset.card_lt_univ_of_notMem",
"Fi... | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.mkLambdaFVarsWithLetDeps | Lean.Meta.ExprDefEq | [
"Pure.pure",
"Bool.not",
"_private.Lean.Meta.ExprDefEq.0.Lean.Meta.mkLambdaFVarsWithLetDeps.addLetDeps",
"ReaderT",
"Monad.toApplicative",
"Lean.Meta.State",
"Option.some",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Applicative.toPure",
"Array",
"Bool.true",
... | true |
FiniteIndexNormalAddSubgroup.instSemilatticeInfFiniteIndexNormalAddSubgroup._proof_3 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | [
"Preorder.toLT",
"Iff.rfl",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"CompleteLattice.toConditionallyCompleteLattice",
"FiniteIndexNormalAddSubgroup",
"AddGroup",
"Iff",
"SetLike.coe",
"LT.lt",
"CompleteBooleanAlgebra.toCompleteLattice",
"FiniteIndexNormalAddSubgroup.instSet... | false |
Lean.Elab.Term.elabRawNatLit._regBuiltin.Lean.Elab.Term.elabRawNatLit.declRange_3 | Lean.Elab.BuiltinTerm | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
Std.Do.PredTrans.const | Std.Do.PredTrans | [
"Std.Do.PostCond",
"Std.Do.Assertion",
"Std.Do.PostShape",
"Std.Do.PredTrans.const._proof_1",
"Std.Do.PredTrans.mk",
"Std.Do.PredTrans"
] | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Complex.ofReal_cpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | [
"Real",
"Real.instZero",
"Complex.instZero",
"Complex.ofReal",
"Complex.ofReal_eq_zero",
"propext",
"Zero.toOfNat0",
"Complex",
"OfNat.ofNat",
"Eq"
] | false |
Sym.countPerms_coe_fill_of_notMem | Mathlib.Data.Nat.Choose.Multinomial | [
"Iff.mpr",
"Multiset.filter_eq_self",
"Eq.mpr",
"instDecidableNot",
"False",
"Nat.choose",
"HMul.hMul",
"congrArg",
"Sym.count_coe_fill_self_of_notMem",
"instIsLeftCancelAddOfAddLeftReflectLE",
"Sym.replicate",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"Multiset.instAddCancelCommMonoid",
... | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.IsAddCyclic.of_exponent_eq_card.match_1_1 | Mathlib.GroupTheory.SpecificGroups.Cyclic | [
"Finset.univ",
"AddMonoid.exponent_eq_max'_addOrderOf._proof_1",
"Finset",
"addOrderOf",
"AddCommGroup.toAddCancelCommMonoid",
"AddCommGroup.toAddGroup",
"Finset.max'",
"Membership.mem",
"Exists",
"AddCommGroup",
"instOfNatNat",
"And.casesOn",
"And",
"Exists.casesOn",
"Fintype",
"AddGr... | false |
Int64.shiftLeft_zero | Init.Data.SInt.Bitwise | [
"Int64.toBitVec_shiftLeft",
"BitVec.instOfNat",
"congrArg",
"_private.Init.Data.SInt.Bitwise.0.Int64.shiftLeft_zero._simp_1_1",
"HShiftLeft.hShiftLeft",
"BitVec",
"BitVec.zero_smod",
"Int64",
"Int64.toBitVec_ofNat",
"BitVec.instHShiftLeftNat",
"instOfNatNat",
"BitVec.toNat",
"BitVec.ofNat",
... | true |
TopologicalSpace.gciGenerateFrom | Mathlib.Topology.Order | [
"OrderDual.toDual",
"Equiv.instEquivLike",
"OrderDual.ofDual",
"PartialOrder.toPreorder",
"setOf",
"TopologicalSpace.gciGenerateFrom._proof_3",
"Preorder.toLE",
"Function.comp",
"CompleteLattice.toConditionallyCompleteLattice",
"Equiv",
"LE.le",
"TopologicalSpace.generateFrom",
"TopologicalS... | true |
isArtinian_of_finite | Mathlib.RingTheory.Artinian.Module | [
"Submodule",
"Preorder.toLT",
"IsWellFounded.mk",
"Finite",
"PartialOrder.toPreorder",
"Submodule.instPartialOrder",
"AddCommMonoid",
"SetLike.instFinite",
"IsArtinian",
"instIsTransLt",
"Submodule.setLike",
"LT.lt",
"instIrreflLt",
"Semiring",
"Module",
"Finite.wellFounded_of_trans_of... | true |
Std.TreeSet.instSliceableRocSlice | Std.Data.TreeSet.Slice | [
"Std.TreeSet",
"Std.Roc.Sliceable",
"Std.TreeMap.inner",
"Std.TreeSet.instSliceableRocSlice._auto_1",
"Ord.mk",
"Ordering",
"Std.TreeSet.inner",
"Std.DTreeMap.inner",
"Std.DTreeMap.Internal.Unit.RocSliceData.mk",
"Std.DTreeMap.Internal.Unit.RocSlice",
"autoParam",
"Unit",
"Std.Slice.mk",
"... | true |
Vector.finRange_zero | Init.Data.Vector.FinRange | [
"Vector.finRange",
"Vector.eq_mk._simp_1",
"Vector",
"congrArg",
"instOfNatNat",
"List.toArray",
"Array",
"Array.ofFn_zero",
"Vector.mk",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Fin",
"Eq",
"Array.size",
"Vector.toArray",
"Vector.ofFn",
"rfl",
"... | true |
Lean.Elab.Level.Context.mk | Lean.Elab.Level | [
"Lean.Syntax",
"Lean.Elab.Level.Context.mk",
"Lean.Elab.Level.Context",
"Bool",
"Lean.Options"
] | true |
_private.Mathlib.Data.Nat.Bitwise.0.Nat.xor_mod_two_eq._simp_1_6 | Mathlib.Data.Nat.Bitwise | [
"Nat.instMod",
"instHMod",
"Ne",
"instOfNatNat",
"HMod.hMod",
"Nat",
"propext",
"OfNat.ofNat",
"Eq",
"Nat.mod_two_ne_zero"
] | false |
List.pair_mem_product | Batteries.Data.List.Lemmas | [
"List.product",
"congrArg",
"List.map",
"Membership.mem",
"Exists",
"Prod.mk",
"_private.Batteries.Data.List.Lemmas.0.List.pair_mem_product._simp_1_1",
"iff_self",
"funext",
"List",
"And",
"Iff",
"List.instMembership",
"Prod.mk.injEq",
"_private.Batteries.Data.List.Lemmas.0.List.pair_mem... | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushInstPending | Lean.Meta.Sym.Pattern | [
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.us",
"Array.push",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.uAssignment",
"modify",
"Lean.Meta.State",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym... | true |
_private.Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar.0.BoundedContinuousFunction.mem_charPoly._simp_1_1 | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | [
"BoundedContinuousFunction.instFunLike",
"TopologicalSpace",
"PseudoMetricSpace",
"propext",
"Eq",
"DFunLike.coe",
"BoundedContinuousFunction",
"BoundedContinuousFunction.ext_iff"
] | false |
NumberField.InfinitePlace.mk_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | [
"NumberField.InfinitePlace.ramifiedPlacesOver",
"AbsoluteValue.LiesOver.mk",
"Real.partialOrder",
"Real",
"NumberField.ComplexEmbedding.mixedEmbeddingsOver",
"CommSemiring.toSemiring",
"NumberField.InfinitePlace.mk_embedding",
"Complex.instNormedField",
"Algebra",
"RingHom",
"Membership.mem",
... | true |
CpltSepUniformSpace.ctorIdx | Mathlib.Topology.Category.UniformSpace | [
"CpltSepUniformSpace",
"Nat"
] | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.instInhabitedVarInfo.default | Lean.Compiler.LCNF.ExplicitRC | [
"Inhabited.default",
"instInhabitedBool",
"instInhabitedNat",
"_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo.mk",
"Nat",
"Bool",
"_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo"
] | true |
Nat.Partition.ofSums._proof_1 | Mathlib.Combinatorics.Enumerative.Partition.Basic | [
"instDecidableNot",
"Preorder.toLT",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Multiset",
"Ne",
"instOfNatNat",
"Bot.bot",
"Multiset.of_mem_filter",
"Multiset.instMembership",
"Nat",
"LT.lt",
"Nat.instPartialOrder",
"instDecidableEqNat",
"Nat.in... | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitLet.match_1 | Lean.Compiler.LCNF.ToLCNF | [
"Lean.Expr.letE",
"_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitLet._sparseCasesOn_1",
"Lean.Expr",
"Nat.hasNotBit",
"Bool",
"Lean.Name",
"Lean.Expr.ctorIdx"
] | false |
VitaliFamily.FineSubfamilyOn.covering.congr_simp | Mathlib.MeasureTheory.Covering.VitaliFamily | [
"VitaliFamily.FineSubfamilyOn.covering",
"MeasureTheory.Measure",
"Eq.rec",
"MeasurableSpace",
"PseudoMetricSpace",
"Eq.ndrec",
"VitaliFamily.FineSubfamilyOn",
"Eq.refl",
"Prod",
"Eq",
"VitaliFamily",
"Set"
] | true |
Std.Roc.lower | Init.Data.Range.Polymorphic.PRange | [
"Std.Roc"
] | true |
NumberField.InfinitePlace.liesOver_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | [
"NumberField.InfinitePlace.ramifiedPlacesOver",
"Real.partialOrder",
"Real",
"congrArg",
"CommSemiring.toSemiring",
"Complex.instNormedField",
"NumberField.InfinitePlace.comap",
"Algebra",
"RingHom",
"Membership.mem",
"Exists",
"algebraMap",
"NumberField.InfinitePlace.IsRamified",
"Eq.rec"... | true |
Std.DTreeMap.toList | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"Std.DTreeMap.Internal.Impl.toList",
"Ordering",
"Std.DTreeMap.inner",
"List",
"Sigma"
] | true |
List.filterMap_flatten | Init.Data.List.Lemmas | [
"congrArg",
"List.map",
"List.rec",
"List.cons",
"instHAppendOfAppend",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"List.filterMap_append",
"List.instAppend",
"List.filterMap",
"Eq",
"HAppend.hAppend",
"Eq.trans",
"List.flatten",
"List.nil",
"Option"
] | true |
IsLocalDiffeomorph.preimage_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | [
"NormedSpace",
"congrArg",
"CommSemiring.toSemiring",
"Set.univ",
"Set.inter_univ",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Eq.mp",
"Ne",
"Set.instInter",
"IsLocalDiffeomorph.isLocalDiffeomorphOn",
"Inter.inter",
"TopologicalSpace",
"ModelWithCorners",
"Set.preimage",
"ModelWithCorn... | true |
CategoryTheory.Abelian.SpectralObject.mono_map | Mathlib.Algebra.Homology.SpectralObject.EpiMono | [
"Eq.mpr",
"CategoryTheory.Abelian.SpectralObject.E",
"instNeZeroNatHAdd_1",
"CategoryTheory.Abelian.SpectralObject.mono_map._auto_9",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Abelian.SpectralObject.opcyclesMap",
"CategoryTheory.Comp... | true |
Complex.basisOneI._proof_6 | Mathlib.LinearAlgebra.Complex.Module | [
"Zero.ofOfNat0",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"NeZero",
"OfNat.ofNat"
] | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Basic.0.Finset.prod_involution._proof_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Basic | [
"Lean.Grind.nestedProof",
"Finset",
"Membership.mem",
"Finset.instSetLike",
"SetLike.instMembership"
] | false |
QuadraticForm.equivalent_weightedSumSquares_units_of_nondegenerate' | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | [
"Pi.Function.module",
"NonAssocSemiring.toAddCommMonoidWithOne",
"IsScalarTower.to_smulCommClass'",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"QuadraticMap.associated_... | true |
NNReal.tendsto_const_div_atTop_nhds_zero_nat | Mathlib.Analysis.SpecificLimits.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"tendsto_const_div_atTop_nhds_zero_nat",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
"ContinuousSMul",
"DivisionSemiring.toNNRatAlgebra",
"PseudoMetricSpace.toUniformSpace",
"DivisionSemiring.toGroupWithZero",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"... | true |
Lean.Elab.Tactic.evalConstructor._regBuiltin.Lean.Elab.Tactic.evalConstructor_1 | Lean.Elab.Tactic.ElabTerm | [
"Lean.Elab.Tactic.tacticElabAttribute",
"Lean.Elab.Tactic.evalConstructor",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
Equiv.Perm.card_cycleType_pos | Mathlib.GroupTheory.Perm.Cycle.Type | [
"Nat.instCanonicallyOrderedAdd",
"Equiv.Perm.cycleType",
"Preorder.toLT",
"Equiv.Perm.instOne",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"Iff.not",
"Ne",
"instOfNatNat",
"AddZero.toZero",
"Iff",
"Fintype",
"Equiv.Perm.card_cycl... | true |
_private.Lean.Meta.Offset.0.Lean.Meta.isNatZero | Lean.Meta.Offset | [
"Pure.pure",
"_private.Lean.Meta.Offset.0.Lean.Meta.isNatZero.match_1",
"Lean.Meta.State",
"Lean.Meta.evalNat",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instOfNatNat",
"Applicative.toPure",
"instBEqOfDecidableEq",
"BEq.beq",
"Lean.Core.CoreM",
"Lean.Meta.instMonadMetaM",
"StateRefT... | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.curriedActionMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Action.End | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategoryStruct.rightUni... | false |
Std.CloseableChannel.tryRecv | Std.Sync.Channel | [
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded",
"Std.CloseableChannel",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.tryRecv",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.tryRecv",
"_private.Std.Sync.Cha... | true |
Sigma.instIsTransLex | Mathlib.Data.Sigma.Lex | [
"trans",
"Sigma.Lex",
"HEq.refl",
"IsTrans.mk",
"Sigma.Lex.casesOn",
"Sigma.mk.noConfusion",
"IsTrans",
"Sigma.Lex.right",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Sigma.mk",
"Eq.symm",
"Eq",
"Sigma",
"Sigma.Lex.left"
] | true |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mintro_1 | Std.Tactic.Do.Syntax | [
"Pure.pure",
"cond",
"Lean.Syntax.node",
"Lean.mkNullNode",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"Lean.Syntax.getArgs",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"L... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.