name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
MonovaryOn.of_inv_left | Mathlib.Algebra.Order.Monovary | [
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"IsOrderedMonoid",
"PartialOrder.toPreorder",
"Pi.instInv",
"DivisionMonoid.toDivInvOneMonoid",
"PartialOrder",
"MonovaryOn",
"AntivaryOn",
"CommGroup",
"CommGroup.toDivisionCommMonoid",
"Inv.inv",
"Iff.mp",
"InvOneCla... | true |
Partrec.map | Mathlib.Computability.Partrec | [
"Part",
"PFun",
"congrArg",
"Part.bind",
"Part.some",
"Partrec.bind",
"Eq.mp",
"Part.bind_some_eq_map",
"funext",
"Computable₂",
"Primcodable",
"Partrec",
"Part.map"
] | true |
Std.Iterators.Types.ArrayIterator.pos | Std.Data.Iterators.Producers.Monadic.Array | [
"Std.Iterators.Types.ArrayIterator",
"Nat"
] | true |
Int.ediv_lt_ediv_iff_of_dvd_of_neg_of_pos | Init.Data.Int.DivMod.Lemmas | [
"Int.instDiv",
"False",
"Int.mul_lt_mul_right_of_neg._simp_1",
"Dvd.dvd",
"instHDiv",
"HMul.hMul",
"congrArg",
"Int.mul_assoc",
"Int.mul_ediv_cancel",
"HDiv.hDiv",
"Int",
"Int.instDvd",
"Int.instMul",
"iff_self",
"Int.instLTInt",
"_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_lt_ediv... | true |
CFC.conjSqrt_ringInverse_conjSqrt._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Turing.PartrecToTM2.Cont'.cons₁.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Cont'",
"Turing.ToPartrec.Code._sizeOf_inst",
"Turing.PartrecToTM2.Cont'._sizeOf_inst",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Turing.PartrecToTM2.Cont'.cons₁",
"Turing.ToPartrec.Code"
] | true |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | [
"Eq.mpr",
"Std.DHashMap.Const.insertManyIfNewUnit",
"Std.ExtDHashMap.instMembershipOfEquivBEqOfLawfulHashable",
"congrArg",
"instForInOfForIn'",
"List.contains",
"Membership.mem",
"inferInstance",
"id",
"Std.ExtDHashMap.inductionOn",
"Std.ExtDHashMap.mk",
"Id",
"Membership",
"LawfulHashabl... | true |
CategoryTheory.Mon.instCreatesLimitsOfSizeForget | Mathlib.CategoryTheory.Monoidal.Internal.Limits | [
"CategoryTheory.CreatesLimitsOfSize.mk",
"CategoryTheory.CreatesLimitsOfShape",
"CategoryTheory.MonoidalCategory",
"inferInstance",
"CategoryTheory.Mon.forget",
"CategoryTheory.CreatesLimitsOfSize",
"CategoryTheory.Mon",
"CategoryTheory.Mon.instCategory",
"CategoryTheory.Mon.instCreatesLimitsOfShape... | true |
Std.HashSet.Equiv.union_right | Std.Data.HashSet.Lemmas | [
"Std.HashSet",
"Std.HashSet.Equiv.inner",
"Std.HashSet.instUnion",
"LawfulHashable",
"Std.HashSet.Equiv.mk",
"Unit",
"EquivBEq",
"Std.HashSet.inner",
"Std.HashMap.Equiv.union_right",
"Std.HashSet.Equiv",
"Hashable",
"Union.union",
"BEq"
] | true |
CategoryTheory.mateEquiv_hcomp | Mathlib.CategoryTheory.Adjunction.Mates | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.mateEquiv._proof_2",
"CategoryTheory.Functor",
"Function.LeftInverse",
"Equiv.instEquivLike",
"CategoryTheory.Adjunction.CoreHomEquivUnitCounit",
"CategoryTheory.Adjunction.comp._proof_2",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.... | true |
_private.Qq.MatchImpl.0.Lean.Syntax.stripPos.match_1 | Qq.MatchImpl | [
"Lean.Syntax.node",
"Unit.unit",
"Lean.Syntax.ident",
"Lean.Syntax.missing",
"String",
"Lean.SourceInfo",
"Lean.Syntax.casesOn",
"Lean.Syntax.atom",
"Lean.Syntax",
"Substring.Raw",
"Array",
"List",
"Unit",
"Lean.Syntax.Preresolved",
"Lean.Name",
"Lean.SyntaxNodeKind"
] | false |
SSet.horn₂₁.ι₁₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | [
"SimplexCategory.instOfNatToTypeOrderHomFinHAddNatLenOfNat._proof_1",
"False",
"congrArg",
"Nat.instAtLeastTwoHAddOfNat",
"Nat.instCharZero",
"Fin.instOfNat",
"Fin.zero_eq_one_iff._simp_1",
"Ne",
"instOfNatNat",
"Nat.instAddMonoidWithOne",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Si... | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.mem_toList_iff_isPlausibleIndirectOutput._simp_1_4 | Init.Data.Iterators.Lemmas.Consumers.Loop | [
"Std.IterStep",
"Std.IterStep.successor",
"Option.some",
"Exists",
"Std.Iter.IsPlausibleSuccessorOf",
"Std.Iter.isPlausibleSuccessorOf_iff_exists",
"Id",
"Std.Iterator",
"And",
"Std.Iter",
"propext",
"Std.Iter.IsPlausibleStep",
"Eq",
"Option"
] | false |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_strictMono.match_1_1 | Mathlib.Order.SuccPred.WithBot | [
"WithBot.instPreorder",
"False",
"Option.some.noConfusion",
"WithBot.some",
"WithBot",
"Preorder.toLT",
"Option.ctorIdx",
"WithBot.LT.coe_lt_coe",
"HEq.refl",
"False.elim",
"Option.casesOn",
"noConfusion_of_Nat",
"Option.some",
"Bot.bot",
"WithBot.LT",
"Option.none",
"LT.lt",
"With... | false |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.fdo_eq_interior_fd._simp_1_1 | Mathlib.NumberTheory.Modular | [
"Membership.mem",
"Set.preimage",
"propext",
"Eq",
"Set.instMembership",
"Set.mem_preimage",
"Set"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.le_sum_card_subset_chunk_parts | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | [
"Finpartition.ofSubset_parts",
"Real.instIsOrderedRing",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"div_le_iff₀",
"SzemerediRegularity.stepBound",
"Real.partialOrder",
"Real.instLE",
"Real",
"Lattice.toSemilatticeSup",
"instHDiv",
"Nat.instIsOrder... | true |
Fin2.last.eq_1 | Mathlib.Data.Fin.Fin2 | [
"Fin2.fz",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Fin2.last",
"Fin2"
] | true |
exists_eq_pow_of_mul_eq_pow | Mathlib.Algebra.GCDMonoid.Basic | [
"HMul.hMul",
"GCDMonoid",
"MulZeroClass.toMul",
"_private.Mathlib.Algebra.GCDMonoid.Basic.0.exists_eq_pow_of_mul_eq_pow.match_1_1",
"IsUnit",
"Exists",
"Units",
"CommMonoidWithZero.toMonoidWithZero",
"Monoid.toPow",
"GCDMonoid.gcd",
"associated_iff_eq",
"Associated",
"MonoidWithZero.toMulZer... | true |
_private.Batteries.Tactic.HelpCmd.0.Batteries.Tactic.elabHelpCat._sparseCasesOn_12 | Batteries.Tactic.HelpCmd | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
Rat.padicValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | [
"NormedCommRing.toNormedRing",
"Rat.instOfNat",
"Int.instAddCommMonoid",
"Multiplicative.linearOrder",
"Int.instIsStrictOrderedRing",
"NormedRing.toRing",
"instConditionallyCompleteLinearOrder",
"congrArg",
"Int.instLinearOrder",
"Rat",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder... | false |
Lean.Meta.withFreshCache | Lean.Meta.Basic | [
"Lean.Meta.State.mk",
"Lean.Meta.instBEqInfoCacheKey",
"Lean.Meta.instHashableDefEqCacheKey",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"modify",
"Lean.Meta.State.mctx",
"Lean.Meta.instBEqDefEqCacheKey",
"Lean.Meta.State",
"Lean.Meta.InfoCacheKey",
"instMonadLiftT",
... | true |
Metric.coveringNumber_empty | Mathlib.Topology.MetricSpace.CoveringNumbers | [
"Set.encard",
"iInf",
"instCompleteLinearOrderENat",
"Iff.of_eq",
"congrArg",
"CommSemiring.toSemiring",
"CompletelyDistribLattice.toCompleteLattice",
"Set.encard_empty",
"NNReal",
"HasSubset.Subset",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"Metric.IsCover",
"Pseud... | true |
Module.isTorsionBySet_iff_subseteq_ker_lsmul | Mathlib.Algebra.Module.Torsion.Basic | [
"Iff.mpr",
"Submodule",
"Module.IsTorsionBySet",
"instHSMul",
"DFunLike.congr_fun",
"Semiring.toModule",
"LinearMap.ext",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"LinearMap.ker",
"LinearMap.instFunLike",
"Membership.mem",
"LinearMap.lsmul",
... | true |
Real.volume_Ioo | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | [
"Real.partialOrder",
"ConditionallyCompleteLinearOrder.toCompactIccSpace",
"Real",
"MeasureTheory.Measure",
"StieltjesFunction.measure_Ioo",
"Real.volume_val",
"MulZeroClass.toMul",
"ENNReal.ofReal",
"congrArg",
"Real.instSub",
"StieltjesFunction.id_leftLim",
"MeasureTheory.MeasureSpace.toMeas... | true |
PiTensorProduct.tprod._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Function.update",
"CommSemiring.toSemiring",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"PiTensorProduct.instAddCommMonoid",
"AddCommMonoid",
"CommSemiring",
"AddMonoidWithOne.toOne",
"instHAdd",
"HAdd.hAdd",
"PiTensorProduct.tprodCoeff",
"PiTensorPr... | false |
Finset.centerMass | Mathlib.Analysis.Convex.Combination | [
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Finset",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
... | true |
CoalgEquiv.instEquivLike._proof_1 | Mathlib.RingTheory.Coalgebra.Equiv | [
"CoalgebraStruct",
"CoalgHom.toLinearMap",
"CommSemiring.toSemiring",
"CoalgHom",
"CoalgEquiv.toCoalgHom_injective",
"LinearMap.toAddHom",
"AddCommMonoid",
"CommSemiring",
"CoalgEquiv.toCoalgHom",
"DFunLike.coe_injective",
"AddCommSemigroup.toAddCommMagma",
"CoalgHom.funLike",
"Module",
"C... | false |
List.mapIdx_singleton | Init.Data.List.MapIdx | [
"List.mapIdx",
"congrArg",
"instOfNatNat",
"List.cons",
"List",
"Nat",
"True",
"eq_self",
"List.mapIdx_cons",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Eq",
"Eq.trans",
"List.nil"
] | true |
SSet.boundary_zero | Mathlib.AlgebraicTopology.SimplicialSet.Boundary | [
"Set.ext",
"Eq.mpr",
"False",
"Lattice.toSemilatticeSup",
"Opposite",
"SimplexCategory.instFintypeToTypeOrderHomFinHAddNatLenOfNat",
"iff_false",
"CompleteLattice.toLattice",
"congrArg",
"_private.Mathlib.AlgebraicTopology.SimplicialSet.Boundary.0.SSet.boundary_zero._simp_1_2",
"OrderBot.toBot",... | true |
AlexDisc.category._aux_5 | Mathlib.Topology.Order.Category.AlexDisc | [
"Quiver.mk",
"Quiver.Hom",
"TopCat.instCategory",
"AlexDisc.category._aux_1",
"CategoryTheory.InducedCategory.Hom",
"AlexDisc",
"AlexDisc.toTopCat",
"CategoryTheory.InducedCategory",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.InducedCategory.Hom.mk",
"CategoryTheory.Category.toCategor... | false |
instLTOption | Init.Data.Option.Basic | [
"LT.mk",
"Option.lt",
"LT.lt",
"LT",
"Option"
] | true |
Lean.JsonRpc.RequestID.null.sizeOf_spec | Lean.Data.JsonRpc | [
"Lean.JsonRpc.RequestID.null",
"instOfNatNat",
"Nat",
"SizeOf.sizeOf",
"Lean.JsonRpc.RequestID._sizeOf_inst",
"Eq.refl",
"Lean.JsonRpc.RequestID",
"OfNat.ofNat",
"Eq"
] | true |
HomogeneousPow.rec | Init.Prelude | [
"HomogeneousPow.mk",
"HomogeneousPow"
] | false |
TensorProduct.instBialgebra._proof_18 | Mathlib.RingTheory.Bialgebra.TensorProduct | [
"TensorProduct.instBialgebra._proof_6",
"AlgHom.toLinearMap",
"Eq.mpr",
"IsScalarTower.to_smulCommClass'",
"Coalgebra.toCoalgebraStruct",
"Algebra.to_smulCommClass",
"Bialgebra.comulAlgHom",
"AlgHom.algHomClass",
"HMul.hMul",
"IsScalarTower.right",
"AlgEquiv.toAlgHom",
"Monoid.toMulOneClass",
... | false |
Std.Iterators.PostconditionT.bind | Init.Data.Iterators.PostconditionMonad | [
"Monad.toApplicative",
"Exists",
"Std.Iterators.PostconditionT.Property",
"Subtype",
"Std.Iterators.PostconditionT.mk",
"Std.Iterators.PostconditionT.operation",
"Subtype.mk",
"And",
"Applicative.toFunctor",
"Std.Iterators.PostconditionT",
"Monad.toBind",
"Bind.bind",
"Monad",
"Subtype.val... | true |
Perfection.lift._proof_12 | Mathlib.RingTheory.Perfection | [
"PerfectRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.Prime",
"frobeniusEquiv",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"AddMonoid.toAddZeroClass",
"RingHom",
"Fact",
"AddZeroClass.toAddZero",
"Distrib.toAdd",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
... | false |
Polynomial.Splits.comp_of_degree_le_one | Mathlib.Algebra.Polynomial.Splits | [
"WithBot.instPreorder",
"WithBot",
"Nat.instOne",
"Preorder.toLE",
"instOfNatNat",
"Polynomial.degree",
"LE.le",
"Field.toSemifield",
"WithBot.one",
"Polynomial",
"Semifield.toDivisionSemiring",
"Nat.instPreorder",
"Polynomial.Splits.comp_of_natDegree_le_one",
"Nat",
"DivisionSemiring.to... | true |
Lean.Parser.ParserContextCore.quotDepth._inherited_default | Lean.Parser.Types | [
"id",
"instOfNatNat",
"Nat",
"OfNat.ofNat"
] | false |
AddSubmonoid.center.addCommMonoid | Mathlib.GroupTheory.Submonoid.Center | [
"AddSubsemigroup.instSetLike",
"AddSubmonoid.toAddMonoid",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"AddSubsemigroup.center",
"AddSubmonoid",
"AddCommMonoid",
"AddSubsemigroup",
"AddMonoid",
"AddSubmonoid.center",
"AddZero.toAdd",
"AddSubsemigroup.... | true |
_private.Init.Data.Dyadic.Basic.0.Dyadic.neg_ofIntWithPrec._simp_1_2 | Init.Data.Dyadic.Basic | [
"Int.instNegInt",
"Int",
"Int.neg_eq_zero",
"instOfNat",
"propext",
"OfNat.ofNat",
"Eq",
"Neg.neg"
] | false |
Lean.Elab.initFn._@.Lean.Elab.Util.1238572749._hygCtx._hyg.2 | Lean.Elab.Util | [
"IO",
"Lean.Name.mkStr3",
"Lean.Elab.mkMacroAttribute",
"Lean.KeyedDeclsAttribute",
"Lean.Macro"
] | false |
Lean.Parser.simprocPatternBuiltin | Init.Simproc | [
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.const",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
MeasureTheory.VectorMeasure.restrict_le_restrict_subset | Mathlib.MeasureTheory.VectorMeasure.Basic | [
"MeasurableSet",
"MeasureTheory.VectorMeasure.restrict_le_restrict_of_subset_le",
"Set.Subset.trans",
"PartialOrder.toPreorder",
"MeasureTheory.VectorMeasure.subset_le_of_restrict_le_restrict",
"Preorder.toLE",
"PartialOrder",
"HasSubset.Subset",
"LE.le",
"AddCommMonoid",
"MeasurableSpace",
"T... | true |
_private.Mathlib.Algebra.Ring.Associator.0.associator_op._simp_1_2 | Mathlib.Algebra.Ring.Associator | [
"MulOpposite.unop_sub",
"MulOpposite",
"HSub.hSub",
"MulOpposite.instSub",
"instHSub",
"MulOpposite.unop",
"Eq.symm",
"Eq",
"Sub"
] | false |
Lean.Parser.Command.elab._regBuiltin.Lean.Parser.Command.elabTail.parenthesizer_19 | Lean.Parser.Syntax | [
"Lean.Name.mkStr5",
"IO",
"Lean.PrettyPrinter.Parenthesizer",
"Lean.PrettyPrinter.parenthesizerAttribute",
"Unit",
"Lean.Parser.Command.elabTail.parenthesizer",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
NumberField.mixedEmbedding.fundamentalCone.expMap_symm_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | [
"Real",
"NumberField.mixedEmbedding.realSpace",
"HMul.hMul",
"Pi.topologicalSpace",
"NumberField.InfinitePlace.mult",
"PseudoMetricSpace.toUniformSpace",
"OpenPartialHomeomorph.toFun'",
"Nat.cast",
"Real.log",
"NumberField.mixedEmbedding.fundamentalCone.expMap",
"Real.instMul",
"NumberField.In... | true |
Topology.RelCWComplex.mkFiniteType_map | Mathlib.Topology.CWComplex.Classical.Finite | [
"Real",
"pseudoMetricSpacePi",
"ChainCompletePartialOrder.instOfCompleteLattice",
"outParam",
"Pi.topologicalSpace",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"Real.instZero",
"PartialEquiv.target",
"PartialEquiv",
"Set.univ",
"Finite",
"Set.PairwiseDisjoint",
"Topology.RelCWComplex... | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_map_app_hom_hom | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | [
"CategoryTheory.CommMon.instCategory",
"CategoryTheory.Monoidal.monFunctorCategoryEquivalence",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Mon.Hom.hom",
"CategoryTheory.Functor.cate... | true |
Function.uncurry.eq_1 | Mathlib.Data.Set.NAry | [
"Prod.fst",
"Eq.refl",
"Function.uncurry",
"Prod",
"Eq",
"Prod.snd"
] | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.iInf_neBot_of_directed'._simp_1_1 | Mathlib.Order.Filter.Basic | [
"Exists",
"propext",
"Classical.not_forall",
"Eq",
"Not"
] | false |
IsLocalization.Away.integralClosure | Mathlib.RingTheory.Localization.Integral | [
"Subalgebra.instSetLike",
"Eq.mpr",
"CommRing",
"instSMulOfMul",
"IsLocalization",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"HEq.refl",
"IsScalarTower",
"IsLocalization.Away",
"Algebra",
"RingHom",
"Algebra.toSMul",
"Membership.mem",
"Eq.casesOn",
"Subtype",
"Is... | true |
Sat.Literal.pos.sizeOf_spec | Mathlib.Tactic.Sat.FromLRAT | [
"Sat.Literal._sizeOf_inst",
"instOfNatNat",
"Sat.Literal.pos",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Sat.Literal",
"instAddNat",
"Eq.refl",
"instSizeOfNat",
"OfNat.ofNat",
"Eq"
] | true |
Std.Rxi.Iterator.instLawfulIteratorLoop | Init.Data.Range.Polymorphic.RangeIterator | [
"Std.IteratorLoop.defaultImplementation._proof_1",
"Pure.pure",
"Iff.mpr",
"Std.IteratorLoop.forIn",
"Eq.mpr",
"Std.LawfulIteratorLoop.mk",
"_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loop.wf.match_1",
"Std.Shrink.deflate",
"Exists.choose_spec",
"bind_co... | true |
_private.Init.Grind.Ring.Field.0.Lean.Grind.Field.natCast_div_of_dvd._proof_1_1 | Init.Grind.Ring.Field | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval",
"Option.some",
"Lean.Omega.combo_s... | false |
Finset.sup_eq_bot_iff._simp_2 | Mathlib.Data.Finset.Lattice.Fold | [
"Finset",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderBot",
"Membership.mem",
"Bot.bot",
"Finset.instSetLike",
"propext",
"Finset.sup",
"SemilatticeSup.toPartialOrder",
"Eq",
"SemilatticeSup",
"Finset.sup_eq_bot_iff",
"SetLike.instMembership"
] | false |
neg_eq_self | Mathlib.Algebra.Group.Torsion | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"Iff.rfl",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"IsAddTorsionFree",
"SubNegZeroMonoid.toNegZeroClass",
"eq_comm",
"AddGroup",
"Iff",
"AddGroup.toSubNegMonoid",
"self_eq_neg",
"propext",
"Zero.toOfNat0"... | true |
PiTensorProduct.distribMulAction'._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | [
"Monoid",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semigroup.toMul",
"instHSMul",
"instSMulOfMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"smul_smul",
"AddZeroClass.toAddZero",
"MulOne.toM... | false |
List.minimum_cons | Mathlib.Data.List.MinMax | [
"List.maximum_cons",
"List.minimum",
"LinearOrder",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"SemilatticeInf.toMin",
"WithTop.some",
"List.cons",
"List",
"LinearOrder.toDecidableLT",
"WithTop.semilatticeInf",
"OrderDual",
"OrderDual.instLinear... | true |
List.SortedLT | Mathlib.Data.List.Sort | [
"StrictMono",
"List.get",
"PartialOrder.toPreorder",
"List",
"Fin.instPartialOrder",
"Fin",
"List.length",
"Preorder"
] | true |
Lean.PrettyPrinter.Delaborator.delabAttribute | Lean.PrettyPrinter.Delaborator.Basic | [
"Classical.ofNonempty",
"Lean.PrettyPrinter.Delaborator.Delab",
"Lean.KeyedDeclsAttribute",
"Lean.instNonemptyKeyedDeclsAttribute"
] | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrM._proof_5 | Batteries.Data.Vector.Basic | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_congr",
"Lean.Om... | false |
Lean.Elab.Term.StructInst.FieldView.mk.noConfusion | Lean.Elab.StructInst | [
"Lean.Elab.Term.StructInst.FieldLHS",
"Lean.Syntax",
"id",
"Lean.Syntax.Term",
"Lean.Elab.Term.StructInst.FieldView.noConfusion",
"List",
"Lean.Elab.Term.StructInst.FieldView.mk",
"Eq",
"Lean.Elab.Term.StructInst.FieldView"
] | false |
Int.mul_tdiv_cancel_left | Init.Data.Int.DivMod.Lemmas | [
"Int.mul_tdiv_cancel",
"HMul.hMul",
"Eq.rec",
"Ne",
"Int",
"Int.instMul",
"Int.tdiv",
"instOfNat",
"Int.mul_comm",
"OfNat.ofNat",
"Eq",
"instHMul"
] | true |
Complex.UnitDisc.instMulActionClosedBall._aux_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"Complex.instNormedField",
"Complex.instZero",
"AddCommGroup.toAddGroup",
"Membership.mem",
"NormedField.toField",
... | false |
Lean.Lsp.instToJsonTextDocumentIdentifier.toJson | Lean.Data.Lsp.Basic | [
"Lean.Json",
"Lean.Json.mkObj",
"String",
"Lean.instToJsonString",
"Lean.ToJson.toJson",
"Prod.mk",
"List.cons",
"Lean.Lsp.DocumentUri",
"Lean.Lsp.TextDocumentIdentifier",
"List",
"Prod",
"List.flatten",
"Lean.Lsp.TextDocumentIdentifier.uri",
"List.nil"
] | true |
Lean.Server.Test.Runner.Client.instToJsonHighlightedSubexprInfo.toJson | Lean.Server.Test.Runner | [
"Lean.Json",
"Lean.Json.mkObj",
"String",
"Lean.Server.Test.Runner.Client.SubexprInfo",
"Lean.instToJsonString",
"Lean.ToJson.toJson",
"Prod.mk",
"Lean.Server.Test.Runner.Client.HighlightedSubexprInfo",
"List.cons",
"Unit",
"Lean.Server.Test.Runner.Client.instToJsonSubexprInfo",
"Prod",
"_pr... | true |
MulEquiv.instFintype._proof_2 | Mathlib.Data.Fintype.Perm | [
"Iff.mpr",
"Equiv.instEquivLike",
"HMul.hMul",
"Iff.of_eq",
"congrArg",
"Option.instMembership",
"Mul",
"Option.some.injEq",
"Option.some",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"Equiv",
"dite",
"Option.none",
"Exists.casesOn",
"Fintype",
"Option.mem_def._simp_1",
"exists_... | false |
Quot.out | Mathlib.Data.Quot | [
"Quot.exists_rep",
"Classical.choose",
"Quot",
"Eq",
"Quot.mk"
] | true |
Lean.PArray | Lean.Data.PersistentArray | [
"Lean.PersistentArray"
] | true |
CategoryTheory.CommComon.instCategory._proof_8 | Mathlib.CategoryTheory.Monoidal.CommComon_ | [
"Quiver.mk",
"CategoryTheory.CategoryStruct.mk",
"CategoryTheory.Category.comp_id._autoParam",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.CommComon.instCategory._aux_1",
"CategoryTheory.InducedCategory.instCategory._proof_4",
"CategoryT... | false |
AddSubgroup.orderIsoAddCon._proof_7 | Mathlib.GroupTheory.QuotientGroup.Defs | [
"AddCon.instFunLikeForallProp",
"Iff.mpr",
"QuotientAddGroup.leftRel_apply",
"AddGroup.toSubtractionMonoid",
"AddCon",
"Eq.mpr",
"NegZeroClass.toNeg",
"QuotientAddGroup.con._proof_1",
"Equiv.instEquivLike",
"congrArg",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddSubgroup.instP... | false |
HasDerivAt.congr_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Semiring.toModule",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"HasFDerivAt.congr_fderiv",
"NormedSpace.toModule",
"AddMonoid.toAddZero... | true |
AddUnits.map._proof_6 | Mathlib.Algebra.Group.Units.Hom | [
"AddUnits.val",
"AddUnits.map._proof_4",
"AddMonoid.toAddZeroClass",
"AddUnits.map._proof_3",
"AddZeroClass.toAddZero",
"AddUnits.map._proof_2",
"AddUnits.ext",
"instHAdd",
"AddGroup.toSubNegMonoid",
"AddUnits.map._proof_5",
"HAdd.hAdd",
"AddUnits.map._proof_1",
"AddMonoid",
"AddUnits.inst... | false |
CategoryTheory.HasClassifier.reflectsIsomorphisms | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.Functor",
"CategoryTheory.HasSubobjectClassifier.reflectsIsomorphisms",
"CategoryTheory.HasSubobjectClassifier",
"CategoryTheory.Functor.Faithful",
"CategoryTheory.Functor.ReflectsIsomorphisms",
"CategoryTheory.Category"
] | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.Functor.copyObj._proof_3 | Mathlib.CategoryTheory.NatIso | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"False",
"eq_false",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Classical.byContradiction",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso.hom_inv_id",
"Eq.mp",
"id",
"CategoryTheory.Iso",
"Catego... | false |
PMF.mem_support_ofMultiset_iff | Mathlib.Probability.Distributions.Uniform | [
"Multiset.toFinset",
"SetLike.mem_coe._simp_1",
"congrArg",
"PMF.ofMultiset",
"Finset",
"Classical.propDecidable",
"Membership.mem",
"PMF.support",
"Multiset",
"Ne",
"PMF.support_ofMultiset",
"Multiset.mem_toFinset._simp_1",
"iff_self",
"Multiset.instMembership",
"Iff",
"SetLike.coe",
... | true |
Matrix.vec2_add | Mathlib.LinearAlgebra.Matrix.Notation | [
"Matrix.add_cons",
"congrArg",
"Matrix.tail_cons",
"instOfNatNat",
"Matrix.empty_add_empty",
"instHAdd",
"Pi.instAdd",
"HAdd.hAdd",
"Matrix.vecHead",
"Nat",
"True",
"eq_self",
"Matrix.vecEmpty",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Fin",
"Matrix.vecTail",
"Nat.succ",
"Eq"... | true |
_private.Mathlib.Data.EReal.Basic.0.Mathlib.Meta.Positivity.evalRealToEReal._proof_2 | Mathlib.Data.EReal.Basic | [
"Qq.QuotedDefEq",
"Lean.Expr.const",
"PLift",
"Lean.Expr.sort",
"Lean.Level",
"PLift.down",
"List.cons",
"Qq.Quoted",
"Lean.Level.zero",
"Lean.Expr.app",
"Lean.Level.succ",
"Lean.Level.instOfNat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"List.nil"
] | false |
_private.Lean.Elab.RecAppSyntax.0.Lean.getRecAppSyntax?.match_1 | Lean.Elab.RecAppSyntax | [
"_private.Lean.Elab.RecAppSyntax.0.Lean.getRecAppSyntax?._sparseCasesOn_1",
"Option.ctorIdx",
"Option.some",
"Lean.DataValue.ctorIdx",
"Lean.Syntax",
"Nat.hasNotBit",
"_private.Lean.Elab.RecAppSyntax.0.Lean.getRecAppSyntax?._sparseCasesOn_2",
"Lean.DataValue",
"Lean.DataValue.ofSyntax",
"Option"
] | false |
CategoryTheory.isCoseparator_of_isLimit_fan | Mathlib.CategoryTheory.Generator.Basic | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ObjectProperty.ofObj.casesOn",
"CategoryTheory.ObjectProperty.ofObj",
"CategoryTheory.Limits.Fan.proj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.Fan.mk",
"cong... | true |
Lean.Compiler.LCNF.CSE.State.mk.injEq | Lean.Compiler.LCNF.CSE | [
"Eq.propIntro",
"Lean.Expr.instBEq",
"Lean.Compiler.LCNF.CSE.State.mk.inj",
"Lean.PHashMap",
"Lean.Compiler.LCNF.CSE.State.mk",
"Lean.injEq_helper",
"Lean.Expr",
"Lean.FVarId",
"Lean.Compiler.LCNF.Purity.pure",
"Lean.Compiler.LCNF.CSE.State",
"And",
"Eq.ndrec",
"Eq.refl",
"Lean.Expr.instHa... | true |
ContinuousLinearMapWOT.toCLM_surjective._simp_1 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | [
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMapWOT",
"RingHom",
"NormedField.toField",
"AddCommGroup",
"Field.toSemifield",
"NormedField",
"ContinuousLinearMap",
"TopologicalSpace",
"Semifield.toDivisionSemiring",
"True",
"ContinuousLinearMapWOT.toCLM",
"eq_true",
"DivisionSemiring.to... | false |
PreLp.ring._aux_4 | Mathlib.Analysis.Normed.Lp.lpSpace | [
"MulOne.toOne",
"NormedRing.toRing",
"NormedRing.toNonUnitalNormedRing",
"NonAssocSemiring.toMulZeroOneClass",
"MulZeroOneClass.toMulOneClass",
"NonUnitalNormedRing.toNormedAddCommGroup",
"MulOneClass.toMulOne",
"PreLp",
"One.toOfNat1",
"OfNat.ofNat",
"Semiring.toNonAssocSemiring",
"Ring.toSem... | false |
Lean.Widget.HighlightMatchesParams.mk.inj | Lean.Server.FileWorker.WidgetRequests | [
"Lean.Widget.HighlightMatchesParams.mk.noConfusion",
"String",
"Lean.Widget.InteractiveMessage",
"Lean.Widget.HighlightMatchesParams",
"Lean.Widget.HighlightMatchesParams.mk",
"And",
"And.intro",
"Eq"
] | true |
AddCon.addGroup._proof_4 | Mathlib.GroupTheory.Congruence.Defs | [
"AddCon",
"instHSMul",
"AddMonoid.toAddZeroClass",
"AddCon.instZSMul",
"Quotient.mk''",
"AddZeroClass.toAddZero",
"AddCon.hasNeg",
"Int",
"Nat.cast",
"autoParam",
"Quotient.mk''_surjective",
"AddCon.toSetoid",
"AddGroup",
"AddGroup.toSubNegMonoid",
"Nat",
"SubNegMonoid.toNeg",
"Funct... | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_121 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Subtype.coind.congr_simp | Mathlib.Data.Set.Operations | [
"Eq.rec",
"Subtype",
"Subtype.coind",
"Eq.ndrec",
"Eq.refl",
"Eq"
] | true |
AbstractSimplicialComplex.instCompleteSemilatticeInf._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | [
"AbstractSimplicialComplex.instInfSet",
"Iff.mpr",
"lowerBounds",
"PreAbstractSimplicialComplex.faces",
"Set.iInter",
"Finset",
"PartialOrder.toPreorder",
"setOf",
"Set.mem_iInter₂",
"Preorder.toLE",
"Membership.mem",
"HasSubset.Subset.trans",
"upperBounds",
"Set.instIsTransSubset",
"Set... | false |
Std.TransCmp.lt_of_isLE_of_lt | Init.Data.Order.Ord | [
"congrArg",
"Ordering",
"Ordering.eq",
"Eq.mp",
"Ordering.isLE_iff_eq_lt_or_eq_eq",
"Std.TransCmp",
"Or.casesOn",
"Bool.true",
"Ordering.lt",
"propext",
"Bool",
"Or",
"Ordering.isLE",
"Eq",
"Std.TransCmp.lt_of_eq_of_lt",
"Std.TransCmp.lt_trans"
] | true |
Modular.«_aux_Mathlib_NumberTheory_Modular___macroRules_Modular_term𝒟ᵒ_1» | Mathlib.NumberTheory.Modular | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.instMonad",
"Lean.TSyntax.... | false |
_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult.mk._flat_ctor | Lean.Meta.Injective | [
"_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult",
"Lean.Expr",
"Lean.Level",
"List",
"_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult.mk",
"Nat"
] | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_603 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._aux_34 | Mathlib.Geometry.Manifold.Immersion | [
"Equiv.instEquivLike",
"NormedSpace",
"Manifold.IsImmersionAtOfComplement",
"PseudoMetricSpace.toUniformSpace",
"Exists",
"Manifold.IsImmersionAtOfComplement.smallComplement",
"Equiv",
"TopologicalSpace",
"ModelWithCorners",
"And",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"Set.preimage",
... | false |
Profinite.NobelingProof.C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | [
"Preorder.toLT",
"isWellOrder_lt",
"Ordinal.partialOrder",
"LinearOrder",
"WellFoundedLT",
"PartialOrder.toPreorder",
"setOf",
"SemilatticeInf.toPartialOrder",
"Ordinal.type",
"DistribLattice.toLattice",
"Set.instInter",
"Profinite.NobelingProof.term",
"Inter.inter",
"LT.lt",
"Bool",
"... | true |
WithLp.linearEquiv_apply | Mathlib.Analysis.Normed.Lp.WithLp | [
"WithLp",
"AddCommGroup.toAddCommMonoid",
"WithLp.instAddCommGroup",
"AddCommGroup",
"Equiv.toFun",
"RingHomInvPair.ids",
"LinearEquiv",
"ENNReal",
"Semiring",
"WithLp.addEquiv",
"LinearEquiv.instEquivLike",
"Eq.refl",
"AddCommSemigroup.toAddCommMagma",
"WithLp.instModule",
"AddEquiv.toE... | true |
Subspace.top_mem_of_biUnion_eq_univ | Mathlib.GroupTheory.CosetCover | [
"AddCommGroup.toAddCommMonoid",
"Finset",
"Set.univ",
"Membership.mem",
"DivisionRing.toDivisionSemiring",
"AddCommGroup",
"id",
"Submodule.instTop",
"Subspace.biUnion_ne_univ_of_top_notMem",
"Mathlib.Tactic.Contrapose.contrapose₁",
"Subspace",
"SetLike.coe",
"Finset.instSetLike",
"Submodu... | true |
Mathlib.Meta.NormNum.isNat_clog | Mathlib.Tactic.NormNum.NatLog | [
"Mathlib.Meta.NormNum.IsNat",
"Mathlib.Meta.NormNum.IsNat.mk",
"AddMonoidWithOne.toNatCast",
"Nat.instAddMonoidWithOne",
"Nat.cast",
"_private.Mathlib.Tactic.NormNum.NatLog.0.Mathlib.Meta.NormNum.isNat_clog.match_1_1",
"Nat",
"Nat.clog",
"Eq",
"rfl"
] | true |
Lean.Order.FlatOrder | Init.Internal.Order.Basic | [] | true |
CategoryTheory.AddGrp.comp'_assoc | Mathlib.CategoryTheory.Monoidal.Grp | [
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.AddGrp",
"CategoryTheory.AddMon.instCategory",
"Eq.mp",
"CategoryTheory.AddGrp.toAddMon",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryTheory.SemiCartesianMonoidalCategory... | true |
CategoryTheory.Limits.Sigma.π.hcongr_8 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"CategoryTheory.Limits.HasCoproduct",
"eq_of_heq",
"Eq.ndrec",
"CategoryTheory.Limits.Sigma.π",
"HEq",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Limits.sigmaObj",
"Eq... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.