name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft_sumInl._proof_1_1 | Mathlib.Logic.Equiv.Basic | [
"False",
"Equiv.instEquivLike",
"eq_false",
"Equiv.sumPiEquivProdPi_symm_apply",
"Classical.byContradiction",
"Eq.mp",
"Sum",
"id",
"Equiv",
"Prod.mk",
"Equiv.piCongrLeft",
"Sum.inl",
"Prod.fst",
"Equiv.sumPiEquivProdPi",
"Sum.inr",
"True",
"eq_true",
"Eq.refl",
"Equiv.piCongrLef... | false |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_one._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Subgroup.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Group.Basic | [
"Subgroup.topologicalClosure._proof_1",
"HMul.hMul",
"Monoid.toMulOneClass",
"Submonoid.toSubsemigroup",
"Group",
"Membership.mem",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDivInvMonoid",
"TopologicalSpace",
"MulOneClass.toMulOne",
"IsTopologicalGroup",
"Subsemigroup.c... | false |
FourierInvSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | [
"instHSMul",
"outParam",
"FourierInvSMul",
"SMul",
"FourierInvSMul.mk",
"FourierTransformInv.fourierInv",
"HSMul.hSMul",
"Eq",
"FourierTransformInv"
] | false |
_private.Init.Data.String.Basic.0.String.Pos.sliceFrom._proof_1 | Init.Data.String.Basic | [
"Iff.mpr",
"Eq.mpr",
"String.sliceFrom",
"String.Pos.Raw.unoffsetBy",
"congrArg",
"String",
"id",
"LE.le",
"instLENat",
"String.Pos.Raw",
"String.Pos.Raw.IsValidForSlice",
"String.Pos.Raw.offsetBy",
"String.Pos.isValid",
"Nat",
"String.instLERaw",
"Iff.mp",
"String.Pos",
"String.Po... | false |
Subfield.topologicalClosure.congr_simp | Mathlib.Topology.Instances.Complex | [
"Field.toDivisionRing",
"Eq.rec",
"Subfield.topologicalClosure",
"TopologicalSpace",
"Eq.refl",
"IsTopologicalDivisionRing",
"Subfield",
"Eq",
"Field"
] | true |
WithLp.neg_snd | Mathlib.Analysis.Normed.Lp.ProdLp | [
"WithLp",
"NegZeroClass.toNeg",
"WithLp.instAddCommGroup",
"AddCommGroup",
"WithLp.snd",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"ENNReal",
"AddCommGroup.toDivisionAddCommMonoid",
"Prod",
"Eq",
"Neg.neg",
"rfl"... | true |
MeasureTheory.AEStronglyMeasurable.real_toNNReal | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | [
"NNReal.instTopologicalSpace",
"Continuous.comp_aestronglyMeasurable",
"Real",
"MeasureTheory.Measure",
"PseudoMetricSpace.toUniformSpace",
"NNReal",
"MeasurableSpace",
"continuous_real_toNNReal",
"Real.pseudoMetricSpace",
"UniformSpace.toTopologicalSpace",
"MeasureTheory.AEStronglyMeasurable",
... | true |
Descriptive.Tree.drop_coe | Mathlib.SetTheory.Descriptive.Tree | [
"Descriptive.Tree.drop",
"Membership.mem",
"Subtype",
"Descriptive.tree",
"List",
"CompleteSublattice.instSetLike",
"List.drop",
"Nat",
"CompleteSublattice",
"CompleteBooleanAlgebra.toCompleteLattice",
"Eq.refl",
"Descriptive.Tree.subAt",
"Subtype.val",
"Eq",
"Descriptive.instSetLikeSubt... | true |
Metric.unitClosedBall.coe_mul | Mathlib.Analysis.Normed.Field.UnitBall | [
"NonUnitalSeminormedRing",
"Semigroup.toMul",
"Real",
"HMul.hMul",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Membership.mem",
"NonUnitalRing.toNonUnitalNonAssocRing",
"Set.Elem",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Metric.unitClosedBall.instSemigroup",
"Real.instOne",
"Dis... | true |
Lean.Language.Lean.CommandElaboratingSnapshot.noConfusion | Lean.Language.Lean.Types | [
"Lean.Language.Lean.CommandElaboratingSnapshot.noConfusionType",
"Lean.Language.SnapshotTree",
"Lean.Language.Lean.CommandElaboratingSnapshot",
"Lean.Language.DynamicSnapshot",
"Lean.Language.SnapshotTask",
"Lean.Language.Snapshot",
"Lean.Language.Lean.CommandResultSnapshot",
"Lean.Language.Lean.Comma... | false |
add_mem_closedBall_add_iff | Mathlib.Analysis.Normed.Group.Basic | [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"NegZeroClass.toNeg",
"Real.instLE",
"Real",
"SeminormedAddGroup.toAddGroup",
"SeminormedAddCommGroup",
"congrArg",
"add_add_neg_add_cancel",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZ... | true |
circleAverage_log_norm_sub_const_eq_posLog | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | [
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real.instLE",
"Real",
"Preorder.toLT",
"circleAverage_log_norm_sub_const₁",
"Real.lattice",
"Real.posLog",
"Real.instZero",
"Real.instRCLike",
"instReflLe",
"abs... | true |
Finset.val_covBy_val._simp_1 | Mathlib.Data.Finset.Grade | [
"Preorder.toLT",
"Finset",
"CovBy",
"PartialOrder.toPreorder",
"Multiset",
"Finset.partialOrder",
"Finset.val",
"propext",
"Eq",
"Multiset.instPartialOrder",
"Finset.val_covBy_val"
] | false |
_private.Mathlib.Dynamics.Ergodic.MeasurePreserving.0.MeasureTheory.MeasurePreserving.iterate.match_1_1 | Mathlib.Dynamics.Ergodic.MeasurePreserving | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
Matrix.UnitaryGroup.transpose_inv_eq_map_star | Mathlib.LinearAlgebra.UnitaryGroup | [
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Matrix",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"Matrix.unitaryGroup",
"Subtype",
"No... | true |
SSet.Truncated.Edge.CompStruct.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | [
"SSet.Truncated.Edge",
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"SSet.Truncated.Edge.CompStruct._proof_1",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ConcreteCategory.hom",
"SSet.Truncated.Edge._proof_2",
"SSet.Truncated.Edge.edge",
"Quiver.Hom.op",
"SimplexCa... | false |
Aesop.DisplayRuleName.casesOn | Aesop.Rule.Name | [
"Aesop.RuleName",
"Aesop.DisplayRuleName.rec",
"Aesop.DisplayRuleName",
"Aesop.DisplayRuleName.ruleName",
"Aesop.DisplayRuleName.normUnfold",
"Aesop.DisplayRuleName.normSimp"
] | false |
IsSelfAdjoint.star_eq | Mathlib.Algebra.Star.SelfAdjoint | [
"IsSelfAdjoint",
"Star",
"Eq",
"Star.star"
] | true |
AlgebraicGeometry.sigmaOpenCover | Mathlib.AlgebraicGeometry.Limits | [
"AlgebraicGeometry.Scheme",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Discrete.instSubsingletonDiscreteHom",
"AlgebraicGeometry.Scheme.forget",
"CategoryTheory.Functor.comp",
"CategoryTheory.Discrete.functor",
"AlgebraicGeometry.Scheme.OpenCover",
"CategoryTheory.Limits... | true |
Int32.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | [
"instXorOpInt32",
"Int32.xor_eq_zero_iff",
"HXor.hXor",
"propext",
"Int32.instOfNat",
"OfNat.ofNat",
"Eq",
"instHXorOfXorOp",
"Int32"
] | false |
Lean.Server.LoadedILean.moduleUri | Lean.Server.References | [
"Lean.Lsp.DocumentUri",
"Lean.Server.LoadedILean"
] | true |
Stream'.inits_eq | Mathlib.Data.Stream.Init | [
"Stream'.take",
"Eq.mpr",
"Stream'.get_succ",
"congrArg",
"Stream'.inits",
"id",
"Stream'.get_map",
"instOfNatNat",
"Stream'.get_inits",
"List.cons",
"Nat.casesAuxOn",
"Stream'",
"List",
"instHAdd",
"Stream'.get",
"HAdd.hAdd",
"Stream'.map",
"Nat",
"Eq.ndrec",
"instAddNat",
"... | true |
CategoryTheory.HasRightDual.noConfusion | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | [
"HEq.refl",
"CategoryTheory.HasRightDual",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.HasRightDual.noConfusionType",
"CategoryTheory.HasRightDual.casesOn",
"CategoryTheory.ExactPairing",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Eq",
"CategoryTheory.Category"
] | false |
Polynomial.expand_mul | Mathlib.Algebra.Polynomial.Expand | [
"HMul.hMul",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"Algebra.id",
"Polynomial.expand_expand",
"instMulNat",
"Polynomial",
"CommSemiring",
"Polynomial.semiring",
"Nat",
"Polynomial.expand",
"Eq.symm",
"Eq",
"DFunLike.coe",
"instHMul"
] | true |
AsBoolRing | Mathlib.Algebra.Ring.BooleanRing | [] | true |
lpSubmodule._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | [
"Eq.mpr",
"instHSMul",
"NormedRing.toRing",
"AddSubsemigroup.instSetLike",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"instAddCommGroupPreLp",
"AddSubsemigroup.carrier",
"AddCommGroup.toAddGroup",
"Membership.mem",
"IsBoundedSMul",
"AddZeroC... | false |
Nat.instAssociativeHAnd | Init.Data.Nat.Bitwise.Lemmas | [
"Nat.instAndOp",
"Std.Associative.mk",
"Nat",
"Nat.and_assoc",
"HAnd.hAnd",
"instHAndOfAndOp",
"Std.Associative"
] | true |
UInt16.reduceToNat._regBuiltin.UInt16.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.356 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | [
"IO",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"UInt16.reduceToNat",
"Lean.Meta.Simp.Simproc"
] | false |
MeasureTheory.lpMeasSubgroupToLpTrim_neg | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | [
"MeasureTheory.StronglyMeasurable.neg",
"MeasureTheory.ae",
"NegZeroClass.toNeg",
"MeasureTheory.Measure",
"Pi.instNeg",
"MeasurableSpace.instLE",
"instIsTransOfTrans",
"MeasureTheory.lpMeasSubgroupToLpTrim_ae_eq",
"Filter.instTransForallEventuallyEq",
"NormedAddCommGroup.toMetricSpace",
"Measur... | true |
_private.Lean.Environment.0.Lean.RealizationContext.casesOn | Lean.Environment | [
"Lean.NameMap",
"NonScalar",
"_private.Lean.Environment.0.Lean.RealizationContext",
"_private.Lean.Environment.0.Lean.RealizationContext.rec",
"_private.Lean.Environment.0.Lean.RealizationContext.mk",
"IO.Ref",
"Lean.Options"
] | false |
Ordinal.mul_div_le | Mathlib.SetTheory.Ordinal.Arithmetic | [
"Iff.mpr",
"Ordinal.instLinearOrder",
"instHDiv",
"le_rfl",
"HMul.hMul",
"LinearOrder.toDecidableEq",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"instIsBotZeroClass",
"zero_le._simp_1",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"HDiv.hDiv",
... | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.elabParserName.match_1 | Lean.Elab.Syntax | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Lean.Parser.ParserResolution",
"Option"
] | false |
Lean.ResolveName.resolveGlobalName | Lean.ResolveName | [
"Lean.MacroScopesView.name",
"String",
"Lean.extractMacroScopes",
"List",
"Lean.MacroScopesView",
"Lean.Name",
"_private.Lean.ResolveName.0.Lean.ResolveName.resolveGlobalName.loop",
"Prod",
"Lean.Options",
"Lean.Environment",
"Lean.OpenDecl",
"List.nil"
] | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH.match_1 | Lean.Meta.IndPredBelow | [
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"Lean.Expr.fvar",
"Lean.Expr.ctorIdx",
"_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH._sparseCasesOn_1"
] | false |
_private.Init.Prelude.0.Lean.Macro.State.mk.noConfusion | Init.Prelude | [
"Lean.Macro.State.noConfusion",
"String",
"id",
"List",
"Lean.Macro.State",
"Lean.MacroScope",
"Lean.Name",
"Prod",
"_private.Init.Prelude.0.Lean.Macro.State.mk",
"Eq"
] | false |
NonUnitalRingHom.op_apply_apply | Mathlib.Algebra.Ring.Opposite | [
"Equiv.instEquivLike",
"ZeroHom.toFun",
"AddMonoid.toAddZeroClass",
"MulOpposite",
"AddMonoidHom.toZeroHom",
"AddZeroClass.toAddZero",
"NonUnitalRingHom.op",
"Equiv",
"NonUnitalRingHom.instFunLike",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"AddZero.toZero",
"NonUnitalRingHom.toAddMonoidHom... | true |
Commute.function_commute_mul_right | Mathlib.Algebra.Group.Commute.Basic | [
"Semigroup",
"Semigroup.toMul",
"HMul.hMul",
"Function.Commute",
"Commute",
"SemiconjBy.function_semiconj_mul_right_swap",
"instHMul"
] | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.mk_isRelPrime_iff._simp_1_2 | Mathlib.Algebra.GroupWithZero.Associated | [
"Monoid",
"Associates.mk",
"Associates.forall_associated",
"Associates",
"propext",
"Eq"
] | false |
Turing.ToPartrec.Cont._sizeOf_inst | Mathlib.Computability.TuringMachine.Config | [
"Turing.ToPartrec.Cont",
"Turing.ToPartrec.Cont._sizeOf_1",
"SizeOf.mk",
"SizeOf"
] | false |
NNRat.den_one | Mathlib.Data.NNRat.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommSemiring.toSemiring",
"NNRat",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"instCommSemiringNNRat",
"AddMonoidWithOne.toOne",
"NNRat.den",
"Nat",
"One.toOfNat1",
"OfNat.ofNat",
"Semiring.toNonAssocSemiring",
"Eq",
"rfl"
] | true |
List.getElem?_append_right._f | Init.Data.List.Lemmas | [
"Eq.mpr",
"congrArg",
"HSub.hSub",
"List.instGetElem?NatLtLength",
"_private.Init.Data.List.Lemmas.0.List.getElem?_append_right.match_1_1",
"id",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"List.cons",
"instHAppendOfAppend",
"List",
"instHAdd",
"instHSub",
"Nat.lt_succ_iff",
... | false |
Std.DHashMap.Raw.Const.get!_filterMap | Std.Data.DHashMap.RawLemmas | [
"Iff.mpr",
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Eq.mpr",
"Std.DHashMap.Internal.Raw.Const.get!_eq",
"Std.DHashMap.Internal.Raw₀.Const.get?",
"Std.DHashMap.Raw.filterMap",
"Std.DHashMap.Internal.Raw₀.Const.get!_filterMap",
"congrArg",
"Std.DHashMap.Internal.Raw₀... | true |
Submodule.restrictScalars_mono | Mathlib.Algebra.Module.Submodule.RestrictScalars | [
"Submodule",
"Submodule.restrictScalars_monotone",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"Submodule.restrictScalars",
"SMul",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"Submodule.instPartialOrde... | true |
Std.TreeSet.Raw.WF.merge | Std.Data.TreeSet.Raw.WF | [
"Unit.unit",
"Std.TreeSet.Raw.WF.mk",
"Std.TreeMap.Raw.WF.mergeWith",
"Std.TreeSet.Raw.WF.out",
"Std.TreeSet.Raw.merge",
"Ordering",
"Std.TreeSet.Raw",
"Unit",
"Std.TreeSet.Raw.inner",
"Std.TreeSet.Raw.WF"
] | true |
LatticeCon.ker._proof_2 | Mathlib.Order.Lattice.Congruence | [
"Lattice",
"congrArg",
"Setoid.ker",
"id",
"LatticeHomClass",
"SemilatticeInf.toMin",
"InfHomClass.map_inf",
"congr",
"True",
"eq_self",
"of_eq_true",
"LatticeHomClass.toInfHomClass",
"Eq",
"DFunLike.coe",
"Min.min",
"Setoid.r",
"Eq.trans",
"FunLike",
"Lattice.toSemilatticeInf"
] | false |
Field.insepDegree | Mathlib.FieldTheory.SeparableClosure | [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"Cardinal",
"IntermediateField",
"IntermediateField.toField",
"Algebra",
"Membership.mem",
"Subtype",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Field.toSemifield",
"Field.toCommRin... | true |
Int.emod_add_cancel_left | Init.Data.Int.DivMod.Lemmas | [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"id",
"instHMod",
"Int",
"Int.add_comm",
"instHAdd",
"HMod.hMod",
"Iff",
"HAdd.hAdd",
"Int.emod_add_cancel_right",
"propext",
"Int.instAdd",
"Int.instMod",
"Eq"
] | true |
Std.DTreeMap.Internal.Impl.Ordered | Std.Data.DTreeMap.Internal.Ordered | [
"List.Pairwise",
"Ord",
"Ordering",
"Sigma.fst",
"Ord.compare",
"Ordering.lt",
"Std.DTreeMap.Internal.Impl.toListModel",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Sigma"
] | true |
Matrix.Exists._f | Mathlib.Data.Matrix.Reflection | [
"Equiv.instEquivLike",
"Matrix",
"Matrix.of",
"Equiv",
"Matrix.Forall.match_1",
"instOfNatNat",
"Nat.below",
"instHAdd",
"HAdd.hAdd",
"FinVec.Exists",
"Nat",
"Matrix.vecEmpty",
"instAddNat",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"DFunLike.coe",
"Matrix.vecCons",
"EquivLike.toFunLike"... | false |
Subgroup.le_closure_toSubmonoid | Mathlib.Algebra.Group.Subgroup.Lattice | [
"Iff.mpr",
"Subgroup.closure",
"Monoid.toMulOneClass",
"PartialOrder.toPreorder",
"Group",
"Preorder.toLE",
"DivInvMonoid.toMonoid",
"HasSubset.Subset",
"LE.le",
"Group.toDivInvMonoid",
"Subgroup.subset_closure",
"SetLike.coe",
"Submonoid.instPartialOrder",
"Submonoid.closure",
"Submonoi... | true |
_private.Mathlib.Algebra.Star.Module.0.IsIdempotentElem.star_iff._simp_1_1 | Mathlib.Algebra.Star.Module | [
"HMul.hMul",
"StarMul",
"Mul",
"StarMul.toInvolutiveStar",
"StarMul.star_mul",
"InvolutiveStar.toStar",
"Eq.symm",
"Eq",
"instHMul",
"Star.star"
] | false |
Finite.recOn | Mathlib.Data.Finite.Defs | [
"Finite.intro",
"Finite",
"Equiv",
"Finite.rec",
"Nat",
"Fin"
] | false |
List.filter_filterMap | Init.Data.List.Lemmas | [
"Eq.mpr",
"Option.guard",
"List.filterMap_filterMap",
"congrArg",
"Option.casesOn",
"Option.some",
"Eq.rec",
"Option.bind",
"id",
"instDecidableEqBool",
"Bool.true",
"funext",
"Option.none",
"List",
"Option.filter",
"List.filter",
"eq_self",
"Bool",
"of_eq_true",
"Eq.ndrec",
... | true |
Std.HashMap.getElem?_alter | Std.Data.HashMap.Lemmas | [
"Std.HashMap.alter",
"Std.DHashMap.Const.get?_alter",
"Membership.mem",
"instDecidableEqBool",
"Std.HashMap",
"LawfulHashable",
"Bool.true",
"BEq.beq",
"EquivBEq",
"Bool",
"Hashable",
"GetElem?.getElem?",
"Std.HashMap.instGetElem?Mem",
"Std.HashMap.inner",
"BEq",
"Eq",
"Std.HashMap.i... | true |
Module.Basis.reindexFinsetRange_self | Mathlib.LinearAlgebra.Basis.Defs | [
"Finset.mem_univ",
"Eq.mpr",
"Module.Basis.reindexFinsetRange.eq_1",
"Equiv.instEquivLike",
"Module.Basis.reindexFinsetRange",
"Finset.univ",
"congrArg",
"Finset",
"Module.Basis.reindexRange_apply",
"Membership.mem",
"Module.Basis.reindexRange",
"Equiv.subtypeEquiv",
"Set.Elem",
"id",
"E... | true |
Lean.Lsp.TextDocumentRegistrationOptions.mk.injEq | Lean.Data.Lsp.Basic | [
"Lean.Lsp.DocumentSelector",
"Lean.Lsp.TextDocumentRegistrationOptions",
"Eq.propIntro",
"Lean.Lsp.TextDocumentRegistrationOptions.mk",
"Lean.Lsp.TextDocumentRegistrationOptions.mk.inj",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Option"
] | true |
Lean.Elab.PartialTermInfo.mk | Lean.Elab.InfoTree.Types | [
"Lean.Elab.PartialTermInfo",
"Lean.Elab.ElabInfo",
"Lean.Elab.PartialTermInfo.mk",
"Lean.Expr",
"Lean.LocalContext",
"Option"
] | true |
Aesop.Script.DynStructureM.Context.noConfusion | Aesop.Script.StructureDynamic | [
"Lean.instBEqMVarId",
"Lean.PHashMap",
"Lean.MVarId",
"Aesop.Script.DynStructureM.Context.casesOn",
"Aesop.Script.DynStructureM.Context",
"Aesop.Script.DynStructureM.Context.noConfusionType",
"Lean.instHashableMVarId",
"Nat",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Eq",
"Aesop.Script.Step"
] | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.mkCommRingLinOrdThmPrefix | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | [
"Pure.pure",
"Lean.Meta.Grind.GrindM",
"Lean.Meta.Grind.Arith.Linear.Struct.type",
"Lean.Meta.Grind.Arith.Linear.Struct.u",
"Lean.Meta.Grind.Arith.Linear.getLawfulOrderLTInst",
"Lean.Meta.Grind.Arith.Linear.instMonadGetStructOfMonadLift",
"Lean.Meta.Grind.Arith.Linear.instMonadGetStructLinearM",
"Lean... | true |
MeasureTheory.Measure.count.isFiniteMeasure | Mathlib.MeasureTheory.Measure.Count | [
"Set.encard",
"MeasureTheory.Measure",
"Preorder.toLT",
"MeasureTheory.Measure.count_apply",
"MeasurableSet",
"instTopENat",
"congrArg",
"Set.univ",
"Finite",
"PartialOrder.toPreorder",
"ENat.toENNReal_lt_top._simp_1",
"ENat.toENNReal",
"Set.encard_univ",
"MeasurableSpace",
"MeasureTheor... | true |
Polynomial.map_prod | Mathlib.Algebra.Polynomial.Eval.Defs | [
"RingHom.instRingHomClass",
"CommSemiring.toSemiring",
"Finset",
"RingHom",
"RingHomClass.toMonoidWithZeroHomClass",
"NonAssocSemiring.toMulZeroOneClass",
"MonoidWithZeroHomClass.toMonoidHomClass",
"map_prod",
"Polynomial",
"Finset.prod",
"CommSemiring",
"RingHom.instFunLike",
"Polynomial.ma... | true |
IsLocalRing.specializes_closedPoint | Mathlib.RingTheory.Spectrum.Prime.Topology | [
"Specializes",
"PrimeSpectrum.isPrime",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"IsLocalRing",
"CommSemiring",
"PrimeSpectrum.instPartialOrder",
"PrimeSpectrum.le_iff_specializes",
"IsLocalRing.le_maximalIdeal",
"IsLocalRing.closedPoint",
"Iff.mp",
"... | true |
Encodable.encodeSum | Mathlib.Logic.Encodable.Basic | [
"HMul.hMul",
"Sum",
"instMulNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Encodable.encode",
"Encodable.encodeSum.match_1",
"OfNat.ofNat",
"Encodable",
"instHMul"
] | true |
_private.Batteries.Data.Vector.Lemmas.0.Vector.scanlM.loop_toArray | Batteries.Data.Vector.Lemmas | [
"Pure.pure",
"Eq.mpr",
"of_eq_false",
"False",
"Nat.recAux",
"dite_congr",
"bind_congr",
"Vector.push",
"instDecidableTrue",
"Vector",
"Array.push",
"congrArg",
"Monad.toApplicative",
"Vector.instGetElemNatLt",
"HSub.hSub",
"Array.scanlM.loop",
"Vector.scanlM._proof_4",
"Vector.sca... | true |
conjneg_neg'._simp_1 | Mathlib.Algebra.Order.Star.Conjneg | [
"CommRing",
"Pi.preorder",
"Preorder.toLT",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"conjneg",
"PartialOrder",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Pi.instZero",
"NonUnitalCommSemiri... | false |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_2 | Mathlib.Order.Interval.Finset.Defs | [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"Finset",
"Subtype.coe_lt_coe",
"Membership.mem",
"id",
"Subtype",
"Finset.mem_Ioo'",
"And",
"Iff",
"Finset.instSetLike",
"Finset.mem_subtype",
"LT.lt",
"propext",
"Subtype.instLT",
"LocallyFiniteOrder",
"congrFun'",
"Finset.subtype",
"Sub... | false |
unitOfInvertible | Mathlib.Algebra.Group.Invertible.Basic | [
"Monoid",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Invertible.invOf",
"Units",
"MulOne.toMul",
"unitOfInvertible._proof_2",
"MulOneClass.toMulOne",
"Units.mk",
"Invertible",
"unitOfInvertible._proof_1"
] | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Append.0.Std.IterM.toArray_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Append | [
"Unit.unit",
"Std.IterStep",
"Std.IterStep.skip",
"Unit",
"Std.IterStep.yield",
"Std.IterStep.done",
"Eq.refl",
"Std.IterM.toArray_eq_match_step.match_1",
"Std.IterM",
"Eq"
] | true |
_private.Mathlib.Control.Fix.0.Part.Fix.approx.match_1.splitter | Mathlib.Control.Fix | [
"instOfNatNat",
"Unit",
"Nat",
"Part.Fix.approx.match_1",
"OfNat.ofNat",
"Nat.succ"
] | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.match_1 | Lean.Elab.MacroArgUtil | [
"Unit.unit",
"Option.casesOn",
"Lean.Syntax.Ident",
"Option.some",
"Option.none",
"Unit",
"Option"
] | false |
Topology.IsOpenEmbedding.isGeneratedBy | Mathlib.Topology.Convenient.OpenClosed | [
"Topology.IsOpenEmbedding.toIsEmbedding",
"Topology.IsGeneratedBy",
"IsOpen.isGeneratedBy",
"TopologicalSpace.Opens",
"Membership.mem",
"Set.Elem",
"Subtype",
"TopologicalSpace.Opens.instSetLike",
"Topology.IsOpenEmbedding.isOpen_range",
"TopologicalSpace",
"Homeomorph.instEquivLike",
"Topolog... | true |
Batteries.Tactic.TransRelation.implies.sizeOf_spec | Batteries.Tactic.Trans | [
"Batteries.Tactic.TransRelation.implies",
"Lean.BinderInfo._sizeOf_inst",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Lean.instSizeOfName",
"Nat",
"Batteries.Tactic.TransRelation._sizeOf_inst",
"SizeOf.sizeOf",
"Batteries.Tactic.TransRelation",
"instAddNat",
"Lean.Name",
"Eq.refl",
"Lean.Bin... | true |
_private.Mathlib.Order.Defs.PartialOrder.0.lt_iff_le_iff_gt_iff_ge._proof_1_1 | Mathlib.Order.Defs.PartialOrder | [
"instLawfulOrderLT_mathlib",
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"lt_iff_le_not_ge",
"False.elim",
"Classical.byContradiction",
"... | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.elabReorder.match_7 | Mathlib.Tactic.Translate.Reorder | [
"MProd.casesOn",
"Subtype",
"MProd.mk",
"instOfNatNat",
"LE.le",
"instLENat",
"Array",
"List",
"Nat",
"MProd",
"Prod",
"OfNat.ofNat",
"Mathlib.Tactic.Translate.ArgReorder",
"List.length"
] | false |
NonUnitalNonAssocRing.toHasDistribNeg._proof_4 | Mathlib.Algebra.Ring.Defs | [
"NonUnitalNonAssocRing",
"HMul.hMul",
"NonUnitalNonAssocRing.toAddCommGroup",
"AddCommGroup.toAddGroup",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"SubtractionMonoid.toSubNegMonoid",
"eq_neg_of_add_eq_zero_left",
"SubtractionCommMonoid.toSubtractionMonoid",
"AddGroup.toSubNegMonoid",
"D... | false |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.ImportState.minImports._default | Mathlib.Tactic.Linter.MinImports | [
"Lean.NameSet",
"id",
"Lean.NameSet.instEmptyCollection",
"EmptyCollection.emptyCollection"
] | false |
SimpleGraph.CompleteEquipartiteSubgraph.card_verts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | [
"Eq.mpr",
"Nat.instMulZeroClass",
"instHSMul",
"HMul.hMul",
"_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.CompleteEquipartiteSubgraph.card_verts._simp_1_2",
"MulZeroClass.toMul",
"congrArg",
"SimpleGraph.CompleteEquipartiteSubgraph.disjoint",
"Finset",
"Nat.instIsC... | true |
CategoryTheory.Functor.commShiftOp_iso_eq | Mathlib.CategoryTheory.Shift.Opposite | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"CategoryTheory.Functor.commShiftOp",
"Opposite",
"CategoryTheory.instCategoryOppositeShift",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Iso",
"CategoryTheory.instHasShiftOp... | true |
LinearOrder.liftWithOrd._proof_1 | Mathlib.Order.Basic | [
"LinearOrder.toOrd",
"Ord",
"LinearOrder",
"Ordering",
"Ord.compare",
"Eq.symm",
"Eq"
] | false |
Part.inv_mem_inv | Mathlib.Data.Part | [
"Part",
"Eq.mpr",
"Inv",
"Membership.mem",
"Exists",
"id",
"Part.instMembership",
"And",
"Inv.inv",
"And.intro",
"Exists.intro",
"Part.mem_map_iff._simp_1",
"Eq.refl",
"Eq",
"Part.instInv"
] | true |
Std.Time.Timestamp.subWeeks | Std.Time.DateTime.Timestamp | [
"Std.Time.Duration.ofSeconds",
"HSub.hSub",
"Std.Time.Timestamp.val",
"Function.comp",
"Std.Time.Second.Offset",
"Std.Time.Week.Offset.toDays",
"Std.Time.Day.Offset",
"Std.Time.Day.Offset.toSeconds",
"Std.Time.Timestamp.mk",
"Std.Time.Timestamp",
"Std.Time.Duration",
"Std.Time.Week.Offset",
... | true |
Module.fgSystem.equiv_comp_of | Mathlib.Algebra.Colimit.Finiteness | [
"Submodule",
"Module.DirectLimit.lift_of",
"LinearMap.ext",
"congrArg",
"Submodule.addCommMonoid",
"Module.DirectLimit.of",
"PartialOrder.toPreorder",
"Module.DirectLimit.module",
"LinearMap.instFunLike",
"Module.fgSystem.equiv",
"Membership.mem",
"Module.fgSystem.equiv._proof_2",
"Subtype",... | true |
Std.IterM.drain_eq_map_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Std.IterM.toList_eq_match_step",
"Pure.pure",
"Eq.mpr",
"Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3",
"bind_congr",
"Std.IterStep",
"congrArg",
"Std.Shrink",
"LawfulMonad.bind_assoc",
"Monad.toApplicative",
"Std.PlausibleIterStep",
"Std.IteratorLoop",
"Std.IterM.IsPlausibleStep... | true |
groupHomology.instPreservesZeroMorphismsRepChainComplexModuleCatNatChainsFunctor | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | [
"ChainComplex",
"CommRing",
"HomologicalComplex.instCategory",
"Nat.instOne",
"ModuleCat",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Group",
"Rep.instCategory",
"Nat.instAddCancelCommMonoid",
"DivIn... | true |
GenContFract.IntFractPair.mapFr.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | [
"GenContFract.IntFractPair",
"GenContFract.IntFractPair.mk",
"GenContFract.IntFractPair.mapFr",
"GenContFract.IntFractPair.b",
"GenContFract.IntFractPair.fr",
"Eq.refl",
"Eq"
] | true |
MeasureTheory.Measure.InnerRegularWRT.eq_of_innerRegularWRT_of_forall_eq | Mathlib.MeasureTheory.Measure.Regular | [
"Eq.mpr",
"MeasureTheory.Measure",
"congrArg",
"iSup",
"HEq.refl",
"Eq.casesOn",
"id",
"HasSubset.Subset",
"SupSet",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"MeasureTheory.Measure.InnerRegularWRT",
"MeasurableSpace",
"funext",
"CompleteLinearOrder.toConditionally... | true |
Module.Relations.Solution.congr_var | Mathlib.Algebra.Module.Presentation.Basic | [
"Eq.mpr",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"id",
"Module.Relations.Solution",
"Module.Relations.G",
"Eq.refl",
"Module.Relations",
"Module",
"Ring.toSemiring",
"Eq",
"Ring",
"Module.Relations.Solution.var"
] | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk.inj | Lean.Server.Logging | [
"Lean.JsonRpc.MessageKind",
"_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk.noConfusion",
"Lean.JsonRpc.Message",
"And",
"And.intro",
"_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry",
"Std.Time.ZonedDateTime",
"Eq",
"Lean.JsonRpc.MessageDirection",
"_private.Lean.Serve... | true |
BoxIntegral.Box.mem_mk._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | [
"Set.Ioc",
"Real",
"Real.instLT",
"Membership.mem",
"BoxIntegral.Box.mem_mk",
"BoxIntegral.Box.instMembershipForallReal",
"LT.lt",
"propext",
"BoxIntegral.Box.mk",
"Eq",
"Set.instMembership",
"BoxIntegral.Box",
"Real.instPreorder",
"Set"
] | false |
IO.FS.SystemTime.noConfusion | Init.System.IO | [
"IO.FS.SystemTime.noConfusionType",
"IO.FS.SystemTime",
"Int",
"IO.FS.SystemTime.casesOn",
"Eq.ndrec",
"UInt32",
"Eq.refl",
"Eq"
] | false |
CochainComplex.HomComplex.CohomologyClass.mk_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | [
"CochainComplex.HomComplex.CohomologyClass.mk",
"AddGroupWithOne.toAddMonoidWithOne",
"CochainComplex.HomComplex.instAddCommGroupCocycle",
"AddCancelMonoid.toAddRightCancelMonoid",
"SubtractionMonoid.toSubNegZeroMonoid",
"Int",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMon... | true |
Finsupp.prod_finset_sum_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"Finset",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"MulOne.toMul",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"Finset.prod",
"AddZero.toZero",
"instHAdd",
"MulOneClass.toMulOne",
"HAdd.hAdd",
"CommMonoid.toMonoid",
"O... | true |
CategoryTheory.Limits.WalkingParallelFamily.Hom.line.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | [
"CategoryTheory.Limits.WalkingParallelFamily.one",
"CategoryTheory.Limits.WalkingParallelFamily",
"CategoryTheory.Limits.WalkingParallelFamily.Hom.line",
"id",
"CategoryTheory.Limits.WalkingParallelFamily.Hom",
"CategoryTheory.Limits.WalkingParallelFamily.zero",
"heq_of_eq",
"Eq.refl",
"HEq",
"Cat... | false |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1 | Lean.Widget.Types | [
"Lean.Widget.RpcEncodablePacket.mk._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1"
] | false |
InformationTheory.klDiv_eq_integral_klFun | Mathlib.InformationTheory.KullbackLeibler.Basic | [
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"ENNReal.ofReal",
"Real.instRCLike",
"congrArg",
"if_ctx_congr",
"Real.instSub",
"Set.univ",
"Iff.rfl",
"MeasureTheory.Measure.real",
"HSub.hSub",
"MeasureTheory.Measure.r... | true |
Fin.reduceCastSucc._regBuiltin.Fin.reduceCastSucc.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2550739679._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | [
"IO",
"Bool.true",
"Unit",
"Fin.reduceCastSucc",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.Simproc"
] | false |
CategoryTheory.Localization.Monoidal.triangle | Mathlib.CategoryTheory.Localization.Monoidal.Basic | [
"CategoryTheory.Localization.Monoidal.leftUnitor_hom_app",
"CategoryTheory.Localization.Monoidal.whiskerLeft_comp",
"Eq.mpr",
"CategoryTheory.MorphismProperty",
"CategoryTheory.Category.assoc",
"CategoryTheory.Iso.comp_inv_eq",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct",
"Cate... | true |
_private.Mathlib.Order.Atoms.0.bot_covBy_iff._simp_1_1 | Mathlib.Order.Atoms | [
"Preorder.toLT",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderBot",
"PartialOrder",
"bot_lt_iff_ne_bot",
"Ne",
"Bot.bot",
"LT.lt",
"propext",
"Eq"
] | false |
Std.Internal.List.getKey!_map | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Std.Internal.List.getKey!",
"congrArg",
"List.map",
"Option.get!",
"Sigma.fst",
"List",
"EquivBEq",
"congr",
"True",
"eq_self",
"of_eq_true",
"Inhabited",
"Std.Internal.List.getKey!_eq_getKey?",
"Sigma.mk",
"Std.Internal.List.getKey?_map",
"Std.Inte... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.