name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Homotopy.mkInductiveAux₁._proof_2 | Mathlib.Algebra.Homology.Homotopy | [
"PSigma.snd",
"ChainComplex",
"HomologicalComplex.instCategory",
"Nat.instOne",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddCommGroup.toAddCommMonoid",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.instAddCanc... | false |
neg_strictConvexOn_iff | Mathlib.Analysis.Convex.Function | [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"SubtractionMonoid.toInvolutiveNeg",
"neg_lt_neg_iff",
"StrictConcaveOn",
"instHSMul",
"Preorder.toLT",
"Pi.instNeg",
"AddLeftCancel... | true |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_toReal_le._simp_1_2 | Mathlib.Data.EReal.Basic | [
"le_refl",
"Preorder.toLE",
"LE.le",
"True",
"eq_true",
"Eq",
"Preorder"
] | false |
MeasureTheory.MemLp.locallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | [
"Filter.instMembership",
"MeasureTheory.Measure.finiteAt_nhds",
"Eq.mpr",
"MeasureTheory.Measure",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"MeasureTheory.LocallyIntegrable",
"MeasureTheory.Integrable",
"Membership.mem",
"nhds",
"Fact",
"MeasureTheory.Measure.restrict",
"Mea... | true |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.parserDescrHasAtom | Lean.Elab.DocString.Builtin.Keywords | [
"Lean.ParserDescr.brecOn",
"String",
"Lean.ParserDescr",
"_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.parserDescrHasAtom._f",
"Lean.Elab.Term.TermElabM",
"Option"
] | true |
Std.ExtDHashMap.get_map | Std.Data.ExtDHashMap.Lemmas | [
"Std.ExtDHashMap.inner",
"Std.ExtDHashMap.instMembershipOfEquivBEqOfLawfulHashable",
"instLawfulHashableOfLawfulBEq",
"Quot.pliftOn._proof_2",
"LawfulBEq",
"Membership.mem",
"Std.ExtDHashMap.inductionOn",
"Std.ExtDHashMap.mem_of_mem_map",
"Std.ExtDHashMap.mk",
"_private.Std.Data.ExtDHashMap.Basic.... | true |
_private.Mathlib.Data.List.Sort.0.List.«_aux_Mathlib_Data_List_Sort___macroRules__private_Mathlib_Data_List_Sort_0_List_term_≼__1_1» | Mathlib.Data.List.Sort | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Name.mkNum",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.add_right_eq_self | Std.Tactic.BVDecide.Normalize.Equal | [
"Eq.mpr",
"BitVec.add_right_eq_self._simp_1",
"instLawfulBEq",
"congrArg",
"BitVec.instAdd",
"BitVec",
"Bool.eq_iff_iff",
"id",
"instOfNatNat",
"BitVec.ofNat",
"instBEqOfDecidableEq",
"instDecidableEqBitVec",
"iff_self",
"Bool.true",
"instHAdd",
"BEq.beq",
"Iff",
"HAdd.hAdd",
"Na... | true |
Function.HasUncurry.noConfusionType | Mathlib.Logic.Function.Basic | [
"Function.HasUncurry",
"Function.HasUncurry.casesOn",
"HEq"
] | false |
Int.add_neg_mul_fmod_self_left | Init.Data.Int.DivMod.Lemmas | [
"Eq.mpr",
"HMul.hMul",
"Int.neg_mul_eq_mul_neg",
"congrArg",
"Int.add_mul_fmod_self_left",
"id",
"Int.instNegInt",
"Int",
"Int.fmod",
"Int.instMul",
"instHAdd",
"HAdd.hAdd",
"Int.instAdd",
"Eq.refl",
"Eq",
"Neg.neg",
"instHMul"
] | true |
Lean.IR.Arg.var.elim | Lean.Compiler.IR.Basic | [
"PULift.up",
"Lean.IR.Arg.var",
"Lean.IR.Arg",
"Lean.IR.VarId",
"Nat",
"Lean.IR.Arg.ctorIdx",
"Lean.IR.Arg.ctorElim",
"Eq.symm",
"Eq"
] | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_6 | Mathlib.Algebra.Category.ModuleCat.Biproducts | [
"Submodule",
"ModuleCat",
"AddCommGroup.toAddCommMonoid",
"LinearMap.ker",
"CategoryTheory.ShortComplex.moduleCatMkOfKerLERange",
"LinearMap.range",
"AddCommGroup",
"LinearMap",
"CategoryTheory.ShortComplex.Exact",
"ModuleCat.of",
"ModuleCat.moduleCategory",
"CategoryTheory.Preadditive.preaddi... | false |
ENNReal.inv_mul_ne_top | Mathlib.Data.ENNReal.Inv | [
"False",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"CommSemiring.toSemiring",
"ENNReal.mul_inv_ne_top._simp_1",
"Ne",
"CommMagma.toMul",
"NonUnitalCommSemiring.toNonUnitalNonAssocCommSemiring",
"ENNReal.instCommSemiring",
"instDistribOfSemiring",
"Inv.inv",
"Distrib.to... | true |
_private.Mathlib.NumberTheory.Rayleigh.0.Beatty.no_collision._simp_1_7 | Mathlib.NumberTheory.Rayleigh | [
"HMul.hMul",
"Mul",
"instHAdd",
"HAdd.hAdd",
"right_distrib",
"Eq.symm",
"Eq",
"Add",
"instHMul",
"RightDistribClass"
] | false |
UniformOnFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | [
"ENNReal.instCanonicallyOrderedAdd",
"not_exists._simp_1",
"False",
"NNDist.nndist",
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Real.instLE",
"Real",
"ENNReal.ofNNReal",
"Lattice.toSemilatticeSup",
"Equiv.instEquivLike",
"PseudoMetricSpace.toBornology",
"Set.mem_empty_iff_false._simp_1",
... | false |
Subring.instCovariantClassHSMulLe | Mathlib.Algebra.Ring.Subring.Pointwise | [
"CovariantClass.mk",
"Monoid",
"instHSMul",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"Set.image_mono",
"PartialOrder.toPreorder",
"Preorder.toLE",
"RingHom",
"MulSemiringAction.toRingHom",
"LE.le",
"RingHom.instFunLike",
"SetLike.coe",
"Subring",
"Subring.instPartialOrder",
"MulSe... | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.isLimitMapConeOfIsLimitSheafConditionFork._proof_2 | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | [
"CategoryTheory.Functor.op",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.Cone.π",
"TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_obj_π_app",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Q... | false |
Lean.Meta.Sym.AlphaShareCommon.State | Lean.Meta.Sym.AlphaShareCommon | [
"Lean.Meta.Sym.AlphaShareCommon.State.mk"
] | true |
MeasureTheory.IsLocallyFiniteMeasure.casesOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | [
"MeasureTheory.Measure",
"MeasureTheory.IsLocallyFiniteMeasure.rec",
"nhds",
"MeasureTheory.Measure.FiniteAtFilter",
"MeasurableSpace",
"TopologicalSpace",
"MeasureTheory.IsLocallyFiniteMeasure.mk",
"MeasureTheory.IsLocallyFiniteMeasure"
] | false |
lift_rank_add_lift_rank_le_rank_prod | Mathlib.LinearAlgebra.Dimension.Constructions | [
"Nontrivial",
"Eq.mpr",
"LE.le.trans_eq",
"LinearEquiv.prodCongr",
"Cardinal",
"congrArg",
"ULift",
"Cardinal.lift",
"id",
"rank_ulift",
"LE.le",
"Cardinal.instAdd",
"AddCommMonoid",
"Cardinal.instLE",
"instHAdd",
"HAdd.hAdd",
"ULift.module'",
"ULift.moduleEquiv",
"LinearEquiv.ra... | true |
CategoryTheory.Limits.coprod.map_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.HasBinaryCoproduct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.coprod.desc",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryTheory.Limits.coprod.map",
"CategoryTheory.CategoryS... | true |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.collectHeaders.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | [
"String",
"Prod.mk",
"Nat",
"Prod",
"Prod.casesOn"
] | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.instRKHS._proof_2 | Mathlib.Analysis.InnerProductSpace.Reproducing | [
"NormedCommRing.toNormedRing",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"CompleteSpace",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Matr... | false |
Std.Internal.List.getValue?_filter_containsKey_of_containsKey_eq_false_right | Std.Data.Internal.List.Associative | [
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"congrArg",
"Std.Internal.List.List.getValue?_filter_containsKey",
"Bool.false_eq_true",
"id",
"instDecidableEqBool",
"Sigma.fst",
"Bool.true",
"Option.none",
"List",
"Std.Internal.List.containsKey",
"EquivBEq",
"Std.Internal.List.getValue?",
"... | true |
Option.elim | Init.Data.Option.Basic | [
"Option.elim.match_1",
"Option"
] | true |
CategoryTheory.Functor.CoreMonoidal.μIso_hom_natural_left._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
SSet.Augmented.stdSimplex._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | [
"CategoryTheory.Limits.hasFiniteLimits_of_hasLimits",
"Eq.mpr",
"CategoryTheory.Comma.right",
"Opposite",
"SSet.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.SimplicialObject.const",
"CategoryTheory.CommaMorph... | false |
MeasureTheory.«term__[_|_]» | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | [
"Lean.ParserDescr.trailingNode",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr.unary",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.Name.mkStr2",
"Lean.ParserDescr.const",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Lean.TrailingParserDescr"
] | true |
Option.not_lt_pfilter | Init.Data.Option.Lemmas | [
"Eq.mpr",
"False",
"Decidable.casesOn",
"Option.pfilter",
"eq_false",
"congrArg",
"Option.casesOn",
"Decidable",
"Option.pfilter_none",
"Option.some",
"id",
"instDecidableEqBool",
"instLTOption",
"if_pos",
"Option.some_lt_some._simp_1",
"Bool.true",
"Option.none",
"LT.lt",
"True"... | true |
_private.Mathlib.Data.Matrix.Cartan.0.CartanMatrix.D_off_diag_nonpos._proof_1_5 | Mathlib.Data.Matrix.Cartan | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.LinearCombo.eval",
"Option.some",
"id",
"instDecidableEqBool",
"Int.instNegInt",
"Int.sub_nonneg_of_le",
"Int",
"... | false |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.match_1 | Lean.Elab.Syntax | [
"Prod.mk",
"Lean.Syntax.Term",
"Nat",
"Prod",
"Prod.casesOn",
"Option"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.degree_eq_zero._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Finite | [
"SimpleGraph.neighborFinset",
"SimpleGraph.neighborSet",
"Set.Elem",
"SimpleGraph",
"SimpleGraph.card_neighborFinset_eq_degree",
"Fintype",
"Nat",
"Finset.card",
"SimpleGraph.degree",
"Eq.symm",
"Eq"
] | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.Cartan.0.ValueDistribution.log_trailingCoeff_eq_zero_on_unitSphere | Mathlib.Analysis.Complex.ValueDistribution.Cartan | [
"Real.instIsOrderedRing",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"meromorphicOrderAt_const",
"False",
"Decidable.casesOn",
"Real",
"Preorder.toLT",
"instConditionallyCompleteLinearOrd... | true |
Language.mem_one._simp_1 | Mathlib.Computability.Language | [
"Language.instOne",
"Language.mem_one",
"Membership.mem",
"List",
"propext",
"One.toOfNat1",
"Language.instMembershipList",
"Language",
"OfNat.ofNat",
"Eq",
"List.nil"
] | false |
LeftInvariantDerivation.instCoeDerivationContMDiffMapModelWithCornersSelfSomeENatTop._proof_2 | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | [
"chartedSpaceSelf",
"instContMDiffAddSelf",
"instTopENat",
"AddCommGroup.toAddCommMonoid",
"PseudoMetricSpace.toUniformSpace",
"NormedCommRing.toNonUnitalNormedCommRing",
"WithTop.some",
"NonUnitalNormedRing.toNormedAddCommGroup",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"ENat",
"NonUnitalN... | false |
Std.DTreeMap.Internal.Impl.contains | Std.Data.DTreeMap.Internal.Queries | [
"Ord",
"Std.DTreeMap.Internal.Impl.contains._f",
"Std.DTreeMap.Internal.Impl.brecOn",
"Bool",
"Std.DTreeMap.Internal.Impl"
] | true |
SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | [
"CategoryTheory.Category.assoc",
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_3",
"SimplexCategory.Truncated.δ₂",
"SimplexCategory.Truncated.δ₂_zero_comp_σ₂_one._proof_4",
... | true |
Lean.Order.SeqLeft.monotone_seqLeft | Init.Internal.Order.Lemmas | [
"Applicative.toSeqLeft",
"Eq.mpr",
"congrArg",
"Monad.toApplicative",
"Lean.Order.Functor.monotone_map",
"Lean.Order.Seq.monotone_seq",
"id",
"LawfulMonad",
"Seq.seq",
"funext",
"Unit",
"SeqLeft.seqLeft",
"Lean.Order.PartialOrder",
"Function.const",
"Applicative.toFunctor",
"Monad.toBi... | true |
AddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | [
"AddSemigroup",
"AddSemigroupAction.mk"
] | true |
CategoryTheory.Functor.mapAddGrpFunctor._proof_2 | Mathlib.CategoryTheory.Monoidal.Grp | [
"CategoryTheory.Functor.Monoidal.ofChosenFiniteProducts",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.instPreservesFiniteProductsOfPreservesFiniteLimits",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.leftExactFunctor",
"Cat... | false |
PrimitiveSpectrum.gc | Mathlib.Topology.Order.HullKernel | [
"Iff.mpr",
"OrderDual.toDual",
"sSup_le_iff._simp_2",
"Equiv.instEquivLike",
"Set.Ici",
"PrimitiveSpectrum.hull",
"OrderDual.ofDual",
"Iff.of_eq",
"congrArg",
"Set.mem_image._simp_1",
"PartialOrder.toPreorder",
"Subtype.forall._simp_1",
"Preorder.toLE",
"Set.mem_Iic._simp_2",
"Membership... | true |
TopCat.instCommRingHomObjTopCommRingCatForget₂SubtypeRingHomαContinuousCoeContinuousMapCarrier._proof_11 | Mathlib.Topology.Sheaves.CommRingCat | [
"Continuous",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommSemiring.toSemiring",
"CategoryTheory.ConcreteCategory.hom",
"TopCommRingCat.instConcreteCategorySubtypeRingHomαContinuousCoe",
"TopCat.instCategory",
"ContinuousMap",
"TopCommRingCat.instCategory",
"RingHom",
"CategoryTh... | false |
SeparationQuotient.instNonUnitalnonAssocSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | [
"IsTopologicalSemiring",
"IsTopologicalSemiring.toContinuousMul",
"SeparationQuotient.instMul",
"SeparationQuotient.instNonUnitalnonAssocSemiring._proof_1",
"SeparationQuotient.instNonUnitalnonAssocSemiring._proof_4",
"NonUnitalNonAssocSemiring.mk",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Topolo... | true |
ONote.mul.eq_def | Mathlib.SetTheory.Ordinal.Notation | [
"ONote.brecOn.go",
"Eq.mpr",
"False",
"ONote.mul",
"ONote.rec",
"ONote.below",
"HMul.hMul",
"ONote.instAdd",
"congrArg",
"ONote.oadd",
"ONote.instZero",
"ONote.mul._f",
"id",
"ONote.zero",
"instMulPNat",
"instHAdd",
"_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.sub.match_3.spl... | true |
AddSubmonoid.LocalizationMap.ofAddEquivOfLocalizations.match_3 | Mathlib.GroupTheory.MonoidLocalization.Maps | [
"AddMonoid.toAddZeroClass",
"Exists",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"Exists.casesOn",
"Exists.intro",
"AddEquiv",
"AddZero.toAdd",
"AddCommMonoid.toAddMonoid",
"AddEquiv.instEquivLike",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | false |
AddSubgroup.closure_le_centralizer_centralizer | Mathlib.GroupTheory.Subgroup.Centralizer | [
"Iff.mpr",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"HasSubset.Subset",
"LE.le",
"AddSubgroup",
"AddSubgroup.centralizer",
"AddGroup",
"AddGroup.toSubNegMonoid",
"SetLike.coe",
"AddSubgroup.instSetLike... | true |
Batteries.AssocList.mapKey.eq_2 | Batteries.Data.AssocList | [
"Batteries.AssocList.mapKey",
"Batteries.AssocList",
"Batteries.AssocList.cons",
"Eq.refl",
"Eq"
] | true |
Aesop.AddRapp.mk.injEq | Aesop.Tree.AddRapp | [
"Eq.propIntro",
"Lean.injEq_helper",
"Aesop.GoalRef",
"And",
"Aesop.AddRapp.mk",
"Aesop.AddRapp",
"Aesop.RuleApplication",
"Eq.ndrec",
"Aesop.AddRapp.mk.inj",
"Eq.refl",
"Aesop.Percent",
"Aesop.RegularRule",
"Eq"
] | true |
Lean.Meta.abstractProof | Lean.Meta.AbstractNestedProofs | [
"Pure.pure",
"Bool.not",
"ReaderT",
"Monad.toApplicative",
"Lean.withoutExporting",
"Lean.Meta.State",
"instMonadLiftT",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Bool.and",
"EIO",
"liftM",
"ReaderT.instMonadLift",
"MonadLiftT",
"Applicative.toPure",
"Bool.true",
"Option.non... | true |
Finset.consPiProd_fst | Mathlib.Data.Finset.Insert | [
"Finset.cons",
"Finset",
"Membership.mem",
"Prod.fst",
"Finset.instSetLike",
"Eq.refl",
"Eq",
"Finset.mem_cons_self",
"Finset.consPiProd",
"Not",
"SetLike.instMembership"
] | true |
normGroupNorm | Mathlib.Analysis.Normed.Group.Basic | [
"GroupNorm",
"NormedGroup",
"SeminormedGroup.toGroup",
"GroupSeminorm",
"NormedGroup.toGroup",
"normGroupNorm._proof_1",
"NormedGroup.toSeminormedGroup",
"normGroupSeminorm",
"GroupNorm.mk"
] | true |
Submodule.injective_tensorToSpan | Mathlib.LinearAlgebra.Span.TensorProduct | [
"Eq.mpr",
"Submodule",
"Submodule.module._proof_1",
"LinearMap.restrictScalars",
"Algebra.to_smulCommClass",
"instHSMul",
"Module.Flat.lTensor_preserves_injective_linearMap",
"Semiring.toModule",
"instSMulOfMul",
"Submodule.injective_inclusionSpan",
"IsScalarTower.right",
"LinearMap.ext",
"c... | true |
Subspace.dualLift_injective | Mathlib.LinearAlgebra.Dual.Lemmas | [
"Function.LeftInverse.injective",
"Submodule",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"Membership.mem",
"Subspa... | true |
Finmap.instDecidableMem | Mathlib.Data.Finmap | [
"decidable_of_iff",
"Finmap.instMembership",
"Decidable",
"Membership.mem",
"instDecidableEqBool",
"Finmap.lookup",
"Bool.true",
"Finmap.lookup_isSome",
"Bool",
"Option.isSome",
"Eq",
"Finmap",
"DecidableEq"
] | true |
Aesop.Safety.ctorIdx | Aesop.Rule | [
"Aesop.Safety.casesOn",
"Aesop.Safety",
"Nat"
] | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.merge? | Lean.Elab.Tactic.Try | [
"Lean.TSyntax",
"_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mergeSimp?",
"_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mergeGrind?",
"Lean.TSyntax.raw",
"instDecidableEqBool",
"Lean.Syntax.getKind",
"List.cons",
"Bool.true",
"Option.none",
"BEq.beq",
"Bool",
"Lean.SyntaxNodeK... | true |
PrimeMultiset.coeNat | Mathlib.Data.PNat.Factors | [
"Multiset",
"Coe.mk",
"Nat",
"Coe",
"PrimeMultiset",
"PrimeMultiset.toNatMultiset"
] | true |
Module.End.invtSubmodule.instBoundedOrderSubtypeSubmoduleMemSublattice | Mathlib.Algebra.Module.Submodule.Invariant | [
"Sublattice",
"Submodule",
"Submodule.completeLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"Subtype",
"Submodule.instPartialOrder",
"Bot.bot",
"Submodule.instTop",
"Top.mk",
"OrderTop.mk",
"AddCommMonoid",
"Subt... | true |
_private.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux.match_4 | Lean.Meta.FunInfo | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Array",
"Nat",
"_private.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux._sparseCasesOn_1",
"Option"
] | false |
Polynomial.evalEval_surjective | Mathlib.Algebra.Polynomial.Bivariate | [
"Polynomial.CC",
"Polynomial.evalEval_CC",
"Polynomial",
"Polynomial.evalEval",
"Polynomial.semiring",
"Exists.intro",
"Semiring",
"Eq",
"Function.Surjective"
] | true |
Nat.shiftRight_succ_inside | Init.Data.Nat.Lemmas | [
"instHDiv",
"Nat.shiftRight_succ_inside._f",
"Nat.brecOn",
"HDiv.hDiv",
"instOfNatNat",
"instHShiftRightOfShiftRight",
"instHAdd",
"Nat.instShiftRight",
"HAdd.hAdd",
"HShiftRight.hShiftRight",
"Nat",
"Nat.instDiv",
"instAddNat",
"OfNat.ofNat",
"Eq"
] | true |
Std.DTreeMap.getKeyD_maxKeyD | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.isEmpty",
"Std.DTreeMap.maxKeyD",
"Ord.mk",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.Internal.Impl.getKeyD_maxKeyD",
"Std.DTreeMap.wf",
"Bool",
"Bool.false",
"Eq",
"Std.DTreeMap.getKeyD"
] | true |
_private.Mathlib.Computability.DFA.0.DFA.accepts_reindex._simp_1_1 | Mathlib.Computability.DFA | [
"Membership.mem",
"List",
"DFA.accept",
"DFA.accepts",
"propext",
"DFA.eval",
"Language.instMembershipList",
"Language",
"DFA",
"Eq",
"Set.instMembership",
"DFA.mem_accepts",
"Set"
] | false |
DirectSum.id._proof_5 | Mathlib.Algebra.DirectSum.Basic | [
"Inhabited.default",
"instAddCommMonoidDirectSum",
"Unique",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.id",
"AddZeroClass.toAddZero",
"DirectSum.id._proof_2",
"DirectSum.id._proof_4",
"AddCommMonoid",
"decidableEq_of_subsingleton",
"DirectSum.id._proof_1",
"Unique.instSubsingleton",
"DirectS... | false |
Valuation.IsRankOneDiscrete.generator_zpowers_eq_valueGroup | Mathlib.RingTheory.Valuation.Discrete.Basic | [
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Exists.choose_spec",
"Preorder.toLT",
"ValuationClass.toMonoidWithZeroHomClass",
"PartialOrder.toPreorder",
"LinearOrderedCommMonoidWithZero.toLinearOrder",
"SemilatticeInf.toPartialOrder",
"Units"... | true |
Std.Http.Status.isError | Std.Internal.Http.Data.Status | [
"instDecidableEqBool",
"Std.Http.Status",
"Std.Http.Status.isServerError",
"Bool.true",
"Bool",
"Or",
"Decidable.decide",
"Eq",
"instDecidableOr",
"Std.Http.Status.isClientError"
] | true |
CategoryTheory.AbelianOfAdjunction.hasKernels | Mathlib.CategoryTheory.Abelian.Transfer | [
"CategoryTheory.Abelian.toPreadditive",
"Eq.mpr",
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesFiniteLimits",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.NatIso.naturality_1",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"CategoryTheory.Limits.P... | true |
equicontinuous_iInf_rng | Mathlib.Topology.UniformSpace.Equicontinuity | [
"UniformSpace",
"Eq.mpr",
"Equicontinuous",
"iInf",
"Continuous",
"Equiv.instEquivLike",
"congrArg",
"Function.swap",
"Iff.rfl",
"continuous_iInf_rng",
"Function.comp",
"CompleteLattice.toConditionallyCompleteLattice",
"TopologicalSpace.instCompleteLattice",
"inferInstance",
"id",
"Equ... | true |
Lean.ModuleIdx.toNat | Lean.Environment | [
"Lean.ModuleIdx",
"Nat"
] | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet.0.«term_~ᵤ_» | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | [
"Lean.Name.mkNum",
"Lean.Name.mkStr",
"Lean.ParserDescr.trailingNode",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.Name.anonymous",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Lean.TrailingParserDescr"
] | true |
CategoryTheory.Lax.OplaxTrans.Modification.mk.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | [
"CategoryTheory.Lax.OplaxTrans.naturality",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Lax.OplaxTrans.instCategoryStructLaxFunctor",
"CategoryTheory.Bicategory.whiskerRight",
"CategoryTheory.Lax.OplaxTrans.app",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory... | true |
LieDerivation.ofGradingSum._proof_3 | Mathlib.Algebra.Lie.Graded | [
"LieAlgebra.toModule",
"Submodule",
"CommRing",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"lieAlgebraSelfModule",
"Membership.mem",
"Subtype",
"DirectSum.instLieRingSubtypeMemSubmodule",
"AddCommMonoid",
"LieRing",
"Comm... | false |
NonUnitalSubring.mem_inf._simp_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | [
"NonUnitalNonAssocRing",
"NonUnitalSubring.instSetLike",
"NonUnitalSubring.mem_inf",
"NonUnitalSubring",
"Membership.mem",
"NonUnitalSubring.instMin",
"And",
"propext",
"Eq",
"SetLike.instMembership",
"Min.min"
] | false |
Std.ExtDHashMap.Const.getKey?_alter_self | Std.Data.ExtDHashMap.Lemmas | [
"Std.ExtDHashMap.Const.alter",
"Option.some",
"instDecidableEqBool",
"Std.ExtDHashMap.inductionOn",
"Std.DHashMap.Const.getKey?_alter_self",
"LawfulHashable",
"Std.ExtDHashMap.getKey?",
"Bool.true",
"Option.none",
"EquivBEq",
"Std.ExtDHashMap",
"Bool",
"Hashable",
"Option.isSome",
"BEq",... | true |
Vector.findSome?_singleton | Init.Data.Vector.Find | [
"congrArg",
"List.findSome?_toArray",
"instOfNatNat",
"List.findSome?_singleton",
"List.toArray",
"List.cons",
"Vector.findSome?",
"Array.findSome?",
"List.findSome?",
"Vector.mk",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Eq",
"Array.size",
"rfl",
"E... | true |
conditionallyCompleteLatticeOfsSup._proof_3 | Mathlib.Order.ConditionallyCompleteLattice.Defs | [
"isLUB_lowerBounds",
"Set.insert_nonempty",
"Lattice.ofIsLUBofIsGLB",
"Lattice.toSemilatticeSup",
"lowerBounds",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Set.instSingletonSet",
"Insert.insert",
"SupSet",
"BddAbove",
"Set.Nonempty",
"Set.instInsert",
"IsGLB",
"IsLUB"... | false |
Plausible.Testable.ctorIdx | Plausible.Testable | [
"Plausible.Testable",
"Nat"
] | false |
Submodule.moduleSet._proof_6 | Mathlib.Algebra.Algebra.Operations | [
"Eq.mpr",
"Submodule",
"Submodule.instAddCommMonoidWithOne",
"SetSemiring.down",
"instHSMul",
"Equiv.instEquivLike",
"HMul.hMul",
"IsScalarTower.right",
"congrArg",
"CommSemiring.toSemiring",
"instIsBotZeroClass",
"SetSemiring.instIdemSemiringOfMonoid",
"AddMonoid.toAddZeroClass",
"Partial... | false |
_private.Lean.Shell.0.Lean.versionHeader | Lean.Shell | [
"Unit.unit",
"instDecidableNot",
"Lean.githash",
"String",
"Ne",
"Id.run",
"Id",
"ToString.toString",
"instAppendString",
"instHAppendOfAppend",
"_private.Lean.Shell.0.Lean.Internal.getBuildType",
"PUnit",
"instDecidableEqString",
"PUnit.unit",
"_private.Lean.Shell.0.Lean.shortVersionStr... | true |
DomAddAct.instVAddCommClassForall | Mathlib.GroupTheory.GroupAction.DomAct.Basic | [
"Pi.instVAdd",
"DomAddAct.instVAddForall",
"VAddCommClass.mk",
"VAdd",
"DomAddAct",
"HVAdd.hVAdd",
"instHVAdd",
"VAddCommClass",
"rfl"
] | true |
CategoryTheory.CommSq.LiftStruct.l | Mathlib.CategoryTheory.CommSq | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CommSq",
"CategoryTheory.CommSq.LiftStruct",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Category"
] | true |
Mathlib.Tactic._aux_Mathlib_Tactic_DefEqTransformations___elabRules_Mathlib_Tactic_tacticReduce___1 | Mathlib.Tactic.DefEqTransformations | [
"Lean.TSyntax",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Meta.State",
"Lean.Syntax.isOfKind",
"Lean.Elab.Tactic.Context",
"Lean.TSyntax.mk",
"Lean.Syntax",
"Lean.Name.mkStr3",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.FVarId",
"instDecidableEqBool",
"instOfNatNat",
"Lean... | false |
Lean.PrettyPrinter.Delaborator.delabAppExplicitCore | Lean.PrettyPrinter.Delaborator.Builtins | [
"Pure.pure",
"List.head?",
"_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabAppExplicitCore.match_3",
"Unit.unit",
"Array.mkEmpty",
"Lean.MonadRef.mkInfoFromRefPos",
"Option.instDecidableEq",
"Bool.not",
"Lean.PrettyPrinter.Delaborator.getPPOption",
"Lean.Pre... | true |
Polynomial.card_support_trinomial | Mathlib.Algebra.Polynomial.Coeff | [
"Eq.mpr",
"Polynomial.C",
"Finset.mem_singleton",
"Polynomial.support_trinomial",
"HMul.hMul",
"congrArg",
"Finset",
"RingHom",
"Membership.mem",
"mt",
"id",
"Insert.insert",
"Finset.mem_insert",
"Ne",
"instOfNatNat",
"Polynomial.instAdd",
"not_or_intro",
"Finset.card_insert_of_not... | true |
exists_eq_smul_of_parallel | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | [
"AddGroup.toSubtractionMonoid",
"Units.val",
"Eq.mpr",
"NegZeroClass.toNeg",
"Submodule",
"AffineSubspace.affineSpan_pair_parallel_iff_exists_unit_smul'",
"direction_affineSpan",
"SubtractionMonoid.toInvolutiveNeg",
"Submodule.addSubgroupClass",
"neg_mem_iff",
"instHSMul",
"instSMulOfMul",
"... | true |
Function.support_comp_eq_preimage | Mathlib.Algebra.Notation.Support | [
"Function.comp",
"Set.preimage",
"Function.support",
"Eq",
"rfl",
"Zero",
"Set"
] | true |
MeasureTheory.L1.integral_eq' | Mathlib.MeasureTheory.Integral.Bochner.L1 | [
"NormedCommRing.toNormedRing",
"Eq.mpr",
"Real",
"MeasureTheory.Measure",
"Continuous",
"CompleteSpace",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"NormedSpace",
"congrArg",
"NormedAddCommGroup.toMetricSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Mea... | true |
RegularExpression.matches'_zero | Mathlib.Computability.RegularExpressions | [
"RegularExpression",
"Language.instZero",
"RegularExpression.instZero",
"RegularExpression.matches'",
"Zero.toOfNat0",
"Language",
"OfNat.ofNat",
"Eq",
"rfl"
] | true |
SheafOfModules.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"instSizeOfDefault",
"SheafOfModules.val",
"PresheafOfModules.instCategory",
"CategoryTheory.ObjectProperty.FullSubcategory.obj",
"instOfNatNat",
"RingCat",
"instHAd... | false |
_private.Mathlib.RingTheory.Frobenius.0.AlgHom.IsArithFrobAt.isArithFrobAt_localize._simp_1_3 | Mathlib.RingTheory.Frobenius | [
"Submodule.Quotient.instZeroQuotient",
"Semiring.toModule",
"Ideal.Quotient.mk",
"RingHom",
"Membership.mem",
"Ideal.IsTwoSided",
"Ideal",
"Ideal.Quotient.eq_zero_iff_mem",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"HasQuotient.Quotient",
"Ideal.Quotient.ring",
"RingHom.instFunLike",
"Ide... | false |
CategoryTheory.Pseudofunctor.hasCoeToOplax | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | [
"Coe.mk",
"CategoryTheory.Bicategory",
"CategoryTheory.Pseudofunctor",
"CategoryTheory.OplaxFunctor",
"CategoryTheory.Pseudofunctor.toOplax",
"Coe"
] | true |
AddMonCat.coe_of | Mathlib.Algebra.Category.MonCat.Basic | [
"AddMonCat.of",
"AddMonoid",
"AddMonCat.carrier",
"Eq",
"rfl"
] | true |
_private.Lean.Environment.0.Lean.mkIRData | Lean.Environment | [
"Inhabited.default",
"Lean.EnvironmentHeader.isModule",
"Lean.Environment.header",
"Array",
"Bool.true",
"_private.Lean.Environment.0.Lean.exportIREntries",
"Lean.EnvironmentHeader",
"Lean.OLeanLevel.private",
"Lean.EnvironmentHeader.imports",
"Array.instInhabited",
"Lean.ModuleData.mk",
"Lean... | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.alterKey.eq_1 | Std.Data.DHashMap.Internal.WF | [
"Std.Internal.List.getValueCast?",
"LawfulBEq",
"Std.Internal.List.insertEntry",
"Std.Internal.List.eraseKey",
"List",
"Unit",
"Std.Internal.List.alterKey",
"Eq.refl",
"BEq",
"Eq",
"Sigma",
"_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.alterKey.match_1",
"Option"
] | true |
LocallyFiniteOrder.ofOrderIsoClass | Mathlib.Order.Interval.Finset.Defs | [
"LocallyFiniteOrder.ofOrderIsoClass._proof_1",
"LocallyFiniteOrder.ofOrderIsoClass._proof_6",
"Preorder.toLE",
"Finset.map",
"Function.Embedding.mk",
"LocallyFiniteOrder.finsetIco",
"LocallyFiniteOrder.ofOrderIsoClass._proof_8",
"OrderIsoClass",
"EquivLike",
"LocallyFiniteOrder.finsetIoo",
"Loca... | true |
_private.Mathlib.Data.Finset.Basic.0.Multiset.toFinset_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | [
"Finset",
"Ne",
"Finset.nonempty_iff_ne_empty",
"Finset.instEmptyCollection",
"propext",
"Finset.Nonempty",
"EmptyCollection.emptyCollection",
"Eq"
] | false |
CategoryTheory.Limits.reflectsCofilteredLimitsOfSize_of_univLE | Mathlib.CategoryTheory.Limits.Preserves.Filtered | [
"CategoryTheory.Functor",
"UnivLE",
"CategoryTheory.IsCofiltered",
"CategoryTheory.Shrink.instCategoryShrink",
"CategoryTheory.Equivalence",
"CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.mk",
"CategoryTheory.Limits.reflectsLimitsOfShape_of_equiv",
"UnivLE.small",
"CategoryTheory.locallySmall... | true |
CategoryTheory.ShortComplex.homologyFunctorOpNatIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"Opposite",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.HasHomology",
"CategoryTheory.ShortComplex.instHasHomologyOppositeOp",
"CategoryTheory.ShortComplex.op",
"CategoryTheory.CategoryWithHomology.hasHomology",
"CategoryTheory.Category.opposit... | false |
SimpleGraph.induceHom | Mathlib.Combinatorics.SimpleGraph.Maps | [
"RelHom.instFunLike",
"SimpleGraph.Adj",
"Set.Elem",
"SimpleGraph",
"Set.MapsTo",
"SimpleGraph.induce",
"SimpleGraph.Hom",
"RelHom.mk",
"Set.MapsTo.restrict",
"DFunLike.coe",
"SimpleGraph.induceHom._proof_1",
"Set"
] | true |
_private.Mathlib.NumberTheory.LSeries.MellinEqDirichlet.0.hasSum_mellin_pi_mul_sq'._simp_1_5 | Mathlib.NumberTheory.LSeries.MellinEqDirichlet | [
"False",
"eq_false",
"pow_ne_zero",
"Ne",
"Monoid.toPow",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"Zero.toOfNat0",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq",
"MonoidWithZero.toMonoid",
"MulZeroClass.toZero",
"IsReduced"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.