name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Firefox.ProfileMeta.rec | Lean.Util.Profiler | [
"Lean.Json",
"Lean.Firefox.ProfileMeta",
"String",
"Array",
"Lean.Firefox.SampleUnits",
"Nat",
"Lean.Firefox.ProfileMeta.mk",
"Lean.Firefox.Milliseconds",
"Lean.Firefox.Category"
] | false |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages.0.CategoryTheory.Abelian.PreservesCoimage.hom_coimageImageComparison._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Iso",
"propext",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Iso.eq_inv_comp",
"Eq.symm",
"CategoryTheory.Iso.hom",
"Eq",
"CategoryTheory.Iso.inv",
"CategoryTheory.Cate... | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Mathlib.Meta.Positivity.evalDist._proof_2 | Mathlib.Topology.MetricSpace.Pseudo.Defs | [
"Qq.QuotedDefEq",
"Lean.Expr.const",
"PLift",
"Lean.Expr.sort",
"Lean.Level",
"PLift.down",
"List.cons",
"Qq.Quoted",
"Lean.Level.zero",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Lean.Level.succ",
"Lean.Level.instOfNat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"List.nil"
] | false |
ProofWidgets.instFromJsonRpcEncodablePacket._@.ProofWidgets.Component.HtmlDisplay.3039065598._hygCtx._hyg.10 | ProofWidgets.Component.HtmlDisplay | [
"ProofWidgets.instFromJsonRpcEncodablePacket.fromJson._@.ProofWidgets.Component.HtmlDisplay.3039065598._hygCtx._hyg.10",
"Lean.FromJson",
"Lean.FromJson.mk",
"ProofWidgets.RpcEncodablePacket._@.ProofWidgets.Component.HtmlDisplay.3304690324._hygCtx._hyg.1"
] | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Defs.0.UniformContinuous.pow_const.match_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
Std.Time.PlainDate.instToString | Std.Time.Format | [
"Std.Time.PlainDate",
"Std.Time.PlainDate.toLeanDateString",
"ToString",
"ToString.mk"
] | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.Point.toAffine_some._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | [
"Fin.instOfNat",
"instOfNatNat",
"WeierstrassCurve.Projective.fin3_def_ext",
"Nat.instNeZeroSucc",
"Nat",
"Matrix.vecEmpty",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"Eq",
"Matrix.vecCons"
] | false |
Monoid.CoprodI.NeWord.toList.induct_unfolding | Mathlib.GroupTheory.CoprodI | [
"Monoid",
"Eq.mpr",
"MulOne.toOne",
"Monoid.CoprodI.NeWord.toList.match_1.congr_eq_2",
"_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.NeWord.toList.match_1.splitter",
"Monoid.CoprodI.NeWord",
"Monoid.toMulOneClass",
"congrArg",
"HEq.refl",
"Monoid.CoprodI.NeWord.singleton",
"id",
"Ne",... | true |
CategoryTheory.Limits.isEqualizerCompMono._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"_private.Mathlib.CategoryTheory.Limits.Shapes.Equalizers.0.CategoryTheory.Limits.Fork.IsLimit.mk._simp_3",
"CategoryTheory.Limits.walkingParallelPairHomCategory",
"id",
"Catego... | false |
MeasureTheory.Measure.instAdd._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | [
"Eq.mpr",
"le_refl",
"MeasureTheory.Measure",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"MeasureTheory.OuterMeasure",
"id",
"MeasureTheory.Measure.trimmed",
"LE.le",
"MeasurableSpace",
"MeasureTheory.Measure.toOuterMeasure",
"instHAdd",
"HAdd.hAdd",
"MeasureTheory.OuterMeas... | false |
Filter.map₂ | Mathlib.Order.Filter.NAry | [
"Filter.instMembership",
"SProd.sprod",
"Filter.map",
"setOf",
"Membership.mem",
"Exists",
"HasSubset.Subset",
"And",
"Set.image2",
"Filter.map₂._proof_5",
"Filter.copy",
"Function.uncurry",
"Prod",
"Filter.instSProd",
"Filter",
"Set.instHasSubset",
"Set"
] | true |
Lean.Parser.Command.openRenaming | Lean.Parser.Command | [
"Lean.Parser.Command.openRenamingItem",
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.sepBy1",
"Lean.Parser.symbol",
"Lean.Parser.ppSpace",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Lean.Parser.atomic",
"... | true |
Order.IsPredLimit.isMin | Mathlib.Order.SuccPred.Limit | [
"Order.IsPredLimit.isPredPrelimit",
"Preorder.toLE",
"Order.IsPredPrelimit.isMin",
"Order.pred",
"PredOrder",
"IsMin",
"Preorder",
"Order.IsPredLimit"
] | true |
Real.norm_two | Mathlib.Analysis.Normed.Group.Real | [
"Norm.norm",
"Real.partialOrder",
"Real",
"Real.lattice",
"Real.instZeroLEOneClass",
"Nat.instAtLeastTwoHAddOfNat",
"AddGroupWithOne.toAddMonoidWithOne",
"Real.instFloorRing",
"Real.instAddGroup",
"Real.instRing",
"instOfNatNat",
"Nat.instNeZeroSucc",
"Nat",
"Real.instAddCommMonoid",
"ab... | true |
MeasureTheory.L2.innerProductSpace._private_1 | Mathlib.MeasureTheory.Function.L2Space | [
"Norm.norm",
"Real",
"MeasureTheory.Measure",
"MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal",
"AddMonoid.toAddSemigroup",
"Inner.inner",
"Real.instAddMonoid",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"Nat.instAtLeastTwoHAddOfNat",
"PseudoMetricSpace.toUniformSpace"... | false |
Std.Time.instHSubOffsetOffset_21 | Std.Time.Date.Basic | [
"Rat.instOfNat",
"Std.Time.Hour.Offset",
"Std.Time.Hour.Offset.toMinutes",
"Rat",
"Std.Time.Internal.UnitVal.sub",
"Std.Time.Minute.Offset",
"HSub.mk",
"OfNat.ofNat",
"HSub"
] | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert._proof_1_1 | Mathlib.Data.Finset.Basic | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Finset",
"False.elim",
"Classical.byContradiction",
"Finset.ext",
"Membership.mem",
"Exists",
"Eq.mp",
"i... | false |
Std.Internal.IO.Process.ResourceUsageStats.noConfusion | Std.Internal.Async.Process | [
"UInt64",
"Std.Internal.IO.Process.ResourceUsageStats.casesOn",
"Std.Internal.IO.Process.ResourceUsageStats.noConfusionType",
"Std.Time.Millisecond.Offset",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Std.Internal.IO.Process.ResourceUsageStats"
] | false |
Turing.TM1to1.write._f | Mathlib.Computability.TuringMachine.PostTuringMachine | [
"Turing.TM1.Stmt.move",
"List.cons",
"List",
"Turing.TM1.Stmt.write",
"Turing.TM1to1.Λ'",
"Turing.TM1to1.write.match_1",
"Bool",
"List.below",
"Turing.Dir.right",
"Turing.TM1.Stmt",
"List.nil"
] | false |
_private.Mathlib.Dynamics.Ergodic.Action.Regular.0.instErgodicSMulOfIsMulLeftInvariant._simp_1 | Mathlib.Dynamics.Ergodic.Action.Regular | [
"Filter.Eventually",
"Filter.eventuallyConst_set",
"Filter.EventuallyConst",
"Membership.mem",
"propext",
"Or",
"Eq",
"Set.instMembership",
"Not",
"Filter",
"Set"
] | false |
Lean.JsonRpc.instBEqErrorCode.beq | Lean.Data.JsonRpc | [
"Lean.JsonRpc.ErrorCode",
"instBEqOfDecidableEq",
"BEq.beq",
"Nat",
"Lean.JsonRpc.ErrorCode.ctorIdx",
"Bool",
"instDecidableEqNat"
] | true |
LinearMap.map_algebraMap_mul | Mathlib.Algebra.Algebra.Basic | [
"Eq.mpr",
"instHSMul",
"SemilinearMapClass.toMulActionSemiHomClass",
"HMul.hMul",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"LinearMap.instFunLike",
"Algebra",
"RingHom",
"Algebra.toSMul",
"Algebra.toModule",
"id",
"LinearMap.semilinearMapClass",
"LinearMap",
"instDi... | true |
MvQPF.WEquiv.casesOn | Mathlib.Data.QPF.Multivariate.Constructions.Fix | [
"PFunctor.B",
"TypeVec.append1",
"instOfNatNat",
"MvPFunctor.A",
"MvQPF.WEquiv.abs",
"instHAdd",
"HAdd.hAdd",
"Nat",
"MvPFunctor.appendContents",
"MvQPF.WEquiv.ind",
"MvQPF.WEquiv.trans",
"MvPFunctor.B",
"MvPFunctor.last",
"instAddNat",
"MvQPF",
"Sigma.mk",
"MvQPF.P",
"MvQPF.WEquiv... | false |
ByteArray.get_set_ne._proof_2 | Batteries.Data.ByteArray | [
"Fin.val",
"_private.Batteries.Data.ByteArray.0.ByteArray.get_set_ne._proof_1",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"Nat.decLt",
"instLTNat",
"ByteArray",
"Fin",
"Not",
"ByteArray.size"
] | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_69 | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.Λ'.read",
"Turing.PartrecToTM2.Λ'",
"Eq.symm",
"Eq",
"Option"
] | false |
BialgCat.of_comul | Mathlib.Algebra.Category.BialgCat.Basic | [
"BialgCat.instBialgebra",
"CommRing",
"Coalgebra.toCoalgebraStruct",
"Ring.toNonAssocRing",
"Bialgebra.toCoalgebra",
"CommSemiring.toSemiring",
"TensorProduct.addCommMonoid",
"Algebra.toModule",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"LinearMap",
"NonAssocRing.toNonUnitalNonAssocRi... | true |
FirstOrder.Language.DefinableSet.instBooleanAlgebra._proof_1 | Mathlib.ModelTheory.Definability | [
"Set.Definable",
"Subtype",
"Subtype.coe_injective",
"FirstOrder.Language.Structure",
"FirstOrder.Language",
"Function.Injective",
"Subtype.val",
"Set"
] | false |
String.Pos.Splits.exists_eq_singleton_append_of_ne_startPos | Init.Data.String.Lemmas.Splits | [
"String.Pos.Splits",
"String.sliceFrom",
"String",
"String.Pos.splits_prev_right._proof_1",
"Exists",
"String.startPos",
"Ne",
"String.Slice.copy",
"instAppendString",
"instHAppendOfAppend",
"String.Pos.prev",
"Exists.intro",
"String.Pos",
"String.Pos.splits_prev",
"String.sliceTo",
"S... | true |
Equiv.Perm.subtypePerm_apply_pow_of_mem | Mathlib.GroupTheory.Perm.Cycle.Basic | [
"Iff.mpr",
"Equiv.instEquivLike",
"_private.Mathlib.Algebra.Group.End.0.Equiv.Perm.pow_aux",
"congrArg",
"Finset",
"Equiv.Perm.instPowNat",
"Membership.mem",
"Subtype",
"Equiv.Perm.subtypePerm",
"Subtype.mk",
"Iff",
"HPow.hPow",
"Finset.instSetLike",
"Equiv.Perm",
"Nat",
"True",
"eq_... | true |
Lean.Parser.instInhabitedFirstTokens | Lean.Parser.Types | [
"Lean.Parser.instInhabitedFirstTokens.default",
"Inhabited",
"Lean.Parser.FirstTokens",
"Inhabited.mk"
] | true |
AccPt | Mathlib.Topology.Defs.Filter | [
"Compl.compl",
"Filter.NeBot",
"nhdsWithin",
"Set.instSingletonSet",
"Filter.instInf",
"Set.instCompl",
"TopologicalSpace",
"Singleton.singleton",
"Filter",
"Min.min",
"Set"
] | true |
Filter.HasBasis.uniformity_of_nhds_zero_neg_add_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | [
"AddGroup.toSubtractionMonoid",
"UniformSpace",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"AddMonoid.toAddZeroClass",
"uniformity",
"setOf",
"Membership.mem",
"nhds",
"AddZeroClass.toAddZero",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"IsUniformAd... | true |
WellFoundedLT.toWellFoundedRelation.eq_1 | Mathlib.Order.RelClasses | [
"WellFoundedRelation",
"WellFoundedLT",
"WellFoundedLT.toWellFoundedRelation",
"LT.lt",
"Eq.refl",
"Eq",
"IsWellFounded.toWellFoundedRelation",
"LT"
] | true |
OreLocalization.«_aux_Mathlib_GroupTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1» | Mathlib.GroupTheory.OreLocalization.Basic | [
"Pure.pure",
"Lean.TSyntax",
"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",
"Lean.Name.mkStr3",... | false |
_private.Lean.Elab.Task.0.Lean.Elab.Tactic.TacticM.asTask.match_1 | Lean.Elab.Task | [
"Prod.mk",
"Prod",
"Prod.casesOn",
"Lean.Elab.Tactic.State"
] | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Convert.0.Std.Tactic.BVDecide.LRAT.Internal.CNF.unsat_of_convertLRAT_unsat._simp_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Convert | [
"Exists",
"exists_eq_right",
"And",
"propext",
"Eq"
] | false |
AlgHom.coe_prod | Mathlib.Algebra.Algebra.Prod | [
"AlgHom",
"AlgHom.funLike",
"Algebra",
"Prod.instSemiring",
"Prod.algebra",
"CommSemiring",
"Function.prod",
"Semiring",
"Prod",
"Eq",
"DFunLike.coe",
"rfl",
"AlgHom.prod"
] | true |
PiLp.norm_toLp_const | Mathlib.Analysis.Normed.Lp.PiLp | [
"WithLp",
"PiLp.instNorm",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real.instPow",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"SeminormedAddCommGroup",
"HMul.hMul",
"congrArg",
"Real.instInv",
"SeminormedAddGroup.toNNNorm",
"NNNorm.nnnorm",
"... | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | [
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.coreToInt",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.div... | true |
_private.Mathlib.Algebra.Lie.Abelian.0.LieSubalgebra.isLieAbelian_lieSpan_iff._simp_1_3 | Mathlib.Algebra.Lie.Abelian | [
"Subtype",
"Subtype.ext_iff",
"propext",
"Subtype.val",
"Eq"
] | false |
RingHom.IsStableUnderBaseChange | Mathlib.RingTheory.RingHomProperties | [
"CommRing",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IsScalarTower",
"Algebra.IsPushout",
"Algebra",
"RingHom",
"Algebra.toSMul",
"CommRing.toCommSemiring",
"Semiring.toNonAssocSemiring"
] | true |
Filter.coprod_inf_prod_le | Mathlib.Order.Filter.Prod | [
"Eq.mpr",
"Trans.trans",
"Lattice.toSemilatticeSup",
"sup_le_sup",
"le_rfl",
"CompleteLattice.toLattice",
"SProd.sprod",
"congrArg",
"Filter.prod_inf_prod",
"le_top._simp_2",
"Filter.prod_mono",
"Filter.instCompleteLatticeFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeI... | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.Real.rpowIntegrand₀₁_eq_sub._proof_1_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | [
"instLawfulOrderLT_mathlib",
"Lean.RArray.leaf",
"Lean.Grind.Field.toCommRing",
"False",
"Real.partialOrder",
"Real.instLE",
"Real",
"Lean.Grind.CommRing.Mon.mult",
"Lean.Grind.CommRing.diseq_to_eq",
"Lean.Grind.not_not",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"Lean.Grind.Co... | false |
Lean.Lsp.SignatureHelpTriggerKind.invoked.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.SignatureHelpTriggerKind._sizeOf_inst",
"instOfNatNat",
"Lean.Lsp.SignatureHelpTriggerKind",
"Lean.Lsp.SignatureHelpTriggerKind.invoked",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq"
] | true |
PSigma.Lex.linearOrder._proof_1 | Mathlib.Data.PSigma.Order | [
"Preorder.toLT",
"PSigma.Lex.left",
"Lex",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PSigma.Lex.right",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"PSigma.casesOn",
"le_total",
"LE.le",
"Or.casesOn",
"LT.lt",
"PSigma.Lex.partialOrder",
"PSigma.mk",
... | false |
_private.Mathlib.Data.Set.Insert.0.Set.subset_pair_iff._proof_1_1 | Mathlib.Data.Set.Insert | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"Set.singleton_subset_iff",
"False",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"Set.subset_def",
"congrArg",
"Lean.Grind.eq_false_of_or_eq_false_left",
"Classical.byContradiction",
"Membership.mem",
"Exists",
"E... | false |
Order.Icc_subset_Ioc_pred_left | Mathlib.Order.SuccPred.Basic | [
"Set.Ioc",
"not_isMin",
"Preorder.toLT",
"Order.Icc_subset_Ioc_pred_left_of_not_isMin",
"NoMinOrder",
"HasSubset.Subset",
"Set.Icc",
"Order.pred",
"PredOrder",
"Preorder",
"Set.instHasSubset",
"Set"
] | true |
MeasCat | Mathlib.MeasureTheory.Category.MeasCat | [
"MeasCat.of"
] | true |
Lean.Meta.DefEqContext._sizeOf_1 | Lean.Meta.Basic | [
"Lean.LocalContext._sizeOf_inst",
"Lean.LocalInstance",
"Lean.LocalInstance._sizeOf_inst",
"Lean.Expr",
"instOfNatNat",
"Array._sizeOf_inst",
"Lean.Meta.DefEqContext.rec",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Lean.LocalInstances",
"OfNat.ofNat",
"Lean.LocalCont... | false |
Lean.OLeanLevel.server.elim | Lean.Environment | [
"PULift.up",
"Lean.OLeanLevel.ctorIdx",
"Lean.OLeanLevel.ctorElim",
"Nat",
"Lean.OLeanLevel.server",
"Lean.OLeanLevel",
"Eq.symm",
"Eq"
] | false |
Std.ExtHashMap.getKey!_eq_of_contains | Std.Data.ExtHashMap.Lemmas | [
"Std.ExtHashMap.contains",
"instLawfulHashableOfLawfulBEq",
"Std.ExtHashMap.inner",
"LawfulBEq",
"Std.ExtHashMap",
"Bool.true",
"Std.ExtHashMap.getKey!",
"Bool",
"Inhabited",
"Hashable",
"instEquivBEqOfLawfulBEq",
"BEq",
"Eq",
"Std.ExtDHashMap.getKey!_eq_of_contains"
] | true |
TopologicalSpace.IsTopologicalBasis.recOn | Mathlib.Topology.Bases | [
"Set.univ",
"Set.sUnion",
"Membership.mem",
"Exists",
"HasSubset.Subset",
"Set.instInter",
"TopologicalSpace.generateFrom",
"Inter.inter",
"TopologicalSpace",
"And",
"TopologicalSpace.IsTopologicalBasis",
"Eq",
"Set.instMembership",
"TopologicalSpace.IsTopologicalBasis.rec",
"Topological... | false |
_private.Init.Data.Array.Attach.0.Array.pmap_eq_self._simp_1_1 | Init.Data.Array.Attach | [
"List.pmap_eq_self",
"Membership.mem",
"List.pmap",
"List",
"List.instMembership",
"propext",
"Eq"
] | false |
Lean.Elab.Do.ReturnCont.mk.injEq | Lean.Elab.Do.Basic | [
"Lean.Elab.Do.ReturnCont.mk.inj",
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Expr",
"And",
"Lean.Elab.Do.DoElabM",
"Eq.ndrec",
"Eq.refl",
"Lean.Elab.Do.ReturnCont",
"Lean.Elab.Do.ReturnCont.mk",
"Eq"
] | true |
CategoryTheory.shiftEquiv'._proof_1 | Mathlib.CategoryTheory.Shift.Basic | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"AddMonoid.toAddSemigroup",
"congrArg",
"add_assoc",
"AddMonoid.toAddZeroClass",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"add_left_inj",
"SubNegZeroMonoid.toNegZeroClass",
"zer... | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.monoidalOppositeRightAction_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Opposites | [
"CategoryTheory.MonoidalOpposite.unmop",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.MonoidalOpposite",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj",
"CategoryTheory.monoidalCategoryMop",
"CategoryTheory.MonoidalCat... | true |
Lean.Elab.Tactic.Rfl.evalApplyRfl._regBuiltin.Lean.Elab.Tactic.Rfl.evalApplyRfl_1 | Lean.Elab.Tactic.Rfl | [
"Lean.Elab.Tactic.tacticElabAttribute",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Name.mkStr4",
"Lean.Elab.Tactic.Rfl.evalApplyRfl",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
LinearMap.applyₗ._proof_1 | Mathlib.Algebra.Module.LinearMap.End | [
"CommSemiring.toSemiring",
"smulCommClass_self",
"AddCommMonoid",
"CommSemiring",
"CommMonoid.toMonoid",
"CommSemiring.toCommMonoid",
"Monoid.toSemigroup",
"Module.toDistribMulAction",
"SemigroupAction.toSMul",
"AddCommMonoid.toAddMonoid",
"Module",
"MulAction.toSemigroupAction",
"SMulCommCl... | false |
Representation.ofMulActionSelfAsModuleEquiv._proof_4 | Mathlib.RepresentationTheory.Basic | [
"Function.LeftInverse",
"Semiring.toModule",
"Finsupp.module",
"CommSemiring.toSemiring",
"Group",
"DivInvMonoid.toMonoid",
"LinearEquiv.toAddEquiv",
"Equiv.toFun",
"Finsupp.instAddCommMonoid",
"Representation.asModule",
"Group.toDivInvMonoid",
"CommSemiring",
"NonUnitalNonAssocSemiring.toAd... | false |
AlgebraicGeometry.Scheme.Cover.copy._proof_2 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | [
"CategoryTheory.PreZeroHypercover.mk",
"AlgebraicGeometry.PresheafedSpace.Hom",
"Eq.mpr",
"CategoryTheory.MorphismProperty",
"AlgebraicGeometry.Scheme",
"CategoryTheory.PreZeroHypercover.f",
"Equiv.instEquivLike",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",... | false |
Std.DHashMap.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | [
"congrArg",
"Std.DHashMap.Internal.Raw₀.Const.get!_union_of_contains_eq_false_right",
"Std.DHashMap.Raw",
"Membership.mem",
"Eq.mp",
"Std.DHashMap.instMembership",
"Std.DHashMap.wf",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"Std.DHashMap.Const.get!",
"LawfulHashable",
"Subtype.m... | true |
absConvexHull_nonempty | Mathlib.Analysis.LocallyConvex.AbsConvex | [
"Eq.mpr",
"ChainCompletePartialOrder.instOfCompleteLattice",
"absConvexHull",
"congrArg",
"SMul",
"PartialOrder.toPreorder",
"PartialOrder",
"id",
"Ne",
"ClosureOperator.instFunLike",
"ClosureOperator",
"ChainCompletePartialOrder.toPartialOrder",
"AddCommMonoid",
"Iff",
"Set.Nonempty",
... | true |
ZFSet.vonNeumann_inj._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | [
"ZFSet.vonNeumann_inj",
"ZFSet",
"ZFSet.vonNeumann",
"propext",
"Eq",
"Ordinal"
] | false |
CategoryTheory.PreOneHypercover.map_Y | Mathlib.CategoryTheory.Sites.Continuous | [
"CategoryTheory.Functor",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.PreOneHypercover.map",
"CategoryTheory.PreZeroHypercover.map",
"CategoryTheory.PreOneHypercover.Y",
"CategoryTheory.PreZeroHypercove... | true |
Polynomial.roots_expand_map_frobenius | Mathlib.FieldTheory.Perfect | [
"PerfectRing",
"Polynomial.roots_expand",
"IsDomain",
"CommRing",
"instHSMul",
"Polynomial.roots",
"Multiset.map",
"frobeniusEquiv",
"congrArg",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"AddGroupWithOne.toAddMonoidWi... | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | [
"Std.Do.SPred.entails",
"Std.Do.PostCond",
"Std.Do.Assertion",
"Std.Do.PostShape",
"Std.Do.WP",
"Std.Do.Triple.iff",
"Std.Do.PredTrans.apply",
"Std.Do.Triple",
"propext",
"Std.Do.PostShape.args",
"Eq",
"Std.Do.WP.wp"
] | false |
Denumerable.lower_raise._f | Mathlib.Logic.Equiv.Multiset | [
"Denumerable.lower",
"Eq.mpr",
"Nat.add_sub_cancel_right",
"congrArg",
"_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower_raise.match_1_1",
"HSub.hSub",
"id",
"instSubNat",
"Denumerable.lower.eq_2",
"List.cons",
"Denumerable.raise.eq_2",
"List",
"instHAdd",
"instHSub",
"HAdd.hAdd... | false |
Ideal.instIsTwoSided | Mathlib.RingTheory.Ideal.Defs | [
"Semiring.toModule",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"CommSemiring.toSemiring",
"Membership.mem",
"Eq.rec",
"Ideal.IsTwoSided",
"CommMagma.toMul",
"NonUnitalCommSemiring.toNonUnitalNonAssocCommSemiring",
"Ideal",
"CommSemiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",... | true |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.Fin.succ.match_1.splitter | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | [
"Fin.mk",
"Fin.succ.match_1",
"Nat",
"LT.lt",
"instLTNat",
"Fin"
] | true |
CategoryTheory.Quiv.lift_map | Mathlib.CategoryTheory.Category.Quiv | [
"CategoryTheory.composePath",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Paths.categoryPaths",
"CategoryTheory.Paths",
"CategoryTheory.Quiv.lift",
"CategoryTheory.Functor.map",
"Prefunctor",
"Quiver",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"... | true |
_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor.match_9 | Mathlib.Tactic.Use | [
"_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor._sparseCasesOn_9",
"Nat.hasNotBit",
"List.cons",
"List",
"_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor._sparseCasesOn_10",
"Lean.Name",
"List.ctorIdx",
"List.nil"
] | false |
Lean.Doc.Data.ConvTactic.casesOn | Lean.Elab.DocString.Builtin | [
"Lean.Doc.Data.ConvTactic.mk",
"Lean.Doc.Data.ConvTactic.rec",
"Lean.Name",
"Lean.Doc.Data.ConvTactic"
] | false |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | [
"Ord.mk",
"Ordering",
"Std.DTreeMap.Raw.Equiv",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Inhabited",
"Std.DTreeMap.Raw.Equiv.inner",
"Std.DTreeMap.Raw.maxKey!",
"Std.DTreeMap.Internal.Impl.Equiv.maxKey!_eq",
"Eq",
"Std.DTreeMap.Raw.WF",
"Std.DTreeMap.Raw"
] | true |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | [
"Units.instMulAction",
"HomologicalComplex.instCategory",
"instHSMul",
"HMul.hMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Monoid.toMulOneClass",
"congrArg",
"CochainComplex.shiftFunctorObjXIso._proof_1",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Cate... | false |
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | [
"Int.instAddCommGroup",
"LinearMap.toAddMonoidHom",
"LinearMap.toAddMonoidHom_coe",
"AddGroup.toSubtractionMonoid",
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"ModN.basis._proof_4",
"Int.cast",
"Eq.mpr",
"Int.instAddCommMonoid",
"Submodule",
"Submodule.Quotient.instZeroQuotient",
"Su... | false |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | [
"sub_neg",
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"AddGroup.toSubtractionMonoid",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"Semiring.toModule",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"Real.denselyNormedField",
"Real.instZero",
"SignType.instOne",
"congrArg",
"Compl.... | true |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | [
"MeasureTheory.stoppedValue",
"Eq.rec",
"Nonempty",
"Eq.refl",
"Eq",
"WithTop"
] | true |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | [
"Lean.TSyntax",
"Unit.unit",
"Option.casesOn",
"Option.some",
"List.cons",
"Array",
"Option.none",
"Unit",
"Lean.SyntaxNodeKind",
"Lean.Name.mkStr1",
"List.nil",
"Option"
] | false |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | [
"Eq.mpr",
"congrArg",
"SimpleGraph.Walk.support",
"SimpleGraph.Walk",
"Membership.mem",
"SimpleGraph.Walk.takeUntil.congr_simp",
"SimpleGraph.Walk.subset_support_append_left",
"SimpleGraph.Walk.take_spec",
"id",
"SimpleGraph",
"List",
"List.instMembership",
"SimpleGraph.Walk.dropUntil",
"T... | true |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | [
"Cardinal",
"Nat.cast",
"AddCommMonoid",
"Module.finrank_eq_rank",
"StrongRankCondition",
"Semiring",
"Module.Finite",
"Module.rank",
"Module",
"Eq.symm",
"Eq",
"Module.finrank",
"Cardinal.instNatCast"
] | false |
EIO.adapt_pure | Batteries.Lean.LawfulMonadLift | [
"Pure.pure",
"Monad.toApplicative",
"EIO",
"instMonadEIO",
"Applicative.toPure",
"Eq.refl",
"EIO.adapt",
"Eq"
] | true |
CategoryTheory.Functor.leibnizPushout_obj_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.leibnizPushout._proof_1",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.PushoutObjObj.ofHasPushout",
"CategoryTheory.Functor.PushoutObjObj.ι",
"CategoryTheory.Arrow.left",
"CategoryTheory.Arrow.hom",
"CategoryTheory.instCategoryArrow",
"... | true |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | [
"Module.Baer.extension_property",
"AddCommGroup.toAddCommMonoid",
"Module.Injective",
"LinearMap.instFunLike",
"Exists",
"AddCommGroup",
"Module.Baer.of_injective",
"LinearMap",
"LinearMap.comp",
"Function.Injective",
"Module",
"RingHom.id",
"RingHomCompTriple.ids",
"Semiring.toNonAssocSem... | true |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | [
"AddCommGroup.ModEq",
"AddCommMonoidWithOne.toAddCommMonoid",
"AddCommMonoidWithOne",
"AddCommGroup.natCast_modEq_natCast",
"AddMonoidWithOne.toNatCast",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Nat.cast",
"CharZero",
"Nat.ModEq",
"Nat",
"Iff.mp"
] | true |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | [
"AddGroupWithOne.toAddGroup",
"congrArg",
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"AddZeroClass.toAddZero",
"Distrib.toAdd",
"RingQuot.Rel",
"instDistribOfSemiring",
"SubNegMonoid.toSub",
"instHAdd",
"instHSub",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"congr",
"True"... | true |
CategoryTheory.Types.instPreservesColimitsOfSizeForgetTypeFun | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | [
"CategoryTheory.Limits.PreservesColimitsOfSize",
"TypeCat.instFunLikeFun",
"CategoryTheory.Limits.id_preservesColimitsOfSize",
"TypeCat.Fun",
"CategoryTheory.types",
"CategoryTheory.forget",
"instConcreteCategoryTypeFun"
] | true |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | [
"List.countP",
"List",
"Multiset.ofList",
"DecidablePred",
"Nat",
"Multiset.countP",
"Decidable.decide",
"Eq",
"rfl"
] | true |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | [
"Iff.mpr",
"Compl.compl",
"Set.image_mono",
"HasSubset.Subset",
"Set.instCompl",
"Set.compl_subset_compl",
"Set.image",
"Set.instHasSubset",
"Set"
] | false |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | [
"instDecidableEqDyckStep",
"DyckStep.U",
"DyckWord",
"DyckWord.mk",
"LE.le",
"instLENat",
"instBEqOfDecidableEq",
"List",
"List.count",
"Nat",
"DyckStep.D",
"Eq",
"List.take",
"DyckStep"
] | false |
SetLike.ext_iff | Mathlib.Data.SetLike.Basic | [
"SetLike",
"Function.Injective.eq_iff",
"Membership.mem",
"SetLike.coe_injective",
"Iff",
"SetLike.coe",
"Iff.trans",
"Set.ext_iff",
"Eq",
"SetLike.instMembership",
"Iff.symm",
"Set"
] | true |
GromovHausdorff.repGHSpaceMetricSpace._aux_6 | Mathlib.Topology.MetricSpace.GromovHausdorff | [
"GromovHausdorff.IsometryRel.setoid._proof_1",
"NormedCommRing.toNormedRing",
"TopologicalSpace.NonemptyCompacts.instSetLike",
"NormedCommRing.toSeminormedCommRing",
"Real",
"TopologicalSpace.NonemptyCompacts",
"PseudoMetricSpace.toUniformSpace",
"instAddCommGroupPreLp",
"AddCommGroup.toAddGroup",
... | false |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | [
"ZFSet.instEmptyCollection",
"ZFSet",
"ZFSet.empty_subset",
"HasSubset.Subset",
"True",
"eq_true",
"ZFSet.instHasSubset",
"EmptyCollection.emptyCollection",
"Eq"
] | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | [
"instHDiv",
"_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_4",
"HDiv.hDiv",
"instOfNatNat",
"LE.le",
"instLENat",
"Fin.val",
"Array",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Nat.instDiv",
"Decidable.byContradiction",
"instAddNat",
"OfNat.ofNat",
"Fin",
"Eq",
"Array.size",... | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"Fin.instOfNat",
"instOfNatNat",
"WeierstrassCurve.Jacobian.Equation",
"WeierstrassCurve.Jacobian",
"Monoid.toPow",
"CommRing.toCommSemiring",
"HPow.hPow",
"Nat.instNeZeroSucc",
"Nat",
"WeierstrassCurve.Jacobian.equation_of_Z_eq_zero",
"Semiring.toMonoi... | false |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | [
"NegZeroClass.toNeg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"PartialOrder",
"AddCommGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"Filter.atTop",
"Filter.Tendsto",
"propext",
"Filter.atBot",
... | false |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | [
"GrpCat.instConcreteCategoryMonoidHomCarrier",
"Eq.mpr",
"CategoryTheory.Functor.mapCommGrp",
"GrpCat.hasForgetToMonCat",
"CategoryTheory.Functor",
"CategoryTheory.Limits.instPreservesFiniteProductsOfPreservesFiniteLimits",
"MonTypeEquivalenceMon.inverse",
"GrpCat",
"MonoidHom.instFunLike",
"Categ... | false |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | [
"UpperSet.coe_add",
"UpperSet",
"AddCommGroup.toAddCommMonoid",
"UpperSet.instSetLike",
"Preorder.toLE",
"AddCommGroup",
"UpperSet.instAdd",
"SetLike.coe",
"UpperSet.instAddAction._proof_1",
"AddCommSemigroup",
"Set.addCommSemigroup",
"AddCommMonoid.toAddCommSemigroup",
"IsOrderedAddMonoid",... | true |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Nontrivial",
"Continuous",
"Semiring.toModule",
"instSMulOfMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"quasispectrum.instZero",
"IsTopologicalSemiring",
"IsScalarTower",
"ContinuousStar",
"SeparatelyContinuousMul.to_continuousSMul",
"ContinuousMap",
"AddMonoid.toAddZ... | false |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"Std.DHashMap.Internal.Raw₀.inter",
"Std.DHashMap.Internal.Raw₀.contains",
"Std.DHashMap.Internal.Raw.WF.out",
"instLawfulHashableOfLawfulBEq",
"congrArg",
"Std.DHashMap.Raw",
"Std.DHashMap.Internal.Raw₀.contains_eq_containsKey",
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.