name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
_private.Lean.ResolveName.0.Lean.resolveLocalName.go | Lean.ResolveName | [
"_private.Lean.ResolveName.0.Lean.resolveLocalName.go._f",
"Lean.Name.brecOn",
"Lean.MacroScopesView",
"Lean.Name",
"Lean.LocalDecl",
"Option"
] | true |
CategoryTheory.evaluationAdjunctionRight._proof_9 | Mathlib.CategoryTheory.Adjunction.Evaluation | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.evaluationAdjunctionRight._proof_4",
"CategoryTheory.Functor.category",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.S... | false |
IsCoprime.of_isCoprime_of_dvd_right | Mathlib.RingTheory.Coprime.Basic | [
"Dvd.dvd",
"CommSemiring.toNonUnitalCommSemiring",
"IsCoprime.symm",
"semigroupDvd",
"SemigroupWithZero.toSemigroup",
"NonUnitalSemiring.toSemigroupWithZero",
"NonUnitalCommSemiring.toNonUnitalSemiring",
"CommSemiring",
"IsCoprime.of_isCoprime_of_dvd_left",
"IsCoprime"
] | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_oneMore_iff | Init.Data.String.Decode | [
"ByteArray.utf8DecodeChar?.parseFirstByte",
"ByteArray.utf8DecodeChar?.FirstByte.invalid",
"Eq.mpr",
"instDecidableNot",
"False",
"Trans.trans",
"UInt8.instOfNat",
"of_decide_eq_true",
"eq_false",
"instLawfulBEq",
"congrArg",
"False.elim",
"noConfusion_of_Nat",
"instDecidableEqUInt8",
"B... | true |
Lean.Export.Entry | Mathlib.Util.Export | [
"Lean.Export.Entry.level",
"Lean.Export.Entry.defn",
"Lean.Export.Entry.name",
"Lean.Export.Entry.expr"
] | true |
ArithmeticFunction.pow_apply | Mathlib.NumberTheory.ArithmeticFunction.Misc | [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"Preorder.toLT",
"Nat.instIsOrderedAddMonoid",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"Arithme... | true |
CategoryTheory.instNonemptyFreeGroupoid | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | [
"CategoryTheory.FreeGroupoid",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Paths.categoryPaths",
"CategoryTheory.Paths",
"Quiver.symmetrifyQuiver",
"Nonempty.intro",
"Quiver.Symmetrify",
"Quiver.FreeGroupoid",
"Quiver.FreeGroupoid.redStep",
"Quiver.FreeGroupoid.instCategory",
"Clas... | true |
NormedAddGroup.ofSeparation | Mathlib.Analysis.Normed.Group.Defs | [
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Real",
"SeminormedAddGroup.toAddGroup",
"Real.instZero",
"NormedAddGroup.mk",
"SeminormedAddGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"NormedAddGroup.ofSeparation._proof_1",
"Met... | true |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian_p | Mathlib.Algebra.Homology.ShortComplex.Abelian | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.Limits.cokernel",
"CategoryTheory.Abelian",
"CategoryTheory.ShortComplex.RightHomologyData.ofAbelian",
"CategoryTheory.Shor... | true |
RingHom.Flat.tensorProductMap | Mathlib.RingTheory.RingHom.Flat | [
"Eq.mpr",
"RingHom.Flat",
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommRing",
"AlgHom.algHomClass",
"TensorProduct.comm",
"AlgHom.toMonoidHom'._proof_2",
"LinearEquiv.bijective",
"AlgEquiv.toAlgHom",
"congrArg",
"CommSemiring.toSemiring",
"Algebra.TensorProduct.instCommRing",
"Algebra.Ten... | true |
Polynomial.Splits.coeff_zero_eq_leadingCoeff_mul_prod_roots | Mathlib.Algebra.Polynomial.Splits | [
"Polynomial.eval_multiset_prod",
"Eq.mpr",
"Polynomial.C",
"Polynomial.eval",
"NegZeroClass.toNeg",
"IsDomain",
"MulOne.toOne",
"Multiset.prod_map_neg",
"Semigroup.toMul",
"CommRing",
"Polynomial.roots",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Polynomial.coeff_zero_eq_eval_zero",
... | true |
Std.Time.OffsetX.hourMinuteColon.sizeOf_spec | Std.Time.Format.Basic | [
"Std.Time.OffsetX._sizeOf_inst",
"Std.Time.OffsetX.hourMinuteColon",
"instOfNatNat",
"Nat",
"Std.Time.OffsetX",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq"
] | true |
Vector.insertIdx_eraseIdx._proof_5 | Init.Data.Vector.InsertIdx | [
"_private.Init.Data.Vector.InsertIdx.0.Vector.insertIdx_eraseIdx._proof_4",
"HSub.hSub",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"instAddNat",
"instDecidableEqNat",
"instLTNat",
"OfNat.ofNat",... | false |
Lean.Elab.Tactic.MkSimpContextResult._sizeOf_1 | Lean.Elab.Tactic.Simp | [
"Lean.Syntax._sizeOf_inst",
"Lean.Elab.Tactic.MkSimpContextResult",
"Lean.Elab.Tactic.Simp.DischargeWrapper._sizeOf_inst",
"Lean.Syntax",
"Lean.Meta.Simp.Simprocs._sizeOf_inst",
"instOfNatNat",
"Array._sizeOf_inst",
"Array",
"Lean.Elab.Tactic.MkSimpContextResult.rec",
"Lean.Meta.Simp.Simprocs",
... | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_15 | Mathlib.Data.List.Triplewise | [
"Nat.succ_lt_succ_iff",
"Lean.Grind.nestedProof",
"HSub.hSub",
"instSubNat",
"instOfNatNat",
"List.cons",
"List",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Iff.mp",
"instAddNat",
"List.getElem_cons.match_1",
"instLTNat",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"List.length... | false |
_private.Lean.Meta.Sym.Intro.0.Lean.Meta.Sym.introCore.visit._unsafe_rec | Lean.Meta.Sym.Intro | [
"Inhabited.default",
"Lean.LocalDeclKind.default",
"Array.push",
"ReaderT",
"Lean.Meta.Sym.Internal.instMonadShareCommonSymM",
"Lean.Meta.State",
"Lean.Meta.Sym.Internal.mkFVarS",
"instMonadLiftT",
"Lean.Meta.Sym.Context",
"Lean.LocalDeclKind",
"Lean.MVarId",
"ReaderT.instMonad",
"GE.ge",
... | false |
TensorProduct.gradedMul_one | Mathlib.LinearAlgebra.TensorProduct.Graded.External | [
"TensorProduct.instDistribMulAction",
"Int.instCommMonoid",
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommRing",
"instHSMul",
"instAddCommMonoidDirectSum",
"Algebra.algebraMap",
"Algebra.TensorProduct.instOneTensorProduct",
"DirectSum.instModule",
"congrArg",
"CommSemiring.toSemiring",
"Tens... | true |
CategoryTheory.Functor.relativelyRepresentable.lift_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.Representable | [
"CategoryTheory.Functor.relativelyRepresentable.fst",
"CategoryTheory.Functor.relativelyRepresentable.lift_fst",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"Ca... | true |
Submodule.instOrderTop | Mathlib.Algebra.Module.Submodule.Lattice | [
"Submodule",
"trivial",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Submodule.instPartialOrder",
"Submodule.instTop",
"OrderTop.mk",
"OrderTop",
"AddCommMonoid",
"Submodule.setLike",
"Semiring",
"Module",
"SetLike.instMembership"
] | true |
_private.Std.Http.Protocol.H1.Parser.0.Std.Http.Protocol.H1.parseChunkPartial.match_1 | Std.Http.Protocol.H1.Parser | [
"Prod.mk",
"Array",
"Nat",
"Std.Http.Chunk.ExtensionValue",
"Prod",
"Prod.casesOn",
"Std.Http.Chunk.ExtensionName",
"Option"
] | false |
Std.DHashMap.Raw.Equiv.union_congr | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"Std.DHashMap.Internal.Raw₀.Equiv.union_congr",
"congrArg",
"Std.DHashMap.Raw",
"id",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"Std.DHashMap.Internal.Raw₀.union",
"LawfulHashable",
"Std.DHashMap.Raw.Equiv",
"Subtype.mk",
"EquivBEq",
"implies_... | true |
List.take_succ_eq_append_getElem | Init.Data.List.TakeDrop | [
"instOfNatNat",
"List.cons",
"GetElem.getElem",
"instHAppendOfAppend",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"instLTNat",
"List.instAppend",
"List.instGetElemNatLtLength",
"List.take_append_getElem",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"List.take",
"List.leng... | true |
Std.Do.WPMonad.rec | Std.Do.WP.Monad | [
"Pure.pure",
"Std.Do.PredTrans.instMonad",
"Monad.toApplicative",
"Std.Do.PostShape",
"LawfulMonad",
"Std.Do.WP",
"Applicative.toPure",
"Std.Do.WPMonad.mk",
"Std.Do.WPMonad",
"Monad.toBind",
"Bind.bind",
"Std.Do.PredTrans",
"Monad",
"Eq",
"Std.Do.WP.wp"
] | false |
String.isNat_toSlice | Std.Data.String.ToNat | [
"String.toSlice",
"String",
"String.isNat",
"Bool",
"Eq",
"String.Slice.isNat",
"rfl"
] | true |
DFinsupp.filter_single_neg | Mathlib.Data.DFinsupp.Defs | [
"Eq.mpr",
"congrArg",
"DFinsupp.single",
"id",
"DFinsupp.instZero",
"DecidablePred",
"DFinsupp.filter",
"DFinsupp.filter_single",
"Zero.toOfNat0",
"Eq.refl",
"DFinsupp",
"OfNat.ofNat",
"Eq",
"if_neg",
"Not",
"DecidableEq",
"Zero",
"ite"
] | true |
Sum.elim_inr | Init.Data.Sum.Basic | [
"Sum.inr",
"Eq",
"rfl",
"Sum.elim"
] | true |
_private.Mathlib.NumberTheory.RamificationInertia.Unramified.0.IsUnramifiedAt.of_liesOver_of_ne_bot.match_1_1 | Mathlib.NumberTheory.RamificationInertia.Unramified | [
"CommRing",
"Algebra.algebraMap",
"OreLocalization.instAlgebra",
"Localization.AtPrime.isLocalRing",
"CommSemiring.toSemiring",
"instIsLocalHomAtPrimeRingHomAlgebraMap",
"Localization.AtPrime",
"Localization.AtPrime.algebraOfLiesOver",
"Algebra",
"IsLocalRing.maximalIdeal",
"RingHom",
"IsLocal... | false |
ContinuousLinearMap.prodMapL._proof_25 | Mathlib.Analysis.Normed.Operator.Prod | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"ContinuousLinearMap.uniformSpace._proof_4",
"Prod.normedSpace",
"SeminormedAddCommGroup",
"NormedRing.toRing",
"NormedSpace",
"AddMonoid.toAddSemigroup",
"ContinuousLinearMap.topologicalAddGroup",
"Prod.instIsTopologicalAddGrou... | false |
instHAppendOfAppend | Init.Prelude | [
"Append",
"HAppend",
"HAppend.mk",
"Append.append"
] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"Ordering",
"Ordering.eq",
"Ord.compare",
"Bool.true",
"BEq.beq",
"propext",
"Bool",
"Std.LawfulBEqOrd",
"BEq",
"Eq",
"Std.LawfulBEqOrd.compare_eq_iff_beq"
] | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.map_rootsOfUnity._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Basic | [
"Monoid",
"Monoid.toMulOneClass",
"map_pow",
"Monoid.toPow",
"MulOneClass.toMulOne",
"HPow.hPow",
"Nat",
"MonoidHomClass",
"instHPow",
"Eq.symm",
"Eq",
"DFunLike.coe",
"FunLike"
] | false |
Aesop.ScopeName.noConfusionType | Aesop.Rule.Name | [
"Aesop.ScopeName",
"noConfusionTypeEnum",
"Nat",
"instDecidableEqNat",
"Aesop.ScopeName.ctorIdx"
] | true |
CategoryTheory.Limits.binaryFanZeroLeftIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.BinaryFan",
"CategoryTheory.Functor.category",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.WalkingPair.right",
"CategoryTheory.Category.comp_id",
"CategoryTheory.Limi... | false |
List.dropInfix?.go | Batteries.Data.List.Basic | [
"List.brecOn",
"List",
"Prod",
"BEq",
"List.dropInfix?.go._f",
"Option"
] | true |
Lean.OptionDecl._sizeOf_inst | Lean.Data.Options | [
"Lean.OptionDecl",
"Lean.OptionDecl._sizeOf_1",
"SizeOf.mk",
"SizeOf"
] | false |
BooleanAlgebra.mk | Mathlib.Order.BooleanAlgebra.Defs | [
"BooleanAlgebra",
"Lattice.toSemilatticeSup",
"Compl.compl",
"HImp",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeSup.toMax",
"DistribLattice.toLattice",
"Bot.bot",
"BooleanAlgebra.himp_eq._autoParam",
"Bot",
"SemilatticeInf.toMin",
"LE.le",
"autoParam",
"SemilatticeInf.mk",
... | true |
Std.Roi.toArray_iter | Std.Data.Iterators.Lemmas.Producers.Range | [
"Std.PRange.UpwardEnumerable",
"Std.Rxi.instIteratorIteratorIdOfUpwardEnumerable",
"Std.Roi.iter",
"Std.Iter.toArray",
"Std.Roi.toArray",
"Array",
"Std.Rxi.IsAlwaysFinite",
"Std.Rxi.Iterator",
"Eq.refl",
"Eq",
"Std.Roi",
"Std.PRange.LawfulUpwardEnumerable"
] | true |
NeZero.of_gt' | Mathlib.Algebra.Order.IsBotOne | [
"Preorder.toLT",
"One",
"Preorder.toLE",
"Fact",
"NeZero.of_gt",
"IsBotZeroClass",
"LT.lt",
"One.toOfNat1",
"NeZero",
"OfNat.ofNat",
"Fact.out",
"Preorder",
"Zero"
] | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda._proof_6 | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | [
"CategoryTheory.Functor.op",
"CategoryTheory.Limits.Types.hasColimitsOfShape",
"CategoryTheory.Over",
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"Opposite",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"Cate... | false |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.apply.match_7 | Mathlib.Tactic.GRewrite.Core | [
"DoResultPR",
"Unit",
"DoResultPR.return",
"PUnit",
"Bool",
"DoResultPR.casesOn",
"DoResultPR.pure"
] | false |
_private.Mathlib.Tactic.Widget.StringDiagram.0.Mathlib.Tactic.Widget.StringDiagram.mkKind.match_5 | Mathlib.Tactic.Widget.StringDiagram | [
"Unit.unit",
"Mathlib.Tactic.Bicategory.Context",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Option"
] | false |
Std.Time.instReprOffsetX | Std.Time.Format.Basic | [
"Std.Time.instReprOffsetX.repr",
"Repr.mk",
"Std.Time.OffsetX",
"Repr"
] | true |
ZeroAtInftyContinuousMap.instMulActionWithZero._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | [
"ZeroHom.funLike",
"Semigroup.toMul",
"ZeroAtInftyContinuousMap.coe_smul",
"instHSMul",
"HMul.hMul",
"ZeroAtInftyContinuousMap.instSMul",
"SMulWithZero.toSMulZeroClass",
"Function.Injective.mulAction._proof_2",
"ZeroAtInftyContinuousMap.coe_zero",
"ZeroAtInftyContinuousMap.instFunLike",
"Pi.inst... | false |
OrderIso.divRight₀_apply | Mathlib.Algebra.Order.GroupWithZero.OrderIso | [
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"instHDiv",
"MulPosReflectLT",
"GroupWithZero.toDivInvMonoid",
"MulZeroClass.toMul",
"PartialOrder.toPreorder",
"GroupWithZero",
"Preorder.toLE",
"PartialOrder",
"HDiv.hDiv",
"LE.le",
"RelIso",
"MonoidWithZero.toMulZeroOneClass",
"RelIso... | true |
GroupSeminorm.instMin._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | [
"Eq.mpr",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"instHDiv",
"InvOneClass.toOne",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Real.instZero",
"Real.instAddMonoid",
"congrArg",
"GroupSeminormClass.map_one_eq_zero",
"DivInvOneMonoid.toDivInvMonoid",
"AddMo... | false |
Module.compHom.toLinearEquiv._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | [
"RingEquiv.toEquiv",
"RingEquiv.map_add'",
"Distrib.toAdd",
"Equiv.toFun",
"instDistribOfSemiring",
"instHAdd",
"Distrib.toMul",
"HAdd.hAdd",
"Semiring",
"RingEquiv",
"Eq"
] | false |
MvPFunctor.M.Path.root | Mathlib.Data.PFunctor.Multivariate.M | [
"MvPFunctor",
"PFunctor.A",
"PFunctor.Obj",
"PFunctor.M",
"PFunctor.B",
"MvPFunctor.M.Path.root",
"instOfNatNat",
"MvPFunctor.A",
"instHAdd",
"HAdd.hAdd",
"Nat",
"MvPFunctor.M.Path",
"MvPFunctor.B",
"MvPFunctor.last",
"PFunctor.M.dest",
"instAddNat",
"Sigma.mk",
"MvPFunctor.drop",
... | true |
IsCancelVAdd.mk | Mathlib.Algebra.Group.Action.Defs | [
"VAdd",
"HVAdd.hVAdd",
"instHVAdd",
"Eq",
"IsLeftCancelVAdd",
"IsCancelVAdd",
"IsCancelVAdd.mk"
] | true |
instModuleZModOfNatNatAdditiveUnitsInt._proof_1 | Mathlib.Data.ZMod.IntUnitsPower | [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"Equiv.instEquivLike",
"HMul.hMul",
"ZMod.commRing",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"CommSemiring.toSemiring",
"Additive",
"Additive.toMul",
"ZMod.val_mul",
"Units",
"id",
"Equiv",
"Nat.instMod",
"instHMod",
"CommMagma.... | false |
HNNExtension.toSubgroup.eq_1 | Mathlib.GroupTheory.HNNExtension | [
"Group",
"Units",
"Int.instDecidableEq",
"Subgroup",
"Int",
"Units.instOne",
"Int.instMonoid",
"HNNExtension.toSubgroup",
"One.toOfNat1",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Units.instDecidableEq",
"ite"
] | true |
GradedLieAlgebra.mk | Mathlib.Algebra.Lie.Graded | [
"LieAlgebra.toModule",
"Submodule",
"DirectSum.Decomposition",
"Submodule.addSubmonoidClass",
"CommRing",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieRingModule.toBracket",
"AddCommMonoid",
"LieRing",
"CommRing.toCommSemiring",
"Submodule.setLike"... | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection.0.ContMDiffAt.sum_section._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | [
"ContMDiffWithinAt",
"NormedSpace",
"Set.univ",
"TopologicalSpace",
"ModelWithCorners",
"ENat",
"propext",
"ContMDiffAt",
"contMDiffWithinAt_univ",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"Eq.symm",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"Eq",
"NormedA... | false |
String.Slice.Pos.le_ofSliceFrom._simp_1 | Init.Data.String.Basic | [
"String.instLEPos_1",
"String.Slice.sliceFrom",
"String.Slice",
"LE.le",
"String.Slice.Pos.ofSliceFrom",
"True",
"eq_true",
"String.Slice.Pos",
"Eq",
"String.Slice.Pos.le_ofSliceFrom"
] | false |
HNNExtension.NormalWord.instMulAction_1._proof_1 | Mathlib.GroupTheory.HNNExtension | [
"HNNExtension.NormalWord",
"instHSMul",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"MulAction.toPerm_apply",
"MulAction.toPermHom",
"Subgroup.mul",
"Group",
"Membership.mem",
"Units",
"Equiv",
... | false |
_private.Mathlib.RingTheory.Algebraic.Integral.0.Algebra.IsIntegral.isAlgebraic_iff_top._simp_1_1 | Mathlib.RingTheory.Algebraic.Integral | [
"CommRing",
"IsAlgebraic",
"Algebra",
"Algebra.IsAlgebraic",
"CommRing.toCommSemiring",
"Algebra.isAlgebraic_def",
"propext",
"Ring.toSemiring",
"Eq",
"Ring"
] | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Elab.Tactic.Induction | [
"Pure.pure",
"Lean.Elab.Tactic.elabElimTargets",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction.match_1",
"Lean.Meta.ElimInfo",
"Lean.Elab.Tactic.focus",
"Lean.Meta.State",
"instMonadLiftT",
"Lean.Syntax.Ident",
"Lean.Elab.Ta... | true |
OrderIso.sumCongr | Mathlib.Data.Sum.Order | [
"RelIso.mk",
"Sum",
"Equiv",
"OrderIso",
"OrderIso.sumCongr._proof_2",
"OrderIso.instEquivLike",
"LE.le",
"LE",
"Equiv.sumCongr",
"Sum.instLESum",
"EquivLike.toEquiv"
] | true |
Lean.Lsp.FileSystemWatcher.globPattern | Lean.Data.Lsp.Workspace | [
"String",
"Lean.Lsp.FileSystemWatcher"
] | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_43 | Batteries.Data.List.Lemmas | [
"List.idxsOf",
"Lean.Grind.CommRing.le_norm_expr",
"Lean.Grind.instOrderedRingInt",
"Lean.RArray.leaf",
"eq_false",
"Lean.Grind.CommRing.Expr.var",
"congrArg",
"Lean.Grind.Order.le_of_eq_2_k",
"Std.IsLinearPreorder.toIsPreorder",
"Lean.Grind.Order.le_eq_true_of_le_k",
"Lean.Grind.instIsLinearOrd... | false |
Unitization.instSub | Mathlib.Algebra.Algebra.Unitization | [
"Unitization.equiv",
"Prod.instSub",
"Unitization",
"Prod",
"Sub",
"Equiv.sub"
] | true |
Lean.Meta.FunInfo.mk._flat_ctor | Lean.Meta.Basic | [
"Array",
"Lean.Meta.ParamInfo",
"Lean.Meta.FunInfo",
"Nat",
"Lean.Meta.FunInfo.mk"
] | false |
List.Forall₂ | Batteries.Data.List.Basic | [
"List.Forall₂.cons",
"List.Forall₂.nil",
"List"
] | true |
Dynamics.coverEntropyEntourage_union | Mathlib.Dynamics.TopologicalEntropy.Subset | [
"Eq.mpr",
"ENNReal.instAdd",
"Lattice.toSemilatticeSup",
"le_of_le_of_eq",
"SetRel",
"ExpGrowth.expGrowthSup_add",
"congrArg",
"PartialOrder.toPreorder",
"Set.subset_union_right",
"EReal",
"Preorder.toLE",
"Set.instUnion",
"SemilatticeSup.toMax",
"instAddENat",
"id",
"ENat.toENNReal",
... | true |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.schroeder_bernstein_of_rel._proof_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | [
"Set.compl_subset_compl_of_subset",
"False",
"ChainCompletePartialOrder.instOfCompleteLattice",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Compl.compl",
"Set.image_mono",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
... | false |
_private.Mathlib.RingTheory.LocalProperties.Basic.0.Ideal.iInf_ker_le._simp_1_1 | Mathlib.RingTheory.LocalProperties.Basic | [
"Submodule",
"iInf",
"Submodule.mem_iInf",
"Membership.mem",
"AddCommMonoid",
"Submodule.setLike",
"propext",
"Semiring",
"Module",
"Eq",
"SetLike.instMembership",
"Submodule.instInfSet"
] | false |
Lean.PersistentHashMap.EntriesNode | Lean.Data.PersistentHashMap | [
"Lean.PersistentHashMap.Node",
"Subtype",
"Lean.PersistentHashMap.IsEntriesNode"
] | true |
_private.Lean.Meta.Tactic.Cbv.ControlFlow.0.Lean.Meta.Sym.Simp.matchDecideDecidable | Lean.Meta.Tactic.Cbv.ControlFlow | [
"Pure.pure",
"Unit.unit",
"Lean.Expr.isApp",
"ReaderT",
"Lean.Meta.State",
"Lean.Meta.Sym.Simp.MethodsRef",
"Lean.Expr.cleanupAnnotations",
"instMonadLiftT",
"Lean.Meta.Sym.Context",
"Lean.Name.mkStr3",
"ReaderT.instMonad",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEq... | true |
Std.Tactic.BVDecide.BVPred._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"Std.Tactic.BVDecide.BVPred._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"Std.Tactic.BVDecide.BVPred"
] | false |
NNReal.coe_inj | Mathlib.Data.NNReal.Defs | [
"Real",
"Function.Injective.eq_iff",
"NNReal",
"Iff",
"NNReal.coe_injective",
"Eq",
"NNReal.toReal"
] | true |
CategoryTheory.Functor.LaxLeftLinear.μₗ_naturality_left._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
wellApproximable.eq_1 | Mathlib.NumberTheory.WellApproximable | [
"Real",
"SeminormedGroup",
"CompleteLattice.toConditionallyCompleteLattice",
"Filter.blimsup",
"instOfNatNat",
"wellApproximable",
"approxOrderOf",
"Filter.atTop",
"Nat.instPreorder",
"Nat",
"LT.lt",
"CompleteBooleanAlgebra.toCompleteLattice",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Eq... | true |
_private.Mathlib.Data.Set.Basic.0.Set.nonempty_of_not_subset.match_1_1 | Mathlib.Data.Set.Basic | [
"Membership.mem",
"Exists",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Set.instMembership",
"Not",
"Set"
] | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0._regBuiltin.Int.reduceNegSucc.declare_147._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.3257793191._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | [
"IO",
"Lean.Meta.DiscrTree.Key.star",
"Lean.Meta.DiscrTree.Key",
"instOfNatNat",
"Int.reduceNegSucc",
"List.toArray",
"List.cons",
"Unit",
"Nat",
"Lean.Meta.Simp.registerBuiltinDSimproc",
"Lean.Name.mkStr2",
"OfNat.ofNat",
"Lean.Meta.DiscrTree.Key.const",
"List.nil"
] | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_e_f_ne._proof_1_8 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | [
"Lean.RArray.leaf",
"False",
"Lean.Grind.AC.Expr.op",
"CommRing",
"Lean.Grind.not_not",
"Lean.Grind.nestedProof",
"eq_false",
"AddMonoid.toAddSemigroup",
"congrArg",
"CommSemiring.toSemiring",
"RootPairing.Base",
"AddCommGroup.toAddCommMonoid",
"Finset",
"Lean.Grind.AC.Expr",
"AddMonoid.... | false |
TruncatedWittVector.coeff_out | Mathlib.RingTheory.WittVector.Truncated | [
"Eq.mpr",
"TruncatedWittVector.coeff",
"CommRing",
"congrArg",
"CommSemiring.toSemiring",
"dif_pos",
"Fin.mk",
"Fin.is_lt",
"id",
"Fin.eta",
"Fin.val",
"dite",
"CommRing.toCommSemiring",
"WittVector",
"Nat",
"LT.lt",
"TruncatedWittVector.out",
"WittVector.mk'",
"Nat.decLt",
"Ze... | true |
UInt64.natCast | Init.GrindInstances.Ring.UInt | [
"UInt64.ofNat",
"UInt64",
"NatCast",
"Nat",
"NatCast.mk"
] | true |
_private.Mathlib.Order.Disjointed.0.preimage_find_eq_disjointed._simp_1_1 | Mathlib.Order.Disjointed | [
"Exists",
"And",
"DecidablePred",
"Nat",
"LT.lt",
"Nat.find",
"propext",
"instLTNat",
"Eq",
"Not",
"Nat.find_eq_iff"
] | false |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.go._unary | Lean.Meta.Tactic.AC.Main | [
"Pure.pure",
"Array.instAppend",
"Lean.mkAppN",
"Array.push",
"instMonadControlTOfPure",
"_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.go._unary._proof_2",
"Lean.Meta.State",
"InvImage",
"Lean.Meta.AC.PreContext",
"HSub.hSub",
"WellFounded.Nat.fix",
"Lean.Meta.withLocalDeclD"... | false |
Computability._aux_Mathlib_Algebra_Order_Kleene___unexpand_KStar_kstar_1 | Mathlib.Algebra.Order.Kleene | [
"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 |
Zsqrtd.addGroupWithOne._proof_2 | Mathlib.NumberTheory.Zsqrtd.Basic | [
"AddMonoid.toAddSemigroup",
"AddCommGroup.toAddGroup",
"Zsqrtd.instOne",
"instOfNatNat",
"Int",
"Nat.cast",
"instHAdd",
"AddSemigroup.toAdd",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"Zsqrtd.ofInt",
"Nat",
"One.toOfNat1",
"instAddNat",
"Eq.refl",
"instNatCastInt",
"SubNegMonoid.toAddM... | false |
OrderIso.ofIsEmpty | Mathlib.Order.Hom.Basic | [
"RelIso.mk",
"Equiv.equivOfIsEmpty",
"Preorder.toLE",
"OrderIso",
"LE.le",
"IsEmpty",
"OrderIso.ofIsEmpty._proof_1",
"Preorder"
] | true |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.«_aux_Mathlib_AlgebraicGeometry_Gluing___delab_app__private_Mathlib_AlgebraicGeometry_Gluing_0_AlgebraicGeometry_Scheme_IsLocallyDirected_term↓__1» | Mathlib.AlgebraicGeometry.Gluing | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Name.mkNum",
"Mathlib.Notation3.MatchState.empty",
"Mathlib.Notation3.withHeadRefIfTagAppFns",
"Mathlib.Notation3.matchApp",
"Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM",
"Lean.SourceInfo",
"Lean.PrettyPrinter.Delaborator.Contex... | false |
_private.Std.Time.Format.Basic.0.Std.Time.formatMonthLong | Std.Time.Format.Basic | [
"Std.Time.DateFormatSymbols.monthLong",
"Vector.get",
"Std.Time.Internal.Bounded.LE.toFin",
"String",
"HSub.hSub",
"instOfNatNat",
"Int",
"instHSub",
"instOfNat",
"Nat",
"Std.Time.Internal.Bounded.LE.sub",
"Int.instSub",
"Std.Time.DateFormatSymbols",
"_private.Std.Time.Format.Basic.0.Std.T... | true |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjective_localRingHom_iff.match_1_2 | Mathlib.RingTheory.SurjectiveOnStalks | [
"CommRing",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"Subtype.casesOn",
"Membership.mem",
"Subtype",
"Prod.mk",
"Ideal",
"Subtype.mk",
"CommRing.toCommSemiring",
"CommMonoid.toMonoid",
"CommSemiring.toCommMonoid",
"Ideal.IsPrime",
"Ideal.primeCompl",
"Submonoid.instSetLike",
... | false |
AlternatingMap.domCoprod' | Mathlib.LinearAlgebra.Alternating.DomCoprod | [
"AlternatingMap",
"LinearMap.mk₂",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AlternatingMap.domCoprod'._proof_2",
"TensorProduct.addCommMonoid",
"AlternatingMap.domCoprod'._proof_1",
"AddCommGroup",
"Sum",
"AlternatingMap.domCoprod'._proof_4",
"AlternatingMap.domCoprod",
"Lin... | true |
Equiv.addZeroClass._proof_2 | Mathlib.Algebra.Group.TransferInstance | [
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"AddZeroClass.toAddZero",
"Equiv",
"instHAdd",
"AddZeroClass",
"HAdd.hAdd",
"AddZero.toAdd",
"Equiv.symm",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | false |
AffineMap.restrict._proof_2 | Mathlib.LinearAlgebra.AffineSpace.Restrict | [
"Eq.mpr",
"Submodule",
"RingHomSurjective.ids",
"AffineSubspace.direction_le",
"AffineSubspace.map",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"id",
"Submodule.instPartialOrder",
"LE.le",
"AffineMap"... | false |
instSemiringTensorAlgebra._proof_12 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | [
"instSemiringTensorAlgebra._proof_7",
"instSemiringTensorAlgebra._proof_11",
"FreeAlgebra.instSemiring",
"instSemiringTensorAlgebra._aux_8",
"RingQuot.instAddCommMonoid._proof_7",
"AddMonoid.toAddSemigroup",
"CommSemiring.toSemiring",
"AddMonoid.mk",
"TensorAlgebra",
"AddSemigroup.mk",
"AddCommM... | false |
ConnectedComponents.isQuotientMap_coe | Mathlib.Topology.Connected.Clopen | [
"ConnectedComponents.mk",
"ConnectedComponents.instTopologicalSpace",
"TopologicalSpace",
"Topology.IsQuotientMap",
"ConnectedComponents",
"connectedComponentSetoid",
"Setoid.r",
"isQuotientMap_quot_mk"
] | true |
CentroidHomClass.mk | Mathlib.Algebra.Ring.CentroidHom | [
"HMul.hMul",
"outParam",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidHomClass",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Distrib.toMul",
"CentroidHomClass.mk",
"NonUnitalNonAssocSemiring.toDistrib",
"AddCommMonoid.toAddMonoid",
"NonUnitalNonAssocSemiring",
"Eq",
"DFu... | true |
Real.toNNReal_le_toNNReal | Mathlib.Data.NNReal.Defs | [
"Real.instLE",
"Real",
"PartialOrder.toPreorder",
"Preorder.toLE",
"NNReal",
"LE.le",
"Real.toNNReal_mono",
"NNReal.instPartialOrder",
"Real.toNNReal"
] | true |
freeGroupEquivCoprodI_apply | Mathlib.GroupTheory.CoprodI | [
"FreeGroup.of",
"Unit.unit",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"Monoid.CoprodI.of",
"Equiv.instEquivLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Equiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"FreeGroup.lift",
"freeGroupEquivCoprodI",
"Monoid.CoprodI",
"Monoid.instCopr... | true |
_private.Mathlib.Tactic.Translate.UnfoldBoundary.0.Mathlib.Tactic.UnfoldBoundary.refoldConsts.go.match_1 | Mathlib.Tactic.Translate.UnfoldBoundary | [
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Expr.forallE",
"_private.Mathlib.Tactic.Translate.UnfoldBoundary.0.Mathlib.Tactic.UnfoldBoundary.refoldConsts.go._sparseCasesOn_1",
"Lean.Name",
"Lean.BinderInfo",
"Lean.Expr.ctorIdx"
] | false |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing.match_3 | Mathlib.RingTheory.Regular.RegularSequence | [
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"List.cons",
"List",
"CommRing.toCommSemiring",
"List.casesOn",
"RingTheory.Sequence.IsWeaklyRegular",
"Module",
"List.nil"
] | false |
Mathlib.Meta.NormNum.inferLinearOrderedSemifield | Mathlib.Tactic.NormNum.Ineq | [
"Pure.pure",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"String",
"Lean.Meta.State",
"Lean.Expr.const",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMonad",
"Lean.throwError",
"Lean.MonadQuotation.toMonadRef",
"HOrElse.hOrElse",
"Lean.Meta.MetaM",
"IO.RealWorld",
"... | true |
MeasureTheory.Lp.boundedContinuousFunction._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | [
"PseudoMetricSpace.toBornology",
"AddMonoid.toAddZeroClass",
"instBoundedAddOfLipschitzAdd",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"BoundedAdd",
"SeminormedAddCommGroup.to_lipschitzAdd",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"AddGroup.toSubNegMonoid",
"AddZero.toAdd",
"Nor... | false |
Field.nnratCast._inherited_default | Mathlib.Algebra.Field.Defs | [
"NNRat.castRec",
"id",
"NNRat",
"Div.mk",
"Nat",
"NatCast.mk"
] | false |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp'._f | Mathlib.CategoryTheory.Monoidal.Free.Coherence | [
"CategoryTheory.MonoidalCategoryStruct.rightUnitor",
"CategoryTheory.MonoidalCategory.whiskerRightIso",
"CategoryTheory.Iso.refl",
"CategoryTheory.Iso",
"CategoryTheory.FreeMonoidalCategory.instMonoidalCategory",
"CategoryTheory.FreeMonoidalCategory.normalizeObj",
"CategoryTheory.FreeMonoidalCategory.of... | false |
instNonemptyOfMonad | Init.Prelude | [
"Pure.pure",
"Monad.toApplicative",
"Applicative.toPure",
"Nonempty.intro",
"_private.Init.Prelude.0.instNonemptyOfMonad.match_1",
"Nonempty",
"Monad"
] | true |
IsAdjoinRoot.adjoin_root_eq_top | Mathlib.RingTheory.IsAdjoinRoot | [
"Eq.mpr",
"CommRing",
"Lattice.toSemilatticeSup",
"IsAdjoinRoot",
"CompleteLattice.toLattice",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"PartialOrder.toPreorder",
"Algebra.instCompleteLatticeSubalgebra",
"Algebra",
"Preorder.toLE",
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.