name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CommRingCat.forget_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | [
"CategoryTheory.Functor",
"UnivLE",
"CommRingCat.carrier",
"CommSemiring.toSemiring",
"CommRingCat",
"CommRingCat.instConcreteCategoryRingHomCarrier",
"CommRingCat.limitCone",
"CategoryTheory.Limits.PreservesLimitsOfSize.mk",
"CategoryTheory.Functor.comp",
"RingHom",
"Membership.mem",
"CommRin... | true |
LocallyFiniteOrder.ofFiniteIcc | Mathlib.Order.Interval.Finset.Defs | [
"LocallyFiniteOrder.ofIcc'",
"Preorder.toLE",
"Set.Finite",
"LE.le",
"Set.Icc",
"Set.Finite.toFinset",
"Classical.decRel",
"LocallyFiniteOrder",
"LocallyFiniteOrder.ofFiniteIcc._proof_1",
"Preorder"
] | true |
Lean.Elab.FieldInfo.lctx | Lean.Elab.InfoTree.Types | [
"Lean.Elab.FieldInfo",
"Lean.LocalContext"
] | true |
CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_obj | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"CategoryTheory.Limits.MulticospanShape.L",
"CategoryTheory.Limits.MulticospanIndex.sndPiMapOfIsLimit",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor",
"CategoryTheory.Limits.WalkingMulticospan.instSmallCategory",
"CategoryTheory.Limits.Fan",
"Categ... | true |
QuadraticAlgebra.smul_mk | Mathlib.Algebra.QuadraticAlgebra.Defs | [
"QuadraticAlgebra.instSMul",
"instHSMul",
"QuadraticAlgebra",
"SMul",
"QuadraticAlgebra.mk",
"HSMul.hSMul",
"Eq",
"rfl"
] | true |
MeasureTheory.Measure.ofMeasurable.congr_simp | Mathlib.MeasureTheory.VectorMeasure.Basic | [
"MeasureTheory.Measure",
"ChainCompletePartialOrder.instOfCompleteLattice",
"MeasurableSet",
"Function.onFun",
"ENNReal.instAddCommMonoid",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"MeasurableSet.empty",
"Disjoint",
"Eq.rec",
"ChainCompletePartialOrder.toPartialOrder",
"MeasurableSpace... | true |
Prod.normedCommRing._proof_21 | Mathlib.Analysis.Normed.Ring.Basic | [
"Norm.norm",
"NonUnitalNormedRing.toNorm",
"Real.instLE",
"Real",
"HMul.hMul",
"NormedCommRing",
"NonUnitalNonAssocRing.toMul",
"NonUnitalRing.toNonUnitalNonAssocRing",
"LE.le",
"Prod.nonUnitalNormedRing",
"NormedCommRing.toNonUnitalNormedCommRing",
"NonUnitalNormedRing.toNonUnitalRing",
"Re... | false |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop | Init.Data.Array.InsertionSort | [
"_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop._f",
"Nat.brecOn",
"Array",
"Nat",
"LT.lt",
"Bool",
"instLTNat",
"Array.size"
] | true |
ContinuousLinearMap.toBilinForm | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"NormedRing.toRing",
"ContinuousLinearMap.topologicalSpace",
"ContinuousLinearMap.toBilinForm._proof_2",
"LinearMap.BilinForm",
"C... | true |
Finsupp.lattice._proof_2 | Mathlib.Order.Preorder.Finsupp | [
"Lattice",
"Lattice.toSemilatticeSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"Finsupp.semilatticeSup",
"SemilatticeSup.toPartialOrder",
"SemilatticeSup.le_sup_right",
"Finsupp",
"SemilatticeSup.sup",
"Zero"
] | false |
KaehlerDifferential.kerToTensor.eq_1 | Mathlib.RingTheory.Smooth.Quotient | [
"Derivation",
"RingHom.instRingHomClass",
"CommRing",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"instAddCommGroupKaehlerDifferential",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommM... | true |
ContinuousLinearMap.nnnorm_holder_apply_apply_le | Mathlib.MeasureTheory.Function.Holder | [
"MeasureTheory.ae",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"ENNReal.ofNNReal",
"MeasureTheory.Measure",
"Preorder.toLT",
"NormedSpace.toIsBoundedSMul",
"MeasureTheory.Lp.memLp",
"HMul.hMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContinuousLinearMap.topo... | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjPullback._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | [
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"TopologicalSpace.Opens.instCompleteLattice",
"CommRingCat",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
... | false |
IsAddUnit.preimage_vadd_set | Mathlib.GroupTheory.GroupAction.Pointwise | [
"AddMonoid.toAddSemigroup",
"Set.vaddSet",
"id",
"IsAddUnit",
"HVAdd.hVAdd",
"AddAction",
"AddAction.toAddSemigroupAction",
"preimage_vadd_setₛₗ_of_isAddUnit_isAddUnit",
"AddSemigroupAction.toVAdd",
"Set.preimage",
"AddActionHomClass",
"AddMonoid",
"instHVAdd",
"Eq",
"DFunLike.coe",
"F... | true |
BitVec.reduceHShiftLeft'._regBuiltin.BitVec.reduceHShiftLeft'.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.4245661560._hygCtx._hyg.28 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | [
"BitVec.reduceHShiftLeft'",
"IO",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.Simproc"
] | false |
CochainComplex.HomComplex.Cocycle.precomp._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | [
"Int",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"Int.instAdd",
"OfNat.ofNat",
"Eq",
"rfl"
] | false |
Finsupp.support_mul | Mathlib.Data.Finsupp.Pointwise | [
"HMul.hMul",
"Finset",
"Finsupp.support",
"Finsupp.support_mul_subset_right",
"MulZeroClass",
"Finsupp.instMul",
"HasSubset.Subset",
"Inter.inter",
"Finset.instInter",
"Finset.instHasSubset",
"Finsupp.support_mul_subset_left",
"Finset.subset_inter",
"Finsupp",
"MulZeroClass.toZero",
"ins... | true |
Lean.Meta.Grind.Order.propagateEqTrue | Lean.Meta.Tactic.Grind.Order.Assert | [
"Lean.Meta.Grind.GrindM",
"Unit.unit",
"Lean.Meta.Sym.ExprPtr.mk",
"Lean.Meta.Grind.Goal",
"_private.Lean.Meta.Tactic.Grind.Order.Assert.0.Lean.Meta.Grind.Order.propagateEqTrue.match_3",
"Lean.Meta.Grind.State",
"ReaderT",
"Lean.Meta.Grind.Order.State.termMapInv",
"Lean.Meta.Grind.Order.getExpr",
... | true |
TopologicalSpace.countable_countableBasis | Mathlib.Topology.Bases | [
"Exists.choose_spec",
"TopologicalSpace.countableBasis",
"SecondCountableTopology",
"Membership.mem",
"TopologicalSpace",
"And",
"TopologicalSpace.exists_countable_basis",
"And.left",
"TopologicalSpace.IsTopologicalBasis",
"Set.instEmptyCollection",
"Exists.choose",
"EmptyCollection.emptyColle... | true |
deriv_id | Mathlib.Analysis.Calculus.Deriv.Basic | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Semiring.toModule",
"NormedRing.toRing",
"deriv",
"HasDerivAt.deriv",
"AddGroupWithOne.toAddMonoidWithOne",
"PseudoMetricSpace.toUniformSpace",
"NormedField.toField",
"id",
"NormedCommRing.toNonUnitalNormedCommRing",
"Field... | true |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.isUnaryEntries.match_3 | Lean.Data.PersistentHashMap | [
"Lean.PersistentHashMap.Entry.entry",
"Unit.unit",
"Lean.PersistentHashMap.Entry",
"Lean.PersistentHashMap.Entry.ref",
"Lean.PersistentHashMap.Node",
"Lean.PersistentHashMap.Entry.casesOn",
"Lean.PersistentHashMap.Entry.null",
"Unit"
] | false |
Tactic.NormNum.irrational_sqrt_rat_of_den | Mathlib.Tactic.NormNum.Irrational | [
"Eq.mpr",
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Real.instPow",
"False",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Nat.coprime_two_right._simp_1",
"mul_inv_cancel₀",
"Tactic.NormNum.irrational_rpow_rat_rat_... | true |
CategoryTheory.Iso.coreWhiskerLeft | Mathlib.CategoryTheory.Core | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.coreComp",
"CategoryTheory.Core.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"CategoryTheory.coreCategory",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.CoreHom.iso",
"Categor... | true |
Valued.toNormedField.one_le_norm_iff._simp_1 | Mathlib.Topology.Algebra.Valued.NormedValued | [
"Norm.norm",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Real.instLE",
"Real",
"Valued.toNormedField",
"InvOneClass.toOne",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"Valued.v",
"PartialOrder.toPreorder",
"LinearOrderedCommMonoidWithZero.toL... | false |
CategoryTheory.Sieve.instCompleteLattice.match_1 | Mathlib.CategoryTheory.Sites.Sieves | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Membership.mem",
"CategoryTheory.Sieve.arrows",
"CategoryTheory.Sieve",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Sieve.sup",
"Set.instMembership",
... | false |
isMin_grade_iff._simp_1 | Mathlib.Order.Grade | [
"GradeMinOrder",
"Preorder.toLE",
"GradeMinOrder.toGradeOrder",
"propext",
"Eq",
"grade",
"IsMin",
"Preorder",
"isMin_grade_iff"
] | false |
Lean.Lsp.instFromJsonCodeActionDisabled.fromJson | Lean.Data.Lsp.CodeActions | [
"Pure.pure",
"Lean.Json",
"Lean.instFromJsonString",
"Monad.toApplicative",
"String",
"Lean.Name.mkStr3",
"Lean.Json.getObjValAs?",
"Applicative.toPure",
"ToString.toString",
"Except.instMonad",
"Lean.Lsp.CodeActionDisabled.mk",
"instAppendString",
"Lean.Lsp.CodeActionDisabled",
"Except.ma... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.mk._flat_ctor | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | [
"Std.Sat.AIG.Decl",
"LE.le",
"instLENat",
"Std.Sat.AIG.Ref",
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput",
"Std.Sat.AIG",
"Nat",
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.mk",
"Hashable",
"Array.size",
"Std.Sat.AIG.decls",
"DecidableEq"
] | false |
rpow_one_add_lt_one_add_mul_self | Mathlib.Analysis.Convex.SpecificFunctions.Basic | [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"add_lt_add_right",
"lt_or_gt_of_ne",
"GroupWithZero.toMonoidWithZero",
"add_neg_cancel",
"NegZeroClass.toNeg",
"lt_add_neg_iff_add_lt",
"MulOne.toOne",
"Real.instPow... | true |
BooleanRing.toBooleanAlgebra._proof_3 | Mathlib.Algebra.Ring.BooleanRing | [
"Eq.mpr",
"MulOne.toOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"AddMonoid.toAddSemigroup",
"congrArg",
"CommSemiring.toSemiring",
"add_assoc",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"BooleanRing.toCommRing",
... | false |
AkraBazziRecurrence.isEquivalent_deriv_rpow_p_mul_one_sub_smoothingFn | Mathlib.Computability.AkraBazzi.AkraBazzi | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"NormedCommRing.toNormedRing",
"Asymptotics.transEventuallyEqIsEquivalent",
"Real.instIsOrderedRing",
"Norm.norm",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Asymptotics.isLittleO_const_left",
"SeminormedRi... | true |
_private.Init.Data.List.Monadic.0.List.zipWithM'.match_1.splitter | Init.Data.List.Monadic | [
"False",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.cons",
"Bool.true",
"Nat.land",
"List",
"absurd",
"Nat",
"_private.Init.Data.List.Monadic.0.List.zipWithM'.match_1.splitter._sparseCasesOn_2",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"HEq",
"OfNat.ofNat... | true |
Std.DTreeMap.Internal.Impl.Tree.mk.injEq | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.Tree.mk",
"Eq.propIntro",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Nat",
"Std.DTreeMap.Internal.Impl.Tree.mk.inj",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Std.DTreeMap.Internal.Impl.Tree",
"Std.DTreeMap.Internal.Impl"
] | true |
Std.IsPreorder.rec | Init.Data.Order.Classes | [
"LE.le",
"LE",
"Std.IsPreorder",
"Std.IsPreorder.mk"
] | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.fixBinderInfos._sparseCasesOn_1 | Mathlib.Tactic.Translate.Reorder | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.rec",
"List.cons",
"Nat.land",
"List",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"List.ctorIdx",
"List.nil"
] | false |
OreLocalization.instSemiring | Mathlib.RingTheory.OreLocalization.Ring | [
"OreLocalization.left_distrib",
"OreLocalization.instSemiring._proof_4",
"Semiring.toModule",
"OreLocalization.instSemiring._proof_9",
"AddMonoid.toAddSemigroup",
"OreLocalization.OreSet",
"OreLocalization.instSemiring._proof_6",
"OreLocalization",
"OreLocalization.instSemiring._proof_2",
"AddMono... | true |
_private.Mathlib.Topology.EMetricSpace.Defs.0.EMetric.tendsto_atTop._simp_1_1 | Mathlib.Topology.EMetricSpace.Defs | [
"Set.Ici",
"Preorder.toLE",
"Membership.mem",
"LE.le",
"Set.mem_Ici",
"propext",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
_private.Mathlib.Data.Num.Lemmas.0.Num.bit1_of_bit1.match_1_1 | Mathlib.Data.Num.Lemmas | [
"Unit.unit",
"Num",
"Unit",
"Num.pos",
"PosNum",
"Num.casesOn",
"Num.zero"
] | false |
Ideal.mem_iInf_smul_pow_eq_bot_iff | Mathlib.RingTheory.Filtration | [
"Iff.mpr",
"Eq.mpr",
"Submodule",
"MulOne.toOne",
"le_refl",
"Ideal.one_eq_top",
"CommRing",
"Nat.recAux",
"instHSMul",
"Submodule.mem_top._simp_1",
"iInf",
"Semiring.toModule",
"HMul.hMul",
"IsScalarTower.right",
"Submodule.mem_iInf",
"Ideal.trivialFiltration",
"Ideal.stableFiltrati... | true |
PowerSeries.rescale_eq_subst | Mathlib.RingTheory.PowerSeries.Substitution | [
"Eq.mpr",
"Unit.unit",
"CommRing",
"instHSMul",
"MvPowerSeries.rescale",
"congrArg",
"CommSemiring.toSemiring",
"MvPowerSeries",
"RingHom",
"Algebra.toSMul",
"PowerSeries.subst",
"Algebra.id",
"id",
"MvPowerSeries.subst",
"MvPowerSeries.instAlgebra",
"PowerSeries.X",
"MvPowerSeries.i... | true |
_private.Lean.Syntax.0.Lean.Syntax.identComponents.match_1 | Lean.Syntax | [
"Prod.mk",
"Substring.Raw",
"Lean.Name",
"Prod",
"Prod.casesOn"
] | false |
Std.HashMap.mem_of_mem_insert | Std.Data.HashMap.Lemmas | [
"Membership.mem",
"Std.HashMap",
"LawfulHashable",
"BEq.beq",
"EquivBEq",
"Bool",
"Hashable",
"Std.HashMap.inner",
"Bool.false",
"BEq",
"Eq",
"Std.HashMap.insert",
"Std.HashMap.instMembership",
"Std.DHashMap.mem_of_mem_insert"
] | true |
Lean.Elab.Tactic.refineCore | Lean.Elab.Tactic.ElabTerm | [
"Lean.instantiateMVars",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.instMonadMCtxOfMonadLift",
"Lean.Elab.Tactic.elabTermWithHoles",
"_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.refineCore.match_4",... | true |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_4 | Lean.Compiler.ExternAttr | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.rec",
"List.cons",
"Nat.land",
"List",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"List.ctorIdx",
"List.nil"
] | false |
Maximal.eq_of_superset | Mathlib.Order.Minimal | [
"SemilatticeInf.toPartialOrder",
"HasSubset.Subset",
"BiheytingAlgebra.toCoheytingAlgebra",
"BooleanAlgebra.toBiheytingAlgebra",
"Maximal.eq_of_ge",
"Set.instLE",
"Set.instBooleanAlgebra",
"CoheytingAlgebra.toGeneralizedCoheytingAlgebra",
"Maximal",
"GeneralizedCoheytingAlgebra.toLattice",
"Eq",... | true |
CategoryTheory.Presheaf.restrictedULiftYonedaHomEquiv'._proof_5 | Mathlib.CategoryTheory.Limits.Presheaf | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"Quiver.Hom.op",
"CategoryTheory.Functor.category",
"ULift",
"C... | false |
AlgebraicGeometry.Scheme.Cover.property_trans | Mathlib.AlgebraicGeometry.Cover.Directed | [
"CategoryTheory.MorphismProperty",
"AlgebraicGeometry.Scheme",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreZeroHypercover.X",
"CategoryTheory.PreZeroHypercover.I₀",
"AlgebraicGeometry.Scheme.Cover",
"AlgebraicGeometry.Scheme.Cover.LocallyDirected.property_trans",
"Cate... | true |
Std.HashSet.Raw.ofList_singleton | Std.Data.HashSet.RawLemmas | [
"Std.HashSet.Raw.insert",
"_private.Std.Data.HashSet.RawLemmas.0.Std.HashSet.Raw.ext",
"Std.HashSet.Raw.ofList",
"List.cons",
"Hashable",
"Std.HashMap.Raw.unitOfList_singleton",
"EmptyCollection.emptyCollection",
"BEq",
"Eq",
"Std.HashSet.Raw.instEmptyCollection",
"Std.HashSet.Raw",
"List.nil"... | true |
Lean.Grind.Ring.intCast_one | Init.Grind.Ring.Basic | [
"Int.cast",
"instOfNatNat",
"Int",
"Lean.Grind.Semiring.ofNat",
"Lean.Grind.Ring.intCast_ofNat",
"instOfNat",
"Lean.Grind.Ring",
"Nat",
"Lean.Grind.Ring.toSemiring",
"Lean.Grind.Ring.intCast",
"OfNat.ofNat",
"Eq"
] | true |
MvPolynomial.monomial_sum_one | Mathlib.Algebra.MvPolynomial.Basic | [
"Finsupp.instAddZeroClass",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MonoidHom.instMonoidHomClass",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"MonoidHom.instFunLike",
"Semiring.toModule",
"Equiv.instEquivLike",
"AddMonoidAlgebra.addAddCommMonoid",
"MonoidHom",
"CommSemiring.toSemir... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_get?_eq_some._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"beqOfOrd",
"Ordering",
"Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false",
"Ordering.eq",
"Ne",
"Ord.compare",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"Eq"
] | false |
String.Slice.Pattern.Model.isLongestMatchAt_startPos_iff | Init.Data.String.Lemmas.Pattern.Basic | [
"Iff.mpr",
"Eq.mpr",
"String.Slice.Pos.sliceFrom",
"String.instLEPos_1",
"String.Pos.Raw.unoffsetBy",
"Iff.of_eq",
"congrArg",
"String.Slice.Pos.offset",
"String.Slice.sliceFrom",
"String.Slice.Pos.startPos_le._simp_1",
"String.Slice",
"Exists",
"_private.Init.Data.String.Lemmas.Pattern.Basi... | true |
List.lt_asymm | Init.Data.List.Lex | [
"List.lex_asymm",
"List.instLT",
"List",
"Std.Asymm",
"LT.lt",
"Std.Asymm.asymm",
"Not",
"LT"
] | true |
_private.Mathlib.RingTheory.Nullstellensatz.0.MvPolynomial.isMaximal_iff_eq_vanishingIdeal_singleton.match_1_1 | Mathlib.RingTheory.Nullstellensatz | [
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"CommSemiring.toSemiring",
"Finsupp.instAddMonoid",
"Nat.instAddMonoid",
"Exists",
"Algebra.id",
"Set.instSingletonSet",
"MvPolynomial.vanishingIdeal",
"Ideal",
"Field.toSemifield",
"Exists.casesOn",
"Nat",
"MvPolynomial",
"Exists.intr... | false |
Rep.applyAsHom_comm_assoc | Mathlib.RepresentationTheory.Rep.Basic | [
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Rep.instCategory",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"Rep.applyAsHom",
"Rep",
"Rep.applyAsHom_comm",
"CommMonoid.toMonoid",
"congr",
"CategoryTheory.CategoryStruct.comp"... | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.eq_1 | Std.Data.DHashMap.Internal.Model | [
"Std.DHashMap.Internal.Raw₀.interSmallerFn",
"Sigma.fst",
"Unit",
"Std.DHashMap.Internal.Raw₀.insert",
"Eq.refl",
"Hashable",
"Std.DHashMap.Internal.Raw₀.getEntry?",
"_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.match_1",
"Sigma.snd",
"BEq",
"Eq",
"Std.D... | true |
Int64.neg_mul_comm | Init.Data.SInt.Lemmas | [
"HMul.hMul",
"BitVec",
"Int64",
"Int64.instNeg",
"instOfNatNat",
"BitVec.neg_mul_comm",
"Nat",
"Iff.mp",
"Int64.toBitVec",
"OfNat.ofNat",
"Eq",
"instMulInt64",
"Neg.neg",
"Int64.toBitVec_inj",
"instHMul"
] | true |
Std.Internal.List.modifyKey_eq_alterKey | Std.Data.Internal.List.Associative | [
"cond",
"Eq.mpr",
"_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.alterKey.match_1.splitter",
"Std.Internal.List.replaceEntry",
"congrArg",
"Std.Internal.List.getValueCast?",
"Option.getD.match_1",
"Option.some",
"LawfulBEq",
"id",
"Std.Internal.List.insertEntry",
"Std.Interna... | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.UniformCauchySeqOn.prodMap._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | [
"Prod.mk",
"propext",
"Prod.forall",
"Prod",
"Eq"
] | false |
Lean.Meta.Grind.EMatchTheoremConstraint.casesOn | Lean.Meta.Tactic.Grind.Extension | [
"Lean.Meta.Grind.EMatchTheoremConstraint",
"Lean.Meta.Grind.EMatchTheoremConstraint.rec",
"Lean.Meta.Grind.EMatchTheoremConstraint.defEq",
"Lean.Meta.Grind.CnstrRHS",
"Lean.Meta.Grind.EMatchTheoremConstraint.genLt",
"Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq",
"Lean.Expr",
"Lean.Meta.Grind.EMat... | false |
Lean.Level.PP.Result._sizeOf_2 | Lean.Level | [
"instOfNatNat",
"List",
"instHAdd",
"Lean.Level.PP.Result",
"HAdd.hAdd",
"Lean.instSizeOfName",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Lean.Name",
"instSizeOfNat",
"OfNat.ofNat",
"Lean.Level.PP.Result.rec_1"
] | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.Hom.comp | Mathlib.CategoryTheory.Galois.Prorepresentability | [
"CategoryTheory.PreGaloisCategory.PointedGaloisObject.pt",
"CategoryTheory.Functor",
"CategoryTheory.ConcreteCategory.hom",
"Finite",
"FintypeCat",
"TypeCat.instFunLikeFun",
"CategoryTheory.ObjectProperty.FullSubcategory.concreteCategory",
"CategoryTheory.PreGaloisCategory.PointedGaloisObject.obj",
... | true |
Filter.IsMeasurablyGenerated | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | [
"MeasurableSpace",
"Filter.IsMeasurablyGenerated.mk",
"Filter"
] | true |
LocallyLipschitzOn.add | Mathlib.Analysis.Normed.Group.Uniform | [
"Filter.instMembership",
"LipschitzOnWith.mono",
"SeminormedAddCommGroup",
"nhdsWithin",
"AddMonoid.toAddZeroClass",
"Filter.inter_mem",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"Distrib.toAdd",
"Set.inter_subset_left",
"NNReal",
"Set.instInter",
"... | true |
Complex.im_qsmul | Mathlib.Data.Complex.Basic | [
"Real",
"instHSMul",
"Real.instAddMonoid",
"Complex.im",
"AddMonoid.toAddZeroClass",
"Rat",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddZero.toZero",
"Real.instDivisionRing",
"Rat.instDistribSMul",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"Complex",
"Eq",
"Complex.smul_i... | true |
Batteries.UnionFind.rootD_rootD | Batteries.Data.UnionFind.Basic | [
"Iff.mpr",
"Batteries.UnionFind.rootD",
"Batteries.UnionFind.parent_rootD",
"Nat",
"Batteries.UnionFind",
"Batteries.UnionFind.rootD_eq_self",
"Eq",
"Batteries.UnionFind.parent"
] | true |
WeierstrassCurve.Projective.negDblY_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | [
"Finsupp.instAddZeroClass",
"WeierstrassCurve.Projective.negY",
"Eq.mpr",
"NegZeroClass.toNeg",
"Nat.instMulZeroClass",
"IsDomain.to_noZeroDivisors",
"neg_div",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"WeierstrassCurve.Projective.Equation",
"CommRing.toNonUnit... | true |
Polynomial.nthRootsFinset.eq_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | [
"Multiset.toFinset",
"IsDomain",
"CommRing",
"CommSemiring.toSemiring",
"Finset",
"Polynomial.nthRoots",
"CommRing.toCommSemiring",
"Nat",
"Polynomial.nthRootsFinset",
"Eq.refl",
"Eq",
"Classical.decEq"
] | true |
Lean.Meta.mkPProdSnd | Lean.Meta.PProdN | [
"Unit.unit",
"Lean.Expr.isApp",
"String",
"Lean.Expr.cleanupAnnotations",
"panicWithPosWithDecl",
"Lean.Expr",
"instDecidableEqBool",
"instOfNatNat",
"Lean.Expr.instToString",
"ToString.toString",
"Lean.Expr.appFnCleanup",
"dite",
"Lean.instInhabitedExpr",
"Bool.true",
"instAppendString"... | true |
instAssociativeUInt32HXor | Init.Data.UInt.Bitwise | [
"UInt32.xor_assoc",
"Std.Associative.mk",
"HXor.hXor",
"UInt32",
"instXorOpUInt32",
"instHXorOfXorOp",
"Std.Associative"
] | true |
Std.DHashMap.Raw.Const.getKey?_ofList_of_mem | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.Const.ofList",
"Eq.mpr",
"List.Pairwise",
"congrArg",
"Std.DHashMap.Internal.Raw₀.getKey?",
"instForInOfForIn'",
"List.map",
"Std.DHashMap.Raw",
"Std.DHashMap.Internal.Raw.getKey?_eq",
"Option.some",
"Membership.mem",
"inferInstance",
"id",
"Std.DHashMap.Internal.Raw₀.Con... | true |
linearIndependent_of_top_le_span_of_card_eq_finrank | Mathlib.LinearAlgebra.Dimension.OrzechProperty | [
"linearIndependent_of_top_le_span_of_card_le_finrank",
"Submodule",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Fintype.card",
"Eq.le",
"Submodule.instPartialOrder",
"Submodule.instTop",
"LE.le",
"AddCommMonoid",
"OrzechProperty",
"Fintype",
"Nat.instPreorder",
"Nat",
"LinearIndependent... | true |
Sym2.map_pmap | Mathlib.Data.Sym.Sym2 | [
"Iff.mpr",
"Sym2.map",
"Sym2.mk",
"Membership.mem",
"Exists",
"Sym2.ind",
"And",
"And.intro",
"Sym2.instSetLike",
"Exists.intro",
"Eq.ndrec",
"Eq.refl",
"Sym2.mem_map",
"Sym2.pmap",
"Eq.symm",
"Eq",
"Sym2",
"SetLike.instMembership",
"rfl"
] | true |
CategoryTheory.Functor.map_mono | Mathlib.CategoryTheory.Functor.EpiMono | [
"CategoryTheory.Functor",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.map",
"CategoryTheory.Functor.PreservesMonomorphisms",
"CategoryTheory.Functor.PreservesMonomorphisms.preserves",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheo... | true |
Lean.Elab.Tactic.BVDecide.LRAT.trim.Context._sizeOf_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | [
"Std.HashMap._sizeOf_inst",
"Std.Tactic.BVDecide.LRAT.Action._sizeOf_inst",
"Std.Tactic.BVDecide.LRAT.IntAction",
"Lean.Elab.Tactic.BVDecide.LRAT.trim.Context.rec",
"instOfNatNat",
"Int",
"Std.HashMap",
"instHashableNat",
"instBEqOfDecidableEq",
"Array._sizeOf_inst",
"Array",
"instHAdd",
"HA... | false |
IsCompact.isOpen_constructibleTopology_of_isOpen | Mathlib.Topology.Spectral.ConstructibleTopology | [
"congrArg",
"and_self",
"Compl.compl",
"true_or",
"setOf",
"constructibleTopology",
"Membership.mem",
"Set.instUnion",
"TopologicalSpace.isOpen_generateFrom_of_mem",
"Set.instCompl",
"IsClosed",
"TopologicalSpace",
"And",
"constructibleTopologySubbasis",
"congr",
"True",
"eq_true",
... | true |
Prod.instRightCancelSemigroup | Mathlib.Algebra.Group.Prod | [
"Prod.instRightCancelSemigroup._proof_1",
"Prod.instSemigroup",
"RightCancelSemigroup.toSemigroup",
"RightCancelSemigroup.mk",
"Prod",
"RightCancelSemigroup"
] | true |
CategoryTheory.ShortComplex.Homotopy.noConfusionType | Mathlib.Algebra.Homology.ShortComplex.Preadditive | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex.Hom.τ₁",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.ShortComplex.Homotopy",
"CategoryTheory.ShortComplex.instCategory",
"CategoryTheory.ShortComp... | false |
Lean.Elab.Tactic.Do.ProofMode.MStartResult._sizeOf_inst | Lean.Elab.Tactic.Do.ProofMode.Basic | [
"Lean.Elab.Tactic.Do.ProofMode.MStartResult",
"SizeOf.mk",
"SizeOf",
"Lean.Elab.Tactic.Do.ProofMode.MStartResult._sizeOf_1"
] | false |
Module.DirectedSystem.map_self | Mathlib.Algebra.Colimit.Module | [
"le_rfl",
"Preorder.toLE",
"DirectedSystem.map_self'",
"LE.le",
"DirectedSystem",
"Eq",
"DFunLike.coe",
"Preorder",
"FunLike"
] | true |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.coev_app._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | [
"CategoryTheory.MonoidalCategory.DayConvolution.convolution",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategory.DayConvolution",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalClosed.pre",
"CategoryTheory.MonoidalCategory.Day... | false |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.ext_iff.match_1_1 | Mathlib.LinearAlgebra.LinearPMap | [
"Submodule",
"AddCommGroup.toAddCommMonoid",
"RingHom",
"Membership.mem",
"AddCommGroup",
"Subtype.mk",
"And.casesOn",
"LinearPMap",
"And",
"And.intro",
"Submodule.setLike",
"Module",
"LinearPMap.domain",
"Semiring.toNonAssocSemiring",
"Ring.toSemiring",
"Eq",
"Ring",
"SetLike.inst... | false |
groupCohomology.isoCocycles₂_hom_comp_i | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | [
"Pi.Function.module",
"Submodule",
"Rep.V",
"CategoryTheory.Functor",
"CommRing",
"CategoryTheory.ShortComplex.leftHomologyData",
"HomologicalComplex.instCategory",
"Pi.addCommMonoid",
"groupCohomology.cocycles",
"Nat.instOne",
"groupCohomology.comp_d₁₂_eq",
"CategoryTheory.CategoryStruct.toQu... | true |
_private.Mathlib.Logic.Function.Basic.0.Function.injective_comp_right_iff_surjective.match_1_1 | Mathlib.Logic.Function.Basic | [
"Exists",
"Exists.casesOn",
"Exists.intro",
"Eq",
"Not"
] | false |
String.getUTF8Byte_eq_getUTF8Byte_toSlice._proof_1 | Init.Data.String.Lemmas.Basic | [
"String.toSlice",
"Eq.mpr",
"String.instLTRaw",
"congrArg",
"String",
"String.rawEndPos_toSlice",
"String.Slice.rawEndPos",
"id",
"String.Pos.Raw",
"String.rawEndPos",
"LT.lt",
"Eq"
] | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.toArray_ne_nil._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | [
"Std.Rci",
"Std.PRange.UpwardEnumerable",
"Std.Rci.toList",
"List.toArray",
"Array",
"Std.Rxi.IsAlwaysFinite",
"Std.Rci.toArray_toList",
"Eq.symm",
"Eq",
"Std.PRange.LawfulUpwardEnumerable",
"Std.Rci.toArray"
] | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.LawfulBackwardPatternModel.skipSuffix?_sliceTo_eq_none_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | [
"String.Slice.Pattern.BackwardPattern",
"String.Slice.Pattern.BackwardPattern.skipSuffix?",
"Option.some",
"String.Slice",
"propext",
"String.Slice.Pattern.Model.PatternModel",
"String.Slice.Pos",
"String.Slice.Pattern.Model.LawfulBackwardPatternModel.skipSuffix?_eq_some_iff",
"String.Slice.Pattern.... | false |
_private.Lean.Elab.Frontend.0.Lean.Elab.IO.processCommandsIncrementally.go | Lean.Elab.Frontend | [
"Lean.Elab.instNonemptyIncrementalState",
"Classical.ofNonempty",
"instNonemptyOfMonad",
"Task",
"Lean.Elab.IncrementalState",
"Array",
"instMonadBaseIO",
"Lean.Parser.InputContext",
"Lean.Language.Lean.CommandParsedSnapshot",
"BaseIO"
] | true |
Lean.Meta.GeneralizeArg.rec | Lean.Meta.Tactic.Generalize | [
"Lean.Meta.GeneralizeArg",
"Lean.Expr",
"Lean.Meta.GeneralizeArg.mk",
"Lean.Name",
"Option"
] | false |
CompHausLike.productIsLimit._proof_6 | Mathlib.Topology.Category.CompHausLike.Cartesian | [
"CategoryTheory.Limits.BinaryFan",
"CompHausLike.instHasPropCarrierToTop",
"CompHausLike",
"TopCat.str",
"TopCat.carrier",
"CompHausLike.category",
"TopCat",
"CompHausLike.toTop",
"CompHausLike.HasProp"
] | false |
FirstOrder.Language.ElementaryEmbedding.instFunLike | Mathlib.ModelTheory.ElementaryMaps | [
"DFunLike.mk",
"FirstOrder.Language.ElementaryEmbedding.toFun",
"FirstOrder.Language.ElementaryEmbedding.instFunLike._proof_2",
"FirstOrder.Language.Structure",
"FirstOrder.Language",
"FirstOrder.Language.ElementaryEmbedding",
"Eq",
"FunLike"
] | true |
Equiv.prodUnique_apply | Mathlib.Logic.Equiv.Prod | [
"Equiv.instEquivLike",
"Unique",
"Equiv",
"Prod.fst",
"Equiv.prodUnique",
"Prod",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike"
] | true |
FiniteField.splits_X_pow_card_sub_X | Mathlib.FieldTheory.Finite.GaloisField | [
"Nat.Prime",
"Algebra.algebraMap",
"HSub.hSub",
"Algebra",
"Field.toDivisionRing",
"Fact",
"Fintype.card",
"DivisionRing.toRing",
"Polynomial.IsSplittingField.splits",
"Field.toSemifield",
"ZMod",
"Polynomial",
"Monoid.toPow",
"ZMod.instField",
"instHSub",
"Semifield.toDivisionSemiring... | true |
CategoryTheory.Functor.leftUnitor._proof_9 | Mathlib.CategoryTheory.Functor.Category | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"CategoryTheory.Functor.leftUnitor._proof_2",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"Catego... | false |
_private.Mathlib.AlgebraicTopology.DoldKan.Faces.0.AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq._proof_1_13 | Mathlib.AlgebraicTopology.DoldKan.Faces | [
"Lean.RArray.leaf",
"False",
"congrArg",
"Classical.byContradiction",
"Nat.Linear.ExprCnstr.eq_true_of_isValid",
"Lean.Grind.Nat.lt_eq",
"Lean.RArray.branch",
"id",
"False.casesOn",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.Linear.Expr.num",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
"Na... | false |
String.get!_eq_get | Init.Data.String.Basic | [
"String",
"String.Pos.Raw",
"String.Pos.Raw.get!",
"String.Pos.Raw.get",
"Char",
"Eq",
"rfl"
] | true |
CategoryTheory.Functor.coconeTypes | Mathlib.CategoryTheory.Limits.Types.ColimitType | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.ColimitType",
"CategoryTheory.Functor.CoconeTypes",
"CategoryTheory.types",
"CategoryTheory.Functor.CoconeTypes.mk",
"CategoryTheory.Functor.ιColimitType",
"CategoryTheory.Functor.coconeTypes._proof_2",
"CategoryTheory.Category"
] | true |
WeierstrassCurve.j_of_isCharTwoJNeZeroNF_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | [
"one_pow",
"Units.val",
"Eq.mpr",
"WeierstrassCurve.Δ",
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"WeierstrassCurve.IsElliptic",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"We... | true |
SSet.Truncated.Path.mk₂ | Mathlib.AlgebraicTopology.SimplicialSet.Path | [
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"Opposite",
"SSet.Truncated.Path.arrow",
"SSet.Truncated.trunc",
"SSet.Truncated.Path.vertex._proof_2",
"CategoryTheory.Functor.category",
"SSet.Truncated",
"SSet.Truncated.Path₁._proof_2",
"SSet.Truncated.Path.mk₂._proof_1",
"SSet.Truncated.Path... | true |
Lean.Parser.checkLineEq | Lean.Parser.Basic | [
"Lean.Parser.ParserInfo.mk",
"Lean.Parser.checkLineEqFn",
"Lean.Parser.FirstTokens.unknown",
"Lean.Parser.Parser",
"String",
"Lean.Parser.Parser.mk",
"Lean.Parser.Token",
"id",
"List",
"optParam",
"Lean.Parser.SyntaxNodeKindSet"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.