name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
ConvexCone.mem_mk | Mathlib.Geometry.Convex.Cone.Basic | [
"instHSMul",
"Preorder.toLT",
"SMul",
"Iff.rfl",
"PartialOrder.toPreorder",
"ConvexCone.instSetLike",
"Membership.mem",
"PartialOrder",
"AddCommMonoid",
"instHAdd",
"Iff",
"ConvexCone.mk",
"HAdd.hAdd",
"LT.lt",
"ConvexCone",
"Semiring",
"Zero.toOfNat0",
"HSMul.hSMul",
"AddCommSem... | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.FunBinders.elabFunBinderViews | Lean.Elab.Binders | [
"Inhabited.default",
"Lean.Elab.Term.BinderView",
"Lean.Elab.Term.instInhabitedTermElabM",
"Lean.Elab.Term.FunBinders.State",
"Array",
"Nat",
"Lean.Elab.Term.TermElabM"
] | true |
Nat.one_lt_succ_succ | Init.Data.Nat.Lemmas | [
"Nat.succ_lt_succ",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.succ_pos",
"LT.lt",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"Nat.succ"
] | true |
HasFDerivWithinAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | [
"NormedCommRing.toNormedRing",
"NormedRing.toRing",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"HSub.hSub",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"HasFDerivWithinAt",
"NormedField.toField",
"id",
"Field.toSemifield",
"ContinuousLinearMap",... | true |
Std.Http.Headers.get! | Std.Http.Data.Headers | [
"Std.Http.Header.Name.instBEq",
"Std.Internal.IndexMultiMap.get!",
"Std.Http.Header.Name",
"Std.Http.Headers.map",
"Std.Http.Header.Value",
"Std.Http.Header.Name.instHashable",
"Std.Http.Headers",
"Std.Http.Header.instInhabitedValue"
] | true |
_private.Qq.Commands.0.Qq.mkLetFVarsFromValues | Qq.Commands | [
"Lean.LocalDecl.ldecl",
"Lean.Meta.instMonadLCtxMetaM",
"Array.push",
"instMonadControlTOfPure",
"Lean.Meta.State",
"Lean.LocalContext.empty",
"Lean.LocalInstance",
"Lean.LocalContext.addDecl",
"Lean.LocalDecl.index",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instOfNatNat",
"Lean.Ex... | true |
Complex.isCauSeq_exp | Mathlib.Analysis.Complex.Exponential | [
"Norm.norm",
"Real",
"instHDiv",
"IsCauSeq.of_abv",
"Complex.instDivInvMonoid",
"Complex.instNorm",
"Complex.isCauSeq_norm_exp",
"HDiv.hDiv",
"Complex.instNatCast",
"Nat.cast",
"Monoid.toPow",
"Finset.range",
"HPow.hPow",
"Nat.factorial",
"Nat",
"Semiring.toMonoid",
"DivInvMonoid.toD... | true |
Filter.le_limsup_iff' | Mathlib.Order.LiminfLimsup | [
"Eq.mpr",
"Filter.le_limsup_of_frequently_le",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"le_of_lt",
"Preorder.toLE",
"Filter.IsCoboundedUnder",
"Exists",
"id",
"exists_between",
"LE.le",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"autoParam",
"foral... | true |
List.monotone_sum_take | Mathlib.Algebra.Order.BigOperators.Group.List | [
"Eq.mpr",
"Preorder.toLT",
"instReflLe",
"congrArg",
"Std.le_refl",
"AddMonoid.toAddZeroClass",
"List.sum",
"PartialOrder.toPreorder",
"Monotone",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"List.take_of_length_le",
"id",
"Nat.le_succ",
"instOfNatNat",
"LE.le",
"CanonicallyOrderedAdd... | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceOfNatAux._regBuiltin.Char.reduceOfNatAux.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.1314572429._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | [
"Char.reduceOfNatAux",
"IO",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.Simproc"
] | false |
AddMonoidAlgebra.smulZeroClass._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | [
"Finsupp.smulZeroClass",
"instHSMul",
"AddMonoidAlgebra.addAddCommMonoid",
"SMulZeroClass",
"AddMonoid.toAddZeroClass",
"smul_zero",
"AddZeroClass.toAddZero",
"inferInstance",
"SMul.mk",
"AddZero.toZero",
"Semiring",
"Zero.toOfNat0",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"AddCommMonoid.... | false |
Lean.Meta.Sym.AlphaShareCommon.State.set._default | Lean.Meta.Sym.AlphaShareCommon | [
"id",
"Lean.Meta.Sym.instBEqAlphaKey",
"Lean.PHashSet",
"Lean.Meta.Sym.AlphaKey",
"Lean.PersistentHashSet.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Lean.Meta.Sym.instHashableAlphaKey"
] | false |
CategoryTheory.Bicategory.Prod.snd_map₂ | Mathlib.CategoryTheory.Bicategory.Product | [
"CategoryTheory.Bicategory.Prod.snd",
"CategoryTheory.StrictPseudofunctorPreCore.mk",
"CategoryTheory.StrictlyUnitaryPseudofunctor.toPseudofunctor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PrelaxFunctorStruct.mk",
"CategoryTheory.StrictPseudofunctor.toStrictlyUnitaryPseud... | true |
MonadControl.noConfusionType | Init.Control.Basic | [
"MonadControl.casesOn",
"HEq",
"Eq",
"MonadControl"
] | false |
ContinuousMap.Homotopy.ulift_apply | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | [
"ULift.topologicalSpace",
"Real",
"ContinuousMap",
"ULift",
"PseudoMetricSpace.toUniformSpace",
"instTopologicalSpaceProd",
"ContinuousMap.Homotopy.uliftMap",
"Membership.mem",
"Set.Elem",
"Prod.mk",
"TopCat.str",
"TopCat.carrier",
"ContinuousMap.Homotopy.instFunLike",
"ContinuousMap.Homot... | true |
_private.Lean.Elab.Do.Switch.0.Lean.Elab.Term.expandTermTry._regBuiltin.Lean.Elab.Term.expandTermTry.declRange_3 | Lean.Elab.Do.Switch | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.Birational.RationalMap | [
"Lean.ParserDescr.trailingNode",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.Name.mkStr2",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Lean.TrailingParserDescr"
] | true |
Finsupp.coe_mk | Mathlib.Data.Finsupp.Defs | [
"Finsupp.instFunLike",
"Finset",
"Membership.mem",
"Finsupp.mk",
"Ne",
"Iff",
"Finset.instSetLike",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"SetLike.instMembership",
"Finsupp",
"rfl",
"Zero"
] | true |
UInt16.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | [
"UInt16.ofNatClamp_toNat",
"UInt16.ofNatClamp",
"UInt16",
"UInt16.toNat",
"Eq"
] | true |
Int.getElem_toList_roo | Init.Data.Range.Polymorphic.IntLemmas | [
"congrArg",
"Std.PRange.instUpwardEnumerableInt",
"GetElem.getElem.congr_simp",
"Int.toList_roo_eq_toList_rco",
"Int",
"Nat.cast",
"Std.PRange.instIsAlwaysFiniteInt_1",
"GetElem.getElem",
"Int.instLTInt",
"List",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"Nat",
"LT.lt",
"True",
"eq_self"... | true |
_private.Mathlib.Tactic.GRewrite.Elab.0.Mathlib.Tactic.GRewrite.updateInfoTree.match_4 | Mathlib.Tactic.GRewrite.Elab | [
"Lean.Elab.InfoTree.ctorIdx",
"Lean.Elab.InfoTree",
"Lean.Elab.PartialContextInfo",
"Lean.Elab.InfoTree.context",
"Nat.hasNotBit",
"Lean.PersistentArray",
"Lean.Elab.InfoTree.node",
"_private.Mathlib.Tactic.GRewrite.Elab.0.Mathlib.Tactic.GRewrite.updateInfoTree._sparseCasesOn_4",
"Lean.Elab.Info"
] | false |
_private.Mathlib.Data.PNat.Basic.0.PNat.dvd_iff._simp_1_1 | Mathlib.Data.PNat.Basic | [
"PNat.val",
"False",
"eq_false",
"PNat.ne_zero",
"instOfNatNat",
"Nat",
"OfNat.ofNat",
"Eq",
"PNat"
] | false |
Rep.coinvariantsTensorIndInv._proof_2 | Mathlib.RepresentationTheory.Induced | [
"Rep.instMonoidalCategory",
"Rep.V",
"CategoryTheory.Functor",
"CommRing",
"MonoidHom",
"Monoid.toMulOneClass",
"Rep.ind",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Rep.hV2",
"CategoryTheory.Functor.category",
"Group",
"Rep.instCategory",
"Rep.hV1",
"DivInvMonoid.toMono... | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.mdifferentiableWithinAt_congr_set'._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.Basic | [
"NormedSpace",
"mdifferentiableWithinAt_iff_exists_hasMFDerivWithinAt",
"AddCommGroup.toAddCommMonoid",
"instAddCommGroupTangentSpace",
"NormedField.toField",
"Exists",
"instModuleTangentSpace",
"Field.toSemifield",
"instTopologicalSpaceTangentSpace",
"ContinuousLinearMap",
"TopologicalSpace",
... | false |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra.0.CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.ext.match_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | [
"Opposite",
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Bicategory.Adj.Hom.l",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.opposite",
"Quiver.Hom.op",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.Cat.str",
"CategoryTheory.Pseudofun... | false |
CategoryTheory.InducedCategory.Hom.mk | Mathlib.CategoryTheory.InducedCategory | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.InducedCategory.Hom",
"CategoryTheory.InducedCategory",
"CategoryTheory.InducedCategory.Hom.mk",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"
] | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | [
"Ord",
"Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1",
"Std.DTreeMap.Internal.Impl.ExplorationStep.lt",
"Ordering",
"Std.DTreeMap.Internal.Impl.ExplorationStep.eq",
"Std.DTreeMap.Internal.Impl.ExplorationStep",
"Std.DTreeMap.Internal.Cell",
"List",
"Ordering.lt",
"Eq",
"Sigma"
] | true |
Std.DTreeMap.Internal.Impl.length_keys | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"Std.Internal.List.length_keys_eq_length",
"Ord",
"congrArg",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.size",
"id",
"Std.DTreeMap.Internal.Impl.WF",
"Std.DTreeMap.Internal.Impl.WF.balanced",
"List",
"Nat",
"Std.DTreeMap.Internal.Impl.size_eq_length",
"congr",
"Std.DTreeMap.Int... | true |
_private.Aesop.RuleTac.Cases.0.Aesop.RuleTac.cases.go.match_10 | Aesop.RuleTac.Cases | [
"Lean.Meta.CasesSubgoal",
"Option.ctorIdx",
"_private.Aesop.RuleTac.Cases.0.Aesop.RuleTac.cases.go._sparseCasesOn_10",
"Option.some",
"Nat.hasNotBit",
"Array",
"Option"
] | false |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstr?.match_1 | Lean.Meta.Tactic.Simp.Arith.Nat.Simp | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"Prod.mk",
"_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstrPos?._sparseCasesOn_1",
"Prod",
"Prod.casesOn",
"Option"
] | false |
MeasureTheory.Measure.AbsolutelyContinuous.support_mono | Mathlib.MeasureTheory.Measure.Support | [
"MeasureTheory.Measure",
"Preorder.toLT",
"Filter.smallSets",
"MeasureTheory.Measure.AbsolutelyContinuous.pos_mono",
"PartialOrder.toPreorder",
"Membership.mem",
"nhds",
"MeasureTheory.Measure.AbsolutelyContinuous",
"Filter.Eventually.of_forall",
"HasSubset.Subset",
"MeasureTheory.Measure.suppor... | true |
List.getLast._proof_1 | Init.Data.List.Basic | [
"List",
"Eq",
"rfl",
"List.nil"
] | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.nz_of_isRat.match_1_1 | Mathlib.Tactic.Positivity.Core | [
"Int.cast",
"Mathlib.Meta.NormNum.IsRat.mk",
"HMul.hMul",
"AddGroupWithOne.toAddMonoidWithOne",
"Invertible.invOf",
"AddMonoidWithOne.toNatCast",
"Int",
"AddGroupWithOne.toIntCast",
"Nat.cast",
"instDistribOfSemiring",
"Int.instLTInt",
"AddMonoidWithOne.toOne",
"Bool.true",
"Mathlib.Meta.N... | false |
FiniteField.frobenius_pow | Mathlib.FieldTheory.Finite.Basic | [
"RingHom.mul_def",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Nat.recAux",
"Nat.Prime",
"HMul.hMul",
"RingHom.id_apply",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Nat.instMonoid",
"pow_succ",
"AddGroupWith... | true |
IsDiscreteValuationRing.unit_mul_pow_congr_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | [
"AddGroup.toSubtractionMonoid",
"Units.val",
"IsDomain",
"CommRing",
"IsDomain.to_noZeroDivisors",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"IsDiscreteValuationRing.unit_mul_pow_congr_pow",
"MulZeroClass.toMul",
"AddGroupWithOne.toAddGroup",
... | true |
ContinuousLinearEquiv.toDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Diffeomorph | [
"ContinuousLinearEquiv.toDiffeomorph._proof_1",
"chartedSpaceSelf",
"NormedSpace",
"instTopENat",
"AddCommGroup.toAddCommMonoid",
"ContMDiff",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"NormedField.toField",
"ContinuousLinearEquiv.equivLike",
"Field.toSemifield",
"WithTop.som... | false |
Fin.foldrM_succ | Init.Data.Fin.Fold | [
"instNeZeroNatHAdd_1",
"Nat.le_refl",
"Fin.succ",
"Fin.foldrM",
"Fin.instOfNat",
"LawfulMonad",
"instOfNatNat",
"funext",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"Monad.toBind",
"Bind.bind",
"OfNat.ofNat",
"Monad",
"Fin",
"_private.Init.Data.Fin.Fold.0... | true |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.inf_dite_neg_le._proof_1_1 | Mathlib.Data.Finset.Lattice.Fold | [
"False",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.Order.le_of_eq_1",
"Finset",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"Lean.Grind.eq_false_of_imp_eq_true",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Eq.mp",
"id",
"LE.le",
"OrderTop",
... | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.error.noConfusion | Mathlib.Tactic.TacticAnalysis.Declarations | [
"_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome",
"_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.noConfusion",
"Lean.TSyntax",
"Lean.MessageData",
"_private.Mathlib.Tactic.TacticAnalysis.Declar... | false |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | [
"PiTensorProduct.instSeminormedAddCommGroup",
"SeminormedAddCommGroup",
"NormedSpace",
"AddMonoid.toAddSemigroup",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"NormedField.toField",
"IsTopologicalAddGroup.toContinuousAdd",
... | false |
Filter.CountableGenerateSets.below.basic | Mathlib.Order.Filter.CountableInter | [
"Filter.CountableGenerateSets.below",
"Membership.mem",
"Filter.CountableGenerateSets",
"Filter.CountableGenerateSets.below.basic",
"Filter.CountableGenerateSets.basic",
"Set.instMembership",
"Set"
] | true |
DirectSum.GSemiring.casesOn | Mathlib.Algebra.DirectSum.Ring | [
"instHSMul",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"GradedMonoid.GOne.toOne",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"GradedMonoid.GOne.one",
"Sigma.fst",
"instOfNatNat",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"DirectSu... | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_13 | Lean.Elab.Tactic.Simp | [
"Lean.Syntax",
"Prod.mk",
"Lean.Elab.Tactic.ElabSimpArgResult",
"Prod",
"Prod.casesOn"
] | false |
Std.Tactic.BVDecide.LRAT.Internal.lratChecker._unsafe_rec | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | [
"Std.Tactic.BVDecide.LRAT.Internal.Formula.delete",
"Std.Tactic.BVDecide.LRAT.Internal.Formula.performRatAdd",
"Std.Tactic.BVDecide.LRAT.Internal.Formula",
"Std.Tactic.BVDecide.LRAT.Action",
"Std.Tactic.BVDecide.LRAT.Internal.lratChecker.match_1",
"instDecidableEqBool",
"Std.Tactic.BVDecide.LRAT.Interna... | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_iff_forall_isSome_getEntry?.match_1_1 | Std.Data.Internal.List.Associative | [
"Unit.unit",
"List.cons",
"List",
"Unit",
"List.casesOn",
"Sigma.mk",
"Sigma.casesOn",
"Sigma",
"List.nil"
] | false |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | [
"List.brecOn",
"AddMonoid.toAddZeroClass",
"List.sum",
"AddZeroClass.toAddZero",
"List.set",
"instOfNatNat",
"AddZero.toZero",
"List",
"instHAdd",
"List.drop",
"HAdd.hAdd",
"Nat",
"LT.lt",
"AddMonoid",
"Nat.decLt",
"instAddNat",
"AddZero.toAdd",
"Zero.toOfNat0",
"instLTNat",
"L... | true |
CategoryTheory.Functor.PushoutObjObj.ofNatIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Functor.PushoutObjObj",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Iso",
"CategoryTheory.Functor.PushoutObjObj.inr",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Functor.PushoutObjObj.m... | true |
Finset.piecewise | Mathlib.Data.Finset.Piecewise | [
"Finset",
"Decidable",
"Membership.mem",
"Finset.instSetLike",
"SetLike.instMembership",
"ite"
] | true |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | [
"Coalgebra.toCoalgebraStruct",
"Semiring.toModule",
"Algebra.algebraMap",
"Coalgebra",
"CommSemiring.toSemiring",
"WithConv.ofConv",
"LinearMap.instFunLike",
"Algebra",
"RingHom",
"CoalgebraStruct.counit",
"Algebra.toModule",
"LinearMap.convOne",
"LinearMap",
"AddCommMonoid",
"CommSemiri... | true |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | [
"Array",
"List",
"PProd",
"PUnit",
"Lean.IR.IRType",
"Lean.Name",
"Lean.IR.IRType.rec",
"Option"
] | false |
AbstractSimplicialComplex.mk | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | [
"AbstractSimplicialComplex.mk",
"PreAbstractSimplicialComplex.faces",
"Finset",
"Membership.mem",
"PreAbstractSimplicialComplex",
"Finset.instSingleton",
"Singleton.singleton",
"Set.instMembership",
"AbstractSimplicialComplex",
"Set"
] | true |
_private.Mathlib.NumberTheory.ModularForms.Discriminant.0.ModularForm.discriminant_eq_q_prod._simp_1_3 | Mathlib.NumberTheory.ModularForms.Discriminant | [
"instHSMul",
"Complex.exp_nsmul",
"AddGroupWithOne.toAddMonoidWithOne",
"AddMonoid.toNSMul",
"Complex.addGroupWithOne",
"Monoid.toPow",
"HPow.hPow",
"Nat",
"Semiring.toMonoid",
"Complex.exp",
"HSMul.hSMul",
"instHPow",
"AddMonoidWithOne.toAddMonoid",
"Complex",
"Eq.symm",
"Eq",
"Comp... | false |
PhragmenLindelof.eq_zero_on_quadrant_IV | Mathlib.Analysis.Complex.PhragmenLindelof | [
"Iff.mpr",
"DiffContOnCl",
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real.instPow",
"Real.instLE",
"Real",
"Set.Ioi",
"HMul.hMul",
"Complex.instNormedAddCommGroup",
"PhragmenLindelof.quadrant_IV",
"PseudoMetricSp... | true |
_private.Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno.0.OrderedFinpartition.eraseMiddle._simp_5 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | [
"Fin.val",
"Nat",
"propext",
"Eq.symm",
"Fin",
"Eq",
"Fin.val_eq_val"
] | false |
IsTopologicalRing.toIsSemitopologicalRing | Mathlib.Topology.Algebra.Ring.Basic | [
"NonUnitalNonAssocRing",
"IsTopologicalSemiring.toContinuousAdd",
"IsTopologicalRing.toIsTopologicalSemiring",
"IsTopologicalSemiring.toContinuousMul",
"IsSemitopologicalSemiring.mk",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"IsSemitopologicalRing",
"IsTopologicalRing",
"TopologicalSpace... | true |
_private.Mathlib.Topology.Order.LeftRightLim.0.Monotone.leftLim_le._simp_1_4 | Mathlib.Topology.Order.LeftRightLim | [
"Set.mem_Iio",
"Preorder.toLT",
"Membership.mem",
"LT.lt",
"propext",
"Set.Iio",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
instRingWithIdealFilter._proof_7 | Mathlib.RingTheory.IdealFilter.Topology | [
"instRingWithIdealFilter._proof_3",
"instRingWithIdealFilter._aux_4",
"AddMonoid.add_zero",
"AddSemigroup.mk",
"WithIdealFilter",
"IdealFilter",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"instRingWithIdealFilter._aux_1",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"OfNat.ofNat",
"Ri... | false |
Monotone.withTop_map | Mathlib.Order.WithBot | [
"Iff.mpr",
"WithTop.instPreorder",
"Monotone",
"WithTop.monotone_map_iff",
"WithTop.map",
"Preorder",
"WithTop"
] | true |
npow_mul_comm | Mathlib.Algebra.Group.NatPowAssoc | [
"_private.Mathlib.Algebra.Group.NatPowAssoc.0.npow_mul_comm._simp_1_1",
"HMul.hMul",
"Pow",
"congrArg",
"MulOne.toMul",
"add_comm",
"instHAdd",
"MulOneClass.toMulOne",
"HPow.hPow",
"HAdd.hAdd",
"Nat",
"congr",
"True",
"eq_self",
"of_eq_true",
"instAddNat",
"AddCommSemigroup.toAddComm... | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushPending | 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 |
MonCat.Colimits.quot_one | Mathlib.Algebra.Category.MonCat.Colimits | [
"MulOne.toOne",
"CategoryTheory.Functor",
"MonCat.Colimits.colimitSetoid",
"Monoid.toMulOneClass",
"MonCat.Colimits.Prequotient",
"MonCat",
"MonCat.instCategory",
"MulOneClass.toMulOne",
"MonCat.Colimits.monoidColimitType",
"MonCat.Colimits.ColimitType",
"MonCat.Colimits.Prequotient.one",
"One... | true |
IsLocalHomeomorphOn.of_comp_left | Mathlib.Topology.IsLocalHomeomorph | [
"IsLocalHomeomorphOn.mk",
"Filter.instMembership",
"Iff.mpr",
"Eq.mpr",
"mem_interior_iff_mem_nhds",
"interior_subset",
"OpenPartialHomeomorph.open_source",
"congrArg",
"ContinuousAt",
"PartialEquiv.target",
"IsLocalHomeomorphOn",
"ContinuousAt.preimage_mem_nhds",
"OpenPartialHomeomorph.tran... | true |
Localization.algEquiv_symm_mk | Mathlib.RingTheory.Localization.Basic | [
"Eq.mpr",
"Localization.mk",
"Localization.mk_eq_mk'",
"IsLocalization",
"AlgEquiv.symm",
"OreLocalization.instAlgebra",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Localization.algEquiv",
"Algebra",
"Membership.mem",
"Algebra.id",
"id",
"Subtype",
"Localization",
... | true |
String.ofList._proof_1 | Init.Prelude | [
"List",
"ByteArray.IsValidUTF8.intro",
"Char",
"ByteArray",
"List.utf8Encode",
"rfl",
"ByteArray.IsValidUTF8"
] | false |
AddChar.PrimitiveAddChar.char | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | [
"PNat.val",
"CommRing",
"AddChar.PrimitiveAddChar",
"AddGroupWithOne.toAddMonoidWithOne",
"AddChar",
"AddChar.PrimitiveAddChar.n",
"Field.toSemifield",
"instFieldCyclotomicField",
"Semifield.toDivisionSemiring",
"CyclotomicField",
"Semiring.toMonoid",
"DivisionSemiring.toSemiring",
"AddMonoi... | true |
_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State.ctorIdx | Lean.Util.CollectAxioms | [
"Nat",
"_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State"
] | false |
Subfield.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | [
"MulOne.toOne",
"instHSMul",
"Monoid.toMulOneClass",
"DivisionRing.toDivisionSemiring",
"one_smul",
"MulOneClass.toMulOne",
"MulAction",
"Semiring.toMonoid",
"Monoid.toSemigroup",
"DivisionSemiring.toSemiring",
"One.toOfNat1",
"HSMul.hSMul",
"DivisionRing",
"SemigroupAction.toSMul",
"Mul... | false |
skyscraperSheafForgetAdjunction | Mathlib.Topology.Sheaves.Skyscraper | [
"TopCat.instCategoryPresheaf",
"Decidable",
"CategoryTheory.Functor.comp",
"TopologicalSpace.Opens",
"Membership.mem",
"TopCat.Presheaf",
"skyscraperSheafFunctor",
"skyscraperPresheafStalkAdjunction",
"TopCat.Sheaf",
"TopologicalSpace.Opens.instSetLike",
"TopCat.str",
"TopCat.carrier",
"TopC... | true |
CategoryTheory.Limits.biprod.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | [
"CategoryTheory.Limits.HasZeroMorphisms",
"Eq.rec",
"CategoryTheory.Limits.HasBinaryBiproduct",
"CategoryTheory.Limits.biprod",
"Eq.ndrec",
"Eq.refl",
"Eq",
"CategoryTheory.Category"
] | true |
MulEquiv.coe_subgroupMap_apply | Mathlib.Algebra.Group.Subgroup.Map | [
"MulEquiv.instEquivLike",
"Subgroup.map",
"Monoid.toMulOneClass",
"MulEquiv.instMulEquivClass",
"Subgroup.mul",
"Group",
"MulEquiv.subgroupMap",
"Membership.mem",
"MulOne.toMul",
"Subtype",
"MonoidHomClass.toMonoidHom",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDivInvMonoid",
"MulOne... | true |
Std.Time.FormatType | Std.Time.Format.Basic | [
"List.brecOn",
"Std.Time.FormatPart",
"Std.Time.FormatType._f",
"Std.Time.FormatString"
] | true |
Polynomial.expand_eq_zero | Mathlib.Algebra.Polynomial.Expand | [
"AlgHom.algHomClass",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"map_zero",
"Algebra.id",
"RingHomClass.toMonoidWithZeroHomClass",
"Function.Injective.eq_iff'",
"NonAssocSemiring.toMulZeroOneClass",
"instOfNatNat",
"Polynomial",
"CommSemiring",
"... | true |
MeasureTheory.measureReal_univ_pos | Mathlib.MeasureTheory.Measure.Real | [
"Real",
"MeasureTheory.Measure",
"Real.instZero",
"Set.univ",
"MeasureTheory.Measure.real",
"Real.instLT",
"MeasureTheory.measure_ne_top",
"MeasureTheory.Measure.instZero",
"ENNReal.toReal_pos",
"MeasurableSpace",
"MeasureTheory.IsFiniteMeasure",
"LT.lt",
"ENNReal",
"MeasureTheory.Measure.... | true |
LieModuleHom.codRestrict.congr_simp | Mathlib.Algebra.Lie.Weights.Cartan | [
"LieSubmodule.instSetLike",
"CommRing",
"LieModuleHom.codRestrict",
"LieModuleHom",
"LieSubmodule.instLieRingModuleSubtypeMem",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieSubmodule.instSMulMemClass",
"LieSubmodule",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Eq.rec",
"... | true |
List.SortedGT.reverse | Mathlib.Data.List.Sort | [
"Iff.mpr",
"List.SortedLT",
"List.SortedGT",
"List",
"List.reverse",
"List.sortedLT_reverse",
"Preorder"
] | true |
instIsLeftCancelSMulOfIsLeftCancelMul | Mathlib.Algebra.Group.Action.Defs | [
"instSMulOfMul",
"IsLeftCancelMul.mul_left_cancel",
"IsLeftCancelMul",
"Mul",
"IsLeftCancelSMul",
"IsLeftCancelSMul.mk"
] | true |
Matrix.addGroup._proof_4 | Mathlib.LinearAlgebra.Matrix.Defs | [
"Pi.addGroup",
"Matrix",
"Matrix.addGroup._aux_2",
"AddMonoid.toZero",
"Int",
"SubNegMonoid.zsmul_zero'._autoParam",
"autoParam",
"AddGroup",
"AddGroup.toSubNegMonoid",
"instOfNat",
"Matrix.addMonoid",
"Zero.toOfNat0",
"SubNegMonoid.toAddMonoid",
"OfNat.ofNat",
"Pi.subNegMonoid._proof_2"... | false |
Std.ExtDTreeMap.Const.isSome_get?_iff_mem | Std.Data.ExtDTreeMap.Lemmas | [
"Std.DTreeMap",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.ExtDTreeMap.Const.get?",
"Bool.true",
"Iff",
"Std.DTreeMap.Const.isSome_get?_iff_mem",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Bool",
"Option.isSome",
"Eq",
"Std.ExtDTreeMap.instMembershipOfTransCmp"
] | true |
CategoryTheory.End.smul_left | Mathlib.CategoryTheory.Endomorphism | [
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"MulOpposite",
"CategoryTheory.End.mulActionLeft",
"CategoryTheory.End.monoid",
"CategoryTheory.End",
"MulOpposite.instMonoid",
"CategoryTheory.CategoryStruct.comp",
"Monoid.toSemigroup",
"MulOpposite.unop",
"HSMul.hSMul",
... | true |
StarAddMonoid.mk | Mathlib.Algebra.Star.Basic | [
"StarAddMonoid.mk",
"AddMonoid.toAddSemigroup",
"InvolutiveStar",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"AddMonoid",
"StarAddMonoid",
"InvolutiveStar.toStar",
"Eq",
"Star.star"
] | true |
_private.Mathlib.RingTheory.MvPowerSeries.Trunc.0.MvPowerSeries.coeff_trunc'_mul_trunc'_eq_coeff_mul._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Trunc | [
"Finsupp.instLE",
"False",
"Nat.instMulZeroClass",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"eq_false",
"Lean.Grind.iff_eq",
"Finset",
"Classical.byContradiction",
"Finset.mem_Iic",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"Membership.mem",
"LocallyFiniteOrder.toLocallyFinit... | false |
IsIntegrallyClosed.of_iInf_eq_bot | Mathlib.RingTheory.LocalProperties.IntegrallyClosed | [
"Subalgebra.instSetLike",
"CommRing",
"Lattice.toSemilatticeSup",
"iInf",
"CompleteLattice.toLattice",
"CommSemiring.toSemiring",
"IsFractionRing",
"Algebra.botEquivOfInjective",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Algebra.instCompleteLatticeSubalgebra",
"Algebra",
"Preorder.toLE",... | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._proof_6 | Mathlib.Algebra.Homology.ExactSequenceFour | [
"CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._auto_1",
"instOfNatNat",
"LE.le",
"instLENat",
"autoParam",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Decidable.byContradiction",
"instAddNat",
"OfNat.ofNat",
"Not",
"Nat.decLe",
"_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.Cate... | false |
CategoryTheory.MonoOver.supLe._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | [
"CategoryTheory.Over",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory.ObjectProperty.FullSubcategory.obj",
"CategoryTheory.instCategoryOver",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.Over.left",
"CategoryTheory.discreteCategory",
"CategoryTheory.Limits.pair",
"Ca... | false |
_private.Lean.Message.0.Lean.MessageData.hasSyntheticSorry.visit._sparseCasesOn_1 | Lean.Message | [
"Lean.MessageData",
"Lean.MessageData.ctorIdx",
"Nat.ne_of_beq_eq_false",
"Lean.MessageData.group",
"Lean.MetavarContext",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.MessageData.ofLazy",
"Lean.MessageData.nest",
"Nat.hasNotBit",
"Lean.Widget.WidgetInstance",
"Lean.MessageData.withNamingContext",
... | false |
conjneg_ne_zero | Mathlib.Algebra.Star.Conjneg | [
"CommSemiring.toSemiring",
"conjneg",
"Iff.not",
"Pi.instZero",
"Ne",
"CommSemiring",
"conjneg_eq_zero",
"AddGroup",
"Iff",
"StarRing",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Zero.toOfNat0",
"OfNat.ofNat",
"Semiring.toNonAssocSemiring",
"Eq",
"MulZeroClass.toZero",
"instMul... | true |
Lean.Elab.FieldRedeclInfo.recOn | Lean.Elab.InfoTree.Types | [
"Lean.Elab.FieldRedeclInfo",
"Lean.Syntax",
"Lean.Elab.FieldRedeclInfo.rec",
"Lean.Elab.FieldRedeclInfo.mk"
] | false |
Multiset.disjoint_finset_sum_left | Mathlib.Algebra.BigOperators.Group.Finset.Defs | [
"Finset",
"Multiset.instAddCancelCommMonoid",
"Disjoint",
"Membership.mem",
"Multiset",
"Multiset.instOrderBot",
"Iff",
"Finset.instSetLike",
"AddCancelCommMonoid.toAddCommMonoid",
"SetLike.instMembership",
"Finset.sum",
"Multiset.instPartialOrder",
"Multiset.disjoint_finsetSum_left"
] | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_498 | Mathlib.CategoryTheory.ComposableArrows.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Finsupp.mem_range_mapDomain_iff | Mathlib.Data.Finsupp.Basic | [
"Finsupp.instFunLike",
"Function.Injective.injOn",
"Finset",
"Finsupp.mapDomain",
"AddMonoid.toAddZeroClass",
"Classical.byContradiction",
"_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mem_range_mapDomain_iff._simp_1_3",
"Finsupp.support",
"Membership.mem",
"Eq.rec",
"AddZeroClass.toAddZero",
... | true |
_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive | Lean.Elab.PreDefinition.Main | [
"Option.isNone",
"Lean.Elab.PreDefinition",
"Lean.Expr",
"Lean.Level",
"Lean.Elab.PreDefinition.value",
"List",
"BEq.beq",
"Lean.Elab.PreDefinition.declName",
"Lean.Expr.find?",
"Bool",
"Lean.Name",
"_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive.match_1",
"Bool.false",
"... | true |
Num.pos.injEq | Mathlib.Data.Num.Basic | [
"Eq.propIntro",
"Num.pos.inj",
"Num",
"Num.pos",
"Eq.ndrec",
"Eq.refl",
"PosNum",
"Eq"
] | true |
Function.FromTypes | Mathlib.Logic.Function.FromTypes | [
"Nat.brecOn",
"Function.FromTypes._f",
"Nat",
"Fin"
] | true |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TuringMachine.Config | [
"Turing.ToPartrec.instDecidableEqCode.decEq",
"DecidableEq",
"Turing.ToPartrec.Code"
] | true |
_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState.output.injEq | Lean.Server.FileWorker.ExampleHover | [
"_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState",
"Eq.propIntro",
"_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState.output",
"Lean.injEq_helper",
"And",
"Nat",
"Eq.ndrec",
"Eq.refl",
"_private.Lean.Server.FileWorker.ExampleHover... | true |
Std.Async.TCP.Socket.Client.noConfusion | Std.Async.TCP | [
"Std.Async.TCP.Socket.Client.noConfusionType",
"Std.Async.TCP.Socket.Client.casesOn",
"Std.Internal.UV.TCP.Socket",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Std.Async.TCP.Socket.Client"
] | false |
Lean.Elab.Term.elabStateRefT | Lean.Elab.BuiltinNotation | [
"Functor.discard",
"Lean.MessageData",
"Lean.Elab.Term.TermElab",
"Unit.unit",
"Lean.MetavarKind.natural",
"Lean.Elab.Term.elabTerm",
"Lean.mkSort",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"Option.some",
"Lean.Syntax",
"Lean.Expr",
"Lean.Meta.... | true |
CompactlyCoherentSpace.casesOn | Mathlib.Topology.Compactness.CompactlyCoherentSpace | [
"CompactlyCoherentSpace",
"Topology.IsCoherentWith",
"setOf",
"CompactlyCoherentSpace.mk",
"CompactlyCoherentSpace.rec",
"TopologicalSpace",
"IsCompact",
"Set"
] | false |
Real.instFloorRing | Mathlib.Algebra.Order.Archimedean.Real.Basic | [
"Real",
"Real.instArchimedean",
"Real.instRing",
"FloorRing",
"Archimedean.floorRing",
"Real.linearOrder",
"Real.instIsStrictOrderedRing"
] | true |
Std.DTreeMap.Equiv.foldrM_eq | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap.foldrM",
"Std.DTreeMap",
"Ord.mk",
"Ordering",
"LawfulMonad",
"Std.DTreeMap.inner",
"Std.DTreeMap.Internal.Impl.Equiv.foldrM_eq",
"Std.TransCmp",
"Std.DTreeMap.Equiv.inner",
"Std.DTreeMap.wf",
"Std.DTreeMap.Equiv",
"Monad",
"Eq"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.