name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
FinBddDistLat.instBoundedOrderCarrier | Mathlib.Order.Category.FinBddDistLat | [
"BddDistLat.isBoundedOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"FinBddDistLat.instDistribLatticeCarrier",
"DistribLattice.toLattice",
"FinBddDistLat",
"BddDistLat.toDistLat",
"FinBddDistLat.toBddDistLat",
"BoundedOrder",
"DistLat.carrier",
"Lattice.to... | true |
CategoryTheory.InjectiveResolution.ctorIdx | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | [
"CategoryTheory.Limits.HasZeroMorphisms",
"Nat",
"CategoryTheory.Limits.HasZeroObject",
"CategoryTheory.InjectiveResolution",
"CategoryTheory.Category"
] | false |
Polynomial.logMahlerMeasure_mul_eq_add_logMahlerMeasure | Mathlib.Analysis.Polynomial.MahlerMeasure | [
"NormedCommRing.toNormedRing",
"False",
"Real",
"HMul.hMul",
"Polynomial.mahlerMeasure_eq_zero_iff._simp_1",
"eq_false",
"Real.instZero",
"congrArg",
"NormedDivisionRing.toNormMulClass",
"Complex.instNormedField",
"Eq.mp",
"id",
"Ne",
"Polynomial.mahlerMeasure_mul",
"NormedField.toNormed... | true |
LaurentSeries.powerSeriesPart_eq_zero._simp_1 | Mathlib.RingTheory.LaurentSeries | [
"MvPowerSeries.instZero",
"SemilatticeInf.toPartialOrder",
"HahnSeries.instZero",
"Int",
"Unit",
"LaurentSeries.powerSeriesPart",
"propext",
"instLatticeInt",
"Semiring",
"Zero.toOfNat0",
"LaurentSeries",
"PowerSeries",
"OfNat.ofNat",
"Eq",
"MulZeroClass.toZero",
"Lattice.toSemilattice... | false |
Std.Internal.List.self_le_maxKey_insertEntry | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Std.Internal.List.maxKey",
"Ord",
"Std.TransOrd",
"Std.OrientedOrd.opposite",
"Std.TransOrd.opposite",
"inferInstance",
"Std.Internal.List.isEmpty_insertEntry",
"Std.Internal.List.minKey_insertEntry_le_self",
"Std.Internal.List.insertEntry",
"Ord.compare",
"B... | true |
BitVec.cpopLayer._unsafe_rec | Init.Data.BitVec.Bitblast | [
"instHDiv",
"HMul.hMul",
"BitVec.extractLsb'",
"BitVec.instHAppendHAddNat",
"HSub.hSub",
"BitVec.instAdd",
"BitVec",
"HDiv.hDiv",
"BitVec.cpopLayer._proof_3",
"instSubNat",
"instMulNat",
"instOfNatNat",
"BitVec.cpopLayer._proof_5",
"BitVec.cpopLayer._proof_7",
"dite",
"instHAdd",
"in... | false |
Prod.mk_wcovBy_mk_iff | Mathlib.Order.Cover | [
"Iff.mpr",
"Prod.mk_wcovBy_mk_iff_right",
"PartialOrder.toPreorder",
"PartialOrder",
"Prod.mk",
"Or.casesOn",
"And.casesOn",
"And",
"Iff",
"And.intro",
"WCovBy",
"Iff.intro",
"Prod.instPreorder",
"Iff.mp",
"Eq.ndrec",
"Or.inl",
"Or",
"Prod",
"Eq",
"Prod.mk_wcovBy_mk_iff_left",
... | true |
CategoryTheory.Localization.HasProductsOfShapeAux.isLimitMapCone._proof_2 | Mathlib.CategoryTheory.Localization.FiniteProducts | [
"CategoryTheory.Limits.limit.π",
"CategoryTheory.MorphismProperty",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Localization.HasProductsOfShapeAux.adj_counit_app",
"CategoryTheory.Functor.compConstIso",
"congrArg",... | false |
Derivation.mapCoeffs._proof_2 | Mathlib.RingTheory.Derivation.MapCoeffs | [
"Derivation",
"add_mul",
"AddGroup.toSubtractionMonoid",
"Finsupp.instFunLike",
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Derivation.toLinearMap",
"LinearEquiv.symm",
"CommRing",
"instHSMul",
"Semiring.toModule",
"Polynomial.toFinsupp",
"HMul.hMul",
... | false |
_private.Mathlib.Computability.TuringMachine.StackTuringMachine.0.Turing.TM2to1.stRun.match_1.splitter | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"Turing.TM2to1.StAct.pop",
"Turing.TM2to1.StAct.peek",
"Turing.TM2to1.StAct.push",
"Turing.TM2to1.stRun.match_1",
"Turing.TM2to1.StAct",
"Option"
] | true |
MeasurableEquiv.symm_vadd | Mathlib.MeasureTheory.Group.MeasurableEquiv | [
"AddGroup.toSubtractionMonoid",
"MeasurableEquiv.instEquivLike",
"NegZeroClass.toNeg",
"MeasurableConstVAdd",
"AddMonoid.toAddSemigroup",
"MeasurableEquiv.symm",
"SubtractionMonoid.toSubNegZeroMonoid",
"MeasurableEquiv.vadd",
"SubNegZeroMonoid.toNegZeroClass",
"MeasurableSpace",
"AddAction",
"... | true |
AList.extract | Mathlib.Data.List.AList | [
"AList.extract._proof_3",
"AList.mk",
"AList.extract.match_1",
"Prod.mk",
"List",
"AList",
"List.NodupKeys",
"Prod",
"Prod.snd",
"Sigma",
"Option",
"List.kextract",
"DecidableEq",
"AList.entries"
] | true |
BddDistLat.mk.injEq | Mathlib.Order.Category.BddDistLat | [
"Eq.propIntro",
"PartialOrder.toPreorder",
"Lean.injEq_helper",
"Preorder.toLE",
"BddDistLat",
"SemilatticeInf.toPartialOrder",
"DistLat.str",
"HEq.homo_ndrec",
"DistribLattice.toLattice",
"And",
"Eq.ndrec",
"Eq.refl",
"HEq",
"BddDistLat.mk.inj",
"BoundedOrder",
"Eq",
"DistLat.carrie... | true |
Nat.Partrec.Code.const_inj._f | Mathlib.Computability.PartrecCode | [
"Nat.Partrec.Code.const",
"congrArg",
"Nat.Partrec.Code",
"instOfNatNat",
"Nat.Partrec.Code.succ",
"Nat.below",
"instHAdd",
"HAdd.hAdd",
"Nat",
"True",
"eq_self",
"of_eq_true",
"instAddNat",
"congrFun'",
"_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.const_inj.match_1_1",... | false |
Lean.Server.ServerTask.BaseIO.mapTaskCostly | Lean.Server.ServerTask | [
"Pure.pure",
"Task",
"Monad.toApplicative",
"Applicative.toPure",
"Lean.Server.ServerTask.mk",
"BaseIO.mapTask",
"Lean.Server.ServerTask.task",
"instMonadBaseIO",
"Lean.Server.ServerTask",
"Task.Priority.dedicated",
"Monad.toBind",
"Bind.bind",
"Bool.false",
"BaseIO"
] | true |
Lean.Meta.LazyDiscrTree.buildPath._unsafe_rec | Lean.Meta.LazyDiscrTree | [
"Pure.pure",
"Array.push",
"Lean.Meta.LazyDiscrTree.buildPath._unsafe_rec",
"Lean.Meta.State",
"Array.isEmpty",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Applicative.toPure",
"Array.pop",
"Array.back!",
"Array",
"Lean.instInhabitedExpr",
"Bool.true",
"Lean... | false |
Lean.Elab.Tactic.RCases.RCasesPatt.brecOn | Lean.Elab.Tactic.RCases | [
"Lean.Elab.Tactic.RCases.RCasesPatt",
"Lean.Elab.Tactic.RCases.RCasesPatt.below_1",
"Lean.Elab.Tactic.RCases.RCasesPatt.below",
"List",
"Lean.Elab.Tactic.RCases.RCasesPatt.brecOn.go"
] | false |
Subgroup.discreteTopology_iff_of_isFiniteRelIndex | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | [
"Eq.mpr",
"Subgroup.subgroupOf",
"congrArg",
"DiscreteTopology",
"Iff.rfl",
"PartialOrder.toPreorder",
"Subgroup.mul",
"Group",
"Preorder.toLE",
"Subgroup.instIsTopologicalGroupSubtypeMem",
"Membership.mem",
"id",
"Subtype",
"Homeomorph.discreteTopology_iff",
"Subgroup",
"LE.le",
"To... | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1._arg_pusher | Lean.Meta.Sym.Pattern | [
"Eq.mpr",
"Unit.unit",
"False",
"congrArg",
"id",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1.eq_12",
"Lean.Level.param",
"Lean.Level.imax",
"Lean.Level",
"Unit",
"Lean.Level.zero",
"congrFun",
"congr",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Level.succ",
... | false |
AdjoinRoot.quotEquivQuotMap_symm_apply_mk | Mathlib.RingTheory.AdjoinRoot | [
"Eq.mpr",
"CommRing",
"AdjoinRoot",
"AlgEquiv.symm",
"congrArg",
"CommSemiring.toSemiring",
"AdjoinRoot.quotEquivQuotMap",
"Ideal.Quotient.mk",
"RingEquiv.instEquivLike",
"Polynomial.algebraOfAlgebra",
"AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot",
"RingHom",
"Algebra.id",
"Set.instSi... | true |
StarMonoidHom.mk.noConfusion | Mathlib.Algebra.Star.MonoidHom | [
"Monoid",
"MulOne.toOne",
"MonoidHom",
"Monoid.toMulOneClass",
"HEq.refl",
"id",
"MulOneClass.toMulOne",
"heq_of_eq",
"OneHom.toFun",
"Star",
"StarMonoidHom",
"StarMonoidHom.mk",
"MonoidHom.toOneHom",
"Eq.refl",
"HEq",
"Eq",
"StarMonoidHom.noConfusion",
"Star.star"
] | false |
AlgebraicGeometry.Scheme.Pullback.gluing_V | Mathlib.AlgebraicGeometry.Pullbacks | [
"AlgebraicGeometry.Scheme",
"CategoryTheory.PreZeroHypercover.f",
"AlgebraicGeometry.Scheme.Pullback.v",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AlgebraicGeometry.Scheme.Pullback.gluing",
"AlgebraicGeometry.Scheme.Pullback.gluing.match_1",
"AlgebraicGeometry.Scheme.OpenCover",
"Cate... | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.Context.ctorIdx | Lean.Meta.Sym.Pattern | [
"Nat",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.Context"
] | false |
Set.Countable.of_sdiff | Mathlib.Data.Set.Countable | [
"Set.instUnion",
"Set.Countable.union",
"SDiff.sdiff",
"Set.subset_sdiff_union",
"Set.Countable.mono",
"Union.union",
"Set.Countable",
"Set.instSDiff",
"Set"
] | true |
TensorProduct.exists_finite_submodule_of_setFinite' | Mathlib.LinearAlgebra.TensorProduct.Finiteness | [
"Submodule",
"RingHomSurjective.ids",
"TensorProduct.mapIncl",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"Submodule.addCommMonoid",
"TensorProduct.addCommMonoid",
"PartialOrder.toPreorder",
"LinearMap.instFunLike",
"Preorder.toLE",
"Set.Finite",
"Membership.mem",
"Exists",
... | true |
Batteries.HashMap.casesOn | Batteries.Data.HashMap.Basic | [
"Batteries.HashMap.mk",
"Std.HashMap",
"Batteries.HashMap.rec",
"Hashable",
"BEq",
"Batteries.HashMap"
] | false |
MeasureTheory.NoAtoms.rec | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | [
"MeasureTheory.Measure",
"MeasureTheory.NoAtoms",
"MeasureTheory.NoAtoms.mk",
"Set.instSingletonSet",
"MeasurableSpace",
"ENNReal",
"Zero.toOfNat0",
"ENNReal.instZero",
"Singleton.singleton",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"MeasureTheory.Measure.instFunLike",
"Set"
] | false |
IntermediateField.one_mem'._inherited_default | Mathlib.FieldTheory.IntermediateField.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Algebra",
"RingHom",
"Membership.mem",
"RingHom.map_one",
"Eq.rec",
"id",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Field.toSemifield",
"AddMonoidWithOne.toOne",
"RingHom.instFunLike",
"Semifield... | false |
Lean.Meta.Grind.Order.mkPropagateEqTrueProof | Lean.Meta.Tactic.Grind.Order.Proof | [
"Lean.Meta.Grind.GrindM",
"_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkPropagateEqTrueProofOffset",
"Lean.Meta.Grind.Goal",
"Lean.Meta.Grind.State",
"ReaderT",
"Lean.Meta.Sym.Context",
"ReaderT.instMonad",
"Lean.Meta.Grind.Context",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.R... | true |
Std.IterM.fold_hom | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Pure.pure",
"Eq.mpr",
"Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3",
"bind_congr",
"Std.IterStep",
"congrArg",
"Std.Shrink",
"LawfulMonad.bind_assoc",
"Monad.toApplicative",
"Std.IteratorLoop",
"Std.IterM.IsPlausibleStep",
"Std.Iterators.Finite",
"LawfulMonad.bind_pure_comp",
... | true |
Equiv.coe_vaddConst | Mathlib.Algebra.Torsor.Defs | [
"Equiv.instEquivLike",
"AddMonoid.toAddSemigroup",
"Equiv.vaddConst",
"Equiv",
"HVAdd.hVAdd",
"AddAction.toAddSemigroupAction",
"AddGroup",
"AddSemigroupAction.toVAdd",
"AddGroup.toSubNegMonoid",
"AddTorsor.toAddAction",
"AddTorsor",
"instHVAdd",
"SubNegMonoid.toAddMonoid",
"Eq",
"DFunLi... | true |
Lean.Meta.Simp.ConfigCtx.unfoldPartialApp._inherited_default | Init.MetaTypes | [
"id",
"Bool",
"Bool.false"
] | false |
CompHausLike.instPreservesLimitTopCatWalkingCospanCospanCompHausLikeToTop | Mathlib.Topology.Category.CompHausLike.Limits | [
"CategoryTheory.Limits.hasFiniteLimits_of_hasLimits",
"CategoryTheory.Limits.PreservesLimit",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopCat.instCategory",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.WidePullbackShape.category",
"TopCat.topCat_hasLimits",
"CategoryTheory.L... | true |
MeasurableVAdd₂ | Mathlib.MeasureTheory.Group.Arithmetic | [
"VAdd",
"MeasurableVAdd₂.mk",
"MeasurableSpace"
] | true |
Vector.getElem?_eq_some_getElem_iff | Init.Data.Vector.Lemmas | [
"instGetElem?OfGetElemOfDecidable",
"getElem?_eq_some_getElem_iff._simp_1",
"Vector",
"congrArg",
"Vector.instGetElemNatLt",
"Option.some",
"GetElem.getElem",
"iff_self",
"Iff",
"Nat",
"LT.lt",
"True",
"of_eq_true",
"Nat.decLt",
"congrFun'",
"instLTNat",
"GetElem?.getElem?",
"instL... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.comap_monotone._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | [
"and_imp",
"And",
"propext",
"Eq"
] | false |
Std.Tactic.BVDecide.LRAT.Internal.CNF.convertLRAT' | Std.Tactic.BVDecide.LRAT.Internal.Convert | [
"Std.Sat.CNF",
"Std.Tactic.BVDecide.LRAT.Internal.CNF.Clause.convertLRAT'",
"Option.some",
"instOfNatNat",
"Array",
"Option.none",
"Unit",
"Array.filterMap",
"Nat",
"Std.Sat.CNF.Clause",
"Std.Tactic.BVDecide.LRAT.Internal.CNF.convertLRAT'.match_1",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultCla... | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx.match_1 | Std.Data.DTreeMap.Internal.Queries | [
"False",
"Std.DTreeMap.Internal.Impl.casesOn",
"HEq.refl",
"False.elim",
"Std.DTreeMap.Internal.Impl.Balanced",
"noConfusion_of_Nat",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"Nat.le.step",
"Nat.le",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"LT.lt",
"Nat.ctor... | false |
USize.toUInt64_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | [
"UInt64",
"HSub.hSub",
"USize.toUInt64_ofNatClamp_of_le._proof_1",
"instSubNat",
"USize.toUInt64",
"instOfNatNat",
"USize.ofNatClamp",
"LE.le",
"instLENat",
"UInt64.ofNatLT",
"USize.toUInt64_ofNatClamp_of_le",
"instHSub",
"Nat",
"USize.size",
"OfNat.ofNat",
"Eq"
] | true |
Lean.Meta.LetToHave.instInhabitedResult.default | Lean.Meta.LetToHave | [
"_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Result.mk",
"Inhabited.default",
"Lean.Expr",
"Lean.instInhabitedExpr",
"_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.Result",
"instInhabitedOption",
"Option"
] | true |
Lean.Meta.DefEqCacheKeyInfo.mk.noConfusion | Lean.Meta.ExprDefEq | [
"id",
"Lean.Meta.DefEqCacheKeyInfo",
"Lean.Meta.DefEqCacheKey",
"Lean.Meta.DefEqCacheKeyInfo.mk",
"Eq",
"Lean.Meta.DefEqCacheKeyInfo.noConfusion",
"Lean.Meta.DefEqCacheKind"
] | false |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂'_term_iff._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | [
"Int.cast",
"Real",
"Complex.ofReal_intCast",
"Int",
"Complex.instIntCast",
"Complex.ofReal",
"Real.instIntCast",
"Complex",
"Eq.symm",
"Eq"
] | false |
_private.Mathlib.RingTheory.PowerSeries.Substitution.0.PowerSeries.substInvFun.match_1.eq_2 | Mathlib.RingTheory.PowerSeries.Substitution | [
"Unit.unit",
"instOfNatNat",
"PowerSeries.substInvFun.match_1",
"Unit",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq"
] | true |
Field.toEuclideanDomain.match_1 | Mathlib.Algebra.EuclideanDomain.Field | [
"Ne",
"Field.toSemifield",
"And.casesOn",
"And",
"Semifield.toDivisionSemiring",
"And.intro",
"DivisionSemiring.toSemiring",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Field",
"MulZeroClass.toZero",
"instMulZeroClassOfSemiring"
] | false |
_private.Init.Data.Nat.Lemmas.0.Nat.sub_add_sub_cancel._proof_1_1 | Init.Data.Nat.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_congr",
"Lean.Om... | false |
CategoryTheory.Kleisli.category_id_of | Mathlib.CategoryTheory.Monad.Kleisli | [
"CategoryTheory.Kleisli.Hom.of",
"CategoryTheory.Monad",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Kleisli",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Monad.toFunctor",
"CategoryTheory.Monad.η",
"Eq.refl",
"CategoryTheory.Categ... | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.instEvalExprNoopConfig.evalExpr | Lean.Elab.Tactic.Grind.Config | [
"guard",
"Pure.pure",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Grind.Config",
"String",
"Lean.Meta.State",
"Lean.Elab.ConfigEval.EvalExpr.withSimpleEvalExpr",
"Lean.Name.mkStr3",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"instOfNatNat",
"Lean.Elab.ConfigEv... | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_10 | Mathlib.MeasureTheory.Function.Jacobian | [
"LE.le",
"OrderTop",
"LE",
"OrderTop.toTop",
"le_top",
"True",
"eq_true",
"Top.top",
"Eq"
] | false |
String.Slice.mk.noConfusion | Init.Data.String.Defs | [
"String",
"String.Slice.mk",
"String.Slice.noConfusion",
"String.Slice",
"id",
"LE.le",
"String.Pos",
"HEq",
"String.instLEPos",
"Eq"
] | false |
Int.Linear.Poly.mul' | Init.Data.Int.Linear | [
"Int.Linear.Poly.mul'._f",
"Int",
"Int.Linear.Poly.brecOn",
"Int.Linear.Poly"
] | true |
ContinuousLinearEquiv.conjContinuousAlgEquiv | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | [
"ContinuousLinearEquiv.conjContinuousAlgEquiv._proof_1",
"ContinuousLinearEquiv.conjContinuousAlgEquiv._proof_5",
"instSMulOfMul",
"ContinuousLinearMap.semiring",
"ContinuousLinearMap.topologicalSpace",
"ContinuousLinearEquiv.toLinearEquiv",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMon... | true |
UpperHalfPlane.atImInfty | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | [
"Real",
"Filter.atTop",
"UpperHalfPlane.im",
"UpperHalfPlane",
"Filter",
"Real.instPreorder",
"Filter.comap"
] | true |
CategoryTheory.Pseudofunctor.map₂_left_unitor_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | [
"CategoryTheory.Pseudofunctor.mapId",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Pseudofunctor.map₂_left_unitor",
"Quiver.Hom",
"CategoryTheory.Cat.leftUnitor_hom_app",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.Functor.comp",
"CategoryTheory.Cat.str",
"CategoryTheory.Cat... | true |
_private.Mathlib.Tactic.ComputeDegree.0.Mathlib.Tactic.ComputeDegree.dispatchLemma.match_1 | Mathlib.Tactic.ComputeDegree | [
"Unit.unit",
"String",
"Nat.hasNotBit",
"Lean.Name.ctorIdx",
"dite",
"Lean.Name.str",
"Lean.Name.anonymous",
"Unit",
"_private.Mathlib.Tactic.ComputeDegree.0.Mathlib.Tactic.ComputeDegree.twoHeadsArgs._sparseCasesOn_2",
"Eq.ndrec_symm",
"instDecidableEqString",
"Lean.Name",
"_private.Mathlib.... | false |
Order.Ideal.instLattice | Mathlib.Order.Ideal | [
"SemilatticeSup.mk",
"Order.Ideal.instLattice._proof_3",
"Lattice",
"IsCodirectedOrder",
"Order.Ideal.instPartialOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Order.Ideal.instMax",
"Order.Ideal.instLattice._proof_5",
"Lattice.mk",
"Order.Ideal.instLattice._proof_6",
"Order.Ideal.instLat... | true |
Submodule.existsUnique_add_of_isCompl | Mathlib.LinearAlgebra.Projection | [
"Submodule",
"AddCommGroup.toAddCommMonoid",
"Submodule.completeLattice",
"_private.Mathlib.LinearAlgebra.Projection.0.Submodule.existsUnique_add_of_isCompl.match_1_1",
"Membership.mem",
"Exists",
"CompleteLattice.toBoundedOrder",
"AddCommGroup",
"Subtype",
"Prod.mk",
"Submodule.instPartialOrder... | true |
MonoidHom.coe_ofClosureMEqTopRight | Mathlib.Algebra.Group.Submonoid.Basic | [
"Monoid",
"MulOne.toOne",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"Membership.mem",
"MulOne.toMul",
"Submonoid.instTop",
"MulOneClass.toMulOne",
"MonoidHom.ofClosureMEqTopRight",
"Submonoid.closure",
"One.toOfNat1",
"Top.top",
"OfNat.ofNat",
"Eq",
"... | true |
SimpleGraph.commonNeighbors_subset_neighborSet_left | Mathlib.Combinatorics.SimpleGraph.Basic | [
"SimpleGraph.neighborSet",
"SimpleGraph.commonNeighbors",
"Set.inter_subset_left",
"HasSubset.Subset",
"SimpleGraph",
"Set.instHasSubset",
"Set"
] | true |
Std.TreeSet.inter_eq | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeSet.inter",
"Ordering",
"Inter.inter",
"Std.TreeSet.instInter",
"eq_self",
"of_eq_true",
"Eq"
] | true |
Std.DHashMap.Internal.Raw.inter_eq | Std.Data.DHashMap.Internal.Raw | [
"dite_cond_eq_true",
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Internal.Raw₀.inter",
"congrArg",
"Std.DHashMap.Raw",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"dite",
"Subtype.mk",
"Std.DHashMap.Raw.inter",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"True",
"eq_self",
"eq_tru... | true |
_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.checkProp._sunfold | Lean.Meta.InferType | [
"_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult",
"_private.Lean.Meta.InferType.0.Lean.Meta.isArrowProposition'.checkProp.match_1",
"Lean.Level.isZero",
"Lean.Expr",
"instDecidableEqBool",
"Lean.Level",
"_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.undef",
"_private.Lean.Meta.Inf... | false |
Pointed.Hom.instInhabited | Mathlib.CategoryTheory.Category.Pointed | [
"Pointed.Hom",
"Pointed.Hom.id",
"Pointed",
"Inhabited",
"Inhabited.mk"
] | true |
Std.ExtTreeMap.foldrM | Std.Data.ExtTreeMap.Basic | [
"Ordering",
"LawfulMonad",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtDTreeMap.foldrM",
"Std.ExtTreeMap.inner",
"Monad"
] | true |
DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate | Mathlib.Analysis.InnerProductSpace.PiL2 | [
"NormedCommRing.toNormedRing",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"Submodule",
"DirectSum.IsInternal.subordinateOrthonormalBasisIndex",
"Submodule.addSubmonoidClass",
"DirectSum.IsInternal",
"NormedRing.toRing",
"Equiv.instEquivLike",
"OrthonormalBasis.reindex",
"congrArg",
"AddCommG... | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.contDiff_pi._simp_1_2 | Mathlib.Analysis.Calculus.ContDiff.Operations | [
"NormedSpace",
"ContDiffOn",
"Pi.normedAddCommGroup",
"Fintype",
"ENat",
"propext",
"NontriviallyNormedField",
"contDiffOn_pi",
"NontriviallyNormedField.toNormedField",
"Pi.normedSpace",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"Eq",
"NormedAddCommGroup",
"WithTop",
"Set"
] | false |
Std.HashSet.Raw.get?_of_isEmpty | Std.Data.HashSet.RawLemmas | [
"Std.HashSet.Raw.isEmpty",
"Std.HashMap.Raw.getKey?_of_isEmpty",
"Std.HashSet.Raw.inner",
"Std.HashSet.Raw.get?",
"Std.HashSet.Raw.WF",
"LawfulHashable",
"Bool.true",
"Option.none",
"Unit",
"EquivBEq",
"Std.HashSet.Raw.WF.out",
"Bool",
"Hashable",
"BEq",
"Eq",
"Std.HashSet.Raw",
"Opt... | true |
existsUnique_eq._simp_1 | Mathlib.Logic.ExistsUnique | [
"existsUnique_eq",
"ExistsUnique",
"True",
"eq_true",
"Eq"
] | false |
ModuleCat.semilinearMapAddEquiv | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | [
"ModuleCat.semilinearMapAddEquiv._proof_6",
"ModuleCat.instAddHom",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"ModuleCat.semilinearMapAddEquiv._proof_1",
"ModuleCat.semilinear... | true |
CategoryTheory.IsKernelPair.lift' | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Subtype",
"CategoryTheory.IsKernelPair",
"Subtype.mk",
"And",
"CategoryTheory.IsKernelPair.lift'._proof_1",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.IsKernelPair.lift",
"Eq",
"Cate... | true |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_nontrivial_inv._simp_1_10 | Mathlib.NumberTheory.JacobiSum.Basic | [
"GroupWithZero.toMonoidWithZero",
"False",
"GroupWithZero.toDivInvMonoid",
"eq_false",
"GroupWithZero",
"DivInvMonoid.toZPow",
"Ne",
"Int",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Zero.toOfNat0",
"zpow_ne_zero",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq... | false |
QuaternionAlgebra.equivTuple._proof_2 | Mathlib.Algebra.Quaternion | [
"QuaternionAlgebra.imI",
"Fin.casesOn",
"HEq.refl",
"False.elim",
"QuaternionAlgebra.re",
"noConfusion_of_Nat",
"QuaternionAlgebra.mk",
"QuaternionAlgebra",
"Fin.mk",
"Fin.instOfNat",
"instOfNatNat",
"Nat.le.step",
"funext",
"instHAdd",
"HAdd.hAdd",
"Nat.le",
"Nat.instNeZeroSucc",
... | false |
Lean.JsonRpc.instCoeOutResponseErrorMessageOfToJson | Lean.Data.JsonRpc | [
"Lean.Json",
"Lean.JsonRpc.ResponseError",
"Lean.JsonRpc.ResponseError.message",
"CoeOut.mk",
"Lean.ToJson.toJson",
"CoeOut",
"Lean.JsonRpc.Message",
"Option.map",
"Lean.JsonRpc.ResponseError.id",
"Lean.JsonRpc.Message.responseError",
"Lean.ToJson",
"Lean.JsonRpc.ResponseError.code",
"Lean.J... | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.seq_eq.match_1_1 | Mathlib.Data.Fin.Tuple.Reflection | [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.zero",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"Nat.casesOn"
] | false |
MeasureTheory.Measure.toSignedMeasure_toMeasureOfZeroLE | Mathlib.MeasureTheory.VectorMeasure.Basic | [
"MeasureTheory.SignedMeasure.toMeasureOfZeroLE_apply",
"Iff.mpr",
"Eq.mpr",
"ENNReal.canLift",
"Real.partialOrder",
"Real.instLE",
"Real",
"ENNReal.ofNNReal",
"MeasureTheory.Measure",
"MeasurableSet",
"Real.instZero",
"congrArg",
"MeasureTheory.measure_lt_top",
"ENNReal.coe_inj",
"Set.un... | true |
MDifferentiableWithinAt.congr_nhds | Mathlib.Geometry.Manifold.MFDeriv.Basic | [
"Filter.instMembership",
"NormedSpace",
"nhdsWithin",
"Membership.mem",
"Eq.rec",
"TopologicalSpace",
"ModelWithCorners",
"self_mem_nhdsWithin",
"MDifferentiableWithinAt.mono_of_mem_nhdsWithin",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"NormedAddCommGroup.toSeminorme... | true |
WeakDual.CharacterSpace.continuousMapEval._proof_8 | Mathlib.Topology.ContinuousMap.Ideals | [
"WeakDual.CharacterSpace.continuousMapEval._proof_4",
"CommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"IsTopologicalRing.toIsTopologicalSemiring",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsSemitopo... | false |
List.getLast_append_right._proof_1 | Init.Data.List.Lemmas | [
"False",
"eq_false",
"congrArg",
"List.append_eq_nil_iff._simp_1",
"False.elim",
"Eq.mp",
"id",
"Ne",
"instHAppendOfAppend",
"List",
"And",
"and_false",
"List.instAppend",
"Eq",
"Not",
"HAppend.hAppend",
"Eq.trans",
"List.nil"
] | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.isStronglyTranscendental_iff_of_field._simp_1_5 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | [
"Nontrivial",
"False",
"eq_false",
"not_subsingleton",
"Subsingleton",
"Eq"
] | false |
List.Vector.snoc_cons | Mathlib.Data.Vector.Snoc | [
"List.Vector",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"List.Vector.snoc",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"List.Vector.cons",
"rfl"
] | true |
_private.Init.Data.UInt.Bitwise.0.UInt64.shiftLeft_or._simp_1_1 | Init.Data.UInt.Bitwise | [
"UInt64",
"UInt64.toBitVec_inj",
"BitVec",
"instOfNatNat",
"Nat",
"propext",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"UInt64.toBitVec"
] | false |
BitVec.getMsbD_ofBoolListLE | Init.Data.BitVec.Lemmas | [
"BitVec.getMsbD",
"congrArg",
"BitVec.getMsbD_eq_getLsbD",
"HSub.hSub",
"Option.getD",
"List.instGetElem?NatLtLength",
"List.getD",
"BitVec.getLsbD",
"BitVec.ofBoolListLE",
"Bool.and",
"instSubNat",
"instOfNatNat",
"List",
"instHSub",
"BitVec.getLsbD_ofBoolListLE",
"Nat",
"congr",
... | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._f | Std.Data.DTreeMap.Internal.Queries | [
"Ordering.gt",
"instDecidableEqOrdering",
"Ord",
"Std.TransOrd",
"False.elim",
"Std.DTreeMap.Internal.Impl.Ordered",
"Std.DTreeMap.Internal.Impl.Const.getEntryGT.match_1",
"Membership.mem",
"Exists",
"Ordering",
"Std.DTreeMap.Internal.Impl.inner",
"Prod.mk",
"Std.DTreeMap.Internal.Impl.Order... | false |
HomologicalComplex₂.toGradedObject.match_1 | Mathlib.Algebra.Homology.HomologicalBicomplex | [
"Prod.mk",
"Prod",
"Prod.casesOn"
] | false |
ContinuousMultilinearMap.recOn | Mathlib.Topology.Algebra.Module.Multilinear.Basic | [
"Continuous",
"Pi.topologicalSpace",
"ContinuousMultilinearMap.rec",
"ContinuousMultilinearMap",
"ContinuousMultilinearMap.mk",
"MultilinearMap",
"AddCommMonoid",
"TopologicalSpace",
"MultilinearMap.toFun",
"Semiring",
"Module"
] | false |
GroupLike.instGroup._proof_5 | Mathlib.RingTheory.HopfAlgebra.GroupLike | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"GroupLike.ext",
"Semigroup.toMul",
"HMul.hMul",
"HopfAlgebraStruct.toBialgebra",
"IsGroupLikeElem",
"Bialgebra.toCoalgebra",
"congrArg",
"GroupLike.instMonoid",
"Algebra.toModule",
"HopfAlgebra",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"GroupLik... | false |
_private.Init.Data.List.Nat.Range.0.List.sum_range'._simp_1_1 | Init.Data.List.Nat.Range | [
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.add_assoc",
"instAddNat",
"Eq.symm",
"Eq"
] | false |
Nat.multichoose_succ_succ | Mathlib.Data.Nat.Choose.Basic | [
"congrArg",
"instOfNatNat",
"instHAdd",
"Nat.add_left_cancel_iff._simp_1",
"HAdd.hAdd",
"Nat",
"True",
"eq_self",
"Nat.multichoose.eq_3",
"of_eq_true",
"instAddNat",
"congrFun'",
"OfNat.ofNat",
"Eq",
"Eq.trans",
"Nat.multichoose"
] | true |
Std.Rxc.Iterator.rec | Init.Data.Range.Polymorphic.RangeIterator | [
"Std.Rxc.Iterator",
"Std.Rxc.Iterator.mk",
"Option"
] | false |
ProbabilityTheory.Kernel.piecewise.congr_simp | Mathlib.Probability.Kernel.Basic | [
"instSubsingletonDecidable",
"MeasurableSet",
"Decidable",
"Membership.mem",
"Eq.rec",
"Pi.instSubsingleton",
"MeasurableSpace",
"ProbabilityTheory.Kernel.piecewise",
"DecidablePred",
"Eq.ndrec",
"Eq.refl",
"Subsingleton.elim",
"Eq",
"Set.instMembership",
"ProbabilityTheory.Kernel",
"S... | true |
TopRep.hom_id | Mathlib.RepresentationTheory.Continuous.TopRep | [
"Monoid",
"Ring.toNonAssocRing",
"TopRep.Hom.hom",
"CategoryTheory.CategoryStruct.id",
"NonAssocRing.toNonUnitalNonAssocRing",
"TopRep.instCategory",
"TopRep.hV3",
"IsTopologicalRing",
"TopRep.hV1",
"TopologicalSpace",
"TopRep",
"TopRep.ρ",
"ContIntertwiningMap",
"TopRep.V",
"TopRep.hV4"... | true |
NonUnitalAlgHom.snd | Mathlib.Algebra.Algebra.NonUnitalHom | [
"Monoid",
"DistribMulActionHom.mk",
"NonUnitalAlgHom.mk",
"MonoidHom.instFunLike",
"NonUnitalAlgHom.snd._proof_2",
"MonoidHom",
"Monoid.toMulOneClass",
"DistribMulAction.toDistribSMul",
"NonUnitalAlgHom.snd._proof_4",
"AddMonoid.toAddZeroClass",
"Prod.instNonUnitalNonAssocSemiring",
"AddZeroCl... | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.argsInGroup.match_5 | Lean.Elab.PreDefinition.Structural.FindRecArg | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Prod.mk",
"Std.Rxo.Iterator",
"Option.none",
"Unit",
"Std.Iter",
"Nat",
"Prod",
"Prod.casesOn",
"Option"
] | false |
instNontrivialFreeRing | Mathlib.RingTheory.FreeRing | [
"Nontrivial",
"instNontrivialFreeRing._proof_1",
"FreeRing"
] | true |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorLeftObjFunctorTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Functor",
"CategoryTheory.MorphismProperty.IsMonoidal",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Localization.instCategoryLocalizedMonoidal",
"CategoryTheory.Iso",
"Category... | true |
Lean.Elab.Tactic.evalTacticSeqBracketed | Lean.Elab.Tactic.BuiltinTactic | [
"Pure.pure",
"Unit.unit",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.Core.instMonadLiftIOCoreM",
"instMonadReaderOfReaderTOfMonad",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.Elab.withInfoContext",
"Lean.Meta.State",
"instMonadLiftT",
"IO",
"Lean.Elab.Tactic.Context",
"Lean.Core.in... | true |
Lean.Elab.Term.Do.ToTerm.Context.casesOn | Lean.Elab.Do.Legacy | [
"Lean.Syntax",
"Lean.Elab.Term.Do.Var",
"Lean.Elab.Term.Do.ToTerm.Context.mk",
"Array",
"Lean.Elab.Term.Do.ToTerm.Context",
"Lean.Elab.Term.Do.ToTerm.Context.rec",
"Lean.Elab.Term.Do.ToTerm.Kind"
] | false |
Std.DHashMap.isEmpty_toArray | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.Raw",
"Array.isEmpty",
"Std.DHashMap.toArray",
"Std.DHashMap.wf",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"Std.DHashMap.Internal.Raw₀.isEmpty_toArray",
"LawfulHashable",
"Subtype.mk",
"EquivBEq",
"Std.DHashMap.inner",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt"... | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.alterKey.match_1.splitter | Std.Data.Internal.List.Associative | [
"Option.some",
"Option.none",
"Unit",
"_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.alterKey.match_1",
"Option"
] | true |
Module.Relations.Solution.postcomp_id | Mathlib.Algebra.Module.Presentation.Basic | [
"LinearMap.id",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"Module.Relations.Solution",
"Module.Relations",
"Module",
"Module.Relations.Solution.postcomp",
"Ring.toSemiring",
"Eq",
"Ring",
"rfl"
] | true |
CategoryTheory.Functor.mapGrp_obj_X | Mathlib.CategoryTheory.Monoidal.Grp | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.mapGrp",
"CategoryTheory.Grp.instCategory",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.CartesianMonoidalCategory",
"Eq.refl",
"CategoryTheory.Grp",
"CategoryTheory.Functor.Monoidal",
"Eq",
"CategoryTheory.Grp... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.