name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
ENNReal.ofReal_eq_zero._simp_1 | Mathlib.Data.ENNReal.Real | [
"Real.instLE",
"Real",
"ENNReal.ofReal_eq_zero",
"Real.instZero",
"ENNReal.ofReal",
"LE.le",
"ENNReal",
"propext",
"Zero.toOfNat0",
"ENNReal.instZero",
"OfNat.ofNat",
"Eq"
] | false |
CategoryTheory.Mon.mkIso'_inv_hom | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Mon.mkIso'",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Mon.Hom.hom",
"CategoryTheory.IsMonHom",
"CategoryTheory.Iso",
"CategoryTheory.Mon",
"CategoryTheory.Mon.instCategory",
"Eq.refl",
"CategoryTheory.Category.toCa... | true |
divp.eq_1 | Mathlib.Algebra.Group.Units.Defs | [
"Monoid",
"Units.val",
"HMul.hMul",
"Monoid.toMulOneClass",
"Units",
"MulOne.toMul",
"divp",
"MulOneClass.toMulOne",
"Inv.inv",
"Eq.refl",
"Eq",
"Units.instInv",
"instHMul"
] | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsCyclotomicExtension.Rat.isIntegralClosure_adjoin_singleton._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | [
"SetLike",
"Membership.mem",
"SetLike.coe",
"SetLike.mem_coe",
"propext",
"Eq.symm",
"Eq",
"Set.instMembership",
"SetLike.instMembership",
"Set"
] | false |
_private.Mathlib.Analysis.Polynomial.CauchyBound.0.Polynomial.IsRoot.norm_lt_cauchyBound._simp_1_5 | Mathlib.Analysis.Polynomial.CauchyBound | [
"False",
"eq_false",
"instOfNatNat",
"two_ne_zero",
"Nat",
"Zero.toOfNat0",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
TensorProduct.directLimitLeft._proof_1 | Mathlib.LinearAlgebra.TensorProduct.DirectLimit | [
"LinearMap.id",
"TensorProduct.toDirectLimit",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"TensorProduct.addCommMonoid",
"Module.DirectLimit.of",
"Module.DirectLimit.module",
"LinearMap.instFunLike",
"Preorder.toLE",
"RingHomInvPair.triples₂",
"LE.le",
"Module.DirectLimit.hom_ex... | false |
Lean.Lsp.CompletionParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.CompletionParams.mk",
"Lean.Lsp.TextDocumentPositionParams",
"Lean.Lsp.CompletionParams.mk.noConfusion",
"Eq",
"Lean.Lsp.CompletionParams"
] | true |
_private.Mathlib.Tactic.ModCases.0.Mathlib.Tactic.ModCases.NatMod.onModCases_succ.match_1 | Mathlib.Tactic.ModCases | [
"LE.le",
"instLENat",
"And.casesOn",
"And",
"Nat.ModEq",
"Nat",
"And.intro",
"LT.lt",
"instLTNat"
] | false |
AddCommGrpCat.factorThruImage | Mathlib.Algebra.Category.Grp.Images | [
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"AddMonoidHom.range",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Subtype",
"AddCommGrpCat.carrier",
"AddSubgroup",
"AddMonoidHom.rangeRestrict",
"AddCommGrpCat",
"AddSubgroup.instSetLike",
"AddCommGrpCat... | true |
Real.Angle.cos_eq_iff_coe_eq_or_eq_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | [
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Int.cast",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.toNeg",
"False",
"Semigroup.toMul",
"Real",
"instHSMul",
"instHDiv",
"NonUnitalCommRing.toNonUnita... | true |
NonemptyChain.isChain' | Mathlib.Order.BourbakiWitt | [
"LE.le",
"LE",
"IsChain",
"NonemptyChain.carrier",
"NonemptyChain"
] | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.ctorIdx | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | [
"Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State",
"Nat"
] | false |
Fin.castAdd | Init.Data.Fin.Basic | [
"Fin.castLE",
"Nat.le_add_right",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Fin"
] | true |
SubMulAction.instCompleteLattice._proof_3 | Mathlib.GroupTheory.GroupAction.SubMulAction | [
"SubMulAction.instSetLike",
"Preorder.toLT",
"SMul",
"Iff.rfl",
"PartialOrder.toPreorder",
"CompleteLattice.toCompleteSemilatticeInf",
"CompleteSemilatticeInf.toPartialOrder",
"Iff",
"SetLike.coe",
"LT.lt",
"CompleteBooleanAlgebra.toCompleteLattice",
"SubMulAction",
"CompleteAtomicBooleanAlg... | false |
Std.DTreeMap.Raw.get?_union | Std.Data.DTreeMap.Raw.Lemmas | [
"Std.DTreeMap.Raw.get?",
"Std.DTreeMap.Raw.instUnion",
"Ord.mk",
"Ordering",
"id",
"Option.or",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.LawfulEqCmp",
"Std.DTreeMap.Raw.inner",
"Std.DTreeMap.Internal.Impl.get?_union!",
"Union.union",
"Eq",
"Std.DTreeMap.Raw.WF",
"Option",
"Std.D... | true |
LinearMap.BilinForm.nonDegenerateFlip_iff | Mathlib.LinearAlgebra.BilinearForm.Properties | [
"LinearMap.BilinForm.nondegenerate_flip_iff",
"LinearMap.BilinForm",
"CommSemiring.toSemiring",
"AddCommMonoid",
"CommSemiring",
"Iff",
"LinearMap.BilinForm.Nondegenerate",
"Module",
"LinearMap.BilinForm.flip"
] | true |
MulAction.stabilizerEquivStabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Basic | [
"MulAction.stabilizerEquivStabilizer",
"MulAction.stabilizerEquivStabilizer._proof_1",
"instHSMul",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"MonoidHom",
"Subgroup.map",
"Monoid.toMulOneClass",
"MulAut.instGroup",
"MulEquiv.trans",
"Subgroup.mul",
"Group",
"MulEquiv.subgroupMap",
... | true |
CategoryTheory.Limits.Fork.op_unop_ι | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | [
"CategoryTheory.Limits.Cofork.unop",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"Quiver.Hom.op",
"Quiver.Hom.unop",
"CategoryTheory.Limits.walkingParallelPairHomCategory",
"CategoryTheory.Limits.Fork",
"CategoryThe... | true |
Lean.MessageData.Exprs.casesOn | Mathlib.Lean.MessageData.ForExprs | [
"Lean.MessageData",
"Lean.MessageData.Exprs.mk",
"Lean.MessageData.Exprs.rec",
"Lean.MessageData.Exprs"
] | false |
CategoryTheory.Bicategory.leftZigzagIso | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.whiskerLeftIso",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.BicategoricalCoherence.whiskerRight",
"CategoryTheory.Bicategory",
"CategoryTheo... | true |
Int.Linear.cooper_dvd_right_split_ineq_cert.eq_1 | Init.Data.Int.Linear | [
"Bool.and'",
"HMul.hMul",
"Int.Linear.Poly.leadCoeff",
"Int.Linear.Poly.beq'",
"Int.instNegInt",
"Int",
"Int.instMul",
"Int.Linear.cooper_dvd_right_split_ineq_cert",
"Int.beq'",
"Int.Linear.Poly.addConst_k",
"Int.Linear.Poly.tail",
"Bool",
"Int.Linear.Poly.combine_mul_k",
"Eq.refl",
"Eq"... | true |
LinearIsometry.submoduleMap._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | [
"RingHomSurjective.ids",
"RingHomSurjective",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Ring.toSemiring",
"Ring"
] | false |
Lean.Linter.MissingDocs.lintField | Lean.Linter.MissingDocs | [
"Lean.Syntax.getId",
"String",
"Lean.Syntax",
"ToString.toString",
"instAppendString",
"instHAppendOfAppend",
"Unit",
"Lean.Linter.MissingDocs.lint",
"Lean.Name.instToString",
"Lean.Name",
"Lean.Elab.Command.CommandElabM",
"HAppend.hAppend",
"instToStringString"
] | true |
ZNum.zneg_pos | Mathlib.Data.Num.ZNum | [
"ZNum.pos",
"ZNum",
"ZNum.instNeg",
"PosNum",
"ZNum.neg",
"Eq",
"Neg.neg",
"rfl"
] | true |
List.foldlM_filterMap | Init.Data.List.Monadic | [
"Pure.pure",
"Eq.mpr",
"List.foldlM",
"congrArg",
"List.foldlM_cons",
"Monad.toApplicative",
"Option.casesOn",
"Option.some",
"id",
"LawfulMonad",
"List.rec",
"List.filterMap.match_1",
"Applicative.toPure",
"List.cons",
"funext",
"Option.none",
"List",
"List.foldlM_filterMap.match_... | true |
Std.ExtTreeMap.getElem?_eq_some_getD | Std.Data.ExtTreeMap.Lemmas | [
"Option.some",
"Membership.mem",
"Ordering",
"Std.ExtTreeMap.getD",
"Std.ExtDTreeMap.Const.get?_eq_some_getD",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Std.ExtTreeMap.instGetElem?Mem",
"Std.ExtTreeMap.instMembershipOfTransCmp",
"GetElem?.getElem?",
"Eq",
"Option"
] | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.norm_jacobiTheta₂_term_fderiv_ge._simp_1_1 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | [
"le_refl",
"Preorder.toLE",
"LE.le",
"True",
"eq_true",
"Eq",
"Preorder"
] | false |
Std.Iterators.HetT.prun | Std.Data.Iterators.Lemmas.Equivalence.HetT | [
"Std.Iterators.HetT.operation",
"Std.Iterators.HetT.small",
"Std.Iterators.HetT.Property",
"Subtype",
"Std.Iterators.HetT",
"Std.Internal.USquash",
"Std.Internal.USquash.inflate",
"Monad.toBind",
"Bind.bind",
"Monad",
"Subtype.val",
"Std.Iterators.HetT.pmap._proof_4"
] | true |
RCLike.copy_of_normedField._proof_14 | Mathlib.Analysis.RCLike.Basic | [
"Semigroup.toMul",
"HMul.hMul",
"Ring.toNeg",
"AddMonoid.toZero",
"NormedField.toField",
"Field.toCommRing",
"NormedField",
"RCLike.toDenselyNormedField",
"RCLike",
"RCLike.I",
"Semiring.toMonoid",
"Monoid.toSemigroup",
"Eq.ndrec",
"One.toOfNat1",
"Zero.toOfNat0",
"Monoid.toOne",
"Ad... | false |
_private.Mathlib.Data.Rat.Cast.Lemmas.0.Rat.cast_nnratCast._simp_1_1 | Mathlib.Data.Rat.Cast.Lemmas | [
"instOfNatNat",
"Int",
"Nat.cast",
"Int.instLTInt",
"instOfNat",
"Nat",
"LT.lt",
"propext",
"instNatCastInt",
"instLTNat",
"OfNat.ofNat",
"Eq",
"Int.natCast_pos"
] | false |
Polynomial.exists_multiset_roots | Mathlib.Algebra.Polynomial.RingDivision | [
"WithBot.instPreorder",
"IsDomain",
"CommRing",
"WithBot",
"CommSemiring.toSemiring",
"Preorder.toLE",
"Exists",
"Multiset.count",
"Multiset",
"Ne",
"Polynomial.degree",
"LE.le",
"instNatCastNat",
"Nat.cast",
"Polynomial",
"And",
"CommRing.toCommSemiring",
"Nat.instPreorder",
"Wi... | true |
SubMulAction.closure_le | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | [
"SubMulAction.instSetLike",
"SMul",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"HasSubset.Subset.trans",
"Set.instIsTransSubset",
"SubMulAction.mem_closure",
"HasSubset.Subset",
"LE.le",
"SubMulAction.instPartialOrder",
"Iff",
"SetLike.coe",
"SubMulAction.subset_closure"... | true |
Set.prod_range_univ_eq | Mathlib.Data.Set.Prod | [
"Set.instSProd",
"Set.ext",
"and_true",
"SProd.sprod",
"congrArg",
"Set.mem_prod._simp_1",
"Set.mem_univ._simp_1",
"Set.univ",
"Prod.forall._simp_1",
"setOf",
"Prod.exists._simp_1",
"Membership.mem",
"Exists",
"Prod.mk",
"Prod.fst",
"iff_self",
"funext",
"And",
"Iff",
"Prod.mk.... | true |
smul_le_smul_of_nonneg_right | Mathlib.Algebra.Order.Module.Defs | [
"instHSMul",
"monotone_smul_right_of_nonneg",
"SMul",
"Preorder.toLE",
"SMulPosMono",
"LE.le",
"Zero.toOfNat0",
"HSMul.hSMul",
"OfNat.ofNat",
"Preorder",
"Zero"
] | true |
TopologicalSpace.Opens.overEquivalence_counitIso_inv_app | Mathlib.Topology.Sheaves.Over | [
"CategoryTheory.Over",
"TopologicalSpace.Opens.overEquivalence._proof_9",
"TopologicalSpace.Opens.overEquivalence._proof_20",
"CategoryTheory.Functor",
"TopologicalSpace.Opens.overEquivalence._proof_6",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopologicalSpace.Opens.instPartialOrder",
... | true |
Lean.Lsp.instFromJsonWorkDoneProgressOptions.fromJson | Lean.Data.Lsp.Basic | [
"Pure.pure",
"Lean.Json",
"Lean.Lsp.WorkDoneProgressOptions",
"Monad.toApplicative",
"String",
"Lean.Name.mkStr3",
"Lean.Json.getObjValAs?",
"Lean.instFromJsonBool",
"Applicative.toPure",
"ToString.toString",
"Except.instMonad",
"instAppendString",
"Except.mapError",
"instHAppendOfAppend",... | true |
Std.TreeMap.Equiv.getEntryLTD_eq | Std.Data.TreeMap.Lemmas | [
"Std.TreeMap.Equiv",
"Std.DTreeMap.Equiv.constGetEntryLTD_eq",
"Std.TreeMap.Equiv.inner",
"Std.TreeMap.inner",
"Ordering",
"Std.TransCmp",
"Std.TreeMap.getEntryLTD",
"Prod",
"Eq",
"Std.TreeMap"
] | true |
SubarrayIterator.step._proof_4 | Init.Data.Slice.Array.Iterator | [
"Subarray",
"instOfNatNat",
"LE.le",
"Subarray.stop",
"instLENat",
"_private.Init.Data.Slice.Array.Iterator.0.SubarrayIterator.step._proof_3",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"Subarray.start",
"Not",
"Nat... | false |
Lean.PrettyPrinter.Delaborator.delabSigma | Lean.PrettyPrinter.Delaborator.Builtins | [
"Lean.PrettyPrinter.Delaborator.Delab",
"Bool.true",
"Lean.PrettyPrinter.Delaborator.delabSigmaCore"
] | true |
Lean.Elab.DecreasingBy.ref | Lean.Elab.PreDefinition.TerminationHint | [
"Lean.Syntax",
"Lean.Elab.DecreasingBy"
] | true |
_private.Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder.0.LocallyFiniteOrder.addMonoidHom._simp_4 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | [
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"eq_sub_iff_add_eq",
"AddZeroClass.toAddZero",
"SubNegMonoid.toSub",
"instHAdd",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"propext",
"AddZero.toAdd",
"SubNegMonoid.toAddMonoid",
"Eq"
] | false |
Representation.FiniteCyclicGroup.coinvariantsEquiv._proof_1 | Mathlib.RepresentationTheory.Homological.FiniteCyclic | [
"RingHomSurjective.ids",
"CommRing",
"CommSemiring.toSemiring",
"CommRing.toCommSemiring",
"RingHomSurjective",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
SkewMonoidAlgebra.ofFinsupp.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | [
"HEq.refl",
"id",
"SkewMonoidAlgebra.ofFinsupp",
"heq_of_eq",
"SkewMonoidAlgebra.noConfusion",
"SkewMonoidAlgebra",
"Eq.refl",
"HEq",
"Eq",
"Finsupp",
"Zero"
] | false |
Topology.RelCWComplex.FiniteDimensional.casesOn | Mathlib.Topology.CWComplex.Classical.Finite | [
"Topology.RelCWComplex",
"Filter.Eventually",
"Topology.RelCWComplex.FiniteDimensional.rec",
"IsEmpty",
"Filter.atTop",
"TopologicalSpace",
"Topology.RelCWComplex.FiniteDimensional.mk",
"Nat.instPreorder",
"Nat",
"Topology.RelCWComplex.cell",
"Topology.RelCWComplex.FiniteDimensional",
"Set"
] | false |
Lean.Lsp.LeanLocationLink.mk.noConfusion | Lean.Data.Lsp.Internal | [
"id",
"Lean.Lsp.LocationLink",
"Lean.Lsp.LeanLocationLink.noConfusion",
"Bool",
"Lean.Lsp.LeanLocationLink",
"Lean.Lsp.LeanDeclIdent",
"Eq",
"Lean.Lsp.LeanLocationLink.mk",
"Option"
] | false |
DirichletCharacter.completedLFunction | Mathlib.NumberTheory.LSeries.DirichletContinuation | [
"ZMod.completedLFunction",
"Nat.instMulZeroClass",
"ZMod.commRing",
"MulChar.instFunLike",
"Field.toSemifield",
"ZMod",
"Nat",
"Semifield.toCommGroupWithZero",
"DirichletCharacter",
"Complex",
"CommRing.toCommMonoid",
"NeZero",
"CommGroupWithZero.toCommMonoidWithZero",
"DFunLike.coe",
"C... | true |
CategoryTheory.Limits.Cocones.whiskeringEquivalence | Mathlib.CategoryTheory.Limits.Cones | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Equivalence",
"CategoryTheory.Functor.comp",
"CategoryTheory.Equivalence.functor",
"CategoryTheory.Limits.Cocone.whiskeringEquivalence",
"CategoryTheory.Limits.Cocone.category",
"CategoryTheory.Category"
] | true |
compactlySupported_eq_top_iff | Mathlib.Topology.ContinuousMap.BoundedCompactlySupported | [
"Nontrivial",
"BoundedContinuousFunction.instNonUnitalRing",
"TwoSidedIdeal.mem_top._simp_1",
"compactlySupported_eq_top_of_isCompact",
"congrArg",
"TwoSidedIdeal",
"Set.univ",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"IsClosed.closure_eq",
"Membership.mem",
"Exists",
"NonUnitalRing.toNonUn... | true |
Std.TreeSet.get!_emptyc | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeSet.get!",
"Inhabited.default",
"Ordering",
"Unit",
"Std.TreeSet.instEmptyCollection",
"Std.TreeMap.getKey!_emptyc",
"Inhabited",
"EmptyCollection.emptyCollection",
"Eq"
] | true |
Std.IterM.all_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Pure.pure",
"LawfulMonadLiftT",
"congrArg",
"Monad.toApplicative",
"Std.IterM.allM",
"Std.Iterators.Types.Map.instIterator",
"MonadLiftT.monadLift",
"Std.Iterators.Types.Map.instFinite",
"Std.instLawfulIteratorLoopDefaultImplementation",
"ULift",
"Std.IteratorLoop",
"WeaklyLawfulMonadAttach",... | true |
GroupTopology.toTopologicalSpace_injective | Mathlib.Topology.Algebra.Group.GroupTopology | [
"GroupTopology.casesOn",
"Group",
"Eq.rec",
"GroupTopology.toTopologicalSpace",
"TopologicalSpace",
"IsTopologicalGroup",
"Eq.ndrec",
"GroupTopology.mk",
"Eq.refl",
"Function.Injective",
"GroupTopology",
"Eq.symm",
"Eq"
] | true |
Ordinal.toZFSet_strictMono | Mathlib.SetTheory.ZFC.Ordinal | [
"Eq.mpr",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"StrictMono",
"Ordinal.partialOrder",
"congrArg",
"ZFSet",
"PartialOrder.toPreorder",
"ZFSet.instIsNonstrictStrictOrderSubsetSSubset",
"HasSSubset.SSubset",
"Preorder.toLE",
"id",
"LT.lt.le",
"HasSubset.Subset",
"LE.le",
"And",
"_... | true |
RootPairing.GeckConstruction.linearIndependent_h | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | [
"Int.instAddCommGroup",
"RootPairing.GeckConstruction.h_def",
"Int.cast",
"Eq.mpr",
"Pi.Function.module",
"Int.instAddCommMonoid",
"Sum.elimZeroLeft",
"Matrix.fromBlocks",
"Submodule",
"IsDomain",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addComm... | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.toMonoType.visitApp._sparseCasesOn_6 | Lean.Compiler.LCNF.MonoTypes | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
CategoryTheory.Limits.WalkingParallelPairHom.comp | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | [
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.WalkingParallelPairHom",
"CategoryTheory.Limits.WalkingParallelPairHom.comp.match_1",
"Unit",
"CategoryTheory.Limits.WalkingParallelPairHom.right",
"CategoryTheory.Limits.WalkingParallelPairHom.left"
] | true |
ZMod.χ₄._proof_1 | Mathlib.NumberTheory.LegendreSymbol.ZModChar | [
"MulOne.toOne",
"ZMod.commRing",
"Monoid.toMulOneClass",
"Int.instNegInt",
"ZMod.χ₄.match_1",
"instOfNatNat",
"Int",
"ZMod",
"MulOneClass.toMulOne",
"Unit",
"instOfNat",
"CommMonoid.toMonoid",
"Nat",
"One.toOfNat1",
"CommRing.toCommMonoid",
"OfNat.ofNat",
"Eq",
"Neg.neg",
"rfl"
] | false |
_private.Mathlib.Data.Set.PowersetCard.0.Set.powersetCard.ofFinEmb_surjective.match_1_1 | Mathlib.Data.Set.PowersetCard | [
"Finset",
"Subtype.casesOn",
"Membership.mem",
"Set.Elem",
"Subtype.mk",
"Nat",
"Set.instMembership",
"Set.powersetCard",
"Set"
] | false |
Lean.Elab.Term.Context.saveRecAppSyntax._default | Lean.Elab.Term.TermElabM | [
"id",
"Bool.true",
"Bool"
] | false |
Function.fromTypes_cons_equiv_symm_apply | Mathlib.Logic.Function.FromTypes | [
"Equiv.instEquivLike",
"Function.FromTypes",
"Equiv",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Function.fromTypes_cons_equiv",
"Nat",
"instAddNat",
"Eq.refl",
"Equiv.symm",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"Eq",
"DFunLike.coe",
"Matrix.vecCons",
"EquivLike.toFunLike"
] | true |
GenLoop.toLoop.eq_1 | Mathlib.Topology.Homotopy.HomotopyGroup | [
"Real",
"GenLoop.toLoop",
"Pi.topologicalSpace",
"GenLoop.toLoop._proof_3",
"GenLoop.toLoop._proof_1",
"ContinuousMap.curry",
"ContinuousMap.mk",
"ContinuousMap",
"PseudoMetricSpace.toUniformSpace",
"instTopologicalSpaceProd",
"ContinuousMap.comp",
"Membership.mem",
"GenLoop.toLoop._proof_2"... | true |
Nat.dfoldRev_succ | Init.Data.Nat.Fold | [
"Nat.dfold_succ._proof_9",
"Nat.dfold._proof_6",
"Nat.fold_succ._proof_2",
"Nat.dfoldRev",
"Nat.fold_succ._proof_1",
"Nat.dfold_succ._proof_6",
"_private.Init.Data.Nat.Fold.0.Nat.dfoldRev._proof_12",
"Nat.dfoldRev_succ._proof_6",
"Nat.dfold_succ._proof_5",
"instOfNatNat",
"LE.le",
"instLENat",... | true |
Std.Iterators.HetT.pmap._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.HetT | [
"Iff.of_eq",
"Std.Iterators.HetT.small",
"exists_const._simp_1",
"Std.Iterators.HetT.Property",
"instInhabitedTrue",
"Exists",
"Subtype",
"Std.Iterators.HetT",
"instNonemptyOfInhabited",
"exists_prop_congr",
"Std.Internal.USquash",
"True",
"eq_self",
"Std.Internal.USquash.inflate",
"prop... | false |
Std.IterM.Equiv.filterMapM | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Std.IterM.filterMapM",
"LawfulMonadLiftT",
"MonadLiftT.monadLift",
"LawfulMonad",
"Std.Iterators.PostconditionT.attachLift",
"MonadLiftT",
"Std.Iterator",
"Std.IterM.Equiv",
"Std.Iterators.Types.FilterMap",
"MonadAttach",
"Std.Iterators.Types.FilterMap.instIterator",
"Std.IterM",
"Monad",
... | true |
Lean.Server.Test.Runner.Client.Hyp.isInstance?._default | Lean.Server.Test.Runner | [
"id",
"Option.none",
"Bool",
"Option"
] | false |
CliffordAlgebraDualNumber.equiv._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | [
"CliffordAlgebra.ι",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"QuadraticMap.instZero",
"CommRing.toNonUnitalCommRing",
"Algebra.algebraMap",
"Ring.toNonAssocRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"CliffordAlgebra"... | false |
Int8.le_rfl | Init.Data.SInt.Lemmas | [
"Int8",
"LE.le",
"Int8.le_refl",
"instLEInt8"
] | true |
MvQPF | Mathlib.Data.QPF.Multivariate.Basic | [
"MvQPF.mk",
"Nat",
"TypeVec"
] | true |
cfcₙ_comp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Nontrivial",
"cfcₙ",
"Set.ext",
"Eq.mpr",
"cfcₙ_comp._auto_1",
"Semiring.toModule",
"instSMulOfMul",
"cfcₙ_comp._auto_9",
"congrArg",
"CommSemiring.toSemiring",
"and_self",
"DistribMulAction.toDistribSMul",
"quasispectrum.instZero",
"IsTopologicalSemiring",
"HEq.refl",
"IsScalarTower"... | true |
Multiset.naturality | Mathlib.Data.Multiset.Functor | [
"List.instLawfulTraversable",
"CommApplicative",
"congrArg",
"ApplicativeTransformation",
"Multiset.traverse",
"Function.comp",
"Multiset",
"CommApplicative.toLawfulApplicative",
"Quotient.inductionOn",
"Quotient.mk",
"Applicative",
"List",
"Multiset.ofList",
"Traversable.traverse",
"Law... | true |
_private.Std.Time.Date.Unit.Week.0.Std.Time.Week.Offset.ofMinutes._proof_1 | Std.Time.Date.Unit.Week | [
"Rat.instOfNat",
"Int.cast",
"Rat.instMul",
"HMul.hMul",
"of_decide_eq_true",
"Rat",
"Rat.instIntCast",
"id",
"Int",
"Bool.true",
"instOfNat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"instDecidableEqRat",
"Decidable.decide",
"Eq",
"instHMul"
] | false |
RandT | Mathlib.Control.Random | [
"StdGen",
"RandGT"
] | true |
CategoryTheory.Limits.Cone.fromCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | [
"CategoryTheory.Limits.ConeMorphism.mk",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.Cone.fromCostructuredArrow._proof_2",
"CategoryTheory.Costru... | true |
hasProd_subtype_mulSupport | Mathlib.Topology.Algebra.InfiniteSum.Basic | [
"MulOne.toOne",
"Set.Subset.refl",
"Monoid.toMulOneClass",
"HasProd",
"Function.comp",
"Membership.mem",
"Set.Elem",
"TopologicalSpace",
"MulOneClass.toMulOne",
"Iff",
"CommMonoid.toMonoid",
"Function.mulSupport",
"hasProd_subtype_iff_of_mulSupport_subset",
"Subtype.val",
"CommMonoid",
... | true |
CategoryTheory.MonoidalCategory.tensorUnitRight | Mathlib.CategoryTheory.Monoidal.Category | [
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategory.tensorRight",
"CategoryTheory.MonoidalCategoryStruct.tensorUnit",
"CategoryTheory.MonoidalCategory.toMonoidalCategoryStruct",
"CategoryTheory.Category"
] | true |
Real.instRCLike._proof_10 | Mathlib.Analysis.RCLike.Basic | [
"Real",
"instZeroAddMonoidHom",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Real.denselyNormedField",
"Real.instZero",
"Real.instAddMonoid",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"NormedField.toField",
"AddZeroClass.toAddZero",
"Real.semiring",
"Field.toCommRing",
"Mu... | false |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq.match_4 | Lean.Meta.Sym.AlphaShareCommon | [
"_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_4",
"Lean.Expr.letE",
"Lean.Expr",
"Nat.hasNotBit",
"Bool",
"Lean.Name",
"Lean.Expr.ctorIdx"
] | false |
Bool.true_bne | Init.Data.Bool | [
"bne",
"Bool.instDecidableForallOfDecidablePred",
"Bool.not",
"of_decide_eq_true",
"id",
"instDecidableEqBool",
"instBEqOfDecidableEq",
"Bool.true",
"Bool",
"Eq.refl",
"Decidable.decide",
"Eq"
] | true |
CategoryTheory.Limits.Fan.ext._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Fan.proj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.Fan",
"CategoryTheory.Limits.Fan.ext.match_1",
"CategoryTheory.Discrete.functor",
"CategoryT... | false |
Std.HashSet.get! | Std.Data.HashSet.Basic | [
"Std.HashSet",
"Std.HashMap.getKey!",
"Unit",
"Std.HashSet.inner",
"Inhabited",
"Hashable",
"BEq"
] | true |
Polynomial.quo_add_sum_rem_div_unique | Mathlib.Algebra.Polynomial.PartialFractions | [
"Algebra.cast",
"Nontrivial",
"WithBot.instPreorder",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"CommRing",
"WithBot",
"Preorder.toLT",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"DivisionCommMonoid.toDiv... | true |
MvPolynomial.ne_zero_of_degreeOf_ne_zero | Mathlib.Algebra.MvPolynomial.Degrees | [
"False",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"congrArg",
"CommSemiring.toSemiring",
"False.elim",
"Finsupp.instAddMonoid",
"Nat.instAddMonoid",
"Eq.mp",
"not_true_eq_false",
"id",
"Ne",
"instOfNatNat",
"CommSemiring",
"Aesop.BuiltinRules.not_intro",
"Nat",
"True",
... | true |
FractionalIdeal.one_le_dual_one | Mathlib.RingTheory.DedekindDomain.Different | [
"Eq.mpr",
"FractionalIdeal.dual",
"IsIntegralClosure",
"IsDomain",
"MulOne.toOne",
"IsDedekindDomain.toIsDomain",
"le_refl",
"CommRing",
"FractionalIdeal.instNontrivialNonZeroDivisors",
"IsDomain.to_noZeroDivisors",
"NeZero.one",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"IsFra... | true |
OrderDual.ofDual_trans_toDual | Mathlib.Order.OrderDual | [
"OrderDual.toDual",
"OrderDual.ofDual",
"Equiv.trans",
"Equiv",
"OrderDual",
"Equiv.refl",
"Eq",
"rfl"
] | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable.0.E2_mdifferentiable._simp_1_7 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable | [
"False",
"eq_false",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"Nat.cast_add_one_ne_zero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"On... | false |
CompleteLattice.WellFoundedGT.isSupClosedCompact | Mathlib.Order.CompactlyGenerated.Basic | [
"Iff.mpr",
"Preorder.toLT",
"WellFoundedGT",
"PartialOrder.toPreorder",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.isSupClosedCompact_iff_wellFoundedGT",
"CompleteLattice.IsSupClosedCompact",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"ConditionallyCompleteLattice... | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk.injEq | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | [
"Eq.propIntro",
"Lean.injEq_helper",
"_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure",
"And",
"_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"_private.Mathl... | true |
Mathlib.Tactic.FieldSimp.Sign.congr | Mathlib.Tactic.FieldSimp.Lemmas | [
"Lean.Expr.const",
"Lean.Expr.sort",
"Lean.Level",
"Mathlib.Tactic.FieldSimp.Sign.minus",
"List.cons",
"Unit",
"Mathlib.Tactic.FieldSimp.Sign.expr",
"Qq.Quoted",
"Mathlib.Tactic.FieldSimp.Sign.mulRight.match_1",
"Qq.Quoted.unsafeMk",
"Mathlib.Tactic.FieldSimp.Sign",
"Lean.Name.mkStr2",
"Lean... | true |
ENat.top_ne_one._simp_1 | Mathlib.Data.ENat.Basic | [
"False",
"instAddMonoidWithOneENat",
"eq_false",
"instTopENat",
"ENat.top_ne_one",
"AddMonoidWithOne.toOne",
"ENat",
"One.toOfNat1",
"Top.top",
"OfNat.ofNat",
"Eq"
] | false |
ContinuousAffineMap.zero_apply | Mathlib.Topology.Algebra.ContinuousAffineMap | [
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"ContinuousAffineMap",
"addGroupIsAddTorsor",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"TopologicalSpace",
"ContinuousAffineMap.instZero",
"Ad... | true |
Lean.Meta.Grind.Arith.Linear.State.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | [
"Lean.Meta.Grind.Arith.Linear.State",
"Lean.PHashMap",
"Lean.PArray",
"Lean.Expr",
"Lean.PHashSet",
"Lean.Meta.Grind.Arith.Linear.Struct",
"Array",
"Lean.Meta.Grind.Arith.Linear.NatStruct",
"Lean.Meta.Sym.instHashableExprPtr",
"Nat",
"Lean.Meta.Grind.Arith.Linear.State.mk",
"Lean.Meta.Sym.Expr... | false |
MeasureTheory.innerRegularWRT_isCompact_isClosed_measure_ne_top_of_group | Mathlib.MeasureTheory.Group.Measure | [
"Eq.mpr",
"MeasureTheory.Measure",
"Preorder.toLT",
"MeasurableSet",
"IsCompact.measure_closure",
"congrArg",
"PartialOrder.toPreorder",
"Group",
"Exists",
"BorelSpace",
"IsCompact.closure",
"id",
"HasSubset.Subset",
"Ne",
"MeasureTheory.Measure.InnerRegularWRT",
"And.casesOn",
"Meas... | true |
Aesop.RuleState.mk.inj | Aesop.Forward.State | [
"Aesop.Substitution.instHashable",
"Aesop.ForwardRule",
"Lean.PHashMap",
"Aesop.Substitution",
"Aesop.instBEqPatSubstSource",
"Lean.PHashSet",
"Array",
"Aesop.Substitution.instBEq",
"And",
"Aesop.RuleState",
"And.intro",
"Aesop.ClusterState",
"Aesop.RuleState.mk",
"Eq",
"Aesop.instHashab... | true |
Subring.sum_mem | Mathlib.Algebra.Ring.Subring.Basic | [
"Subring.instSetLike",
"Ring.toNonAssocRing",
"Finset",
"SubsemiringClass.toAddSubmonoidClass",
"Membership.mem",
"Subring.instSubringClass",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"NonAssocRing.toNonUnitalNonAssocRing",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Finset.instSetLik... | true |
Lean.Meta.simpEq | Mathlib.Lean.Meta.Simp | [
"Pure.pure",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.mkAppN",
"Lean.Meta.simpEq.match_4",
"Lean.Meta.mkEqSymm",
"Lean.Meta.simpEq.match_1",
"Lean.Meta.forallTelescope",
"instMonadControlTOfPure",
"String",
"Lean.Meta.State",
"Lean.instAddErrorMessageContextOfAddMess... | true |
RingQuot.instRing._proof_4 | Mathlib.Algebra.RingQuot | [
"neg_add_rev",
"add_mul",
"AddGroup.toSubtractionMonoid",
"Int.cast",
"NegZeroClass.toNeg",
"Int.cast_natCast",
"zsmul_eq_mul",
"RingQuot.casesOn",
"instHSMul",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"AddMonoid.toAddZeroC... | false |
_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult.mk.inj | Lean.Meta.Basic | [
"Lean.Language.SnapshotTree",
"_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult",
"And",
"And.intro",
"_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult.mk.noConfusion",
"_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult.mk",
"Eq",
"Lean.Exception",
"Option"
] | true |
Valued.toNormedField._proof_3 | Mathlib.Topology.Algebra.Valued.NormedValued | [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"NegZeroClass.toNeg",
"Real",
"neg_sub",
"Valuation.RankOne.hom",
"ValuationClass.toMonoidWithZeroHomClass",
"Monoid.toMulOneClass",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Monoid... | false |
_private.Mathlib.Data.PFun.0.PFun.mem_prodMap._simp_1_5 | Mathlib.Data.PFun | [
"Exists",
"exists_and_left",
"And",
"propext",
"Eq"
] | false |
CategoryTheory.Limits.Types.Small.productLimitCone._proof_4 | Mathlib.CategoryTheory.Limits.Types.Products | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"TypeCat.instFunLikeFun",
"CategoryTheory.Discrete.functo... | false |
Homeomorph.prodUnique_symm_apply_snd | Mathlib.Topology.Homeomorph.Lemmas | [
"Inhabited.default",
"Homeomorph.prodUnique",
"Unique",
"instTopologicalSpaceProd",
"TopologicalSpace",
"Homeomorph.instEquivLike",
"Homeomorph.symm",
"Homeomorph",
"Eq.refl",
"Unique.instInhabited",
"Prod",
"Eq",
"Prod.snd",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.