name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.HasLeftKanExtension",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app",
"CategoryTheory.F... | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._mutual | Lean.Data.Iterators.Producers.PersistentHashMap | [
"Lean.PersistentHashMap.Entry.entry",
"PSum.casesOn",
"Lean.PersistentHashMap.Entry",
"Lean.PersistentHashMap.Entry.ref",
"Lean.PersistentHashMap.Node",
"invImage",
"PSum",
"HSub.hSub",
"instSizeOfDefault",
"_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.mea... | false |
NNReal.coe_inv._simp_1 | Mathlib.Data.NNReal.Defs | [
"Real",
"Real.instInv",
"NNReal.instInv",
"NNReal",
"NNReal.coe_inv",
"Inv.inv",
"Eq.symm",
"Eq",
"NNReal.toReal"
] | false |
_private.Mathlib.Data.Vector.MapLemmas.0.List.Vector.mapAccumr_redundant_pair.match_1_1 | Mathlib.Data.Vector.MapLemmas | [
"Prod.mk",
"Prod",
"Prod.casesOn"
] | false |
HasProdUniformlyOn.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | [
"UniformSpace",
"Equiv.instEquivLike",
"HasProd",
"Function.comp",
"Set.instSingletonSet",
"Equiv",
"instCommMonoidUniformOnFun",
"UniformOnFun.topologicalSpace",
"UniformOnFun.ofFun",
"Eq.refl",
"UniformOnFun",
"Singleton.singleton",
"Eq",
"CommMonoid",
"DFunLike.coe",
"HasProdUniform... | true |
Lean.Elab.PartialFixpointType.inductiveFixpoint | Lean.Elab.PreDefinition.TerminationHint | [
"Lean.Elab.PartialFixpointType.inductiveFixpoint",
"Lean.Elab.PartialFixpointType"
] | true |
AddGroupSeminormClass.toSeminormedAddCommGroup_norm_eq | Mathlib.Analysis.Normed.Order.Hom.Basic | [
"Norm.norm",
"Real.partialOrder",
"Real",
"AddGroupSeminormClass",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"SeminormedAddCommGroup.toNorm",
"AddGroupSeminormClass.toSeminormedAddCommGroup",
"Real.instAddCommMonoid",
"Eq",
"DFunLike.coe",
"rfl",
"FunLike"
] | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Solve.0.Lean.Elab.Tactic.Do.Internal.VCGen.tryLetIntro | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | [
"Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult",
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"Lean.Meta.Grind.GrindM",
"Lean.MessageData",
"Lean.MVarId.replaceTargetDefEq",
"Lean.MonadError.mk",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Expr.isLet",
"instMonadReaderOfReaderTO... | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.div._unary._proof_4 | Mathlib.Tactic.FieldSimp | [
"IsRightCancelAdd.addRightStrictMono_of_addRightMono",
"Nat.instCanonicallyOrderedAdd",
"Lean.RArray.leaf",
"Preorder.toLT",
"Nat.instIsOrderedAddMonoid",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"Nat.instOne",
"congrArg",
"true_or",
"invImage",
"covariant_swap_add_of_covariant_add",
"AddMo... | false |
_private.Mathlib.CategoryTheory.Subobject.Limits.0.CategoryTheory.Limits.kernelOrderHom._simp_1 | Mathlib.CategoryTheory.Subobject.Limits | [
"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.Analysis.Normed.Operator.NormedSpace.0.ContinuousLinearMap.opNNNorm_comp_linearIsometryEquiv._simp_1_1 | Mathlib.Analysis.Normed.Operator.NormedSpace | [
"SeminormedAddCommGroup",
"HMul.hMul",
"ContinuousLinearMap.opNNNorm_le_iff",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"SeminormedAddGroup.toNNNorm",
"ContinuousLinearMap.funLike",
"NNNorm.nnnorm",
"NormedSpace.toModule",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"Pr... | false |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | [
"List.head?",
"Eq.mpr",
"False",
"Bool.not",
"Bool.not_eq_false",
"congrArg",
"List.dropWhile_cons_of_pos",
"List.dropWhile_cons_of_neg",
"List.find?",
"Bool.false_eq_true",
"Option.some",
"Eq.mp",
"List.find?_cons_of_neg",
"id",
"List.find?_cons_of_pos",
"List.rec",
"List.cons",
"... | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"List.rec",
"List.cons",
"Nat.land",
"List",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"List.ctorIdx",
"List.nil"
] | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Eqns.0.Lean.Elab.PartialFixpoint.deltaLHSUntilFix | Lean.Elab.PreDefinition.PartialFixpoint.Eqns | [
"Lean.MessageData",
"Lean.MVarId.replaceTargetDefEq",
"Lean.MVarId.withContext",
"Std.instToFormatString",
"ReaderT",
"Lean.MVarId.getType'",
"instMonadControlTOfPure",
"String",
"Lean.Meta.State",
"instMonadLiftT",
"Option.some",
"Function.comp",
"Lean.MVarId",
"Lean.Expr",
"Lean.Meta.M... | true |
Submodule.finiteQuotientOfFreeOfRankEq | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | [
"Iff.mpr",
"Submodule",
"Finite.of_equiv",
"Submodule.Quotient.addCommMonoid",
"Nat.instMulZeroClass",
"NeZero.mk",
"ZMod.commRing",
"CommSemiring.toSemiring",
"Int.euclideanDomain",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"Pi.finite",
"Finite",
"ZMod.fintype",
"Submod... | true |
Mathlib.Tactic.FieldSimp.NF.one_eq_eval | Mathlib.Tactic.FieldSimp.Lemmas | [
"GroupWithZero.toDivisionMonoid",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"GroupWithZero",
"DivisionMonoid.toDivInvOneMonoid",
"Int",
"Mathlib.Tactic.FieldSimp.NF.eval",
"One.toOfNat1",
"Prod",
"OfNat.ofNat",
"Eq",
"rfl",
"List.nil"
] | true |
Alexandrov.self_mem_principalOpen | Mathlib.Topology.Sheaves.Alexandrov | [
"le_refl",
"Topology.IsUpperSet",
"TopologicalSpace.Opens",
"Membership.mem",
"TopologicalSpace.Opens.instSetLike",
"TopologicalSpace",
"Alexandrov.principalOpen",
"SetLike.instMembership",
"Preorder"
] | true |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TuringMachine.Config | [
"Eq.propIntro",
"Lean.injEq_helper",
"Turing.ToPartrec.Code.comp.inj",
"And",
"Turing.ToPartrec.Code.comp",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Turing.ToPartrec.Code"
] | true |
Lex.instNonAssocRing | Mathlib.Algebra.Order.Ring.Synonym | [
"Lex.instNonAssocRing._proof_4",
"NonAssocRing.mk",
"Lex.instNatCast",
"Lex.instIntCast",
"Lex.instNonAssocRing._proof_1",
"Lex.instNonAssocRing._proof_5",
"Lex",
"Lex.instOne",
"AddGroupWithOne.toAddMonoidWithOne",
"Lex.instNonAssocRing._proof_2",
"AddMonoidWithOne.toNatCast",
"NonAssocRing",... | true |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | [
"Pure.pure",
"Lean.Syntax.node",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax.atom",
"Lean.TSyntax... | false |
HAnd.rec | Init.Prelude | [
"HAnd",
"HAnd.mk"
] | false |
UInt32.toFin_ofNatClamp_of_le._proof_1 | Init.Data.UInt.Lemmas | [
"UInt32.size",
"of_decide_eq_true",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat",
"Bool.true",
"instHSub",
"Nat",
"LT.lt",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Decidable.decide",
"Eq"
] | false |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | [
"Subalgebra.instSetLike",
"ChainCompletePartialOrder.instOfCompleteLattice",
"PartialOrder.toPreorder",
"Algebra",
"Algebra.adjoin",
"GaloisConnection.le_u_l",
"HasSubset.Subset",
"ChainCompletePartialOrder.toPartialOrder",
"CommSemiring",
"SetLike.coe",
"Subalgebra.instPartialOrder",
"Complet... | true |
Std.Rxc.size_pos_iff_le | Init.Data.Range.Polymorphic.Basic | [
"False",
"eq_false",
"Std.PRange.UpwardEnumerable",
"iff_false",
"congrArg",
"Std.Rxc.HasSize",
"iff_true",
"Classical.propDecidable",
"Eq.mp",
"not_true_eq_false",
"Std.Rxc.LawfulHasSize",
"id",
"Ne",
"instOfNatNat",
"LE.le",
"LE",
"iff_self",
"Bool.true",
"Iff",
"_private.Ini... | true |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | [
"TopologicalSpace.CompactOpens.instHImp",
"TopologicalSpace.CompactOpens",
"CompactSpace",
"TopologicalSpace",
"Set.instHImp",
"SetLike.coe",
"T2Space",
"Eq.symm",
"Eq",
"TopologicalSpace.CompactOpens.instSetLike",
"HImp.himp",
"TopologicalSpace.CompactOpens.coe_himp",
"Set"
] | false |
MeasureTheory.VectorMeasure.«_aux_Mathlib_MeasureTheory_VectorMeasure_Integral___delab_app_MeasureTheory_VectorMeasure_term∫ᵛ_In_,_∂<•__1» | Mathlib.MeasureTheory.VectorMeasure.Integral | [
"Pure.pure",
"Lean.Syntax.node",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Mathlib.Notation3.MatchState.empty",
"Mathlib.Notation3.withHeadRefIfTagAppFns",
"Mathlib.Notation3.matchApp",
"Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM",
"Lean.SourceInfo",
"Lean.PrettyPrinter... | false |
CauchyFilter.mem_uniformity | Mathlib.Topology.UniformSpace.Completion | [
"Filter.instMembership",
"UniformSpace",
"SetRel",
"uniformity",
"Membership.mem",
"Exists",
"Filter.mem_lift'_sets",
"HasSubset.Subset",
"CauchyFilter.monotone_gen",
"CauchyFilter.instUniformSpace",
"And",
"Iff",
"CauchyFilter.gen",
"CauchyFilter",
"Prod",
"Filter",
"Set.instHasSubs... | true |
Std.HashMap.Raw.getKeyD_empty | Std.Data.HashMap.RawLemmas | [
"Std.HashMap.Raw.instEmptyCollection",
"Std.HashMap.Raw",
"Std.DHashMap.Raw.getKeyD_empty",
"Std.HashMap.Raw.getKeyD",
"Hashable",
"EmptyCollection.emptyCollection",
"BEq",
"Eq"
] | true |
floorDiv_of_nonpos | Mathlib.Algebra.Order.Floor.Div | [
"FloorDiv.floorDiv_nonpos",
"FloorDiv",
"SMulZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"FloorDiv.floorDiv",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"LE.le",
"AddCommMonoid",
"AddZero.toZero",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"OfNat... | true |
Std.ExtTreeMap.getElem_modify | Std.Data.ExtTreeMap.Lemmas | [
"Std.ExtDTreeMap.Const.get_modify",
"Iff.mpr",
"Std.ExtTreeMap.modify",
"instDecidableEqOrdering",
"GetElem?.toGetElem",
"Membership.mem",
"Ordering",
"Ordering.eq",
"Std.ExtTreeMap.mem_congr",
"Std.TransCmp",
"dite",
"GetElem.getElem",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Iff.mp",... | true |
hasDerivAtFilter_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | [
"NormedCommRing.toNormedRing",
"Norm.norm",
"NormedCommRing.toSeminormedCommRing",
"Real",
"instHSMul",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"HMul.hMul",
"NormedSpace",
"Real.instZero",
"AddGroupWithOne.toAddGroup",
"Real.instInv",
"DistribMulAction.toDistribSMul",
"AddCommG... | true |
Matroid.isNonloop_of_not_isLoop._auto_1 | Mathlib.Combinatorics.Matroid.Loop | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.dickson.match_1.eq_1 | Mathlib.RingTheory.Polynomial.Dickson | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"Polynomial.dickson.match_1",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq"
] | true |
CategoryTheory.Precoverage.toGrothendieck_le_iff_le_toPrecoverage | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | [
"Eq.mpr",
"CategoryTheory.Precoverage",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Precoverage.Saturate",
"Quiver.Hom",
"CategoryTheory.Precoverage.instPartialOrder",
"CategoryTheory.Presieve",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"id",
"Ca... | true |
MeasureTheory.Measure.restrict_toOuterMeasure_eq_toOuterMeasure_restrict | Mathlib.MeasureTheory.Measure.Restrict | [
"Eq.mpr",
"MeasureTheory.Measure",
"MeasureTheory.OuterMeasure.restrict_trim",
"Semiring.toModule",
"IsScalarTower.right",
"MeasurableSet",
"congrArg",
"CommSemiring.toSemiring",
"AddHom",
"MeasureTheory.Measure.liftLinear._proof_7",
"LinearMap.instFunLike",
"MeasureTheory.OuterMeasure.restric... | true |
Lean.Elab.Tactic.nonempty_prop_to_inhabited | Mathlib.Tactic.Inhabit | [
"_private.Mathlib.Tactic.Inhabit.0.Lean.Elab.Tactic.nonempty_prop_to_inhabited._proof_1",
"Nonempty",
"Inhabited",
"Inhabited.mk"
] | true |
Lean.LOption.some.sizeOf_spec | Lean.Data.LOption | [
"Lean.LOption._sizeOf_inst",
"instOfNatNat",
"Lean.LOption.some",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"Eq.refl",
"SizeOf",
"OfNat.ofNat",
"Eq",
"Lean.LOption"
] | true |
_private.Mathlib.Algebra.Notation.Support.0.Function.mulSupport_curry._simp_1_1 | Mathlib.Algebra.Notation.Support | [
"funext_iff",
"propext",
"Eq"
] | false |
Order.pred_covBy | Mathlib.Order.SuccPred.Basic | [
"not_isMin",
"Order.pred_covBy_of_not_isMin",
"Preorder.toLT",
"NoMinOrder",
"CovBy",
"Order.pred",
"PredOrder",
"Preorder"
] | true |
IsLocalization.isRegular_mk'._simp_1 | Mathlib.RingTheory.Localization.Defs | [
"IsLocalization",
"CommSemiring.toSemiring",
"IsLocalization.isRegular_mk'",
"IsRegular",
"Algebra",
"Membership.mem",
"Subtype",
"MulZeroOneClass.toMulOneClass",
"instDistribOfSemiring",
"instMulZeroOneClassOfSemiring",
"CommSemiring",
"IsLocalization.mk'",
"Distrib.toMul",
"propext",
"... | false |
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux.congr_simp | Mathlib.NumberTheory.LSeries.PrimesInAP | [
"Nat.instMulZeroClass",
"Eq.rec",
"ZMod",
"Nat",
"Eq.refl",
"ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux",
"Complex",
"NeZero",
"Eq",
"MulZeroClass.toZero"
] | true |
Lean.Meta.Sym.Arith.instInhabitedSemiring.default | Lean.Meta.Sym.Arith.Types | [
"Inhabited.default",
"Lean.Meta.Sym.Arith.Semiring.mk",
"Lean.instInhabitedLevel",
"instInhabitedNat",
"Lean.Expr",
"Lean.Level",
"Lean.instInhabitedExpr",
"Option.none",
"Nat",
"Lean.Meta.Sym.Arith.Semiring"
] | true |
Set.insert_prod | Mathlib.Data.Set.Prod | [
"Set.instSProd",
"SProd.sprod",
"congrArg",
"Set.instUnion",
"Set.instSingletonSet",
"Insert.insert",
"Set.singleton_prod",
"Prod.mk",
"Set.union_prod",
"Set.instInsert",
"True",
"eq_self",
"of_eq_true",
"Set.image",
"congrFun'",
"Union.union",
"Prod",
"Singleton.singleton",
"Eq"... | true |
CategoryTheory.InjectiveResolution.instInjectiveXIntCochainComplex | Mathlib.CategoryTheory.Abelian.Injective.Extend | [
"CategoryTheory.InjectiveResolution.injective",
"CategoryTheory.InjectiveResolution.cochainComplex",
"CategoryTheory.Injective",
"Nat.instOne",
"CategoryTheory.Injective.of_iso",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
... | true |
Module.Baer.ExtensionOfMaxAdjoin.fst | Mathlib.Algebra.Module.Injective | [
"Submodule",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"Fact",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Subtype",
"DistribSMul.toSMulZeroClass"... | true |
SheafOfModules.GeneratingSections.IsFiniteType.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | [
"AddCommGrpCat.instCategory",
"Finite",
"AddMonoid.toAddZeroClass",
"RingCat.ring",
"AddCommGroup.toAddGroup",
"RingHom",
"AddCommGrpCat.instConcreteCategoryAddMonoidHomCarrier",
"SheafOfModules.GeneratingSections",
"AddZeroClass.toAddZero",
"RingCat.instConcreteCategoryRingHomCarrier",
"SheafOf... | true |
CategoryTheory.GrothendieckTopology.diagramFunctor_map | Mathlib.CategoryTheory.Sites.Plus | [
"CategoryTheory.GrothendieckTopology.Cover.shape",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.GrothendieckTopology.diagramFunctor",
"CategoryTheory.GrothendieckTopology.diagramNatTrans",
"CategoryTh... | true |
Batteries.TotalBLE.recOn | Batteries.Classes.Order | [
"Batteries.TotalBLE",
"Batteries.TotalBLE.rec",
"Bool.true",
"Batteries.TotalBLE.mk",
"Bool",
"Or",
"Eq"
] | false |
ProfiniteAddGrp.recOn | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | [
"ProfiniteAddGrp.rec",
"ProfiniteAddGrp",
"ProfiniteAddGrp.mk",
"TotallyDisconnectedSpace",
"TopCat.str",
"AddGroup",
"Profinite",
"TopCat.carrier",
"TopCat",
"CompHausLike.toTop",
"IsTopologicalAddGroup"
] | false |
ContinuousEval.toContinuousEvalConst | Mathlib.Topology.Hom.ContinuousEval | [
"ContinuousEval",
"continuous_const",
"ContinuousEvalConst.mk",
"id",
"ContinuousEvalConst",
"TopologicalSpace",
"continuous_id",
"Continuous.eval",
"FunLike"
] | true |
Lean.Grind.AC.Seq.subseq | Lean.Meta.Tactic.Grind.AC.Seq | [
"Lean.Grind.AC.SubseqResult.exact",
"Lean.Grind.AC.SubseqResult.false",
"Lean.Grind.AC.SubseqResult.prefix",
"_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.StartsWithResult",
"_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.Seq.startsWith",
"instDecidableEqBool",
"_private.Lean.Meta.Tact... | true |
CompHausLike.mk.congr_simp | Mathlib.Condensed.Light.Sequence | [
"Eq.rec",
"CompHausLike.mk",
"CompHausLike",
"CompactSpace",
"TopCat.str",
"TopCat.carrier",
"T2Space",
"Eq.ndrec",
"Eq.refl",
"TopCat",
"Eq"
] | true |
CategoryTheory.Span.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Span.Basic | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Span.Hom.hom_l._autoParam",
"HEq.refl",
"autoParam",
"CategoryTheory.Span.Hom.hom_r._autoParam",
"CategoryTheory.Span.Hom",
"CategoryTheory.Span.Hom.noConfusionType",
"CategoryTheory.Category... | false |
Perfection.coeffMonoidHom_pow_p_pow_self | Mathlib.RingTheory.Perfection | [
"Eq.mpr",
"MonoidHom.instFunLike",
"Perfection",
"Perfection.coeffMonoidHom",
"Perfection.instCommMonoid",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"id",
"instOfNatNat",
"zero_add",
"Pe... | true |
AddSubmonoid.mk._flat_ctor | Mathlib.Algebra.Group.Submonoid.Defs | [
"Membership.mem",
"AddZeroClass.toAddZero",
"AddSubmonoid",
"AddSubmonoid.mk",
"AddSubsemigroup.mk",
"AddZero.toZero",
"instHAdd",
"AddZeroClass",
"HAdd.hAdd",
"AddZero.toAdd",
"Zero.toOfNat0",
"OfNat.ofNat",
"Set.instMembership",
"Set"
] | false |
Order.Ioc_pred_left | Mathlib.Order.SuccPred.Basic | [
"Set.Ioc",
"not_isMin",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"NoMinOrder",
"LinearOrder",
"PartialOrder.toPreorder",
"DistribLattice.toLattice",
"Order.Ioc_pred_left_of_not_isMin",
"Set.Icc",
"Order.pred",
"SemilatticeSup.toPartialOrder",
"PredOrder",
"Eq",
"instDistribLatticeOfL... | true |
Std.ExtTreeMap.getEntryGED | Std.Data.ExtTreeMap.Basic | [
"Ordering",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Prod",
"Std.ExtDTreeMap.Const.getEntryGED"
] | true |
MulAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | [
"Eq.mpr",
"instHSMul",
"ChainCompletePartialOrder.instOfCompleteLattice",
"MulAction.IsBlock",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"congrArg",
"MulAction.isBlock_iff_smul_eq_or_disjoint",
"Group",
"Disjoint",
"Membership.mem",
"Subgroup.instMulAction",
"MulAction.orbit.eq_or_dis... | true |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.limsup_measure_closed_le_of_forall_tendsto_measure._simp_1_7 | Mathlib.MeasureTheory.Measure.Portmanteau | [
"Set.mem_Iio",
"Preorder.toLT",
"Membership.mem",
"LT.lt",
"propext",
"Set.Iio",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_eq_append_iff_of_size_eq_left._simp_1_1 | Init.Data.ByteArray.Lemmas | [
"Array",
"ByteArray.ext_iff",
"ByteArray.data",
"propext",
"ByteArray",
"UInt8",
"Eq"
] | false |
Lean.instHashableFVarId.hash | Lean.Expr | [
"UInt64.instOfNat",
"_private.Lean.Expr.0.Lean.instHashableFVarId.hash.match_1",
"mixHash",
"UInt64",
"Lean.FVarId",
"Hashable.hash",
"Lean.Name",
"OfNat.ofNat",
"Lean.instHashableName"
] | true |
Mathlib.Tactic.LibraryRewrite.RewriteInterface.tactic | Mathlib.Tactic.Widget.LibraryRewrite | [
"String",
"Mathlib.Tactic.LibraryRewrite.RewriteInterface"
] | true |
of_isDiscreteValuationRing | Mathlib.RingTheory.DiscreteValuationRing.Basic | [
"IsDomain",
"CommRing",
"CommSemiring.toSemiring",
"IsDiscreteValuationRing",
"IsDiscreteValuationRing.toIsPrincipalIdealRing",
"inferInstance",
"ValuationRing.instOfIsLocalRingOfIsBezout",
"IsDiscreteValuationRing.toIsLocalRing",
"CommRing.toCommSemiring",
"IsBezout.of_isPrincipalIdealRing",
"V... | true |
and_congr_left' | Init.PropLemmas | [
"Iff.rfl",
"And",
"Iff",
"and_congr"
] | true |
Lean.Lsp.instToJsonDeclarationParams.toJson | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Json",
"Lean.Json.mkObj",
"Lean.Lsp.instToJsonPosition",
"Lean.Lsp.DeclarationParams",
"String",
"Lean.Lsp.instToJsonTextDocumentIdentifier",
"Lean.ToJson.toJson",
"Prod.mk",
"Lean.Lsp.DeclarationParams.toTextDocumentPositionParams",
"List.cons",
"Lean.Lsp.TextDocumentIdentifier",
"List"... | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceUnary.match_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | [
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.fromExpr?._sparseCasesOn_1",
"Option",
"BitVec.Literal"
] | false |
isStrongAntichain_insert | Mathlib.Order.Antichain | [
"Set.pairwise_insert_of_symm",
"Std.Symm",
"Std.Symm.mk",
"Membership.mem",
"Insert.insert",
"Ne",
"And",
"Iff",
"Or.symm",
"Set.instInsert",
"Or",
"Set.instMembership",
"Not",
"IsStrongAntichain",
"Set"
] | true |
List.Nodup.append | Mathlib.Data.List.Nodup | [
"Iff.mpr",
"List.Disjoint",
"List.Nodup",
"instHAppendOfAppend",
"List",
"And",
"And.intro",
"List.nodup_append'",
"List.instAppend",
"HAppend.hAppend"
] | true |
instCoeLieSubalgebraSubmodule | Mathlib.Algebra.Lie.Subalgebra | [
"LieAlgebra.toModule",
"Submodule",
"CommRing",
"LieRing.toAddCommGroup",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Coe.mk",
"LieRing",
"CommRing.toCommSemiring",
"LieSubalgebra",
"LieAlgebra",
"LieSubalgebra.toSubmodule",
"Coe"
] | true |
Lean.Grind.CommRing.eq_normS_cert | Init.Grind.Ring.CommSemiringAdapter | [
"Lean.Grind.CommRing.Expr.toPolyS",
"Lean.Grind.CommRing.instBEqPoly",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"BEq.beq",
"Bool"
] | true |
StarSubalgebra.toNonUnitalStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"StarSubalgebra.toSubalgebra",
"CommSemiring.toSemiring",
"AddMonoid.toAddZeroClass",
"Submonoid.toSubsemigroup",
"Algebra",
"Algebra.toSMul",
"Membership.mem",
"AddZeroClass.toAddZero",
"MulOne.toMul",
"Subalgebra.toSubsemiring",
"StarSubalgebra",
... | false |
Metric.packingNumber_pos_iff._simp_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | [
"CommSemiring.toSemiring",
"NNReal",
"Metric.packingNumber",
"PseudoEMetricSpace",
"Set.Nonempty",
"ENat",
"LT.lt",
"propext",
"instCommSemiringENat",
"Zero.toOfNat0",
"instLTENat",
"Metric.packingNumber_pos_iff",
"OfNat.ofNat",
"Eq",
"MulZeroClass.toZero",
"instMulZeroClassOfSemiring"... | false |
AlgebraicGeometry.PresheafedSpace.GlueData._sizeOf_inst | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | [
"AlgebraicGeometry.PresheafedSpace.GlueData",
"SizeOf.mk",
"SizeOf",
"AlgebraicGeometry.PresheafedSpace.GlueData._sizeOf_1",
"CategoryTheory.Category"
] | false |
CategoryTheory.Adjunction.leftAdjointUniq | Mathlib.CategoryTheory.Adjunction.Unique | [
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.conjugateIsoEquiv",
"CategoryTheory.Functor.category",
"CategoryTheory.Iso.refl",
"Equiv",
"CategoryTheory.Iso",
"CategoryTheory.Iso.symm",
"CategoryTheory.Adjunction",
"Equiv.symm",
"DFunLike.coe",
"EquivLike.toFunLike",
"Cate... | true |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.flipFunctor._proof_5 | Mathlib.CategoryTheory.Functor.Category | [
"CategoryTheory.CategoryStruct.id.hcongr_3",
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"False",
"eq_false",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"Classical.byContradiction",
"CategoryTheory.Functor.category",
"CategoryTheory.flipFunctor._proof_2",
... | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_le_infEDist_add_hausdorffEDist._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Ne",
"IsBotZeroClass",
"LT.lt",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"pos_iff_ne_zero",
"Zero"
] | false |
_private.Mathlib.Data.Finset.Powerset.0.Finset.powersetCard_map._simp_1_3 | Mathlib.Data.Finset.Powerset | [
"Finset",
"Finset.map",
"HasSubset.Subset",
"Function.Embedding",
"propext",
"Finset.instHasSubset",
"Finset.map_subset_map",
"Eq"
] | false |
_private.Init.Data.List.Lemmas.0.List.flatten.match_1.eq_2 | Init.Data.List.Lemmas | [
"List.cons",
"List",
"Unit",
"Eq.refl",
"Eq",
"List.flatten.match_1",
"List.nil"
] | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.noErrorIfUnused._regBuiltin.Lean.Parser.Term.noErrorIfUnused.declRange_5 | Lean.Parser.Term | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.collectUnassignedMVars.go.match_1 | Lean.Elab.Term.TermElabM | [
"Unit.unit",
"Lean.MVarId",
"List.cons",
"List",
"Unit",
"List.casesOn",
"List.nil"
] | false |
AddEquiv.toLinearEquiv._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | [
"Equiv.right_inv",
"Equiv.toFun",
"AddCommMonoid",
"Function.RightInverse",
"AddEquiv",
"AddCommSemigroup.toAddCommMagma",
"AddEquiv.toEquiv",
"AddCommMonoid.toAddCommSemigroup",
"Equiv.invFun",
"AddCommMagma.toAdd"
] | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop.0.Std.IterM.step_drop.match_1.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop | [
"instOfNatNat",
"Std.IterM.step_drop.match_1",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq"
] | true |
equicontinuousAt_iff_range | Mathlib.Topology.UniformSpace.Equicontinuity | [
"Filter.instMembership",
"Set.mem_range_self",
"UniformSpace",
"congrArg",
"Filter.Eventually",
"uniformity",
"Membership.mem",
"nhds",
"Set.Elem",
"Subtype",
"_private.Mathlib.Topology.UniformSpace.Equicontinuity.0.equicontinuousAt_iff_range._simp_1_2",
"Prod.mk",
"Subtype.mk",
"iff_self"... | true |
Std.Internal.List.maxKey?_le_of_containsKey | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Ord",
"Std.TransOrd",
"Std.OrientedOrd.opposite",
"Std.TransOrd.opposite",
"inferInstance",
"Ord.compare",
"Bool.true",
"List",
"Std.Internal.List.containsKey",
"Std.Internal.List.minKey?_le_of_containsKey",
"Option.get",
"Ord.opposite",
"Std.Internal.Lis... | true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Meta.Grind.Params.containsEMatch | Lean.Elab.Tactic.Grind.Param | [
"Lean.Meta.Grind.Params",
"Lean.Meta.Grind.Theorems.contains",
"Lean.Meta.Grind.EMatchTheorem",
"Lean.Meta.Grind.ExtensionState.ematch",
"Array.any",
"instOfNatNat",
"Lean.Meta.Grind.Params.extensions",
"Nat",
"Lean.Meta.Grind.ExtensionState",
"Bool",
"Lean.Name",
"Lean.Meta.Grind.Origin.decl"... | true |
AddCommGroup.modEq_iff_natModEq | Mathlib.Data.Nat.ModEq | [
"Nat.ModEq.eq_1",
"Eq.mpr",
"AddCommGroup.ModEq",
"instHSMul",
"instHDiv",
"AddCommGroup.ModEq.trans",
"HMul.hMul",
"congrArg",
"Nat.nsmul_eq_mul",
"AddMonoid.toNSMul",
"Nat.instAddMonoid",
"Exists",
"AddCommGroup.nsmul_add_modEq",
"Eq.mp",
"id",
"HDiv.hDiv",
"Nat.instMod",
"instHM... | true |
iteratedDerivWithin_fun_sum | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"NormedRing.toRing",
"NormedSpace",
"ENat.instNatCast",
"UniqueDiffOn",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Finset",
"iteratedDerivWithin",
"PseudoMetricSpace.toUniformSpac... | true |
AlgebraicGeometry.isAffineHom_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.Affine | [
"Iff.mpr",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.instHasAffinePropertyIsAffineHomIsAffine",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AlgebraicGeometry.IsAffineHom",
"inferInstance",
"AlgebraicGeometry.IsAffine",
"AlgebraicGeometry.HasAffineProperty.iff_of_isAffine",
"Categ... | true |
FirstOrder.Language.IsExtensionPair.definedAtLeft | Mathlib.ModelTheory.PartialEquiv | [
"Order.Cofinal",
"FirstOrder.Language.FGEquiv",
"PartialOrder.toPreorder",
"setOf",
"FirstOrder.Language.PartialEquiv.dom",
"Membership.mem",
"FirstOrder.Language.Substructure.instSetLike",
"Order.Cofinal.mk",
"FirstOrder.Language.Substructure",
"FirstOrder.Language.PartialEquiv.instPartialOrder",... | true |
Std.DHashMap.getD_modify | Std.Data.DHashMap.Lemmas | [
"congrArg",
"Std.DHashMap.Raw",
"Option.getD",
"cast",
"LawfulBEq",
"Std.DHashMap.wf",
"instDecidableEqBool",
"instOfNatNat",
"Std.DHashMap.Internal.Raw₀.getD_modify",
"dite",
"Subtype.mk",
"Bool.true",
"Option.map",
"BEq.beq",
"Std.DHashMap.modify",
"Std.DHashMap.inner",
"Nat",
"S... | true |
DirectSum.instCommRingOfNat._proof_7 | Mathlib.Algebra.DirectSum.Ring | [
"AddGroupWithOne.toAddGroup",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddZeroClass.toAddZero",
"AddCommGroup",
"DirectSum.instAddCommGroup",
"DirectSum.GCommRing.toGRing",
"SubtractionMonoid.toSubNegMonoid",
"SubtractionCommMonoid.toSubtractionMonoid",
"AddCommM... | false |
Equiv.transPartialEquiv_source | Mathlib.Logic.Equiv.PartialEquiv | [
"Equiv.instEquivLike",
"PartialEquiv",
"Equiv",
"Set.preimage",
"PartialEquiv.source",
"Eq.refl",
"Eq",
"DFunLike.coe",
"Equiv.transPartialEquiv",
"EquivLike.toFunLike",
"Set"
] | true |
AddSubgroup.isComplement_iff_bijective | Mathlib.GroupTheory.Complement | [
"SetLike",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Subtype",
"Prod.fst",
"instHAdd",
"AddGroup",
"Iff",
"AddGroup.toSubNegMonoid",
"SetLike.coe",
"HAdd.hAdd",
"Function.Bijective",
"AddZero.toAdd",
"AddSubgroup.IsComplement",
"SubNegMonoid.... | true |
SSet.Subcomplex.Pairing.instIsWellFoundedElemNIIAncestralRel | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | [
"IsWellFounded.mk",
"SSet.Subcomplex.N",
"Set.Elem",
"SSet",
"SSet.Subcomplex.Pairing",
"SSet.Subcomplex.Pairing.AncestralRel",
"SSet.Subcomplex.Pairing.IsRegular",
"SSet.Subcomplex",
"SSet.Subcomplex.Pairing.II",
"SSet.Subcomplex.Pairing.wf",
"IsWellFounded"
] | true |
instToStringFormat | Init.Data.ToString.Basic | [
"Std.Format.pretty",
"instOfNatNat",
"Std.Format.defWidth",
"Nat",
"ToString",
"Std.Format",
"ToString.mk",
"OfNat.ofNat"
] | true |
Vector.mem_append_right | Init.Data.Vector.Lemmas | [
"Vector.instMembership",
"Iff.mpr",
"Vector.instHAppendHAddNat",
"Vector",
"Membership.mem",
"instHAdd",
"Vector.mem_append",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Or",
"HAppend.hAppend",
"Or.inr"
] | true |
NonUnitalSubsemiring.closure_mono | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | [
"Iff.mpr",
"NonUnitalSubsemiring.subset_closure",
"Set.Subset.trans",
"PartialOrder.toPreorder",
"Preorder.toLE",
"HasSubset.Subset",
"LE.le",
"NonUnitalSubsemiring.closure",
"SetLike.coe",
"NonUnitalSubsemiring.instSetLike",
"NonUnitalSubsemiring",
"NonUnitalSubsemiring.closure_le",
"NonUni... | true |
Aesop.GoalKind.recOn | Aesop.Stats.Basic | [
"Aesop.GoalKind.preNorm",
"Aesop.GoalKind.rec",
"Aesop.GoalKind",
"Aesop.GoalKind.postNorm"
] | false |
FreeAddGroup.Red.negRev | Mathlib.GroupTheory.FreeGroup.Basic | [
"Relation.ReflTransGen.lift",
"FreeAddGroup.Red.Step.negRev",
"List",
"FreeAddGroup.Red.Step",
"FreeAddGroup.Red",
"FreeAddGroup.negRev",
"Bool",
"Prod"
] | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | [
"Turing.TM0to1.Λ'.act",
"Turing.TM0.Stmt.move",
"Turing.TM0to1.Λ'",
"Eq.refl",
"Turing.TM0to1.tr.match_3",
"Turing.TM0to1.Λ'.normal",
"Eq",
"Turing.Dir",
"Turing.TM0.Stmt.write"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.