name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | [
"MeasureTheory.Measure",
"MeasureTheory.MemLp",
"instZeroENNReal",
"MeasurableSpace",
"TopologicalSpace",
"ENNReal",
"propext",
"ENorm",
"Zero.toOfNat0",
"OfNat.ofNat",
"MeasureTheory.memLp_zero_iff_aestronglyMeasurable",
"Eq",
"MeasureTheory.AEStronglyMeasurable"
] | false |
instDecidablePredPermMemSetDerangements | Mathlib.Combinatorics.Derangements.Finite | [
"instDecidableNot",
"Equiv.instEquivLike",
"Membership.mem",
"Ne",
"Fintype",
"Equiv.Perm",
"DecidablePred",
"Fintype.decidableForallFintype",
"Eq",
"Set.instMembership",
"DFunLike.coe",
"derangements",
"EquivLike.toFunLike",
"DecidableEq",
"Set"
] | true |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | [
"MulOne.toOne",
"HMul.hMul",
"MulOpposite",
"MulOne.toMul",
"MulOneClass.toMulOne",
"One.toOfNat1",
"MulOpposite.unop",
"MulOpposite.unop_injective",
"mul_one",
"MulOneClass",
"OfNat.ofNat",
"Eq",
"MulOpposite.instMulOne",
"instHMul"
] | false |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | [
"Eq.mpr",
"Submodule",
"RingHomSurjective.ids",
"Submodule.inclusion.eq_1",
"congrArg",
"Submodule.addCommMonoid",
"Submodule.map_top",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"LinearMap.range",
"id",
"Subtype",
"Submodule.instPartialOrder",
"Submodule.instTop",
"... | true |
MulEquiv.AddMonoid.End._proof_1 | Mathlib.Algebra.Group.Equiv.TypeTags | [
"HMul.hMul",
"MonoidHom",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.toMultiplicative",
"AddZeroClass.toAddZero",
"Multiplicative.mulOneClass",
"Equiv.toFun",
"AddMonoid.End.instMul",
"Multiplicative",
"MulOneClass.toMulOne",
"AddMonoid",
"AddMonoid.End",
"AddMonoidHom",
"Eq",
"Monoid.End... | false |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Comma.right",
"AlgHom.algHomClass",
"CommRingCat.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommSemiring.toSemiring",
"Algebra.TensorProduct.instCommRing",
"Algebra.TensorProduct.map",
"CommRingCat",
"CommRingCat.mkUnder... | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | [
"cond",
"Bool.not_false",
"Bool.not",
"Bool.and_false",
"congrArg",
"Bool.and_true",
"Bool.and",
"Bool.cond_self",
"Bool.and_self",
"Bool.true",
"Bool.casesOn",
"congr",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"congrFun'",
"Eq.symm",
"Bool.false",
"E... | true |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | [
"PrincipalSeg.trans_apply",
"Eq.mpr",
"InitialSeg.principalSumRelIso",
"PrincipalSeg.relIsoTrans",
"congrArg",
"InitialSeg.eq_relIso",
"PrincipalSeg",
"InitialSeg.transPrincipal",
"PrincipalSeg.toRelEmbedding",
"Sum.casesOn",
"Sum",
"id",
"InitialSeg.eq_principalSeg",
"IsWellOrder",
"Sum... | true |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Types.Small.limitCone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Functor.category",
"LinearMap.instFunLike",
"CategoryTheory.Functor.comp",
... | false |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | [
"Mul",
"MulEquiv.piCongrRight",
"Pi.instMul",
"MulEquiv",
"MulEquiv.symm",
"Eq",
"rfl"
] | true |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | [
"LieSubalgebra.lieAlgebra",
"Eq.mpr",
"LieSubalgebra.ofLe",
"LieSubalgebra.instPartialOrder_1",
"CommRing",
"LieRing.toAddCommGroup",
"LieSubalgebra.instSetLike",
"congrArg",
"PartialOrder.toPreorder",
"Bracket.bracket",
"Subtype.casesOn",
"Preorder.toLE",
"Membership.mem",
"Exists",
"id... | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | [
"False",
"False.elim",
"Ne",
"List",
"absurd",
"Eq.refl",
"Eq",
"List.nil"
] | false |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.LinearMap | [
"Submodule",
"Submodule.ClosedComplemented.exists_isClosed_isCompl",
"AddCommGroup.toAddCommMonoid",
"Submodule.completeLattice",
"Membership.mem",
"CompleteLattice.toBoundedOrder",
"AddCommGroup",
"Subtype",
"Submodule.instPartialOrder",
"Submodule.ClosedComplemented",
"IsClosed",
"Topologica... | true |
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | [
"Equiv.instEquivLike",
"EquivFunctor.mapEquiv",
"Equiv",
"EquivFunctor",
"Eq",
"DFunLike.coe",
"EquivFunctor.map",
"rfl",
"EquivLike.toFunLike"
] | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | [
"PosNum.bit1",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"PosNum.testBit",
"PosNum",
"OfNat.ofNat",
"Eq"
] | true |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | [
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Category"
] | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | [
"Lean.TSyntax",
"Prod.mk",
"Lean.Parser.ModuleParserState",
"List.cons",
"Lean.SyntaxNodeKind",
"Prod",
"Prod.casesOn",
"Lean.Name.mkStr4",
"Lean.MessageLog",
"List.nil"
] | false |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | [
"Rat.instOfNat",
"Std.Time.Hour.Offset",
"Rat",
"Std.Time.Internal.UnitVal",
"Int",
"LE.le",
"Std.Time.Internal.UnitVal.val",
"OfNat.ofNat",
"Int.instLEInt"
] | false |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"ContinuousLinearMap.map_zero",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContinuousLinearMap.topologicalSpac... | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | [
"CategoryTheory.Subobject.underlying",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Subobject.ofLE",
"Preorder.toLE",
"CategoryTheory.Subobject.underlyingIso",
"Preorder.smallCategory",
"LE.le",
"CategoryTheory.instPart... | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MessageData",
"Unit.unit",
"Lean.Exception.internal",
"Lean.Elab.Command.Scope.header",
"Lean.Elab.Command.CommandElab",
"Std.instToFormatString",
"Except.ok",
"Lean.Elab.Command.Scope.mk",
"Lean.Elab.Command.Scope.currNamespace",
"instMonadExceptOfMonadExcep... | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | [
"Finset",
"Subtype.casesOn",
"Membership.mem",
"Subtype",
"Subtype.mk",
"Finset.instSetLike",
"SetLike.instMembership"
] | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"Ordering",
"Std.DTreeMap.inner",
"List",
"Std.DTreeMap.Internal.Impl.keys"
] | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | [
"AddUnits.val",
"IsAddUnit",
"Exists.casesOn",
"AddMonoid",
"Exists.intro",
"Eq",
"AddUnits"
] | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | [
"MulOne.toOne",
"ULift.inv",
"DivInvMonoid.toInv",
"Equiv.instEquivLike",
"Monoid.toMulOneClass",
"ULift.commSemigroup._proof_1",
"ULift.divInvMonoid._proof_2",
"ULift",
"DivInvMonoid.toZPow",
"ULift.divInvMonoid._proof_1",
"Equiv.ulift",
"Equiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
... | true |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | [
"Monoid",
"IsInvariantSubfield.mk",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"Membership.mem",
"Field.toDivisionRing",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"DivisionRing.toRing",
"Subfield.instSetLike",... | false |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | [
"Aesop.LocalNormSimpRule._sizeOf_inst",
"Aesop.LocalRuleSet._sizeOf_inst",
"Aesop.LocalRuleSet.mk",
"instSizeOfDefault",
"Lean.Meta.Simp.Simprocs._sizeOf_inst",
"instOfNatNat",
"Aesop.BaseRuleSet._sizeOf_inst",
"Array._sizeOf_inst",
"Array",
"Aesop.LocalRuleSet",
"Lean.Meta.Simp.Simprocs",
"in... | true |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | [
"VectorAll._unsafe_rec",
"instOfNatNat",
"Vector3.nil",
"Vector3.cons",
"Vector3",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"VectorEx.match_1"
] | false |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | [
"Std.DTreeMap.Raw.minKeyD",
"Std.DTreeMap.Raw.erase",
"Std.DTreeMap.Internal.Impl.minKeyD_erase!_eq_of_not_compare_minKeyD_eq",
"Ord.mk",
"Ordering",
"Ordering.eq",
"Std.DTreeMap.Raw.isEmpty",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Bool",
"Bool.false",
"Eq",
... | true |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.MonoOver.mapIso._proof_3",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.eqToHom_app",
"CategoryTheory.Functor.category",
... | false |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | [
"MulOne.toOne",
"pow_nonneg",
"MulZeroClass.toMul",
"Preorder.toLE",
"ZeroLEOneClass",
"LE.le",
"MulZeroOneClass.toMulOneClass",
"Monoid.toPow",
"MulOneClass.toMulOne",
"MonoidWithZero",
"PosMulMono",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"True",
"eq_true",
"Zero.to... | false |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | [
"Nat.shiftRight",
"Lean.Data.AC.evalList._sparseCasesOn_1",
"Nat.hasNotBit",
"instOfNatNat",
"List.cons",
"Bool.true",
"Nat.land",
"List",
"absurd",
"Nat",
"List.casesOn",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"List.ctorIdx",
"L... | false |
Int.le_of_not_le | Init.Data.Int.Order | [
"Int.le_total",
"Or.resolve_left",
"Int",
"LE.le",
"Not",
"Int.instLEInt"
] | true |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | [
"Topology.IsLowerSet.WithLowerSetHomeomorph._proof_1",
"Topology.WithLowerSet.ofLowerSet",
"Topology.WithLowerSet.instTopologicalSpace",
"Topology.IsLowerSet",
"TopologicalSpace",
"Homeomorph",
"Equiv.toHomeomorphOfIsInducing",
"Topology.WithLowerSet",
"Preorder"
] | true |
Nat.eq_or_lt_of_le._unsafe_rec | Init.Prelude | [
"Nat.zero_le",
"Nat.eq_or_lt_of_le._unsafe_rec",
"Eq.rec",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"Nat.not_succ_le_zero",
"absurd",
"Nat.le_of_succ_le_succ",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"Nat.zero",
"Or.inl",
"Or",
"instLTNat",
"OfNat.ofNat",
"Nat.eq_or... | false |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | [
"ShareCommon.StateFactoryImpl.Set",
"ShareCommon.Object",
"ShareCommon.StateFactoryImpl",
"Option"
] | true |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | [
"Eq.mpr",
"MulOne.toOne",
"id.eq_1",
"Equiv.instEquivLike",
"Equiv.Perm.instOne",
"Monoid.toMulOneClass",
"congrArg",
"true_or",
"zpow_zero",
"Equiv.swap",
"DivInvMonoid.toZPow",
"Membership.mem",
"Eq.mp",
"zpow_one",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Equiv.Perm.SameC... | true |
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | [
"Eq.le",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.cast",
"Polynomial",
"Nat.instPreorder",
"Nat",
"Polynomial.natDegree_natCast",
"Semiring",
"Polynomial.natDegree",
"OfNat.ofNat",
"Polynomial.instNatCast"
] | true |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | [
"PresheafOfModules.map",
"PresheafOfModules.evaluation",
"Eq.mpr",
"CategoryTheory.Limits.IsColimit.fac",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Functor.mapCocone",
"Opposite",
"_private.Mathlib.Algebra.Category.ModuleCat.Presheaf... | false |
Specialization.map_id | Mathlib.Topology.Specialization | [
"OrderHom.id",
"Specialization.instPreorder",
"TopologicalSpace",
"ContinuousMap.id",
"Specialization",
"Specialization.map",
"Eq",
"OrderHom",
"rfl"
] | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | [
"Bool.coe_iff_coe",
"Bool.true",
"Iff",
"propext",
"Bool",
"Eq"
] | false |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | [
"Eq.mpr",
"Matrix.fromBlocks",
"Matrix.transpose_transpose",
"congrArg",
"Matrix",
"Sum",
"id",
"Matrix.fromBlocks_transpose",
"Matrix.transpose",
"True",
"eq_self",
"Matrix.IsSymm",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Eq.symm",
"Eq",
"Eq.trans"
] | true |
Lean.Server.Reference.ci | Lean.Server.References | [
"Lean.Server.Reference",
"Lean.Elab.ContextInfo"
] | true |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Option",
"Lean.instInhabitedOption",
"Bool"
] | true |
Set.iUnion_comm | Mathlib.Data.Set.Lattice | [
"iSup_comm",
"CompleteBooleanAlgebra.toCompleteLattice",
"Eq",
"Set.iUnion",
"CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra",
"Set.instCompleteAtomicBooleanAlgebra",
"Set"
] | true |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | [
"Lean.Expr",
"Lean.Meta.MetaM",
"Lean.Meta.Simp.Result",
"Lean.Meta.TransparencyMode",
"Mathlib.Tactic.AtomM.Context.mk",
"Mathlib.Tactic.AtomM.Context"
] | false |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | [
"Monoid",
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Units.coe_neg_one",
"congrArg",
"Iff.rfl",
"Units.instNeg",
"Units",
"id",
"MulOne.toMul",
"Units.instOne",
"Units.val_inj",
"MulOneClass.toMulOne",
"Iff",
"propext",
"HasDistribNeg",
"One.toOfNat1",
"Has... | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | [
"Std.Do.SPred.entails",
"Std.Do.PostCond",
"Std.Do.Assertion",
"Std.Do.PostShape",
"Std.Do.WP",
"Std.Do.Triple.iff",
"Std.Do.PredTrans.apply",
"Std.Do.Triple",
"propext",
"Std.Do.PostShape.args",
"Eq",
"Std.Do.WP.wp"
] | false |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | [
"Finset",
"Membership.mem",
"HasSubset.Subset",
"Finset.instSetLike",
"Finset.subset_iff",
"propext",
"Finset.instHasSubset",
"Eq",
"SetLike.instMembership"
] | false |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | [
"AddGroupWithOne.toAddGroup",
"MulRingNorm.toMulRingSeminorm",
"MulRingNorm",
"NonAssocRing",
"MulRingSeminorm.toAddGroupSeminorm",
"NonAssocRing.toAddCommGroupWithOne",
"MulRingNorm.eq_zero_of_map_eq_zero'",
"AddGroupNorm",
"AddCommGroupWithOne.toAddGroupWithOne",
"AddGroupNorm.mk"
] | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | [
"Subalgebra.instSetLike",
"MulSemiringAction.toRingAut",
"QuotientGroup.map",
"Monoid",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"CategoryTheory.isCofilteredOrEmpty_of_directed_ge",
"Submodule.instAddCommMonoidWithOne",
"CategoryTheory.Functor",
"CommRing"... | true |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | [
"Algebra.Extension.Hom.mk",
"CommRing",
"Algebra.Extension.commRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"Algebra",
"RingHom",
"algebraMap",
"Algebra.toModule",
"Algebra.id",
"Algebra.Extension.Hom.mk.noConfusion",
"Non... | true |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.Prime",
"Perfection",
"CommSemiring.toSemiring",
"RingHom",
"Fact",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Subtype.mk",
"Monoid.toPow",
"CommSemiring",
"instHAdd",
"RingHom.instFunLike",
"HPow.hPow",
"HAdd.hAdd",
"Per... | true |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | [
"Function.comp",
"Iff.mp",
"Function.Semiconj",
"Eq",
"Function.semiconj_iff_comp_eq"
] | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | [
"Lean.Meta.KExprMap.mk",
"Lean.instBEqHeadIndex",
"Lean.Expr",
"id",
"Lean.PersistentHashMap.Node.entries",
"Lean.PersistentHashMap.mk",
"Lean.instHashableHeadIndex",
"Nat",
"Lean.AssocList",
"Lean.PersistentHashMap.mkEmptyEntriesArray",
"Lean.Meta.KExprMap",
"Lean.HeadIndex"
] | false |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"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",
"Classical.propDecidable",
... | false |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | [
"Set.instSProd",
"Eq.mpr",
"Real",
"SProd.sprod",
"congrArg",
"IsCompact.prod",
"PseudoMetricSpace.toUniformSpace",
"id",
"Prod.mk",
"ProperSpace",
"closedBall_prod_same",
"PseudoMetricSpace",
"PseudoEMetricSpace.toUniformSpace",
"Prod.pseudoMetricSpaceMax",
"ProperSpace.mk",
"ProperSp... | true |
Preord.ofHom_id | Mathlib.Order.Category.Preord | [
"OrderHom.id",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"Preord.instCategory",
"Preord",
"Preord.ofHom",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"rfl",
"Preorder",
"Preord.of"
] | true |
HasFDerivWithinAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | [
"NormedCommRing.toNormedRing",
"NormedRing.toRing",
"NormedSpace",
"NormedSpace.toModule",
"HSub.hSub",
"PseudoMetricSpace.toUniformSpace",
"HasFDerivWithinAt",
"NormedField.toField",
"id",
"NormedAddGroup.toAddGroup",
"Field.toSemifield",
"ContinuousLinearMap",
"SubNegMonoid.toSub",
"inst... | 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 |
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 |
MonadControl.noConfusionType | Init.Control.Basic | [
"MonadControl.casesOn",
"HEq",
"Eq",
"MonadControl"
] | false |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.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 |
_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 |
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 |
_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 |
_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",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddMonoidWithOne",
"Invertible.invOf",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"AddMonoidWithOne.toNatCast",
"Int",
"AddGroupWithOne.toIntCast",
"Nat.cast",
"NonAssocRing.toNonUnita... | 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 |
Lean.ppNoDotAttr._regBuiltin.Lean.ppNoDotAttr.declRange_3 | Lean.PrettyPrinter.Delaborator.Attributes | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"Lean.Name.mkStr2",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk"
] | false |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | [
"PiTensorProduct.instSeminormedAddCommGroup",
"SeminormedAddGroup.toAddGroup",
"SeminormedAddCommGroup",
"NormedSpace",
"AddMonoid.toAddSemigroup",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"NormedField.toField",
"IsTopologicalAddGroup.toContinuous... | 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 |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | [
"List.brecOn",
"List.take_nil",
"eq_false",
"AddMonoid.toAddSemigroup",
"congrArg",
"add_assoc",
"AddMonoid.toAddZeroClass",
"Nat.zero_lt_succ",
"List.sum",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"List.set",
"instOfNatNat",
"_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.... | true |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | [
"Coalgebra.toCoalgebraStruct",
"Semiring.toModule",
"Coalgebra",
"CommSemiring.toSemiring",
"WithConv.ofConv",
"LinearMap.instFunLike",
"Algebra",
"RingHom",
"algebraMap",
"CoalgebraStruct.counit",
"Algebra.toModule",
"LinearMap.convOne",
"LinearMap",
"AddCommMonoid",
"CommSemiring",
"... | true |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | [
"Array",
"List",
"PProd",
"PUnit",
"Lean.IR.IRType",
"Lean.Name",
"Lean.IR.IRType.rec",
"Option"
] | false |
_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 |
_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 |
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 |
Subfield.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | [
"MulOne.toOne",
"instHSMul",
"Monoid.toMulOneClass",
"DivisionRing.toDivisionSemiring",
"one_smul",
"MulOneClass.toMulOne",
"MulAction",
"Monoid.toSemigroup",
"DivisionSemiring.toSemiring",
"One.toOfNat1",
"HSMul.hSMul",
"DivisionRing",
"SemigroupAction.toSMul",
"MulAction.toSemigroupActio... | false |
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 |
Std.Time.FormatType | Std.Time.Format.Basic | [
"Std.Time.TypeFormat",
"List.brecOn",
"Std.Time.FormatPart",
"String",
"Std.Time.FormatType.match_1",
"Std.Time.FormatPart.string",
"Std.Time.FormatPart.modifier",
"List.cons",
"List",
"Unit",
"List.below",
"Std.Time.Modifier",
"Std.Time.FormatString",
"List.nil"
] | true |
Matrix.addGroup._proof_4 | Mathlib.LinearAlgebra.Matrix.Defs | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"instHSMul",
"Pi.addGroup",
"Matrix",
"SubtractionMonoid.toSubNegZeroMonoid",
"Int",
"SubNegZeroMonoid.toNegZeroClass",
"Nat.cast",
"autoParam",
"AddGroup",
"AddGroup.toSubNegMonoid",
"Nat",
"HSMul.hSMul",
"instNatCastInt",
"Int.neg... | false |
_private.Mathlib.RingTheory.MvPowerSeries.Trunc.0.MvPowerSeries.coeff_trunc'_mul_trunc'_eq_coeff_mul._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Trunc | [
"Nat.instCanonicallyOrderedAdd",
"Finsupp.instLE",
"False",
"Nat.instMulZeroClass",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"Finset",
"Classical.byContradiction",
"Finset.mem_Iic",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"Membership.mem",
"LocallyFiniteOrder.toLoc... | 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 |
_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",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Iff.not",
"Pi.instZero",
"Ne",
"CommSemiring",
"conjneg_eq_zero",
"AddGroup",
"Iff",
"StarRing",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Zero.toOfNat0",
"OfNat.ofNat",
"Semiring.toNonAssocSemiring... | true |
_private.Lean.Elab.Print.0.Lean.Elab.Command.printStructure._sparseCasesOn_3 | Lean.Elab.Print | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... | false |
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 | [
"Multiset.sum",
"Eq.mpr",
"Multiset.map",
"congrArg",
"HEq.refl",
"Finset",
"Multiset.mem_map._simp_1",
"PartialOrder.toPreorder",
"Multiset.instAddCancelCommMonoid",
"Preorder.toLE",
"Disjoint",
"OrderBot",
"Membership.mem",
"Exists",
"PartialOrder",
"Multiset",
"Eq.casesOn",
"Mul... | true |
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 |
Std.Time.DateTime.ofPlainDateTimeAssumingUTC | Std.Time.Zoned.DateTime | [
"Std.Time.Timestamp.ofPlainDateTimeAssumingUTC",
"Std.Time.TimeZone.toSeconds",
"Unit",
"Std.Time.DateTime",
"Thunk.mk",
"Std.Time.TimeZone",
"_private.Std.Time.Zoned.DateTime.0.Std.Time.DateTime.mk",
"Std.Time.Timestamp",
"Std.Time.PlainDateTime",
"Std.Time.PlainDateTime.addSeconds"
] | true |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TuringMachine.Config | [
"Turing.ToPartrec.instDecidableEqCode.decEq",
"DecidableEq",
"Turing.ToPartrec.Code"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.