name string | module string | deps list |
|---|---|---|
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | [
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Submodule",
"Semiring.toModule",
"Subring.instSetLike",
"ValuationClass.toMonoidWithZeroHomClass",
"Ring.toNonAssocRing",
"congrArg",
"Valuation.mem_leSubmodule_iff._simp_1",
"AddMonoid.toAddZero... |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | [
"Quiver.Hom",
"Quiver",
"CategoryTheory.ReflQuiver",
"CategoryTheory.ReflQuiver.mk"
] |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | [
"Real",
"Equiv.bijective",
"Real.arsinh",
"Function.Bijective",
"Real.sinhEquiv",
"Equiv.symm"
] |
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply | Mathlib.Analysis.Distribution.FourierMultiplier | [
"NormedCommRing.toNormedRing",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CompleteSpace",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"RCLike.toNormedAlgebra",
"HMul.hMul",
"NormedSpace",
"Schwartz... |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | [
"Equiv.instEquivLike",
"Function.comp",
"AddZeroClass.toAddZero",
"AddOpposite",
"Equiv",
"AddOpposite.instAddZero",
"AddZeroClass",
"Eq.refl",
"AddOpposite.unop",
"Equiv.symm",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"Eq",
"DFunLike.coe",
"AddMonoidHom.op",
"AddOpposite.op",
"Eq... |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | [
"MulOne.toOne",
"Membership.mem",
"MulOne.toMul",
"Submonoid.instTop",
"MulOneClass.toMulOne",
"Subsemigroup.instTop",
"Subsemigroup",
"propext",
"Subsemigroup.carrier",
"One.toOfNat1",
"Submonoid.mk",
"MulOneClass",
"Top.top",
"OfNat.ofNat",
"Eq",
"Set.instMembership",
"Submonoid.mk... |
Lean.Compiler.LCNF.CtorFieldInfo.object.inj | Lean.Compiler.LCNF.ToImpureType | [
"Lean.Compiler.LCNF.CtorFieldInfo.object",
"Lean.Expr",
"And",
"Lean.Compiler.LCNF.CtorFieldInfo",
"Nat",
"Lean.Compiler.LCNF.CtorFieldInfo.object.noConfusion",
"And.intro",
"Eq"
] |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | [
"cond",
"dite_cond_eq_true",
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"False",
"dite_congr",
"congrArg",
"_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey._proof_1",
"Bool.false_eq_true",
"Option.some",
"Std.Internal.List.getValue",
"Option.bind",
"Eq.mp",
"Option.... |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | [
"Lean.PrettyPrinter.Formatter",
"Lean.PrettyPrinter.Formatter.orelse.formatter",
"Lean.Parser.strLit.formatter",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Bool.true",
"Lean.Parser.Command.identPrec.formatter",
"Lean.Parser.Syntax.unicodeAtom.formatter",
"Lean.Parser.mkAntiquot.formatter"... |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.LimitPresentation.casesOn",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.LimitPresentation",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.IsLimit",
"HEq",
"CategoryTheory.Category.toCategoryStruct",
"Ca... |
Cardinal.lt_one_iff_zero | Mathlib.SetTheory.Cardinal.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"Cardinal.instOne",
"Order.succ",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"OrderBot.toBot",
"AddMonoid.toAddZeroClass",
"Cardinal.commSemiring",
"PartialOrder.toPreorder",
"Cardinal.instNoMaxOrder",
"Preorder.toLE",
"Ca... |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | [
"iSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"CompleteLattice.toCompleteSemilatticeInf",
"CompleteSemilatticeInf.toPartialOrder",
"iSup₂_le_iff",
"propext",
"CompleteSemilatticeSup.toSupSet",
"CompleteLattice.toCompleteSemilatticeSup",
"CompleteLattice",
"Eq"
] |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | [
"IsLocalization.IsInteger",
"Finset.mem_univ",
"instHSMul",
"Finset.univ",
"IsLocalization",
"CommSemiring.toSemiring",
"Finset",
"Finite",
"Algebra",
"Algebra.toSMul",
"Membership.mem",
"Exists",
"Subtype",
"NonAssocSemiring.toMulZeroOneClass",
"Nonempty.intro",
"MulZeroOneClass.toMul... |
_private.Mathlib.Data.Set.List.0.Option.getD.match_1.eq_1 | Mathlib.Data.Set.List | [
"Option.getD.match_1",
"Option.some",
"Option.none",
"Unit",
"Eq.refl",
"Eq",
"Option"
] |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | [
"CategoryTheory.Functor.preservesFiniteLimits_of_preservesHomology",
"Iff.mpr",
"CategoryTheory.Abelian.toPreadditive",
"List.IsChain.cons_cons",
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"CategoryTheory.Functor.PreservesHomology.preservesRightHomologyOf",
"CategoryTheory.Functor... |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | [
"Pure.pure",
"Eq.mpr",
"Std.Shrink.deflate",
"False",
"Subtype.mk.congr_simp",
"Decidable.casesOn",
"Std.Iterators.Types.DropWhile.PlausibleStep.start",
"dite_congr",
"bind_congr",
"Std.Iterators.PostconditionT.operation_pure",
"Std.IterStep",
"Std.Iterators.Types.DropWhile.PlausibleStep.dropp... |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | [
"Filter.Germ.ofFun",
"AddMonoid.toAddSemigroup",
"Filter.Germ.instAddMonoid._proof_3",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"AddMonoid.add_zero",
"AddMonoid.toNSMul",
"Function.Surjective.addMonoid",
"AddZeroClass.toAddZero",
"Filter.Germ.instAdd",
"AddZero.toZero",
"instHAdd",
"A... |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | [
"Lean.MessageData",
"Lean.Elab.Term.TermElab",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instAddErrorMessageContextTermElabM",
"Lean.indentD",
"Lean.KeyedDeclsAttribute.AttributeEntry.value",
"instMonadExceptOfMonadExceptOf",
"instMonadReaderOfReaderTOfMonad",
"... |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | [
"Real.instLE",
"Real",
"LE.le",
"Isometry.preimage_setOf_dist",
"PseudoMetricSpace",
"Set.preimage",
"Metric.closedBall",
"Eq",
"Isometry",
"PseudoMetricSpace.toPseudoEMetricSpace",
"Set"
] |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | [
"Lean.Lsp.DocumentUri",
"Lean.Lsp.FileEvent.noConfusionType",
"Lean.Lsp.FileEvent.casesOn",
"Eq.ndrec",
"Eq.refl",
"Lean.Lsp.FileEvent",
"Lean.Lsp.FileChangeType",
"Eq"
] |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | [
"HMul.hMul",
"Nat.ascFactorial",
"instMulNat",
"instOfNatNat",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Nat.factorial.match_1",
"instHMul"
] |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | [
"Lattice.toSemilatticeSup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toBoundedOrder",
"CategoryTheory.Sieve.arrows",
"CategoryTheory.Sieve",
"CategoryTheory.GrothendieckTopo... |
Lean.Elab.Tactic.evalSimpAllArith._regBuiltin.Lean.Elab.Tactic.evalSimpAllArith_1 | Lean.Elab.Tactic.SimpArith | [
"Lean.Elab.Tactic.tacticElabAttribute",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin",
"Lean.Elab.Tactic.evalSimpAllArith"
] |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | [
"OrderDual.toDual",
"Equiv.instEquivLike",
"UpperSet",
"UpperSet.instSetLike",
"Function.comp",
"Equiv",
"Bot.bot",
"LE",
"UpperSet.instBot",
"SetLike.coe",
"OrderDual",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike",
"Set"
] |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | [
"Std.Sat.CNF.relabel",
"Std.Sat.CNF",
"_private.Std.Sat.CNF.Relabel.0.Std.Sat.CNF.sat_relabel._simp_1_1",
"congrArg",
"Std.Sat.CNF.eval_relabel",
"Std.Sat.CNF.eval",
"Function.comp",
"Eq.mp",
"id",
"Bool.true",
"True",
"eq_self",
"Bool",
"of_eq_true",
"congrFun'",
"Std.Sat.CNF.Sat",
... |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | [
"Fin.isLt",
"LE.le",
"instLENat",
"Fin.val",
"Nat",
"LT.lt",
"instLTNat",
"Fin",
"Nat.lt_of_lt_of_le"
] |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | [
"CoheytingHom.casesOn",
"Lattice",
"Lattice.toSemilatticeSup",
"SupHom.toFun",
"SupHom.casesOn",
"CoheytingHom.toLatticeHom",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CoheytingAlgebra.toOrderTop",
"Eq.rec",
"SemilatticeSup.toMax",
"Max",
"CoheytingHom.mk",
"CoheytingHom",
"CoheytingA... |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | [
"Unit.unit",
"Lean.Meta.CongrArgKind.fixedNoParam",
"Lean.Meta.CongrArgKind.subsingletonInst",
"Lean.Meta.CongrArgKind.heq",
"Lean.Meta.CongrArgKind",
"Unit",
"Lean.Meta.CongrArgKind.casesOn",
"Lean.Meta.CongrArgKind.eq",
"Lean.Meta.CongrArgKind.cast",
"Lean.Meta.CongrArgKind.fixed"
] |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | [
"and_true",
"congrArg",
"Set.univ",
"setOf",
"Set.Finite",
"Eq.mp",
"HasSubset.Subset",
"funext",
"Set.countable_univ",
"And",
"True",
"Countable",
"Set.subset_univ._simp_1",
"Set.Countable",
"Eq.trans",
"Set.countable_setOf_finite_subset",
"Set.instHasSubset",
"Set"
] |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | [
"Finset.instUnion",
"Finset",
"Membership.mem",
"Finset.instSetLike",
"propext",
"Finset.mem_union",
"Or",
"Union.union",
"Eq",
"SetLike.instMembership",
"DecidableEq"
] |
Lean.Exception.isInterrupt | Lean.Exception | [
"BEq.beq",
"_private.Lean.Exception.0.Lean.Exception.isInterrupt.match_1",
"Lean.instBEqInternalExceptionId",
"Bool",
"Lean.InternalExceptionId",
"Lean.KVMap",
"Bool.false",
"Lean.Exception",
"Lean.interruptExceptionId"
] |
Lean.Grind.isLE | Init.Grind.Offset | [
"LE.le",
"instLENat",
"Nat",
"Bool",
"Decidable.decide",
"Nat.decLe"
] |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | [
"ValuationSubring.coe_mem_principalUnitGroup_iff",
"Subtype.mk.congr_simp",
"ValuationSubring.unitGroup",
"MulEquiv.instEquivLike",
"congrArg",
"ValuationSubring.unitGroupMulEquiv",
"CommSemiring.toSemiring",
"ValuationSubring.isLocalRing",
"Subgroup.mul",
"IsLocalRing.residue",
"Membership.mem"... |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | [
"Aesop.Frontend.RuleExpr.node"
] |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Group",
"Preorder.toLE",
"TopologicalSpace.instCompleteLattice",
"CompleteLattice.toBoundedOrder",
"GroupTopology.instTop._proof_1",
"Top.mk",
"TopologicalSpace",
"OrderTop.toTop",
"BoundedOrder.toOrderTop",
... |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | [
"single_le_finsum",
"Real.instLE",
"Real",
"Real.instZero",
"PartitionOfUnity.locallyFinite",
"PartitionOfUnity",
"ContinuousMap",
"finsum",
"PseudoMetricSpace.toUniformSpace",
"PartitionOfUnity.nonneg",
"LE.le",
"Real.instOne",
"PartitionOfUnity.instFunLikeContinuousMapReal",
"Topological... |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"Real",
"Continuous",
"NormedSpace",
"BoundedContinuousFunction.instCoeTC._proof_1",
"PseudoMetricSpace.toUniformSpace",
"ContDiffMapSupportedIn.toContDiffMapSupportedInClass",
"ContDiffMapSupportedIn",
"ContDiffMapSupportedInClass.toDFunLike",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"ContDi... |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | [
"False",
"True",
"propext",
"not_true",
"Eq",
"Not"
] |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | [
"ENNReal.div_top",
"AEMeasurable.aestronglyMeasurable",
"Real.hasMeasurablePow",
"Norm.norm",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"MulOne.toOne",
"AEMeasurable.pow_const",
"Real.instPow",
"MeasureTheory.AEStronglyMeasurable.aemeasurable",
"Semigroup.toMul",
"Real",
"DivInvMonoid... |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | [
"Eq.mpr",
"Std.Iter.atIdxSlow?_drop",
"Std.Iter.getElem?_toList_eq_atIdxSlow?",
"List.getElem?_drop",
"congrArg",
"Iff.rfl",
"List.instGetElem?NatLtLength",
"Option.some",
"Std.Iterators.Finite",
"id",
"Std.Iterators.instProductiveOfFinte",
"Id",
"Option.ext",
"Std.Iterator",
"Std.Iter.d... |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"ContDiffMapSupportedInClass.map_contDiff",
"Real",
"NormedSpace",
"outParam",
"Real.denselyNormedField",
"ContDiffMapSupportedInClass",
"ContDiff.continuous",
"PseudoMetricSpace.toUniformSpace",
"ContinuousMapClass",
"WithTop.some",
"ContDiffMapSupportedInClass.toDFunLike",
"ContinuousMapClas... |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | [
"Set.instSProd",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"Function.Injective.injOn",
"Membership.mem",
"tsum_image",
"Set.Elem",
"Set.instSingletonSet",
"id",
"Set.singleton_prod",
"Prod.mk",
"tsum_congr_set_coe",
"AddCommMonoid",
"TopologicalSpace",
"tsum",
"Eq.refl",
"Set.image",
... |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | [
"Set.Subset.antisymm",
"Mul",
"Membership.mem",
"Set.centralizer",
"Set.subset_centralizer_centralizer",
"Eq",
"Set.instMembership",
"Set"
] |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | [
"Real.instLE",
"Real",
"instHSMul",
"HMul.hMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"dist_pair_smul",
"SMul",
"IsBoundedSMul.toUniformContinuousConstSMul",
"PseudoMetricSpace.toUniformSpace",
"IsBoundedSMul",
"inseparableSetoid",
"Quotient.ind₂",
"Quotient.ind",
"LE.le",
... |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | [
"CategoryTheory.Monad",
"CategoryTheory.Monad.Algebra.isoMk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Monad.Algebra.a",
"congrArg",
"CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_2",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"Category... |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | [
"Std.TreeSet.Raw.getD",
"Std.TreeSet.Raw.WF.out",
"Option.some",
"Membership.mem",
"Ordering",
"Std.TreeSet.Raw.instMembership",
"Std.TransCmp",
"Std.TreeMap.Raw.getKey?_eq_some_getKeyD",
"Std.TreeSet.Raw",
"Unit",
"Std.TreeSet.Raw.inner",
"Eq",
"Std.TreeSet.Raw.get?",
"Option",
"Std.Tre... |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.AsSmall.abelian._proof_1",
"CategoryTheory.Abelian",
"CategoryTheory.AsSmall.preadditive",
"CategoryTheory.instSmallCategoryAsSmall",
"CategoryTheory.abelianOfEquivalence",
"CategoryTheory.AsSmall.equiv",
"CategoryTheory.AsSmall.abelian._proof_2"... |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.size_eq_if_roo._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | [
"Std.PRange.UpwardEnumerable",
"Std.Rxo.LawfulHasSize",
"instOfNatNat",
"Nat",
"LT.lt",
"propext",
"Std.Rxo.HasSize",
"Std.Rxo.size_eq_zero_iff_not_le",
"OfNat.ofNat",
"Std.Rxo.HasSize.size",
"Eq",
"Not",
"LT"
] |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | [
"Iff.mpr",
"Eq.mpr",
"UpperSet",
"Finset.instUnion",
"Finset.inf'",
"Finset.truncatedInf",
"congrArg",
"Finset.inf'_congr",
"Finset",
"UpperSet.instSetLike",
"upperClosure",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Eq.rec",
"id",... |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | [
"Eq.mpr",
"Stream'.Seq",
"Nat.zero_le",
"Nat.instMulZeroClass",
"GenContFract.Pair.b",
"Nat.recAux",
"instHDiv",
"GenContFract.Pair.a",
"Nat.instOne",
"GenContFract.squashSeq",
"GenContFract.convs'Aux",
"Ring.toNonAssocRing",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAdd... |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | [
"String",
"instDecidableEqBool",
"String.charactersIn",
"Bool.true",
"Bool",
"Lean.Name",
"Bool.false",
"Eq",
"_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic.match_1",
"ite"
] |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | [
"HMul.hMul",
"Semiring.npow",
"PseudoMetricSpace.toUniformSpace",
"SeminormedRing.toRing",
"inferInstance",
"NonUnitalNonAssocSemiring.toMul",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"instOfNatNat",
"Semiring.npow_succ",
"instHAdd",
"UniformSpace.Completion.ring",
"HAdd.hAdd",
"Nat"... |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | [
"ByteArray.extract_eq_extract_iff_getElem._proof_2",
"Eq.mpr",
"False",
"Nat.recAux",
"ByteArray.extract_add_one",
"and_true",
"_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_eq_extract_iff_getElem._proof_1_2",
"_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_eq_extract_iff_getElem._p... |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"Std.Tactic.BVDecide.BVBinPred.toString.match_1",
"BitVec",
"instBEqOfDecidableEq",
"instDecidableEqBitVec",
"BEq.beq",
"Unit",
"Nat",
"Bool",
"Std.Tactic.BVDecide.BVBinPred",
"BitVec.ult"
] |
expandLemma | Mathlib.Tactic.Lemma | [
"Pure.pure",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax",
"instOfNatNat",
"Lean.MacroM",
"Applicative.toPure",
"Lean.Macro.Context",
"Bool.true",
"Lean.Macro.State",
"Nat",
"EStateM",
"OfNat.ofNat",
"Lean.Name.mkStr4",
"ReaderT.instApplicativeOfMonad",
"Lean.Syntax.setKi... |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | [
"List.unattach",
"Eq.mpr",
"instSubsingletonDecidable",
"congrArg",
"InvImage",
"HSub.hSub",
"Decidable",
"WellFounded.Nat.fix",
"Membership.mem",
"WellFounded.Nat.fix_eq",
"ByteArray.toList.loop._unary._proof_1",
"Eq.rec",
"PSigma.casesOn",
"id",
"Subtype",
"ByteArray.toList.loop._una... |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | [
"Iff.mpr",
"Eq.mpr",
"exists_or",
"Finset.exists_of_one_lt_card_pi",
"HMul.hMul",
"Finset.mem_image",
"Finset.Nonempty.image",
"SProd.sprod",
"congrArg",
"Finset.filter_nonempty_iff",
"Finset",
"uniqueAdd_of_twoUniqueAdd",
"Finset.isWellFounded_ssubset",
"HasSSubset.SSubset",
"Classical.... |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | [
"Real",
"Real.instRCLike",
"EuclideanGeometry.Sphere",
"Membership.mem",
"MetricSpace",
"MetricSpace.toPseudoMetricSpace",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"InnerProductSpace",
"NormedAddCommGroup",
"EuclideanGeometry.Sphere.IsExtTangentAt",
"NormedAddTorsor",
"EuclideanGeometry.... |
Qq.Impl.isIrrefutablePattern | Qq.Match | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Syntax.Term",
"Bool"
] |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | [
"MeasurableSet",
"MeasurableSpace.countablySeparated_def",
"Set.univ",
"MeasurableSpace",
"MeasurableSpace.CountablySeparated",
"HasCountableSeparatingOn",
"propext",
"Eq"
] |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | [
"Eq.mpr",
"Inhabited.default",
"Decidable.casesOn",
"Int.instInhabited",
"congrArg",
"Std.PRange.instUpwardEnumerableInt",
"HSub.hSub",
"Decidable",
"Option.getD",
"Option.some",
"id",
"Int",
"if_pos",
"Nat.cast",
"Int.getElem?_toArray_roo",
"Std.PRange.instIsAlwaysFiniteInt_1",
"Arr... |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | [
"String.instLTRaw",
"String.Slice.rawEndPos",
"String.Slice",
"String.Pos.Raw.instLawfulOrderLT",
"Eq.rec",
"LE.le",
"String.Pos.Raw",
"String.Pos.Raw.IsValidForSlice",
"String.Pos.Raw.isValidForSlice_rawEndPos",
"Std.not_le",
"String.Pos.Raw.instAntisymmLe",
"LT.lt",
"String.instLERaw",
"... |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | [
"Monoid",
"Submodule",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"Module.End.instSemiring",
"LinearMap.instFunLike",
"Membership.mem",
"NonAssocSemiring.toMulZeroOneClass",
"Subrepresentation",
"LinearMap",
"AddCommMonoid",
... |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | [
"Eq.propIntro",
"Lean.Doc.Block",
"Lean.injEq_helper",
"Array",
"Lean.DeclarationRange",
"Empty",
"And",
"Nat",
"Eq.ndrec",
"Lean.Doc.Part",
"Eq.refl",
"Lean.ElabBlock",
"Prod",
"Lean.ElabInline",
"Lean.VersoModuleDocs.Snippet.mk",
"Eq",
"Lean.VersoModuleDocs.Snippet",
"Lean.VersoM... |
Mathlib.Tactic.DepRewrite.instDecidableLECastMode._proof_1 | Mathlib.Tactic.DepRewrite | [
"Nat.le_of_ble_eq_true",
"Nat.ble",
"LE.le",
"instLENat",
"Bool.true",
"Mathlib.Tactic.DepRewrite.CastMode.toNat",
"Nat",
"Mathlib.Tactic.DepRewrite.CastMode",
"Bool",
"Eq"
] |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.invtSubmoduleToLieIdeal_top._simp_1_5 | Mathlib.Algebra.Lie.Weights.IsSimple | [
"Submodule",
"Membership.mem",
"Submodule.instTop",
"AddCommMonoid",
"Submodule.setLike",
"True",
"eq_true",
"Semiring",
"Module",
"Top.top",
"Eq",
"Submodule.mem_top",
"SetLike.instMembership"
] |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | [
"Aesop.ScriptGenerated",
"Bool"
] |
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | [
"Filter.limsInf",
"Lattice.toSemilatticeSup",
"Filter.map_bot",
"Filter.liminf",
"CompleteLattice.toLattice",
"congrArg",
"Filter.map",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toBoundedOrder",
"Bot.bot",
"OrderTop.toTop",... |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | [
"Exists",
"HasSubset.Subset",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Set.instHasSubset",
"Set"
] |
Lean.Grind.toInt_bitVec | Init.GrindInstances.ToInt | [
"Lean.Grind.ToInt.toInt",
"Lean.Grind.instToIntBitVecUint",
"BitVec",
"Lean.Grind.IntInterval.uint",
"Int",
"BitVec.toNat",
"Nat.cast",
"Nat",
"instNatCastInt",
"Eq",
"rfl"
] |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | [
"Dvd.dvd",
"Int",
"Int.instDvd",
"Int.natAbs_dvd_natAbs",
"Nat.instDvd",
"Nat",
"Int.natAbs",
"propext",
"Eq"
] |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | [
"Lean.RArray.leaf",
"False",
"congrArg",
"Classical.byContradiction",
"Lean.RArray.branch",
"id",
"Lean.RArray",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Int.Linear.Poly.num",
"Int.Linear.Poly.add",
"Int.Linear.norm_eq",
"Int.Linear.diseq_unsat",
"Bool.true",
"instHAdd",
"instOfNat"... |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | [
"Continuous.continuousOn",
"NormedSpace",
"PseudoMetricSpace.toUniformSpace",
"TopologicalSpace",
"ModelWithCorners",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"ModelWithCorners.continuous_symm",
"ModelWithCorners.symm",
"NontriviallyNormedField",
"ContinuousOn",
"NontriviallyNormedField.toN... |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | [
"List.Perm",
"Std.DTreeMap.Internal.Impl.Equiv",
"propext",
"Std.DTreeMap.Internal.Impl.toListModel",
"Std.DTreeMap.Internal.Impl.equiv_iff_toListModel_perm",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Sigma"
] |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | [
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"Group",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"QuotientGroup.leftRel",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Inv.... |
AddOpposite.instRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | [
"Semigroup.toMul",
"AddOpposite",
"RightCancelSemigroup.toSemigroup",
"AddOpposite.instRightCancelSemigroup._proof_1",
"AddOpposite.unop",
"Function.Injective.rightCancelSemigroup",
"AddOpposite.unop_injective",
"RightCancelSemigroup",
"AddOpposite.instMul"
] |
Vector.toArray_reverse | Init.Data.Vector.Lemmas | [
"Vector",
"Array.reverse",
"Vector.reverse",
"Array",
"Nat",
"Eq",
"Vector.toArray",
"rfl"
] |
Lean.Elab.FieldInfo.noConfusion | Lean.Elab.InfoTree.Types | [
"Lean.Syntax",
"Lean.Expr",
"Lean.Elab.FieldInfo",
"Lean.Elab.FieldInfo.casesOn",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Elab.FieldInfo.noConfusionType",
"Eq",
"Lean.LocalContext"
] |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.IsLower.isTopologicalSpace_basis._simp_1_6 | Mathlib.Topology.Order.LowerUpperTopology | [
"Set.iInter",
"Membership.mem",
"Set.mem_iInter",
"propext",
"Eq",
"Set.instMembership",
"Set"
] |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processExplicitArg._sparseCasesOn_1 | Lean.Elab.App | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.ctorIdx",
"Bool.true",
"Nat.land",
"Nat",
"Bool.rec",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exists_closedBall_covering_tsum_measure_le._simp_1_16 | Mathlib.MeasureTheory.Covering.Besicovitch | [
"Set.mem_image",
"Membership.mem",
"Exists",
"And",
"propext",
"Set.image",
"Eq",
"Set.instMembership",
"Set"
] |
_private.Mathlib.Data.List.Sym.0.List.Nodup.sym2._simp_1_8 | Mathlib.Data.List.Sym | [
"Exists",
"exists_eq_right",
"And",
"propext",
"Eq"
] |
UniformEquiv.piCongrRight_symm | Mathlib.Topology.UniformSpace.Equiv | [
"UniformEquiv.piCongrRight",
"Pi.uniformSpace",
"UniformSpace",
"UniformEquiv.symm",
"Eq",
"UniformEquiv",
"rfl"
] |
Disjoint.isCompl_sup_right_of_isCompl_sup_left | Mathlib.Order.ModularLattice | [
"Lattice",
"Codisjoint",
"Lattice.toSemilatticeSup",
"codisjoint_assoc",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"IsCompl",
"Max.max",
"Disjoint.disjoint_sup_right_of_disjoint_sup_left",
"BoundedOrder.toOrderTop",
"Bo... |
CauSeq.Completion.ofRat_injective | Mathlib.Algebra.Order.CauSeq.Completion | [
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"LinearOrder",
"CauSeq.Completion.Cauchy",
"HSub.hSub",
"IsStrictOrderedRing",
"_private.Mathlib.Algebra.Order.CauSeq.Completion.0.CauSeq.Completion.ofRat_injective._simp_1_5",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"CauSeq.Completion.ofRat",... |
Lean.Elab.Info.ofOptionInfo.inj | Lean.Elab.InfoTree.Types | [
"Lean.Elab.Info.ofOptionInfo",
"Lean.Elab.Info.ofOptionInfo.noConfusion",
"Lean.Elab.OptionInfo",
"Lean.Elab.Info",
"Eq"
] |
ConvexCone.instCompleteLattice._proof_1 | Mathlib.Geometry.Convex.Cone.Basic | [
"SemilatticeSup.le_sup_left",
"Lattice.toSemilatticeSup",
"ConvexCone.instPartialOrder",
"CompleteLattice.toLattice",
"SMul",
"ConvexCone.hull",
"PartialOrder.toPreorder",
"ConvexCone.instSetLike",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"AddCommMonoid",
"GaloisInsertion.liftCompleteLattic... |
_private.Mathlib.Order.LiminfLimsup.0.limsup_finset_sup'._simp_1_4 | Mathlib.Order.LiminfLimsup | [
"Finset.le_sup'_iff",
"Lattice.toSemilatticeSup",
"Finset",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"LE.le",
"And",
"Finset.instSetLike",
"propext",
"Finset.Nonempty",
"Finset.su... |
DecompositionMonoid | Mathlib.Algebra.Divisibility.Basic | [
"Semigroup",
"DecompositionMonoid.mk"
] |
Lean.Lsp.DeclarationParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.DeclarationParams.casesOn",
"Lean.Lsp.DeclarationParams",
"Lean.Lsp.TextDocumentPositionParams",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Lsp.DeclarationParams.noConfusionType"
] |
Inter.inter | Init.Core | [
"Inter"
] |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getElem_concat_succ._simp_1_1 | Init.Data.BitVec.Lemmas | [
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"propext",
"instAddNat",
"instLTNat",
"Nat.add_lt_add_iff_right",
"Eq"
] |
Algebra.tensorH1CotangentOfIsLocalization_toLinearMap | Mathlib.RingTheory.Etale.Kaehler | [
"Algebra.Extension.Hom.mk",
"Eq.mpr",
"Algebra.Extension.H1Cotangent.equivOfFormallySmooth",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"LinearEquiv.symm",
"CommRing",
"LinearMap.restrictScalars",
"Algebra.to_smulCommClass",
"Algebra.Extension.H1Cotangent.map_eq",
"Al... |
Lean.Meta.Grind.Arith.CommRing.State.mk.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | [
"Lean.Meta.Grind.Arith.CommRing.State.mk.inj",
"Eq.propIntro",
"Lean.Meta.Grind.Arith.CommRing.State",
"Lean.PHashMap",
"Lean.injEq_helper",
"Array",
"Lean.Meta.Grind.Arith.CommRing.Semiring",
"Lean.Meta.Grind.Arith.CommRing.State.mk",
"And",
"Lean.Meta.Sym.instHashableExprPtr",
"Nat",
"Lean.M... |
_private.Mathlib.Probability.StrongLaw.0.ProbabilityTheory.strong_law_aux1._simp_1_10 | Mathlib.Probability.StrongLaw | [
"not_le",
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"LT.lt",
"propext",
"LinearOrder.toPartialOrder",
"Eq",
"Not"
] |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.cos_arg._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | [
"False",
"eq_false",
"four_ne_zero",
"instOfNatNat",
"Nat",
"Zero.toOfNat0",
"NeZero",
"OfNat.ofNat",
"Eq",
"OfNat",
"Zero"
] |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.mem_vonNeumann_succ._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | [
"Preorder.toLT",
"Ordinal.partialOrder",
"ZFSet",
"PartialOrder.toPreorder",
"Membership.mem",
"ZFSet.rank",
"ZFSet.vonNeumann",
"LT.lt",
"propext",
"ZFSet.mem_vonNeumann",
"Eq",
"ZFSet.instMembership",
"Ordinal"
] |
CategoryTheory.Triangulated.SpectralObject._sizeOf_inst | Mathlib.CategoryTheory.Triangulated.SpectralObject | [
"CategoryTheory.Triangulated.SpectralObject",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Triangulated.SpectralObject._sizeOf_1",
"CategoryTheory.shiftFunctor",
"Int",
"Int.instAddMonoid",
"CategoryTheory.Preadditive",
"SizeOf.mk",
"CategoryTheory.Limits.HasZeroObject",
"CategoryTheory.Pret... |
LinearEquiv.mem_transvections_iff_mem_dilatransvections_and_fixedReduce_eq_one | Mathlib.LinearAlgebra.Transvection | [
"Int.instAddCommGroup",
"Module.End.instRing",
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"LinearMap.transvection",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Nat.add_le_add_iff_right",
"IsNoetherianRing.strongRankCondition",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"... |
CategoryTheory.Functor.CoconeTypes.isColimit_iff | Mathlib.CategoryTheory.Limits.Types.Colimits | [
"Eq.mpr",
"CategoryTheory.Limits.IsColimit.fac",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Functor.ιColimitType_jointly_surjective",
"Equiv.instEquivLike",
"instDecidableTrue",
"CategoryTheory.Limits.IsColimit.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Qui... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.