name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.filterFieldList | Lean.ResolveName | [
"Pure.pure",
"Lean.MonadError.toMonadRef",
"Lean.MonadRef.getRef",
"_private.Lean.ResolveName.0.Lean.filterFieldList.match_1",
"Monad.toApplicative",
"String",
"List.map",
"Lean.Syntax",
"instDecidableEqBool",
"Applicative.toPure",
"Prod.fst",
"Bool.true",
"List",
"Unit",
"Lean.MonadErro... | true |
Aesop.NodeState.toCtorIdx | Aesop.Tree.Data | [
"Aesop.NodeState.ctorIdx",
"Nat",
"Aesop.NodeState"
] | false |
WithZero.semilatticeInf._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | [
"WithZero.instIsBotZeroClass",
"WithZero.map₂",
"instReflLe",
"congrArg",
"zero_le._simp_1",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"SemilatticeInf.toPartialOrder",
"inf_le_left._simp_1",
"SemilatticeInf.toMin",
"LE.le",
"WithZero.instZero",
"WithZero.map₂_coe_r... | false |
_private.Mathlib.Probability.Moments.Basic.0.ProbabilityTheory.mgf_pos'._simp_1_5 | Mathlib.Probability.Moments.Basic | [
"False",
"True",
"propext",
"not_false_iff",
"Eq",
"Not"
] | false |
BitVec.ne_intMin_of_lt_of_msb_false | Init.Data.BitVec.Bitblast | [
"instPowNat",
"Eq.mpr",
"BitVec.toNat_lt_of_msb_false",
"congrArg",
"HSub.hSub",
"BitVec",
"id",
"Nat.instMod",
"instHMod",
"instSubNat",
"Ne",
"instOfNatNat",
"BitVec.toNat",
"instNatPowNat",
"HMod.hMod",
"instHSub",
"BitVec.intMin",
"HPow.hPow",
"_private.Init.Data.BitVec.Bitbl... | true |
BoxIntegral.HasIntegral.eq_1 | Mathlib.Analysis.BoxIntegral.Basic | [
"BoxIntegral.IntegrationParams.toFilteriUnion",
"Real",
"NormedSpace",
"BoxIntegral.Prepartition",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"ContinuousLinearMap.addCommMonoid",
"BoxIntegral.integralSum._proof_1",
"BoxIntegral.integralSum",
"nhds... | true |
CategoryTheory.Limits.Sigma.ι_reindex_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"CategoryTheory.Category.assoc",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Function.comp",
"CategoryTheory.Limits.Sigma.ι",
"Eq.mp",
"id",
"Equiv",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryTheory.Limits.HasCoproduct",
"CategoryTheory.Li... | true |
HahnSeries.toPowerSeries_apply | Mathlib.RingTheory.HahnSeries.PowerSeries | [
"RingEquiv.instEquivLike",
"MvPowerSeries.instMul",
"Distrib.toAdd",
"HahnSeries.toPowerSeries",
"HahnSeries.instAdd",
"instDistribOfSemiring",
"MvPowerSeries.instSemiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Unit",
"Nat.instIsOrderedCancelAddMonoid",
"NonAssocSemiring.toNonUnitalNonA... | true |
BitVec.instRxoLawfulHasSize | Init.Data.Range.Polymorphic.BitVec | [
"instDecidableLtBitVec",
"instDecidableLeBitVec",
"Std.Rxo.LawfulHasSize.of_closed",
"Std.Rxo.LawfulHasSize",
"BitVec.instRxcLawfulHasSize",
"BitVec",
"inferInstance",
"BitVec.instUpwardEnumerable",
"BitVec.instIsLinearOrder",
"Std.IsLinearOrder.toIsPartialOrder",
"BitVec.instLawfulUpwardEnumera... | true |
Finpartition.combine | Mathlib.Order.Partition.Finpartition | [
"Lattice",
"Lattice.toSemilatticeSup",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Finpartition.combine._proof_3",
"OrderBot",
"SemilatticeInf.toPartialOrder",
"Finpartition.combine._proof_4",
"Finpartition.mk",
"Finset.biUnion",
"Finpartition.parts",
"Finset.sup",
"IsModularLat... | true |
RingHom.ker | Mathlib.RingTheory.Ideal.Maps | [
"Semiring.toModule",
"Bot.bot",
"Ideal",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Submodule.instBot",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"Ideal.comap",
"Semiring",
"Semiring.toNonAssocSemiring",
"FunLike",
"RingHomClass"
] | true |
Affine.Simplex.reindex_reindex_symm | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | [
"Eq.mpr",
"congrArg",
"Equiv.trans",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"Affine.Simplex.reindex",
"AddCommGroup",
"id",
"Equiv",
"Affine.Simplex.reindex_trans",
"Affine.Simplex",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"AddTorsor",
"instAddNat",
"Equ... | true |
WithOne.coe_ne_one._simp_2 | Mathlib.Algebra.Group.WithOne.Defs | [
"WithOne",
"False",
"eq_false",
"WithOne.coe_ne_one",
"WithOne.coe",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"WithOne.instOne"
] | false |
CategoryTheory.MorphismProperty.HasFactorization.over | Mathlib.CategoryTheory.MorphismProperty.Comma | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Over",
"CategoryTheory.MorphismProperty.MapFactorizationData.Z",
"CategoryTheory.Over.OverMorphism.ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.HasFactorization",
"congrArg",
"CategoryTheory.Morphism... | true |
AddCommGrpCat.coyoneda_obj_obj_coe | Mathlib.Algebra.Category.Grp.Yoneda | [
"CategoryTheory.Functor",
"Opposite",
"AddCommGrpCat.instCategory",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.category",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"AddCommGrpCat.carrier",
"AddGroup.toSubNegMonoid",
"AddCommGrpCat",
"AddCommGrpCat.coyoneda",
"CategoryTheory... | true |
ContinuousAlternatingMap.map_piecewise_smul | Mathlib.Topology.Algebra.Module.Alternating.Basic | [
"MultilinearMap.map_piecewise_smul",
"instHSMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"Finset",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"Finset.piecewise",
"AddCommMonoid",
"Finset.prod",
"CommSemiring",
"TopologicalSpace"... | true |
finCycle | Mathlib.Logic.Equiv.Fin.Rotate | [
"Fin.instSub",
"HSub.hSub",
"Equiv.mk",
"finCycle._proof_2",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Equiv.Perm",
"Nat",
"Fin.instAdd",
"Fin",
"finCycle._proof_1"
] | true |
SmoothBumpCovering.mk._flat_ctor | Mathlib.Geometry.Manifold.PartitionOfUnity | [
"SmoothBumpCovering",
"Real",
"SmoothBumpCovering.mk",
"NormedSpace",
"Real.denselyNormedField",
"Real.instZero",
"Set.univ",
"NormedSpace.toModule",
"Membership.mem",
"Exists",
"nhds",
"Filter.EventuallyEq",
"LocallyFinite",
"Real.instOne",
"SmoothBumpFunction.toFun",
"TopologicalSpac... | false |
_private.Mathlib.Algebra.Ring.Torsion.0.IsDomain.instIsAddTorsionFreeOfCharZero._simp_1 | Mathlib.Algebra.Ring.Torsion | [
"HMul.hMul",
"MulZeroClass.toMul",
"mul_eq_mul_left_iff",
"MulZeroClass",
"IsLeftCancelMulZero",
"propext",
"Zero.toOfNat0",
"Or",
"OfNat.ofNat",
"Eq",
"MulZeroClass.toZero",
"instHMul"
] | false |
GenLoop.copy._proof_2 | Mathlib.Topology.Homotopy.HomotopyGroup | [
"Real",
"Continuous",
"Pi.topologicalSpace",
"ContinuousMap",
"PseudoMetricSpace.toUniformSpace",
"GenLoop.instFunLike",
"Membership.mem",
"Eq.rec",
"Set.Elem",
"GenLoop",
"TopologicalSpace",
"ContinuousMap.continuous_toFun",
"Real.pseudoMetricSpace",
"instTopologicalSpaceSubtype",
"Eq.s... | false |
Lean.Server.RequestCancellationToken.mk.sizeOf_spec | Lean.Server.RequestCancellation | [
"IO.Promise._sizeOf_inst",
"instOfNatNat",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"Lean.Server.RequestCancellationToken",
"Lean.Server.RequestCancellationToken.mk",
"IO.Promise",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"IO.CancelToken",
"OfNat.ofNat",
"Eq",
"Lean.Server.RequestCance... | true |
CategoryTheory.NormalMono.regularMono | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.RegularMono.mk",
"CategoryTheory.NormalMono.isLimit",
"CategoryTheory.NormalMono.g",
"CategoryTheory.NormalMono.regularMono._proof_1",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"Cat... | true |
Summable.matrix_blockDiagonal | Mathlib.Topology.Instances.Matrix | [
"Pi.addCommMonoid",
"Matrix.blockDiagonal",
"Pi.topologicalSpace",
"Matrix",
"AddMonoid.toAddZeroClass",
"SummationFilter",
"AddZeroClass.toAddZero",
"Matrix.addCommMonoid",
"AddCommMonoid",
"HasSum.summable",
"TopologicalSpace",
"AddZero.toZero",
"Summable.hasSum",
"tsum",
"AddCommMonoi... | true |
Lean.Meta.Grind.ENode.rec | Lean.Meta.Tactic.Grind.Types | [
"Lean.Expr",
"Lean.Meta.Grind.ENode.mk",
"Nat",
"Bool",
"Lean.Meta.Grind.ENode",
"Option",
"Lean.Meta.Grind.SolverTerms"
] | false |
Lean.Meta.SimpTheorems.erased._default | Lean.Meta.Tactic.Simp.SimpTheorems | [
"Lean.Meta.instHashableOrigin",
"Lean.Meta.instBEqOrigin",
"id",
"Lean.PHashSet",
"Lean.PersistentHashSet.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Lean.Meta.Origin"
] | false |
Bundle.Trivialization.image_preimage_eq_prod_univ | Mathlib.Topology.FiberBundle.Trivialization | [
"Set.Subset.antisymm",
"Iff.mpr",
"Set.instSProd",
"Bundle.Trivialization.toFun'",
"trivial",
"SProd.sprod",
"PartialEquiv.target",
"Set.univ",
"Bundle.Trivialization.apply_symm_apply",
"instTopologicalSpaceProd",
"Membership.mem",
"Eq.rec",
"HasSubset.Subset",
"OpenPartialHomeomorph.toFun... | true |
Lean.Meta.AC.PreContext.mk.inj | Lean.Meta.Tactic.AC.Main | [
"Lean.Meta.AC.PreContext",
"Lean.Expr",
"And",
"Nat",
"And.intro",
"Lean.Meta.AC.PreContext.mk",
"Eq",
"Lean.Meta.AC.PreContext.mk.noConfusion",
"Option"
] | true |
RootPairing.ker_copolarization_eq_ker_corootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | [
"Submodule",
"CommRing",
"Semiring.toModule",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LinearMap.ker",
"RootPairing.flip",
"RootPairing.CoPolarization",
"AddCommGroup",
"RootPairing.CorootForm",
"LinearMap.module",
"LinearMap",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
... | true |
Manifold.IsSmoothEmbedding.recOn | Mathlib.Geometry.Manifold.SmoothEmbedding | [
"NormedSpace",
"Manifold.IsSmoothEmbedding.rec",
"TopologicalSpace",
"ModelWithCorners",
"ENat",
"NontriviallyNormedField",
"Topology.IsEmbedding",
"NontriviallyNormedField.toNormedField",
"Manifold.IsSmoothEmbedding",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"Manifold.IsImmersion",
"Man... | false |
LinearIndependent.pair_add_smul_add_smul_iff._simp_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | [
"Nontrivial",
"IsDomain",
"CommRing",
"instHSMul",
"HMul.hMul",
"Ring.toNonAssocRing",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Module.IsTorsionFree",
"AddGroupWithOne.toAddMonoidWithOne",
"Ad... | false |
Batteries.RBMap.foldlM | Batteries.Data.RBMap.Basic | [
"Batteries.RBNode.WF",
"Batteries.RBNode",
"Ordering.byKey",
"Batteries.RBMap.foldl.match_3",
"Batteries.RBMap",
"Ordering",
"Prod.fst",
"Prod",
"Monad",
"Batteries.RBNode.foldlM",
"Batteries.RBMap.foldl.match_1"
] | true |
Height.fun_mulHeight_one | Mathlib.NumberTheory.Height.Basic | [
"Real",
"AddGroupWithOne.toAddMonoidWithOne",
"Field.toDivisionRing",
"Height.AdmissibleAbsValues",
"id",
"DivisionRing.toRing",
"Real.instOne",
"AddMonoidWithOne.toOne",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"Field",
"Height.mulHeight",
"Ring.toAddGroupWithOne",
"Height.mulHeight_one"
] | true |
_private.Init.Data.List.MinMaxIdx.0.List.combineMinIdxOn.eq_1 | Init.Data.List.MinMaxIdx | [
"LE.le",
"LE",
"GetElem.getElem",
"_private.Init.Data.List.MinMaxIdx.0.List.combineMinIdxOn",
"List",
"instHAdd",
"DecidableLE",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"Eq.refl",
"instLTNat",
"List.instGetElemNatLtLength",
"Eq",
"List.length",
"ite"
] | true |
MvPolynomial.optionEquivLeft | Mathlib.Algebra.MvPolynomial.Equiv | [
"Polynomial.C",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"MvPolynomial.aeval",
"MvPolynomial.optionEquivLeft._proof_2",
"CommSemiring.toSemiring",
"AddMonoidAlgebra.algebra",
"Polynomial.algebraOfAlgebra",
"MvPolynomial.optionEquivLeft._proof_1",
"Finsupp.instAddMonoid",
"MvPolynomia... | true |
List.isRotated_prev_eq | Mathlib.Data.List.Cycle | [
"Iff.mpr",
"Eq.mpr",
"List.IsRotated.mem_iff",
"List.IsRotated.reverse",
"List.nodup_reverse",
"congrArg",
"Membership.mem",
"List.isRotated_next_eq",
"List.next_reverse_eq_prev",
"id",
"List.mem_reverse",
"List.IsRotated",
"List.Nodup",
"List",
"List.IsRotated.nodup_iff",
"List.instMe... | true |
Lean.JsonNumber.instRepr | Lean.Data.Json.Basic | [
"Std.Format.instAppend",
"Lean.JsonNumber",
"Repr.mk",
"Int",
"instHAppendOfAppend",
"Nat",
"Std.Format.bracket",
"Std.Format",
"Lean.JsonNumber.instRepr.match_1",
"Repr",
"HAppend.hAppend",
"instReprNat",
"repr",
"Std.Format.text",
"Int.instRepr"
] | true |
Equiv.Perm.IsCycle.sign | Mathlib.GroupTheory.Perm.Cycle.Basic | [
"Equiv.Perm.support",
"MonoidHom.instFunLike",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"MonoidHom",
"Monoid.toMulOneClass",
"Equiv.Perm.sign",
"Units.instNeg",
"Units",
"DivInvMonoid.toMonoid",
"Int",
"Equiv.Perm.IsCycle.sign._unary",
"Units.instOne",... | true |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.gcd_mul_left'._simp_1_1 | Mathlib.Algebra.GCDMonoid.Basic | [
"GCDMonoid",
"CommMonoidWithZero.toMonoidWithZero",
"GCDMonoid.gcd",
"Associated",
"MonoidWithZero.toMulZeroOneClass",
"CommMonoidWithZero",
"True",
"eq_true",
"Zero.toOfNat0",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq",
"gcd_zero_left'",
"MonoidWithZero.toMonoid",
"MulZeroCla... | false |
Finset.diffs_subset_iff | Mathlib.Data.Finset.Sups | [
"Finset.diffs",
"Finset",
"Finset.image₂_subset_iff",
"Membership.mem",
"HasSubset.Subset",
"SDiff.sdiff",
"Iff",
"Finset.instSetLike",
"GeneralizedBooleanAlgebra",
"Finset.instHasSubset",
"GeneralizedBooleanAlgebra.toSDiff",
"SetLike.instMembership",
"DecidableEq"
] | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go_get_aux | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend | [
"Std.Sat.AIG.RefVec.get",
"Std.Sat.AIG.Ref.cast",
"Std.Sat.AIG.Decl",
"Std.Sat.AIG.RefVecEntry.vec",
"LE.le",
"instLENat",
"Std.Sat.AIG.Ref",
"Std.Sat.AIG",
"Nat",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastZeroExtend.go_get_aux._unary",
... | true |
Order.IsNormal.recOn | Mathlib.Order.IsNormal | [
"StrictMono",
"lowerBounds",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Order.IsNormal.mk",
"DistribLattice.toLattice",
"Order.IsSuccLimit",
"upperBounds",
"Set.image",
"Set.Iio",
"Set.instMembership",
"instDistribLattic... | false |
NonUnitalSubalgebra.instSetLike | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | [
"SetLike",
"NonUnitalSubalgebra",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"AddSubsemigroup.carrier",
"AddZeroClass.toAddZero",
"AddSubmonoid.toAddSubsemigroup",
"CommSemiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"SetLike.mk",
"NonUnitalSubsemiring.toAddSubmonoid",
"Non... | true |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.CompleteLattice.Iic_coatomic_of_compact_element._simp_1_6 | Mathlib.Order.CompactlyGenerated.Basic | [
"False",
"True",
"propext",
"not_false_iff",
"Eq",
"Not"
] | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.mul_fdiv_self_le._proof_1_2 | Init.Data.Int.DivMod.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Dvd.dvd",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.and_not_not_of_not_or",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.Linear... | false |
Std.Internal.IO.Async.instDecidableEqSignal._proof_1 | Std.Internal.Async.Signal | [
"congrArg",
"Eq.mp",
"Std.Internal.IO.Async.Signal.ctorIdx",
"Nat",
"Std.Internal.IO.Async.Signal.ofNat_ctorIdx",
"Std.Internal.IO.Async.Signal",
"Eq",
"Std.Internal.IO.Async.Signal.ofNat"
] | false |
_private.Mathlib.Algebra.QuadraticAlgebra.Basic.0.QuadraticAlgebra.instField._simp_8 | Mathlib.Algebra.QuadraticAlgebra.Basic | [
"False",
"eq_false",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"three_ne_zero",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
MvPolynomial.mem_symmetricSubalgebra | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | [
"MvPolynomial.IsSymmetric",
"Subalgebra.instSetLike",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"CommSemiring.toSemiring",
"Iff.rfl",
"AddMonoidAlgebra.algebra",
"Finsupp.instAddMonoid",
"Nat.instAddMonoid",
"Membership.mem",
"Algebra.id",
"CommSemiring",
"Iff",
"MvPolynomial.sy... | true |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.inv_height_lt_sum_inv_height._simp_1_2 | Mathlib.Geometry.Euclidean.Incenter | [
"InnerProductSpace.toNormedSpace",
"Affine.Simplex.height",
"Nat.instMulZeroClass",
"Real",
"Real.instZero",
"Real.instRCLike",
"NormedSpace.toModule",
"Real.instLT",
"Affine.Simplex",
"Real.instRing",
"instOfNatNat",
"Affine.Simplex.height_pos",
"instHAdd",
"NormedAddTorsor.toAddTorsor",
... | false |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalInstantiate.ensureNoMinIndexable | Lean.Elab.Tactic.Grind.BuiltinTactic | [
"Pure.pure",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"String",
"Lean.Meta.State",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMonad",
"Lean.throwError",
"Lean.MonadQuotation.toMonadRef",
"Lean.Meta.MetaM",
"IO.RealWorld",
"StateRefT'.instMonadFunctor",
"instDecid... | true |
MeasureTheory.lintegral_image_eq_lintegral_deriv_mul_of_antitoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | [
"IsModuleTopology.toContinuousSMul",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"abs_neg",
"Real",
"MeasureTheory.Measure",
"NonUnitalCommRing... | true |
QuotientGroup.instSeminormedCommGroup | Mathlib.Analysis.Normed.Group.Quotient | [
"QuotientGroup.groupSeminorm._proof_3",
"QuotientGroup.instSeminormedCommGroup._proof_5",
"PseudoMetricSpace.toBornology",
"QuotientGroup.instSeminormedCommGroup._proof_7",
"SeminormedCommGroup.toPseudoMetricSpace",
"QuotientGroup.instSeminormedCommGroup._proof_8",
"PseudoMetricSpace.toUniformSpace",
... | true |
_private.Lean.Elab.PreDefinition.Structural.IndPred.0.Lean.Elab.Structural.replaceIndPredRecApps.loop.match_6 | Lean.Elab.PreDefinition.Structural.IndPred | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Lean.Meta.MetaM",
"Nat.hasNotBit",
"Prod.mk",
"Unit",
"_private.Lean.Elab.PreDefinition.Structural.IndPred.0.Lean.Elab.Structural.replaceIndPredRecApp._sparseCasesOn_1",
"Prod",
"Prod.casesOn",
"Option"
] | false |
Std.Net.IPAddr.toString | Std.Net.Addr | [
"Std.Net.IPAddr",
"Std.Net.IPv6Addr",
"String",
"Std.Net.IPv4Addr",
"Std.Net.IPAddr.family.match_1",
"Std.Net.IPv6Addr.toString",
"Std.Net.IPv4Addr.toString"
] | true |
Submodule.span_singleton_eq_top_iff | Mathlib.LinearAlgebra.Span.Defs | [
"Eq.mpr",
"Submodule",
"instHSMul",
"trivial",
"eq_top_iff",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"Set.instSingletonSet",
"id",
"DistribSMul.toSMulZero... | true |
CategoryTheory.Functor.mapAddMonIdIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.AddMon.instCategory",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso.refl",
"CategoryTheory.Category.comp_id",
"CategoryTheory.AddMonObj.zero... | false |
ContinuousGeneratedByCat.fullyFaithfulToTopCat._proof_2 | Mathlib.Topology.Convenient.Category | [
"Equiv.instEquivLike",
"ContinuousGeneratedByCat.instCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ContinuousGeneratedByCat.homMk",
"TopCat.instCategory",
"ContinuousMap",
"Function.comp",
"id",
"Equiv",
"CategoryTheory.Functor.map",
"ContinuousGeneratedByCat.str",
"Top... | false |
Rep.FiniteCyclicGroup.chainComplexFunctor_obj | Mathlib.RepresentationTheory.Homological.FiniteCyclic | [
"Rep.FiniteCyclicGroup.chainComplexFunctor._proof_1",
"ChainComplex",
"CommRing",
"HomologicalComplex.instCategory",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HomologicalComplex.alternatingConst",
"CommSemiring.toSemiring",
"Rep.FiniteCyclicGroup.chainComplexFunctor._... | true |
Subgroup.IsSubnormal.rec | Mathlib.GroupTheory.IsSubnormal | [
"Subgroup.subgroupOf",
"PartialOrder.toPreorder",
"Group",
"Preorder.toLE",
"Membership.mem",
"Subtype",
"Subgroup",
"LE.le",
"Subgroup.IsSubnormal.step",
"Subgroup.IsSubnormal",
"Subgroup.instPartialOrder",
"Subgroup.instTop",
"Subgroup.IsSubnormal.top",
"Top.top",
"Subgroup.toGroup",
... | false |
CategoryTheory.SubobjectRepresentableBy.χ.congr_simp | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.SubobjectRepresentableBy",
"Eq.rec",
"CategoryTheory.Limits.HasPullbacks",
"CategoryTheory.SubobjectRepresentableBy.χ",
"Eq.ndrec",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"Categ... | true |
HahnSeries.embDomain_zero | Mathlib.RingTheory.HahnSeries.Basic | [
"HahnSeries.support",
"False",
"HahnSeries.embDomain",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"PartialOrder.toPreorder",
"HahnSeries.ext",
"HahnSeries.embDomain_notin_image_support",
"Preorder.toLE",
"Membership.mem",
"PartialOrder",
"HahnSeries.instZero",
"funext",
"True",
"eq_s... | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.hasMVarAtCurrDepth._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
IsLeast.unique | Mathlib.Order.Bounds.Basic | [
"lowerBounds",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"PartialOrder",
"IsLeast",
"le_antisymm",
"And.right",
"And.left",
"Eq",
"Set.instMembership",
"Set"
] | true |
Partrec.vector_mOfFn._f | Mathlib.Computability.Partrec | [
"Part",
"instNeZeroNatHAdd_1",
"PFun",
"Fin.succ",
"Part.bind",
"Part.some",
"Partrec.bind",
"List.Vector",
"id",
"Fin.instOfNat",
"instOfNatNat",
"Primcodable.vector",
"Computable.snd",
"Prod.fst",
"Computable₂.comp",
"Nat.below",
"Primcodable.prod",
"Computable.comp",
"instHAdd... | false |
AddEquiv.symmEquiv_apply_symm_apply | Mathlib.Algebra.Group.Equiv.Defs | [
"Equiv.instEquivLike",
"Equiv",
"AddEquiv",
"Eq.refl",
"AddEquiv.instEquivLike",
"Eq",
"DFunLike.coe",
"AddEquiv.symmEquiv",
"Add",
"AddEquiv.symm",
"EquivLike.toFunLike"
] | true |
Mathlib.Tactic.Ring.Common.Result.recOn | Mathlib.Tactic.Ring.Common | [
"Mathlib.Tactic.Ring.Common.Result.mk",
"Mathlib.Tactic.Ring.Common.Result.rec",
"Lean.Expr.const",
"Mathlib.Tactic.Ring.Common.Result",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"Qq.Quoted",
"Lean.Expr.app",
"Lean.Level.succ",
"Lean.Name.mkStr1",
"List.nil"
] | false |
ComplexShape.Embedding.AreComplementary.Boundary.indexOfBoundaryLE | Mathlib.Algebra.Homology.Embedding.AreComplementary | [
"ComplexShape",
"ComplexShape.Embedding.AreComplementary.Boundary",
"ComplexShape.Embedding",
"ComplexShape.Embedding.AreComplementary.Boundary.exists₁",
"Exists.choose",
"ComplexShape.Embedding.BoundaryLE",
"ComplexShape.Embedding.AreComplementary"
] | true |
Circle.expHom_apply | Mathlib.Analysis.Complex.Circle | [
"Circle.expHom",
"Real",
"Equiv.instEquivLike",
"Real.instAddMonoid",
"Monoid.toMulOneClass",
"Additive",
"ContinuousMap",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"AddZeroClass.toAddZero",
"Equiv",
"DivInvMonoid.toMonoid",
"Additive.addZeroClass",
... | true |
CategoryTheory.Discrete.compNatIsoDiscrete | Mathlib.CategoryTheory.Discrete.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Discrete.natIso",
"Function.comp",
"CategoryTheory.Iso.refl",
"CategoryTheory.Iso",
"CategoryTheory.discreteCategory",
"CategoryTheory.Functor.obj",
"Cat... | true |
Algebra.Presentation.naive_relation | Mathlib.RingTheory.Extension.Presentation.Basic | [
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"CommRing",
"Algebra.Generators.Ring",
"Algebra.Presentation.naive",
"AddMonoidAlgebra.commRing",
"CommSemiring.toSemiring",
"Ideal.Quotient.mk",
"AddMonoidAlgebra.algebra",
"Finsupp.instAddMonoid",
"Nat.instAddMonoid",
"RingHom",
"Algebra... | true |
CategoryTheory.Presheaf.freeYoneda._proof_4 | Mathlib.CategoryTheory.Generator.Presheaf | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"Quiver.Hom.unop"... | false |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_natAddEmb_Ioo._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | [
"Finset",
"Finset.coe_inj",
"SetLike.coe",
"Finset.instSetLike",
"propext",
"Eq.symm",
"Eq",
"Set"
] | false |
_private.Mathlib.Data.Set.Dissipate.0.Set.biInter_dissipate._simp_1_2 | Mathlib.Data.Set.Dissipate | [
"Set.subset_iInter_iff",
"Set.iInter",
"HasSubset.Subset",
"propext",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
CategoryTheory.CoreSmallCategoryOfSet.mk | Mathlib.CategoryTheory.SmallRepresentatives | [
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Set.Elem",
"Equiv",
"CategoryTheory.CoreSmallCategoryOfSet",
"CategoryTheory.CoreSmallCategoryOfSet.mk",
"CategoryTheory.Category.toCategoryStruct",
"DFunLike.coe",
"EquivLike.toFunLike",
"CategoryTheory.Category",
... | true |
DirectSum.sigmaUncurry | Mathlib.Algebra.DirectSum.Basic | [
"DirectSum.sigmaUncurry._proof_1",
"instAddCommMonoidDirectSum",
"DirectSum.sigmaUncurry._proof_2",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidHom.mk",
"Sigma.fst",
"ZeroHom.mk",
"AddCommMonoid",
"AddZero.toZero",
"DFinsupp.sigmaUncurry",
"AddCommMonoid.toAddMonoid",
"Ad... | true |
Lean.Lsp.DeclInfo.selectionRange | Lean.Data.Lsp.Internal | [
"Lean.Lsp.DeclInfo.selectionRangeEndPosCharacter",
"Lean.Lsp.DeclInfo.selectionRangeStartPosLine",
"Lean.Lsp.DeclInfo.selectionRangeEndPosLine",
"Lean.Lsp.Range.mk",
"Lean.Lsp.DeclInfo",
"Lean.Lsp.DeclInfo.selectionRangeStartPosCharacter",
"Lean.Lsp.Position.mk",
"Lean.Lsp.Range"
] | true |
UInt64.toInt64_or | Init.Data.SInt.Bitwise | [
"instHOrOfOrOp",
"UInt64",
"Int64",
"instOrOpInt64",
"HOr.hOr",
"UInt64.toInt64",
"instOrOpUInt64",
"Eq",
"rfl"
] | true |
CategoryTheory.ShortComplex.Homotopy.smul._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Linear | [
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Linear",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"AddCommGroup.toAddGroup",
"s... | false |
CategoryTheory.LiftableCone.mk.injEq | Mathlib.CategoryTheory.Limits.Creates | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.LiftableCone",
"Eq.propIntro",
"Lean.injEq_helper",
"CategoryTheory.Functor.comp",
"HEq.homo_ndrec",
"CategoryTheory.LiftableCone.mk",
"CategoryTheory.Iso",
"And",
"Eq.ndrec",
"Eq.refl",
"HEq",
"CategoryTheory.Functor.... | true |
QuadraticAlgebra.mk.injEq | Mathlib.Algebra.QuadraticAlgebra.Defs | [
"QuadraticAlgebra",
"Eq.propIntro",
"Lean.injEq_helper",
"QuadraticAlgebra.mk.inj",
"And",
"Eq.ndrec",
"QuadraticAlgebra.mk",
"Eq.refl",
"Eq"
] | true |
ExteriorAlgebra.algebraMapInv._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | [
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"AddZeroClass.toAddZero",
"AddCommGroup",
... | false |
AkraBazziRecurrence.tendsto_zero_sumCoeffsExp | Mathlib.Computability.AkraBazzi.SumTransform | [
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"Real.instPow",
"Real.partialOrder",
"Real",
"tendsto_const_nhds_iff._simp_1",
"Mathlib.Meta.NormNum.instAddMonoidWith... | true |
Lean.Expr.relSidesIfSymm? | Mathlib.Tactic.Relation.Symm | [
"Pure.pure",
"Lean.ScopedEnvExtension.StateStack",
"Lean.PersistentEnvExtensionState",
"Lean.Meta.DiscrTree.instInhabited",
"_private.Mathlib.Tactic.Relation.Symm.0.Lean.Expr.relSidesIfSymm?.match_8",
"Lean.Meta.State",
"Lean.ScopedEnvExtension.Entry",
"_private.Mathlib.Tactic.Relation.Symm.0.Lean.Exp... | true |
_private.Init.Data.Rat.Lemmas.0.Rat.divInt_num_den.match_1_5 | Init.Data.Rat.Lemmas | [
"HMul.hMul",
"Exists",
"Int.instNegInt",
"Ne",
"instMulNat",
"instOfNatNat",
"Int",
"Nat.cast",
"Int.instMul",
"And.casesOn",
"And",
"Exists.casesOn",
"Nat",
"And.intro",
"Exists.intro",
"instNatCastInt",
"OfNat.ofNat",
"Eq",
"Neg.neg",
"instHMul"
] | false |
AddMonoidHom.compr₂.eq_1 | Mathlib.Algebra.Group.Hom.Instances | [
"AddMonoidHom.compr₂",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidHom.instAddCommMonoid",
"AddCommMonoid",
"AddZeroClass",
"Eq.refl",
"AddCommMonoid.toAddMonoid",
"AddMonoidHom.compHom",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"Eq",
"AddMonoidHom.comp",
"DFunLike.c... | true |
Int64.toInt16_and | Init.Data.SInt.Bitwise | [
"BitVec.instAndOp",
"Int16",
"congrArg",
"Int64.toBitVec_toInt16",
"BitVec",
"instAndOpInt16",
"Int64",
"instOfNatNat",
"Int64.toBitVec_and",
"BitVec.signExtend_and",
"Nat",
"Int16.toBitVec",
"congr",
"True",
"eq_self",
"Iff.mp",
"BitVec.signExtend",
"of_eq_true",
"instAndOpInt64... | true |
Finsupp.image_sumElim_product_antidiagonal | Mathlib.Data.Finsupp.Antidiagonal | [
"Finsupp.instHasAntidiagonal",
"Eq.mpr",
"Nat.instMulZeroClass",
"Finsupp.comapDomain_inl_sumElim",
"Sum.inr_injective",
"AddMonoid.toAddSemigroup",
"instDecidableEqProd",
"SProd.sprod",
"congrArg",
"Function.Injective.injOn",
"Finset",
"instDecidableEqSum",
"Sum.inl_injective",
"AddMonoid... | true |
Matroid.Matroidᵣ | Mathlib.Combinatorics.Matroid.Minor.Restrict | [
"Matroid.Matroidᵣ.ofMatroid"
] | true |
_private.Init.Data.String.Slice.0.String.Slice.Pos.skipWhile._sparseCasesOn_1 | Init.Data.String.Slice | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
Nat.Linear.Expr.mulR.inj | Init.Data.Nat.Linear | [
"Nat.Linear.Expr",
"And",
"Nat",
"And.intro",
"Nat.Linear.Expr.mulR",
"Eq",
"Nat.Linear.Expr.mulR.noConfusion"
] | true |
HasSolidNorm.continuousSup | Mathlib.Analysis.Normed.Order.Lattice | [
"Lattice",
"OrderDual.instMinOfMax",
"HasSolidNorm.continuousInf",
"Lattice.toSemilatticeSup",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"OrderDual.instHasSolidNorm",
"PseudoMetricSpace.toUniformSpace",
"OrderDual.normedAddCommGroup",
"SemilatticeInf.toPartialOrder",
"Semilattic... | true |
_private.Init.Data.String.Basic.0.List.utf8Decode?_utf8Encode._simp_1_2 | Init.Data.String.Basic | [
"Array.instAppend",
"Array.toList",
"List.toArray",
"Array",
"instHAppendOfAppend",
"List",
"propext",
"List.instAppend",
"Eq",
"HAppend.hAppend",
"Array.append_eq_toArray_iff"
] | false |
Lean.Lsp.SaveOptions | Lean.Data.Lsp.TextSync | [
"Lean.Lsp.SaveOptions.mk"
] | true |
Lean.AssocList.insertNew | Lean.Data.AssocList | [
"Lean.AssocList.cons",
"Lean.AssocList"
] | true |
Lean.MVarId.intro1_ | Lean.Meta.Tactic.Intro | [
"Pure.pure",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.MVarId.withContext",
"Lean.instMonadExceptOfExceptionCoreM",
"_private.Lean.Meta.Tactic.Intro.0.Lean.MVarId.intro1_.match_1",
"Lean.MVarId.getType'",
"instMonadControlTOfPure",
"String",
"Lean.MVarId.getTag",
"Lean.MVarId.assign",
"L... | true |
_private.Mathlib.Analysis.SpecificLimits.ArithmeticGeometric.0.arithGeom.match_1.eq_2 | Mathlib.Analysis.SpecificLimits.ArithmeticGeometric | [
"arithGeom.match_1",
"instOfNatNat",
"Unit",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq"
] | true |
Polynomial.dvd_term_of_dvd_eval_of_dvd_terms | Mathlib.Algebra.Polynomial.AlgebraMap | [
"Eq.mpr",
"Polynomial.eval",
"dvd_zero",
"CommRing",
"Dvd.dvd",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"HEq.refl",
"Finset",
"MulZeroClass.zero_mul",
"AddMonoid.toAddZeroClass",
"semigroupDvd",
"Polynomial.sum",
"SemigroupWithZero.toMulZeroC... | true |
Lean.LocalContext | Lean.LocalContext | [
"Lean.LocalContext.mk"
] | true |
CategoryTheory.Limits.mapIsLimitOfPreservesOfIsLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesLimit",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.BinaryFan.mk",
"Equiv",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.Functor.map",
"Categ... | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.continuousWithinAt._simp_1_4 | Mathlib.Analysis.Calculus.ContDiff.Defs | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"IsBotZeroClass",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"nonpos_iff_eq_zero",
"Zero"
] | false |
_private.Batteries.Data.BinaryHeap.Basic.0.Batteries.BinaryHeap.heapifyDown._unary._proof_10 | Batteries.Data.BinaryHeap.Basic | [
"_private.Batteries.Data.BinaryHeap.Basic.0.Batteries.BinaryHeap.heapifyDown._proof_4",
"Fin.val",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"Nat.decLt",
"instLTNat",
"Fin",
"Not"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.