name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
HomotopicalAlgebra.CofibrantObject.HoCat.adj._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | [
"HomotopicalAlgebra.BifibrantObject",
"CategoryTheory.NatIso.isIso_inv_app._simp_1",
"Eq.mpr",
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"HomotopicalAlgebra.CofibrantObject.HoCat.adjCounitIso",
"HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject",
"CategoryTheory.Functor",... | false |
Interval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | [
"Interval.addZeroClass",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"AddZeroClass.zero_add",
"Interval",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"AddZero.toAdd",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"IsOrderedAddMonoid",
"Preorder"
] | false |
String.contains_slice_iff | Init.Data.String.Lemmas.Pattern.Find.String | [
"String.toSlice",
"congrArg",
"String",
"String.contains",
"String.Slice",
"String.Slice.Pattern.ForwardSliceSearcher.instIteratorLoopIdSearchStep",
"String.Slice.contains_slice_iff._simp_1",
"iff_self",
"List.IsInfix",
"Bool.true",
"String.Slice.copy",
"List",
"Iff",
"String.toList",
"T... | true |
cfc_inv | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Units.val",
"Eq.mpr",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"spectrum",
"Ring.toNonAssocRing",
"congrArg",
"cfc",
"cfc_inv._auto_3",
"IsTopologicalSemiring",
"ContinuousStar",
"ContinuousInv₀",
"PseudoMetricSpace.toUniformSpace",
"Algebra",
"Membership.... | true |
Std.TreeMap.getKey?_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | [
"List.map",
"List.contains",
"Ordering",
"Std.TransCmp",
"Prod.fst",
"Std.DTreeMap.Const.getKey?_ofList_of_contains_eq_false",
"Option.none",
"List",
"Std.LawfulBEqCmp",
"Bool",
"Std.TreeMap.ofList",
"Std.TreeMap.getKey?",
"Prod",
"Bool.false",
"BEq",
"Eq",
"Option"
] | true |
CategoryTheory.ShortComplex.ShortExact.exactAt_X₁._auto_3 | Mathlib.Algebra.Homology.HomologySequenceLemmas | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
UInt8.toUSize_ofNat' | Init.Data.UInt.Lemmas | [
"Eq.mpr",
"UInt8.toUSize_ofNatLT",
"congrArg",
"UInt8.size",
"UInt8.toUSize",
"UInt8.ofNatLT_eq_ofNat",
"USize.ofNat",
"id",
"Nat",
"USize.ofNatLT",
"LT.lt",
"USize.ofNatLT_eq_ofNat",
"Eq.refl",
"USize.size",
"UInt8.size_le_usizeSize",
"instLTNat",
"UInt8.ofNat",
"Eq.symm",
"UInt... | true |
ZMod.dft_eq_fourier | Mathlib.Analysis.Fourier.ZMod | [
"Pi.Function.module",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"Nat.instMulZeroClass",
"Real",
"instHSMul",
"MeasureTheory.Measure",
"CompleteSpace",
"Pi.addCommMonoid",
"HMul.hMul",
"MeasureTheory.Measure.count.isFiniteMeasure",
"Finset.univ",
"ZMod.commRing",
"NormedS... | true |
ContextFreeGrammar.produces_reverse | Mathlib.Computability.ContextFreeGrammar | [
"ContextFreeRule.Rewrites",
"ContextFreeGrammar",
"Symbol",
"ContextFreeGrammar.Produces",
"Equiv.instEquivLike",
"congrArg",
"ContextFreeGrammar.reverse",
"ContextFreeRule.rewrites_reverse_comm._simp_1",
"Finset",
"Finset.map",
"Membership.mem",
"Exists",
"Function.Embedding.mk",
"Equiv",... | true |
_private.Init.Data.List.Lemmas.0.List.mem_map.match_1_1 | Init.Data.List.Lemmas | [
"Unit.unit",
"List.cons",
"List",
"Unit",
"List.casesOn",
"List.nil"
] | false |
Sym2.card_toFinset | Mathlib.Data.Sym.Sym2 | [
"Sym2.card_toFinset_of_not_isDiag",
"eq_false",
"congrArg",
"Sym2.IsDiag.decidablePred",
"instOfNatNat",
"Sym2.toFinset",
"Sym2.card_toFinset_of_isDiag",
"ite_cond_eq_true",
"dite",
"Nat",
"congr",
"True",
"eq_self",
"eq_true",
"Finset.card",
"of_eq_true",
"OfNat.ofNat",
"ite_cond_... | true |
AffineSpace.vadd_asymptoticNhds | Mathlib.Topology.Algebra.AsymptoticCone | [
"Pure.pure",
"Eq.mpr",
"_private.Mathlib.Topology.Algebra.AsymptoticCone.0.AffineSpace.vadd_asymptoticNhds.match_1_1",
"Filter.instVAdd",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Filter.map",
"VAddCommClass.vadd_comm",
"LinearOrder",
"AffineSpace.asymptoticNhds_va... | true |
_private.Mathlib.RingTheory.Coprime.Basic.0.IsCoprime.isUnit_of_dvd.match_1_1 | Mathlib.RingTheory.Coprime.Basic | [
"Semigroup.toMul",
"Dvd.dvd",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"semigroupDvd",
"SemigroupWithZero.toSemigroup",
"NonUnitalSemiring.toSemigroupWithZero",
"NonUnitalCommSemiring.toNonUnitalSemiring",
"CommSemiring",
"Exists.casesOn",
"Exists.intro",
"Eq",
"instHMul"
] | false |
SubMulAction.instSetLike.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | [
"SetLike",
"SubMulAction.instSetLike",
"SMul",
"SetLike.mk",
"SubMulAction.instSetLike._proof_1",
"Eq.refl",
"SubMulAction.carrier",
"Eq",
"SubMulAction",
"Set"
] | true |
_private.Init.Data.List.MapIdx.0.List.length_mapIdx_go._proof_1_6 | Init.Data.List.MapIdx | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval",
"Option.some",
"id",
"instDecidableEqBool",
"Int.... | false |
subset_sInf_def | Mathlib.Order.CompleteLatticeIntervals | [
"Inhabited.default",
"Classical.propDecidable",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"InfSet",
"subsetInfSet",
"dite",
"Subtype.mk",
"And",
"Set.Nonempty",
"And.right",
"BddBelow",
"Inhabited",
"Set.image",
"instDecidableAnd",
"Subtype.val",
"Eq",
"Set.instMembership",
... | true |
Std.ExtTreeMap.maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | [
"Std.ExtTreeMap.maxKey?",
"Ordering",
"Std.ExtDTreeMap.maxKeyD_insert",
"instDecidableEqBool",
"Std.TransCmp",
"Bool.true",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Bool",
"Std.ExtTreeMap.insert",
"Ordering.isLE",
"Option.elim",
"Eq",
"Std.ExtTreeMap.maxKeyD",
"ite"
] | true |
FreeAddMagma.below | Mathlib.Algebra.Free | [
"PProd",
"PUnit",
"FreeAddMagma.rec",
"FreeAddMagma"
] | false |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.boolAtom | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | [
"Pure.pure",
"Unit.unit",
"Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr",
"StateRefT'.instAlternativeOfMonad",
"ReaderT",
"Lean.Meta.State",
"Lean.Name.mkStr5",
"Lean.Expr.cleanupAnnotations",
"instMonadLiftT",
"Option.getD",
"Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred",
"Lean.Elab.T... | true |
Subsemiring.nonneg._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Order | [
"IsOrderedRing",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddLeftMono",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Semiring",
"AddZero.toAdd",
"IsOrderedRing.toIsOrdered... | false |
Array.popWhile._unsafe_rec | Init.Data.Array.Basic | [
"of_decide_eq_true",
"HSub.hSub",
"id",
"instDecidableEqBool",
"Nat.sub_lt",
"instSubNat",
"instOfNatNat",
"Array.pop",
"dite",
"Array",
"GetElem.getElem",
"Bool.true",
"GT.gt",
"Array.popWhile._unsafe_rec",
"instHSub",
"Array.instGetElemNatLtSize",
"Nat",
"LT.lt",
"Bool",
"Nat... | false |
CategoryTheory.Sigma.natIso_inv | Mathlib.CategoryTheory.Sigma.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Sigma.incl",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Sigma.natTrans",
"CategoryTheory.Iso",
"CategoryTheory.Sigma.sigma",
"Eq.refl",
"CategoryTheory.Categor... | true |
CategoryTheory.MorphismProperty.isStableUnderTransfiniteCompositionOfShape_iff | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | [
"CategoryTheory.MorphismProperty",
"Preorder.toLT",
"CategoryTheory.MorphismProperty.transfiniteCompositionsOfShape",
"CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra",
"LinearOrder",
"CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.mk",
"WellFoundedLT",
"PartialO... | true |
NonUnitalRingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | [
"Prod.instNonUnitalNonAssocSemiring",
"NonUnitalRingHom.ext",
"NonUnitalRingHom.instFunLike",
"NonUnitalRingHom.comp",
"NonUnitalRingHom",
"NonUnitalRingHom.prod",
"Prod",
"NonUnitalNonAssocSemiring",
"Eq",
"DFunLike.coe",
"rfl",
"NonUnitalRingHom.snd"
] | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_492 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
MeasureTheory.isFiniteMeasure_toFiniteAux | Mathlib.MeasureTheory.Measure.WithDensityFinite | [
"Eq.mpr",
"Exists.choose_spec",
"MeasureTheory.Measure",
"congrArg",
"Classical.propDecidable",
"MeasureTheory.Measure.AbsolutelyContinuous",
"id",
"if_pos",
"dite",
"MeasurableSpace",
"And",
"MeasureTheory.SFinite",
"MeasureTheory.Measure.toFiniteAux.eq_1",
"Classical.dec",
"And.left",
... | true |
List.head_cons | Init.Data.List.Basic | [
"List.head",
"Ne",
"List.cons",
"List",
"Eq",
"rfl",
"List.nil"
] | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurable_from_prod_countable_left'._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | [
"Membership.mem",
"Set.preimage",
"propext",
"Eq",
"Set.instMembership",
"Set.mem_preimage",
"Set"
] | false |
Std.DHashMap.instForInSigmaOfMonad | Std.Data.DHashMap.Basic | [
"ForInStep",
"ForIn.mk",
"ForIn",
"Hashable",
"Sigma.mk",
"Monad",
"BEq",
"Std.DHashMap.forIn",
"Sigma",
"Std.DHashMap"
] | true |
ThreeGPFree.of_image | Mathlib.Combinatorics.Additive.AP.Three.Defs | [
"IsMulFreimanHom",
"HMul.hMul",
"Monoid.toMulOneClass",
"Membership.mem",
"IsMulFreimanHom.mul_eq_mul",
"MulOne.toMul",
"HasSubset.Subset",
"instOfNatNat",
"MulOneClass.toMulOne",
"CommMonoid.toMonoid",
"Set.mem_image_of_mem",
"Nat",
"Set.image",
"Set.InjOn",
"ThreeGPFree",
"OfNat.ofNa... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.aig | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | [
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput",
"Std.Sat.AIG",
"Hashable",
"DecidableEq"
] | true |
_private.Lean.Parser.Module.0.Lean.Parser.parseCommand.match_1 | Lean.Parser.Module | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Lean.Parser.Error",
"Option"
] | false |
CoalgCat.concreteCategory._proof_1 | Mathlib.Algebra.Category.CoalgCat.Basic | [
"CoalgCat.toModuleCat",
"CommRing",
"Coalgebra.toCoalgebraStruct",
"CoalgCat",
"CoalgHom",
"AddCommGroup.toAddCommMonoid",
"id",
"CoalgCat.instCoalgebra",
"CommRing.toCommSemiring",
"ModuleCat.isAddCommGroup",
"CoalgCat.Hom.toCoalgHom'",
"CoalgCat.Hom.mk",
"ModuleCat.carrier",
"Eq.refl",
... | false |
Submonoid.mem_map_iff_mem | Mathlib.Algebra.Group.Submonoid.Operations | [
"Membership.mem",
"Submonoid.map",
"MulOneClass.toMulOne",
"Iff",
"SetLike.coe",
"MonoidHomClass",
"Submonoid.instSetLike",
"Function.Injective",
"MulOneClass",
"DFunLike.coe",
"SetLike.instMembership",
"Function.Injective.mem_set_image",
"Submonoid",
"FunLike"
] | true |
CategoryTheory.Limits.Sigma.reindex | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"Equiv.instEquivLike",
"CategoryTheory.Functor.comp",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Discrete.natIso",
"Function.comp",
"CategoryTheory.Iso.refl",
"Equiv",
"CategoryTheory.Iso",
"CategoryTheory.Equivalence.functor",
"CategoryTheory.Limits.HasColimit.isoOfEquivalence",
"Catego... | true |
Lean.Meta.Grind.InjectiveInfo.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | [
"Lean.Meta.Grind.InjectiveInfo.mk",
"Lean.Expr",
"id",
"Lean.Level",
"List",
"Lean.Meta.Grind.InjectiveInfo",
"Lean.Meta.Grind.InjectiveInfo.noConfusion",
"Prod",
"Eq",
"Option"
] | false |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_31 | Mathlib.Data.List.Basic | [
"Nat.succ_lt_succ_iff",
"of_eq_false",
"GetElem",
"_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_20",
"_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_30",
"of_decide_eq_true",
"Lean.Grind.nestedProof",
"Lean.Grind.iff_eq",
"congrArg",
"HEq.refl",
"HEq.trans",
"... | false |
Units.mulLECancellable_val | Mathlib.Algebra.Order.Monoid.Unbundled.Units | [
"Monoid",
"Units.val",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_le_mul_right",
"Units",
"Eq.mp",
"MulLeftMono",
"MulOne.toMul",
"LE.le",
"LE",
"MulOneClass.toMulOne",
"Inv.inv",
"congr",
"MulLECancellable",
"Units.instInv",
"instHMul",
"Units.inv_mul_cancel_left"
] | true |
CategoryTheory.Subobject.map_mk | Mathlib.CategoryTheory.Subobject.Basic | [
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Subobject.map",
"Preorder.smallCategory",
"CategoryTheory.instPartialOrderSubobject",
"CategoryTheory.mono_comp",
"CategoryTheory.Subobject.mk",
"CategoryTheory.CategoryStruct.... | true |
Std.Time.Duration.subHours | Std.Time.Duration | [
"Std.Time.Duration.subSeconds",
"Std.Time.Hour.Offset",
"Std.Time.Second.Offset",
"Std.Time.Hour.Offset.toSeconds",
"Std.Time.Duration"
] | true |
Std.DHashMap.Internal.Raw₀.get!_alter | Std.Data.DHashMap.Internal.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"Std.DHashMap.Internal.Raw₀.get?",
"dite_congr",
"Std.DHashMap.Internal.Raw.WF.out",
"instLawfulHashableOfLawfulBEq",
"congrArg",
"Std.Internal.List.getValueCast?",
"Std.DHashMap.Raw",
"Std.DHashMap.Internal.Raw₀.toListModel_alte... | true |
Lean.Meta.MVarRenaming.noConfusionType | Lean.Meta.Match.MVarRenaming | [
"Lean.MVarIdMap",
"Lean.Meta.MVarRenaming.casesOn",
"Lean.MVarId",
"Lean.Meta.MVarRenaming",
"Eq"
] | false |
Absorbs.sInter | Mathlib.Topology.Bornology.Absorbs | [
"Iff.mpr",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero",
"Set.Finite.absorbs_sInter",
"Set.Finite",
"Membership.mem",
"MulAction",
"Monoid.toSemigroup",
"Absorbs",
"SemigroupAction.toSMul",
"MulAction.toSemigroupAction",
"Set.sInter",
"Set.instMembership",
"Bornology",
"MonoidWithZe... | true |
CategoryTheory.MonoOver.imageForgetAdj._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | [
"CategoryTheory.Limits.factorThruImage",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Over",
"CategoryTheory.Limits.HasImages.has_image",
"CategoryTheory.Over.OverMorphism.ext",
"CategoryTheory.Over.homMk.congr_simp",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryT... | false |
AddActionHom.prodMap._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | [
"Prod.instVAdd",
"AddActionHom.fst",
"VAdd",
"id",
"AddActionHom",
"HVAdd.hVAdd",
"AddActionHom.snd",
"AddActionHom.toFun",
"AddActionHom.prodMap._proof_1",
"instHVAdd",
"Prod",
"AddActionHom.prod",
"AddActionHom.map_vadd'",
"AddActionHom.comp",
"Eq"
] | false |
Lean.DefinitionVal.getSafetyEx | Lean.Declaration | [
"Lean.DefinitionVal.safety",
"Lean.DefinitionVal",
"Lean.DefinitionSafety"
] | true |
CategoryTheory.Functor.WellOrderInductionData.ofExists._proof_4 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | [
"CategoryTheory.Functor",
"Exists.choose_spec",
"Opposite",
"Order.succ",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ConcreteCategory.hom",
"Quiver.Hom.op",
"LinearOrder",
"PartialOrder.toPreorder",
"TypeCat.instFunLikeFun",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"D... | false |
Aesop.EqualUpToIdsM.run' | Aesop.Util.EqualUpToIds | [
"Aesop.EqualUpToIdsM.Context.mk",
"Lean.instBEqMVarId",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"Lean.Meta.State",
"Lean.MetavarContext",
"instMonadLiftT",
"IO",
"Aesop.EqualUpToIdsM.State",
"Lean.MVarId",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Std.... | true |
Lean.isIdRestAscii | Init.Meta.Defs | [
"instDecidableEqUInt8",
"Char.toUInt8",
"instBEqOfDecidableEq",
"BEq.beq",
"Bool",
"Bool.or",
"UInt8",
"Decidable.decide",
"Eq",
"_private.Init.Meta.Defs.0.Lean.isAlphanumAscii",
"Char.ofNat"
] | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ici_erase._simp_1_4 | Mathlib.Order.Interval.Finset.Basic | [
"lt_iff_le_and_ne",
"Preorder.toLT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Ne",
"LE.le",
"And",
"LT.lt",
"propext",
"Eq"
] | false |
Lean.Grind.CommRing.Poly.combine.go.eq_5 | Init.Grind.Ring.CommSolver | [
"cond",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Poly.combine.go",
"Lean.Grind.CommRing.Poly.add",
"Ordering",
"Int.instDecidableEq",
"Lean.Grind.CommRing.Poly.insert.go.match_1",
"Lean.Grind.CommRing.Mon.grevlex",
"Int",
"instBEqOfDecidableEq",
"instHAdd",
"BEq.beq",
"Unit",
"inst... | true |
Int32.maxValue_le_iff._simp_1 | Init.Data.SInt.Lemmas | [
"Int32.maxValue_le_iff",
"instLEInt32",
"Int32.maxValue",
"LE.le",
"propext",
"Eq",
"Int32"
] | false |
Filter.Germ.instAddAction._proof_2 | Mathlib.Order.Filter.Germ.Basic | [
"Eq.mpr",
"Filter.Germ.ofFun",
"AddMonoid.toAddSemigroup",
"Pi.addAction",
"congrArg",
"AddMonoid.toAddZeroClass",
"Function.hasVAdd",
"AddZeroClass.toAddZero",
"Filter.EventuallyEq",
"id",
"Filter.Germ.coe_eq",
"HVAdd.hVAdd",
"AddAction",
"AddZero.toZero",
"AddAction.toAddSemigroupActio... | false |
RingHom.FinitePresentation.comp_surjective | Mathlib.RingTheory.FinitePresentation | [
"RingHom.map_add'",
"RingHom.instRingHomClass",
"MulOne.toOne",
"RingHom.FinitePresentation",
"CommRing",
"RingHom.mk",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"OneHom.mk",
"Algebra",
"RingHom",
"MonoidHom.mk",
"NonAssocSemiring.toMulZeroOneClass",
"Ideal.FG",
"MulZeroOneClass.t... | true |
CategoryTheory.WithTerminal.coneEquiv._proof_5 | Mathlib.CategoryTheory.WithTerminal.Cone | [
"CategoryTheory.WithTerminal.coneEquiv._proof_3",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"... | false |
SubgroupClass.inclusion_self | Mathlib.Algebra.Group.Subgroup.Defs | [
"SetLike",
"MonoidHom.instFunLike",
"le_rfl",
"MonoidHom",
"Monoid.toMulOneClass",
"SubgroupClass.inclusion",
"Group",
"Subtype.casesOn",
"Preorder.toLE",
"Membership.mem",
"Subtype",
"DivInvMonoid.toMonoid",
"Subtype.mk",
"Group.toDivInvMonoid",
"SubgroupClass",
"MulOneClass.toMulOne"... | true |
Congruent.index_equiv._simp_1 | Mathlib.Topology.MetricSpace.Congruence | [
"Function.comp",
"Congruent",
"PseudoEMetricSpace",
"EquivLike",
"propext",
"Eq",
"DFunLike.coe",
"Congruent.index_equiv",
"EquivLike.toFunLike"
] | false |
diagonal_dotProduct | Mathlib.Data.Matrix.Mul | [
"Eq.mpr",
"False",
"HMul.hMul",
"Finset.univ",
"dotProduct",
"congrArg",
"HEq.refl",
"Finset",
"MulZeroClass.zero_mul",
"AddMonoid.toAddZeroClass",
"Matrix.diagonal_apply_ne'",
"Matrix.diagonal_apply_eq",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Membership.mem",
"AddZeroClass.toAddZe... | true |
_private.Std.Internal.Http.Data.Body.Stream.0.Std.Http.Body.Stream.recv'._proof_1 | Std.Internal.Http.Data.Body.Stream | [
"instNonemptyOfMonad",
"Std.Http.Chunk",
"instMonadOption",
"instNonemptyOfInhabited",
"Nonempty",
"Std.Http.instInhabitedChunk",
"Option"
] | false |
CategoryTheory.ShortComplex.descRightHomology | Mathlib.Algebra.Homology.ShortComplex.RightHomology | [
"CategoryTheory.ShortComplex.opcycles",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ShortComplex.rightHomology",
"Quiver.Hom",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.ShortComplex.descOpcycles",
"Categor... | true |
CategoryTheory.Limits.Types.limitConeIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Types.Limits | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"TypeCat.instFunLikeFun",
"Membership.mem",
"TypeCat.ofHom",
"id",
"Category... | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.size_union_of_not_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | [
"Membership.mem",
"Std.DHashMap.instMembership",
"Std.DHashMap.contains",
"propext",
"Bool",
"Std.DHashMap.contains_eq_false_iff_not_mem",
"Hashable",
"Eq.symm",
"Bool.false",
"BEq",
"Eq",
"Not",
"Std.DHashMap"
] | false |
List.range'_eq_singleton_iff._simp_1 | Init.Data.List.Nat.Range | [
"List.range'",
"List.range'_eq_singleton_iff",
"instOfNatNat",
"List.cons",
"List",
"And",
"Nat",
"propext",
"OfNat.ofNat",
"Eq",
"List.nil"
] | false |
CommBialgCat.isoEquivBialgEquiv._proof_1 | Mathlib.Algebra.Category.CommBialgCat | [
"CommRing",
"CommBialgCat.isoMk",
"CommBialgCat.bialgEquivOfIso",
"CommSemiring.toSemiring",
"CommBialgCat.of",
"CategoryTheory.Iso",
"CommBialgCat.instCategory",
"CommRing.toCommSemiring",
"Bialgebra",
"Eq",
"CommBialgCat",
"rfl"
] | false |
AddEquiv.ext_int_iff | Mathlib.Data.Int.Cast.Lemmas | [
"AddMonoid.toAddSemigroup",
"HEq.refl",
"AddEquiv.ext_int",
"Eq.casesOn",
"Int",
"AddSemigroup.toAdd",
"Iff",
"instOfNat",
"Iff.intro",
"AddMonoid",
"Eq.ndrec",
"Int.instAdd",
"AddEquiv",
"Eq.refl",
"HEq",
"OfNat.ofNat",
"Eq.symm",
"AddEquiv.instEquivLike",
"Eq",
"DFunLike.coe"... | true |
logDeriv.eq_1 | Mathlib.Analysis.Calculus.LogDeriv | [
"logDeriv",
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"instHDiv",
"NormedRing.toRing",
"Pi.instDiv",
"deriv",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"NormedDivisionRing.toDivisionRing",
"DivisionRing.toDivInvMonoid",
"HDiv.hDiv",
"NormedField.... | true |
Lean.Server.FileWorker.SignatureHelp.CandidateKind.toCtorIdx | Lean.Server.FileWorker.SignatureHelp | [
"Nat",
"Lean.Server.FileWorker.SignatureHelp.CandidateKind.ctorIdx",
"Lean.Server.FileWorker.SignatureHelp.CandidateKind"
] | false |
closureAddCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | [
"closureAddCommutatorRepresentatives",
"Set.instUnion",
"addCommutatorRepresentatives",
"Prod.fst",
"AddSubgroup",
"AddGroup",
"Eq.refl",
"Set.image",
"Union.union",
"Prod",
"Eq",
"Prod.snd",
"AddSubgroup.closure",
"Set"
] | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | [
"False",
"eq_false",
"four_ne_zero",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
ContinuousLinearMap.instMeasurableSpace._proof_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap | [
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"SeminormedAddCommGroup.toAddCommGroup",
"SeminormedAddCommGroup.toIsTopologicalAddGroup",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"UniformSpace.toTopologicalSpace",
"NormedAddCommGroup"... | false |
Path.trans_apply | Mathlib.Topology.Path | [
"not_le",
"Iff.mpr",
"Eq.mpr",
"Real.partialOrder",
"Real.instLE",
"Real",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"Path.trans",
"Real.instZero",
"Real.instZeroLEOneClass",
"congrArg",
"Real.instDivInvMonoid",
"Real.instSub",
"ContinuousMap",
"PartialOrder.toPreorder",
"Nat.instA... | true |
mfderivWithin_prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | [
"MDifferentiableWithinAt.hasMFDerivWithinAt",
"Set.instSProd",
"Prod.normedSpace",
"Prod.normedAddCommGroup",
"NormedSpace",
"SProd.sprod",
"AddCommGroup.toAddCommMonoid",
"instAddCommGroupTangentSpace",
"_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.mfderivWithin_prodMap._proof_1_1... | true |
RelSeries.head_map | Mathlib.Order.RelSeries | [
"RelSeries.map",
"SetRel",
"RelHom.instFunLike",
"Membership.mem",
"Prod.mk",
"RelSeries",
"SetRel.Hom",
"RelSeries.head",
"Prod",
"Eq",
"Set.instMembership",
"DFunLike.coe",
"rfl"
] | true |
Lean.Server.Completion.HoverInfo.noConfusionType | Lean.Server.Completion.CompletionUtils | [
"Lean.Server.Completion.HoverInfo.casesOn",
"Lean.Server.Completion.HoverInfo",
"Nat",
"Eq"
] | false |
IsAddUnit.addUnit_add | Mathlib.Algebra.Group.Units.Defs | [
"AddUnits.val",
"AddMonoid.toAddZeroClass",
"IsAddUnit.add",
"AddZeroClass.toAddZero",
"IsAddUnit",
"AddUnits.ext",
"instHAdd",
"HAdd.hAdd",
"AddMonoid",
"IsAddUnit.addUnit",
"AddZero.toAdd",
"AddUnits.instAdd",
"Eq",
"rfl",
"AddUnits"
] | true |
MonoidHom.finsuppProd_apply | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"Finsupp.instFunLike",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Finsupp.support",
"MonoidHom.finsetProd_apply",
"MulOneClass.toMulOne",
"CommMonoid.toMonoid",
"MonoidHom.instCommMonoid",
"MulOneClass",
"Eq",
"CommMonoid",
"DFunLike.coe",
"Finsupp",
"Finsupp.prod",
... | true |
CategoryTheory.Limits.Types.Small.productLimitCone | Mathlib.CategoryTheory.Limits.Types.Products | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.IsLimit.mk",
"CategoryTheory.Limits.Cone",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"TypeCat.instFunLikeF... | true |
Std.Do.SPred.entails.refl._simp_1 | Std.Do.SPred.Laws | [
"Std.Do.SPred.entails",
"Std.Do.SPred.entails.refl",
"List",
"True",
"eq_true",
"Std.Do.SPred",
"Eq"
] | false |
abs_pow_eq_one | Mathlib.Algebra.Order.Ring.Abs | [
"one_pow",
"Eq.mpr",
"MulOne.toOne",
"Ring.toNonAssocRing",
"Monoid.toMulOneClass",
"AddGroupWithOne.toAddGroup",
"abs",
"HEq.refl",
"LinearOrder",
"covariant_swap_add_of_covariant_add",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"pow_left_inj₀",
"IsStrictOrderedRing"... | true |
Pi.uniformSpace.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | [
"Pi.uniformSpace",
"UniformSpace",
"iInf",
"Pi.topologicalSpace",
"Pi.uniformSpace._proof_1",
"UniformSpace.toCore",
"Function.eval",
"UniformSpace.ofCoreEq",
"Eq.refl",
"UniformSpace.comap",
"UniformSpace.toTopologicalSpace",
"Eq",
"instInfSetUniformSpace"
] | true |
Aesop.RappId.instLT | Aesop.Tree.Data | [
"LT.mk",
"Nat",
"Aesop.RappId",
"Aesop.RappId.toNat",
"LT.lt",
"instLTNat",
"LT"
] | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | [
"Std.Sat.AIG.ArbitraryShiftTarget.mk",
"Std.Sat.AIG.ArbitraryShiftTarget.casesOn",
"Std.Sat.AIG",
"Nat",
"Std.Sat.AIG.ArbitraryShiftTarget",
"Hashable",
"Std.Sat.AIG.RefVec",
"DecidableEq"
] | false |
mem_absConvexHull_iff | Mathlib.Analysis.LocallyConvex.AbsConvex | [
"_private.Mathlib.Analysis.LocallyConvex.AbsConvex.0.mem_absConvexHull_iff._simp_1_1",
"Eq.mpr",
"ChainCompletePartialOrder.instOfCompleteLattice",
"absConvexHull",
"congrArg",
"Set.iInter",
"SMul",
"AbsConvex",
"PartialOrder.toPreorder",
"Membership.mem",
"PartialOrder",
"id",
"HasSubset.Su... | true |
_private.Lean.Meta.Basic.0.Lean.Meta.getConstTemp?._sparseCasesOn_1 | Lean.Meta.Basic | [
"Lean.ConstantInfo.recInfo",
"Lean.ConstantInfo.defnInfo",
"Lean.ConstructorVal",
"Nat.ne_of_beq_eq_false",
"Lean.QuotVal",
"Lean.ConstantInfo.inductInfo",
"Lean.ConstantInfo.opaqueInfo",
"Nat.shiftRight",
"Lean.ConstantInfo.thmInfo",
"Nat.hasNotBit",
"Lean.ConstantInfo.rec",
"instOfNatNat",
... | false |
Polynomial.eval₂_finset_sum | Mathlib.Algebra.Polynomial.Eval.Defs | [
"Finset",
"RingHom",
"Polynomial.eval₂",
"Polynomial",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Polynomial.semiring",
"Semiring",
"Polynomial.eval₂_finsetSum",
"Semiring.toNonAssocSemiring",
"Eq",
"Finset.sum"
] | true |
Aesop.ForwardHypData | Aesop.RuleTac.Forward.Basic | [
"Aesop.ForwardHypData.mk"
] | true |
CoeT.mk.noConfusion | Init.Coe | [
"HEq.refl",
"id",
"CoeT",
"heq_of_eq",
"Eq.refl",
"HEq",
"CoeT.noConfusion",
"Eq",
"CoeT.mk"
] | false |
Lean.MetavarContext.MkBinding.Context.noConfusionType | Lean.MetavarContext | [
"Lean.MVarIdSet",
"Bool",
"Lean.Name",
"Lean.MetavarContext.MkBinding.Context.casesOn",
"Lean.BinderInfo",
"Eq",
"Lean.MetavarContext.MkBinding.Context"
] | false |
WeierstrassCurve.Jacobian.addZ_self | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | [
"CommRing",
"HMul.hMul",
"sub_self",
"AddGroupWithOne.toAddGroup",
"CommSemiring.toSemiring",
"Fin.instOfNat",
"instOfNatNat",
"instDistribOfSemiring",
"Monoid.toPow",
"CommRing.toCommSemiring",
"HPow.hPow",
"Distrib.toMul",
"Nat.instNeZeroSucc",
"Nat",
"Semiring.toMonoid",
"Zero.toOfN... | true |
_private.Init.Data.List.Sort.Basic.0.List.mergeSort.match_1.congr_eq_2 | Init.Data.Array.Sort.Lemmas | [
"_private.Init.Data.List.Sort.Basic.0.List.mergeSort.match_1",
"id",
"List.cons",
"List",
"heq_of_eq",
"List.casesOn",
"Bool",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Eq",
"List.nil"
] | true |
Nat.getD_toList_roc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | [
"getElem?_neg",
"congrArg",
"HSub.hSub",
"Option.getD",
"List.instGetElem?NatLtLength",
"List.getD",
"Std.Roc.toList",
"instSubNat",
"LE.le",
"instLENat",
"Std.PRange.instLawfulUpwardEnumerableLENat",
"Nat.not_lt._simp_1",
"Option.none",
"List",
"instHAdd",
"instHSub",
"Std.Roc.lengt... | true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | [
"inv_eq_zero",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"GroupWithZero",
"DivisionMonoid.toDivInvOneMonoid",
"Inv.inv",
"MonoidWithZero.toMulZeroOneClass",
"propext",
"Zero.toOfNat0",
"InvOneClass.toInv",
"MulZeroOneClass.toMulZeroCla... | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.map.match_1.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.WithTerminal",
"CategoryTheory.WithTerminal.of",
"CategoryTheory.WithTerminal.star",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.WithTerminal.map.match_1",
"CategoryTheory.WithTerminal.instCategory",
... | true |
Lean.Parser.Term.optSemicolon.parenthesizer | Lean.Parser.Term | [
"Lean.Parser.ppDedent.parenthesizer",
"Lean.Parser.ppLine.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.andthen.parenthesizer",
"Lean.Parser.semicolonOrLinebreak.parenthesizer"
] | true |
Finset.biUnion_congr | Mathlib.Data.Finset.Union | [
"Finset",
"Membership.mem",
"Finset.biUnion",
"_private.Mathlib.Data.Finset.Union.0.Finset.biUnion_congr._proof_1_1",
"Finset.instSetLike",
"Eq",
"SetLike.instMembership",
"DecidableEq"
] | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_7 | Mathlib.GroupTheory.Perm.Centralizer | [
"Multiset.map",
"Multiset.mem_map",
"Membership.mem",
"Exists",
"Multiset",
"Multiset.instMembership",
"And",
"propext",
"Eq"
] | false |
Std.TreeSet.forIn_eq_forIn | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet.instForInOfMonad",
"Std.TreeSet",
"Std.TreeSet.forIn",
"Ordering",
"LawfulMonad",
"ForIn.forIn",
"ForInStep",
"Monad",
"Eq",
"rfl"
] | true |
Matrix.submatrix_gram | Mathlib.Analysis.InnerProductSpace.GramMatrix | [
"Matrix.submatrix",
"SeminormedAddCommGroup",
"Matrix",
"Function.comp",
"Set.Elem",
"RCLike",
"InnerProductSpace.toInner",
"Matrix.gram",
"Eq",
"InnerProductSpace",
"rfl",
"Set"
] | true |
Subalgebra.frontier_spectrum | Mathlib.Analysis.Normed.Algebra.Spectrum | [
"SetLike",
"Eq.mpr",
"frontier_compl",
"NormedCommRing.toSeminormedCommRing",
"frontier",
"Filter.Eventually.filter_mono",
"False",
"Filter.map_mono",
"Trans.trans",
"CompleteSpace",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"IsClosed.isOpen_compl",
"Algebra.algebraMap",
"spect... | true |
HahnSeries.SummableFamily.hasFiniteSupport_smul | Mathlib.RingTheory.HahnSeries.Summable | [
"Set.instSProd",
"HahnSeries.SummableFamily.toFun",
"instHSMul",
"SProd.sprod",
"SMulWithZero.toSMulZeroClass",
"Finset",
"AddMonoid.toAddZeroClass",
"Function.HasFiniteSupport",
"setOf",
"HahnSeries.SummableFamily.smul_support_subset_prod",
"AddZeroClass.toAddZero",
"PartialOrder",
"Set.Ele... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.