name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
Std.DTreeMap.Raw.Const.getD_union | Std.Data.DTreeMap.Raw.Lemmas | [
"Std.DTreeMap.Raw.instUnion",
"Std.DTreeMap.Internal.Impl.Const.getD_union!",
"Ord.mk",
"Ordering",
"id",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Union.union",
"Eq",
"Std.DTreeMap.Raw.WF",
"Std.DTreeMap.Raw.Const.getD",
"Std.DTreeMap.Raw"
] | true |
LibraryNote.lower_cancel_priority | Mathlib.Algebra.Group.Defs | [
"Inhabited.default",
"Batteries.Util.instInhabitedLibraryNote",
"Batteries.Util.LibraryNote"
] | true |
HomologicalComplex.dTo | Mathlib.Algebra.Homology.HomologicalComplex | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HomologicalComplex",
"ComplexShape.prev",
"ComplexShape",
"HomologicalComplex.xPrev",
"CategoryTheory.Category.toCategoryStruct",
"HomologicalComplex.X",
"CategoryTheory.Category",
"HomologicalComp... | true |
Lean.Meta.getMatcherInfo? | Lean.Meta.Match.MatcherInfo | [
"Pure.pure",
"Lean.Meta.getMatcherInfoCore?",
"Monad.toApplicative",
"Applicative.toPure",
"Lean.Meta.Match.MatcherInfo",
"Lean.Name",
"Monad.toBind",
"Bind.bind",
"Lean.MonadEnv",
"Lean.MonadEnv.getEnv",
"Monad",
"Lean.Environment",
"Option"
] | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalRight._regBuiltin.Lean.Elab.Tactic.evalRight.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
Nat.bertrand | Mathlib.NumberTheory.Bertrand | [
"Nat.Prime",
"HMul.hMul",
"Exists",
"Ne",
"instMulNat",
"instOfNatNat",
"LE.le",
"instLENat",
"And",
"Nat",
"LT.lt",
"instLTNat",
"Nat.exists_prime_lt_and_le_two_mul",
"OfNat.ofNat",
"instHMul"
] | true |
IsLprojection.Subtype.zero._proof_3 | Mathlib.Analysis.Normed.Module.MStructure | [
"IsLprojection",
"IsLprojection.mk",
"IsLprojection.Subtype.zero._proof_1",
"AddCommGroup.toAddCommMonoid",
"IsLprojection.Subtype.zero._proof_2",
"Zero.toOfNat0",
"NormedAddCommGroup.toAddCommGroup",
"Module",
"OfNat.ofNat",
"Ring.toSemiring",
"Ring",
"NormedAddCommGroup",
"MulZeroClass.toZ... | false |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff'._simp_1_1 | Mathlib.MeasureTheory.Measure.WithDensity | [
"Exists",
"exists_prop",
"And",
"propext",
"Eq"
] | false |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.opowAux.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Notation | [
"ONote.opowAux.match_1",
"instOfNatNat",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq"
] | true |
_private.Mathlib.Algebra.BigOperators.Finsupp.Basic.0.Finsupp.support_sum.match_1_1 | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"Finsupp.instFunLike",
"Finset",
"AddMonoid.toAddZeroClass",
"Finsupp.support",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"Ne",
"AddCommMonoid",
"And.casesOn",
"AddZero.toZero",
"And",
"Exists.casesOn",
"Finset.instSetLike",
"And.intro",
"Exists.intro",
"Zero.toOfNat0",
... | false |
Bracket.casesOn | Mathlib.Data.Bracket | [
"Bracket",
"Bracket.rec",
"Bracket.mk"
] | false |
Std.TreeSet.not_mem_emptyc | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeMap.not_mem_emptyc",
"Membership.mem",
"Ordering",
"Unit",
"Std.TreeSet.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Not",
"Std.TreeSet.instMembership"
] | true |
MeasureTheory.hasFiniteIntegral_const_iff_isFiniteMeasure | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | [
"Iff.mpr",
"MeasureTheory.Measure",
"SeminormedAddGroup.toNNNorm",
"AddMonoid.toAddZeroClass",
"NormedAddGroup.toSeminormedAddGroup",
"PseudoMetricSpace.toUniformSpace",
"AddZeroClass.toAddZero",
"SeminormedAddGroup.toContinuousENorm",
"Ne",
"NormedAddGroup.toENormedAddMonoid",
"SubtractionMonoi... | true |
MulAction.fst_mem_orbit_of_mem_orbit | Mathlib.GroupTheory.GroupAction.Basic | [
"Monoid",
"instHSMul",
"Prod.instSMul",
"Membership.mem",
"Prod.fst",
"MulAction.orbit",
"Exists.casesOn",
"MulAction",
"MulAction.mem_orbit",
"Monoid.toSemigroup",
"Eq.ndrec",
"HSMul.hSMul",
"SemigroupAction.toSMul",
"Prod",
"MulAction.toSemigroupAction",
"Eq",
"Set.instMembership",... | true |
TopologicalSpace.Compacts.isClosedEmbedding_singleton | Mathlib.Topology.Sets.VietorisTopology | [
"TopologicalSpace.Compacts.isEmbedding_coe",
"TopologicalSpace.Compacts.instSingleton",
"TopologicalSpace.vietoris",
"TopologicalSpace",
"SetLike.coe",
"TopologicalSpace.Compacts.instSetLike",
"T2Space",
"TopologicalSpace.Compacts.topology",
"TopologicalSpace.vietoris.isClosedEmbedding_singleton",
... | true |
ModuleCat.ctorIdx | Mathlib.Algebra.Category.ModuleCat.Basic | [
"ModuleCat",
"Nat",
"Ring"
] | false |
Asymptotics.isLittleO_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | [
"SeminormedAddCommGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"SeminormedAddCommGroup.toNorm",
"NormedAddCommGroup.toNorm",
"propext",
"Zero.toOfNat0",
"NormedAddCommGroup.toAddCommGroup",
"Asymptotics.IsLittleO",
... | false |
Module.Basis.sumCoords._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instDistribSMul",
"AddMonoid.nat_smulCommClass'",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"AddZero.toZero",
"NonAssocSemiring.toNonUnitalNonAssoc... | false |
SeparatelyContinuousAdd.mk | Mathlib.Topology.Algebra.Monoid.Defs | [
"Continuous",
"SeparatelyContinuousAdd.mk",
"SeparatelyContinuousAdd",
"TopologicalSpace",
"instHAdd",
"HAdd.hAdd",
"Add"
] | true |
Std.DHashMap.Raw.mem_insert_self._simp_1 | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Std.DHashMap.Raw",
"Membership.mem",
"LawfulHashable",
"EquivBEq",
"Std.DHashMap.Raw.mem_insert_self",
"True",
"eq_true",
"Hashable",
"BEq",
"Eq",
"Std.DHashMap.Raw.insert"
] | false |
IsWellFounded.recOn | Mathlib.Order.RelClasses | [
"IsWellFounded.mk",
"WellFounded",
"IsWellFounded.rec",
"IsWellFounded"
] | false |
localizedModuleIsLocalizedModule | Mathlib.Algebra.Module.LocalizedModule.Basic | [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Algebra.to_smulCommClass",
"instHSMul",
"Module.End.instMonoid",
"Semiring.toModule",
"instSMulOfMul",
"HMul.hMul",
"IsScalarTower.right",
"Algebra.algebraMap",
"LocalizedModule",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Di... | true |
continuousSubmonoid.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | [
"Continuous",
"continuousSubmonoid._proof_1",
"Subsemigroup.mk",
"setOf",
"MulOne.toMul",
"continuousSubmonoid",
"Pi.mulOneClass",
"TopologicalSpace",
"MulOneClass.toMulOne",
"ContinuousMul",
"Eq.refl",
"continuousSubmonoid._proof_2",
"Submonoid.mk",
"MulOneClass",
"Eq",
"Submonoid"
] | true |
QuotientAddGroup.map.eq_1 | Mathlib.GroupTheory.QuotientGroup.Defs | [
"AddSubgroup.comap",
"QuotientAddGroup.map",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"QuotientAddGroup.Quotient.addGroup",
"AddZeroClass.toAddZero",
"LE.le",
"QuotientAddGroup.mk'",
"AddSubgroup",
"AddSubgroup.Normal",
"HasQuoti... | true |
Polynomial.monomial_mem_lifts | Mathlib.Algebra.Polynomial.Lifts | [
"Set.mem_range",
"Subsemiring.instSetLike",
"Semiring.toModule",
"congrArg",
"Polynomial.map_monomial",
"LinearMap.instFunLike",
"RingHom",
"Membership.mem",
"Exists",
"Polynomial.monomial",
"Subsemiring",
"LinearMap",
"Polynomial",
"RingHom.instFunLike",
"Exists.casesOn",
"Polynomial.... | true |
WithAbs.congr_trans | Mathlib.Analysis.Normed.Ring.WithAbs | [
"WithAbs",
"PartialOrder",
"Distrib.toAdd",
"instDistribOfSemiring",
"Distrib.toMul",
"Semiring",
"RingEquiv.trans",
"WithAbs.instSemiring",
"WithAbs.congr",
"RingEquiv",
"Eq",
"rfl",
"AbsoluteValue"
] | true |
Lean.Meta.Iterator.next | Lean.Meta.Iterator | [
"Lean.Meta.Iterator",
"Lean.Meta.SavedState",
"Lean.Meta.MetaM",
"Prod",
"Option"
] | true |
Mathlib.Tactic.Ring.Common.ExBaseNat | Mathlib.Tactic.Ring.Common | [
"Lean.Expr.const",
"Mathlib.Tactic.Ring.Common.ExBaseNat.atom",
"Lean.Level",
"Qq.Quoted",
"Mathlib.Tactic.Ring.Common.ExBaseNat.sum",
"Lean.Name.mkStr1",
"List.nil"
] | true |
Commute.span_left | Mathlib.LinearAlgebra.Span.Defs | [
"Submodule",
"instSMulOfMul",
"DistribMulAction.toDistribSMul",
"Commute.zero_left",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Submodule.span_induction",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Commute",
"Commute.smul_left",
"Membership.mem",
"AddZeroClass.toAddZero",
"DistribSMul.t... | true |
Lean.Meta.ACLt.ReduceMode.noConfusionType | Lean.Meta.ACLt | [
"Lean.Meta.ACLt.ReduceMode.ctorIdx",
"noConfusionTypeEnum",
"Lean.Meta.ACLt.ReduceMode",
"Nat",
"instDecidableEqNat"
] | true |
Fin.encodeProd | Batteries.Data.Fin.Coding | [
"HMul.hMul",
"Fin.encodeProd.match_1",
"instMulNat",
"Fin.mkDivMod",
"Nat",
"Prod",
"Fin",
"instHMul"
] | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.stateLP | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.PositiveVector | [
"Rat.instOfNat",
"Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm",
"List.map",
"Rat",
"Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.getValues",
"Prod.mk",
"instOfNatNat",
"List.range",
"List.cons",
"instHAppendOfAppend",
"List",
"instHAdd",
"HAdd.hAdd"... | true |
Lean.Lsp.FileSystemWatcher.ctorIdx | Lean.Data.Lsp.Workspace | [
"Nat",
"Lean.Lsp.FileSystemWatcher"
] | false |
WithZero.lt_ofAdd_of_toAdd_unzero_lt | Mathlib.Algebra.Order.GroupWithZero.Canonical | [
"Eq.mpr",
"Preorder.toLT",
"Equiv.instEquivLike",
"ofAdd_toAdd",
"Multiplicative.ofAdd_lt",
"congrArg",
"WithZero.coe_unzero",
"id",
"Equiv",
"WithZero.unzero",
"Ne",
"WithZero.instZero",
"Multiplicative",
"WithZero",
"instLTMultiplicative",
"WithZero.coe",
"LT.lt",
"propext",
"W... | true |
CategoryTheory.ParametrizedAdjunction._sizeOf_1 | Mathlib.CategoryTheory.Adjunction.Parametrized | [
"CategoryTheory.ParametrizedAdjunction.rec",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"CategoryTh... | false |
_private.Mathlib.Order.Filter.Prod.0.Filter.compl_mem_coprod._simp_1_2 | Mathlib.Order.Filter.Prod | [
"Filter.instMembership",
"Membership.mem",
"And",
"Max.max",
"Filter.mem_sup",
"propext",
"Filter.instSup",
"Eq",
"Filter",
"Set"
] | false |
Std.Internal.List.maxKey?_of_perm | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Ord",
"Std.TransOrd",
"Std.OrientedOrd.opposite",
"Std.TransOrd.opposite",
"inferInstance",
"List.Perm",
"Ord.compare",
"Std.Internal.List.minKey?_of_perm",
"List",
"Ord.opposite",
"Std.Internal.List.maxKey?",
"Std.LawfulBEqOrd",
"Std.LawfulBEqOrd.opposit... | true |
ProbabilityTheory.HasArgminEstimator.mk | Mathlib.Probability.Decision.BayesEstimator | [
"ProbabilityTheory.HasArgminEstimator",
"StandardBorelSpace",
"ProbabilityTheory.IsFiniteKernel",
"MeasureTheory.Measure",
"Exists",
"ProbabilityTheory.HasArgminEstimator.mk",
"MeasurableSpace",
"MeasureTheory.IsFiniteMeasure",
"ENNReal",
"Nonempty",
"ProbabilityTheory.IsArgminEstimator",
"Pro... | true |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.isColimitFiniteSubproductsCocone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | [
"CategoryTheory.Limits.ColimitCocone.cocone",
"Finset.singleton_subset_iff._simp_1",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory.Limits.HasColimitsOfShape",
"CategoryTheory.CategoryStruct.toQuiver",
"Qui... | false |
NNReal.nhds_zero | Mathlib.Topology.Instances.NNReal.Lemmas | [
"NNReal.instTopologicalSpace",
"Eq.mpr",
"Preorder.toLT",
"iInf",
"Iff.of_eq",
"congrArg",
"Filter.instInfSet",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"nhds",
"id",
"NNReal",
"Ne",
"Bot.bot",
"NNReal.instZero",
"_private.Mathlib.Topology.Instances.NNReal.Lemmas... | true |
ContinuousAddEquiv._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousMonoidHom | [
"ContinuousAddEquiv._sizeOf_1",
"TopologicalSpace",
"SizeOf.mk",
"ContinuousAddEquiv",
"SizeOf",
"Add"
] | false |
Relation.fun_eq_comp | Mathlib.Logic.Relation | [
"congrArg",
"exists_eq_left'._simp_1",
"iff_self",
"funext",
"Iff",
"Relation.Comp",
"True",
"propext",
"of_eq_true",
"congrFun'",
"Eq",
"Eq.trans"
] | true |
CategoryTheory.IsPreconnected | Mathlib.CategoryTheory.IsConnected | [
"CategoryTheory.IsPreconnected.mk",
"CategoryTheory.Category"
] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.of_forall_constGet?_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"Ordering",
"Ordering.eq",
"Ord.compare",
"Bool.true",
"BEq.beq",
"propext",
"Bool",
"Std.LawfulBEqOrd",
"BEq",
"Eq",
"Std.LawfulBEqOrd.compare_eq_iff_beq"
] | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | [
"Unit.unit",
"Option.some",
"Option.none",
"Unit",
"Std.DHashMap.Internal.Raw₀.alterₘ.match_1",
"Eq.refl",
"Eq",
"Option"
] | true |
CategoryTheory.Functor.FullyFaithful.isMonHom_preimage | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.Functor.FullyFaithful.map_injective",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.LaxMonoidal.ε",
"CategoryTheory.Functor.monObjObj",
"CategoryTheory.IsMonHom",
"_private.Ma... | true |
CochainComplex.HomComplex.Cochain.rightShiftLinearEquiv._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | [
"CochainComplex.HomComplex.instModuleCochain",
"HomologicalComplex.instCategory",
"instHSMul",
"CochainComplex.HomComplex.Cochain.rightShift",
"CochainComplex.HomComplex.instAddCommGroupCochain",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass"... | false |
_private.Lean.Elab.Tactic.Simpa.0.Lean.Elab.Tactic.Simpa.evalSimpaCore.match_6 | Lean.Elab.Tactic.Simpa | [
"Option.ctorIdx",
"Option.some",
"Lean.Syntax.TSepArray",
"Nat.hasNotBit",
"List.cons",
"_private.Lean.Elab.Tactic.Simpa.0.Lean.Elab.Tactic.Simpa.evalSimpaCore._sparseCasesOn_3",
"Lean.SyntaxNodeKind",
"Lean.Name.mkStr4",
"List.nil",
"Option"
] | false |
Finite.of_injective | Mathlib.Data.Fintype.EquivFin | [
"Finite.of_equiv",
"Equiv.instEquivLike",
"Finite",
"Classical.propDecidable",
"Function.comp",
"Membership.mem",
"Exists",
"Subtype.fintype",
"Set.Elem",
"Equiv",
"Finite.of_fintype",
"Fin.fintype",
"Equiv.ofInjective",
"Exists.casesOn",
"Function.Injective.comp",
"Nat",
"Nonempty.c... | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.Multiset.aestronglyMeasurable_fun_prod._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | [
"Multiset.map",
"Multiset.prod",
"Pi.multiset_prod_apply",
"Multiset",
"Pi.commMonoid",
"Eq.symm",
"Eq",
"CommMonoid"
] | false |
IsCyclotomicExtension.norm_zeta_sub_one_of_isPrimePow | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | [
"Nat.instMulZeroClass",
"MonoidHom.instFunLike",
"MonoidHom",
"AddGroupWithOne.toAddGroup",
"CommSemiring.toSemiring",
"IsPrimePow",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"Algebra",
"IsPrimitiveRoot.sub_one_norm_isPrimePow",
"Polynomial.cyclotomic",
"Field.toDivisionRing",
"Irre... | true |
AddSubmonoid.pi_mem_of_single_mem_aux | Mathlib.Algebra.Group.Submonoid.Finite | [
"SetLike",
"Eq.mpr",
"False",
"AddSubmonoidClass.toAddMemClass",
"Function.update",
"eq_false",
"congrArg",
"true_or",
"Finset",
"Membership.mem",
"AddSubmonoidClass",
"Eq.rec",
"AddZeroClass.toAddZero",
"Pi.single_eq_of_ne",
"id",
"Insert.insert",
"Pi.instZero",
"Finset.mem_insert... | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Syntax.binary._regBuiltin.Lean.Parser.Syntax.binary.formatter_7 | Lean.Parser.Syntax | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Lean.Parser.Syntax.binary.formatter",
"Unit",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl_obj | Mathlib.CategoryTheory.Galois.Prorepresentability | [
"CategoryTheory.Functor",
"CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl",
"CategoryTheory.PreGaloisCategory.PointedGaloisObject.instCategory",
"Finite",
"FintypeCat",
"CategoryTheory.PreGaloisCategory.PointedGaloisObject.obj",
"CategoryTheory.PreGaloisCategory.PointedGaloisObject",
"Categ... | true |
_private.Init.Data.Array.Sort.Lemmas.0.Array.mergeSort_of_pairwise._simp_1_1 | Init.Data.Array.Sort.Lemmas | [
"Array.toList",
"List.toArray",
"Array",
"List",
"propext",
"List.toArray_eq_iff",
"Eq"
] | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction.0.UpperHalfPlane.denom_cocycle'._simp_1_4 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | [
"False",
"eq_false",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"three_ne_zero",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] | false |
Std.ExtDTreeMap.Const.get?_modify_self | Std.Data.ExtDTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Const.get?_modify_self",
"Ordering",
"Std.TransCmp",
"Std.ExtDTreeMap.Const.get?",
"Option.map",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Std.ExtDTreeMap.Const.modify",
"Eq",
"Option"
] | true |
CategoryTheory.MonoidalOpposite.tensorRightIso_inv_app_unmop | Mathlib.CategoryTheory.Monoidal.Opposite | [
"CategoryTheory.Functor",
"CategoryTheory.unmopFunctor",
"CategoryTheory.MonoidalOpposite.unmop",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.MonoidalOpposite",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.mopFunctor",
"CategoryT... | true |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimpMatch._regBuiltin.Lean.Elab.Tactic.Conv.evalSimpMatch_1 | Lean.Elab.Tactic.Conv.Simp | [
"Lean.Elab.Tactic.tacticElabAttribute",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Elab.Tactic.Conv.evalSimpMatch",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
Ideal.mem_span_singleton' | Mathlib.RingTheory.Ideal.Span | [
"Semiring.toModule",
"HMul.hMul",
"Membership.mem",
"Submodule.mem_span_singleton",
"Exists",
"Set.instSingletonSet",
"Ideal",
"instDistribOfSemiring",
"Iff",
"Distrib.toMul",
"Submodule.setLike",
"Semiring",
"Ideal.span",
"Singleton.singleton",
"Eq",
"Semiring.toAddCommMonoid",
"Set... | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.revMatchesAt_iff_splits.match_1_3 | Init.Data.String.Lemmas.Pattern.String.Basic | [
"String",
"String.Slice",
"Exists",
"And.casesOn",
"String.Slice.copy",
"instAppendString",
"instHAppendOfAppend",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"String.Slice.Pos",
"HAppend.hAppend",
"String.Slice.Pos.Splits"
] | false |
CategoryTheory.Over.starPullbackIsoStar._proof_7 | Mathlib.CategoryTheory.Comma.Over.Pullback | [
"CategoryTheory.Over.pullback._proof_2",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.HasBinaryProducts",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.Limits.HasPullback",
"CategoryTheory.instCategoryOver",
"CategoryTheo... | false |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?.match_1 | Lean.Elab.Declaration | [
"String",
"_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?._sparseCasesOn_2",
"Nat.hasNotBit",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?._sparseCasesOn_1",
"Lean.Name"
] | false |
SecondCountableTopology.rec | Mathlib.Topology.Bases | [
"SecondCountableTopology",
"Exists",
"SecondCountableTopology.mk",
"TopologicalSpace.generateFrom",
"TopologicalSpace",
"And",
"Set.Countable",
"Eq",
"Set"
] | false |
OreLocalization.instFieldNonZeroDivisors._proof_7 | Mathlib.RingTheory.OreLocalization.Ring | [
"Nontrivial",
"Semigroup.toMul",
"CommRing",
"HMul.hMul",
"DivisionRing.mul_inv_cancel",
"CommSemiring.toSemiring",
"OreLocalization.OreSet",
"OreLocalization",
"AddMonoid.toZero",
"nonZeroDivisors",
"inferInstance",
"Ne",
"DivisionRing.toRing",
"instDistribOfSemiring",
"CommRing.toCommS... | false |
Lean.Meta.Sym.DSimp.Result.ctorElimType | Lean.Meta.Sym.DSimp.DSimpM | [
"cond",
"Lean.Meta.Sym.DSimp.Result.rfl",
"Nat.ble",
"Lean.Meta.Sym.DSimp.Result",
"Lean.Expr",
"PULift",
"Nat",
"Bool",
"Lean.Meta.Sym.DSimp.Result.step"
] | false |
Lean.Grind.NoopConfig.splits._default | Init.Grind.Config | [
"id",
"instOfNatNat",
"Nat",
"OfNat.ofNat"
] | false |
NonemptyInterval.instCommSemiringOfCanonicallyOrderedAdd._proof_4 | Mathlib.Algebra.Order.Interval.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Prod.instCommSemiring",
"instHSMul",
"NonemptyInterval.toProd_nsmul",
"AddMonoid.toAddSemigroup",
"CommSemiring.toSemiring",
"NonemptyInterval.toProd_injective",
"covariant_swap_add_of_covariant_add",
"Function.swap",
"AddMonoid.toAddZeroClass",
"Parti... | false |
EuclideanDomain.lcm_eq_zero_iff | Mathlib.Algebra.EuclideanDomain.Basic | [
"Eq.mpr",
"Semigroup.toMul",
"IsDomain.to_noZeroDivisors",
"Dvd.dvd",
"instHDiv",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"MulZeroClass.toMul",
"EuclideanDomain.lcm_zero_left",
"congrArg",
"CommSemiring.toSemiring",
"semigroupDvd",
"CommSemiring.toCommMonoidWithZero",
"SemigroupWithZe... | true |
one_le_cfc_iff._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Lean.Class.0.Lean.init | Lean.Class | [
"Lean.MessageData",
"Lean.MonadError.mk",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Name.mkNum",
"Lean.Core.instMonadRefCoreM",
"Lean.AttrM",
"String",
"Lean.Core.instMonadEnvCoreM",
"Lean.Attribute.Builtin.ensureNoArgs",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMona... | true |
OrderIso.dualAntisymmetrization._proof_8 | Mathlib.Order.Antisymmetrization | [
"OrderDual.instLE",
"AntisymmRel.setoid",
"Equiv.instEquivLike",
"OrderIso.dualAntisymmetrization._proof_7",
"Iff.rfl",
"PartialOrder.toPreorder",
"OrderIso.dualAntisymmetrization._proof_4",
"Preorder.toLE",
"Quotient.mk''",
"Equiv.mk",
"Quotient.inductionOn'",
"id",
"Equiv",
"OrderIso.dua... | false |
_private.Init.Data.Array.Lemmas.0.Array.push_eq_push._simp_1_1 | Init.Data.Array.Lemmas | [
"And.comm",
"And",
"propext",
"Eq"
] | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.unfoldBothDefEq._sparseCasesOn_1 | Lean.Meta.ExprDefEq | [
"Lean.LBool.false",
"Nat.ne_of_beq_eq_false",
"Lean.LBool.undef",
"Lean.LBool.rec",
"Nat.shiftRight",
"Lean.LBool.true",
"Nat.hasNotBit",
"Lean.LBool.ctorIdx",
"instOfNatNat",
"Nat.land",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Lean.LBool"
] | false |
Std.DTreeMap.getKey?_union_of_not_mem_left | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap.instUnion",
"Std.DTreeMap",
"congrArg",
"Ord.mk",
"Membership.mem",
"Ordering",
"Eq.mp",
"Std.DTreeMap.contains_eq_false_iff_not_mem",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.getKey?",
"Std.DTreeMap.instMembership",
"Std.DTreeMap.wf",
"propext",
"Bool",
"Std.D... | true |
BitVec.getElem_signExtend | Init.Data.BitVec.Lemmas | [
"dite_congr",
"instDecidableTrue",
"congrArg",
"Decidable.decide.congr_simp",
"BitVec",
"BitVec.getLsbD",
"Bool.and",
"Bool.true_and",
"decide_true",
"dite",
"GetElem.getElem",
"Bool.true",
"BitVec.getLsbD_signExtend",
"Nat",
"congr",
"LT.lt",
"True",
"eq_self",
"BitVec.signExten... | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.ctorIdx | Lean.Meta.Sym.Simp.Forall | [
"_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo",
"Nat"
] | false |
div_eq_zero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | [
"GroupWithZero.toMonoidWithZero",
"instHDiv",
"GroupWithZero.toDivInvMonoid",
"GroupWithZero",
"HDiv.hDiv",
"MonoidWithZero.toMulZeroOneClass",
"propext",
"DivInvMonoid.toDiv",
"Zero.toOfNat0",
"Or",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq",
"div_eq_zero_iff",
"MulZeroClass.... | false |
CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp_base | Mathlib.CategoryTheory.Presentable.ColimitPresentation | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp",
"CategoryTheory.Limits.ColimitPresentation.Total.Hom.base",
"Sigma.fst",
"CategoryTheory.Limits.ColimitPresentation.Total",
"CategoryTheory.Limits.ColimitPresen... | true |
Polynomial.isRoot_cyclotomic_iff | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | [
"Eq.mpr",
"RingHom.instRingHomClass",
"IsDomain",
"FractionRing.field",
"_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Roots.0.Polynomial.isRoot_cyclotomic_iff'",
"CommRing",
"Algebra.algebraMap",
"OreLocalization.instAlgebra",
"congrArg",
"CommSemiring.toSemiring",
"IsFractionRing.injective... | true |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRoo.decEq._proof_3 | Init.Data.Range.Polymorphic.PRange | [
"False",
"Std.Roo.mk.noConfusion",
"eq_of_heq",
"HEq",
"Eq",
"Not",
"Std.Roo",
"Std.Roo.mk"
] | false |
Int.Linear.le_of_le_diseq | Init.Data.Int.Linear | [
"Int.Linear.le_of_le_diseq_cert",
"Eq.mpr",
"False",
"Bool.and'",
"Int.Linear.Poly.addConst_k_eq_addConst",
"HMul.hMul",
"Int.Linear.Poly.addConst",
"congrArg",
"Int.neg_eq_zero._simp_1",
"Int.lt_of_le_of_lt",
"Bool.and'_eq_and",
"Int.neg_one_mul",
"False.elim",
"Int.Linear.Poly.mul_k",
... | true |
Lean.Grind.CommRing.d_normEq0 | Init.Grind.Ring.CommSolver | [
"Int.cast",
"Eq.mpr",
"Lean.Grind.CommRing.Poly",
"HMul.hMul",
"Lean.Grind.CommRing.Poly.normEq0",
"congrArg",
"Bool.and'_eq_and",
"Lean.Grind.CommRing.Poly.beq'",
"Lean.Grind.CommRing.Poly.normEq0_eq",
"Lean.Grind.CommSemiring.toSemiring",
"id",
"Lean.Grind.AddCommMonoid.toZero",
"Bool.and"... | true |
Prod.instBornology | Mathlib.Topology.Bornology.Constructions | [
"Bornology.mk",
"Prod.instBornology._proof_1",
"Bornology.cobounded",
"Prod",
"Filter.coprod",
"Bornology"
] | true |
DirectSum.instLieAlgebraSubtypeMemSubmodule | Mathlib.Algebra.Lie.Graded | [
"LieAlgebra.toModule",
"Submodule",
"CommRing",
"LieAlgebra.mk",
"instAddCommMonoidDirectSum",
"LieRing.toAddCommGroup",
"DirectSum.instModule",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"Module.mk",
"DirectSum.instLieAlgebraSubtypeMemSubmodule._proo... | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodySum_volume._simp_1_9 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | [
"InnerProductSpace.toNormedSpace",
"Real",
"MeasureTheory.Measure",
"HMul.hMul",
"Real.instRCLike",
"NormedField.toField",
"MeasureTheory.integral_prod_mul",
"NormedCommRing.toNonUnitalNormedCommRing",
"Field.toSemifield",
"Prod.fst",
"RCLike.toDenselyNormedField",
"instDistribOfSemiring",
"... | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | [
"CommMonoidWithZero.toCommMonoid",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Additive.linearOrder",
"Additive",
"Additive.preorder",
"PartialOrder.toPreorder",
"LinearOrderedCommMonoidWithZero.toLinearOrder",
"LinearOrderedCommMonoidWithZero.toIsOrderedMonoid",
"LinearOrde... | false |
CategoryTheory.Comonad.comparison_obj_A | Mathlib.CategoryTheory.Monad.Adjunction | [
"CategoryTheory.Functor",
"Eq.refl",
"CategoryTheory.Comonad.Coalgebra.A",
"CategoryTheory.Adjunction.toComonad",
"CategoryTheory.Comonad.comparison",
"CategoryTheory.Adjunction",
"CategoryTheory.Comonad.Coalgebra",
"Eq",
"CategoryTheory.Functor.obj",
"CategoryTheory.Comonad.Coalgebra.eilenbergMoo... | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.newDepHyp.noConfusion | Lean.Meta.Tactic.Grind.Intro | [
"Lean.Meta.Grind.Goal",
"_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult",
"id",
"_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.noConfusion",
"Eq",
"_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.newDepHyp"
] | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.where._regBuiltin.Lean.Parser.Command.where_1 | Lean.Parser.Command | [
"IO",
"Lean.Parser.Command.where",
"Unit",
"Lean.Parser.addBuiltinLeadingParser",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_1 | Mathlib.RingTheory.LittleWedderburn | [
"IsDomain",
"Subring.instSetLike",
"Ring.toNonAssocRing",
"Membership.mem",
"Subtype",
"DivisionRing.toRing",
"Subring.toRing",
"Subring.instIsDomainSubtypeMem",
"Subring",
"DivisionRing.isDomain",
"DivisionRing",
"Ring.toSemiring",
"SetLike.instMembership"
] | false |
exists_mem_nhdsSet_isClosed_subset | Mathlib.Topology.Separation.Regular | [
"Filter.instMembership",
"Iff.mpr",
"subset_closure",
"Membership.mem",
"Exists",
"mem_nhdsSet_iff_exists",
"HasSubset.Subset.trans",
"Set.instIsTransSubset",
"Set.instReflSubset",
"HasSubset.Subset",
"And.casesOn",
"IsClosed",
"TopologicalSpace",
"And",
"Exists.casesOn",
"closure",
... | true |
_private.Mathlib.Analysis.Calculus.FDeriv.OfCompLeft.0.HasFDerivAtFilter.of_comp_aux | Mathlib.Analysis.Calculus.FDeriv.OfCompLeft | [
"Asymptotics.IsBigOTVS.congr'",
"NormedCommRing.toSeminormedCommRing",
"Asymptotics.IsBigOTVS",
"NormedSpace.toIsBoundedSMul",
"map_sub",
"sub_left_inj._simp_1",
"SemilinearMapClass.distribMulActionSemiHomClass",
"NormedSpace",
"Asymptotics.IsBigOTVS.comp_tendsto",
"HasFDerivAtFilter.isBigOTVS_sub... | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_cons_aux | Init.Data.List.MinMaxIdx | [
"Eq.mpr",
"of_eq_false",
"False",
"List.minIdxOn",
"eq_false",
"congrArg",
"List.instDecidableEqNil",
"False.elim",
"GetElem.getElem.congr_simp",
"_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.eq_1",
"noConfusion_of_Nat",
"List.getElem_minIdxOn",
"id",
"_private.Init.Data.List.MinMaxId... | true |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.Monic.geom_sum._simp_1_2 | Mathlib.RingTheory.Polynomial.Basic | [
"Preorder.toLT",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddLeftMono",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"ZeroLEOneClass",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
... | false |
Unitization.instMulOneClass._proof_1 | Mathlib.Algebra.Algebra.Unitization | [
"Monoid",
"MulOne.toOne",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"DistribMulAction.toDistribSMul",
"MulZeroClass.zero_mul",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"smul_zero",
"AddZeroClass.toAddZero",
"MulOne.toMul",
"Distrib.toAdd",... | false |
Lean.Grind.OrderedAdd.add_le_add | Init.Grind.Ordered.Module | [
"Std.instTransLeOfIsPreorder",
"Lean.Grind.OrderedAdd.add_le_left",
"LE.le",
"Std.le_trans",
"Lean.Grind.OrderedAdd.add_le_right",
"Lean.Grind.AddCommMonoid",
"LE",
"instHAdd",
"Std.IsPreorder",
"HAdd.hAdd",
"Lean.Grind.AddCommMonoid.toAdd",
"Lean.Grind.OrderedAdd"
] | true |
CategoryTheory.isIso_left_of_isIso_biprod_map | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.BinaryBicone.inl_fst",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.biprod.map",
"congrArg",
"CategoryTheory.IsIso.inv_hom_id",
"C... | true |
Lean.MessageData.instCoeFormat | Lean.Message | [
"Lean.MessageData",
"Coe.mk",
"Lean.MessageData.ofFormat",
"Std.Format",
"Coe"
] | true |
CategoryTheory.Functor.preservesZeroMorphisms_of_isLeftAdjoint | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | [
"Eq.mpr",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Functor",
"Trans.trans",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Adjunction.ofIsLeftAdjoint",
"CategoryTheory.Limits.comp_zero",
"CategoryTheory.Functor.comp",
"_private.Mathlib.Catego... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.