name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | [
"Set.univ",
"Membership.mem",
"True",
"Set.mem_univ",
"eq_true",
"Eq",
"Set.instMembership",
"Set"
] | false |
DoResultPRBC.recOn | Init.Core | [
"DoResultPRBC.rec",
"DoResultPRBC.continue",
"DoResultPRBC.pure",
"DoResultPRBC.break",
"DoResultPRBC",
"DoResultPRBC.return"
] | false |
IsMin.eq_of_ge | Mathlib.Order.Max | [
"LE.le.antisymm'",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"Eq",
"IsMin"
] | true |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | [
"CondensedMod",
"CategoryTheory.Functor",
"Opposite",
"ModuleCat",
"CondensedMod.ofSheafProfinite._proof_1",
"TotallyDisconnectedSpace",
"TopCat.str",
"CategoryTheory.regularTopology.EqualizerCondition",
"Profinite",
"TopCat.carrier",
"Condensed.ofSheafProfinite",
"ModuleCat.moduleCategory",
... | true |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | [
"DifferentiableWithinAt.congr",
"AddCommGroup.toAddCommMonoid",
"Membership.mem",
"NormedField.toField",
"AddCommGroup",
"Field.toSemifield",
"TopologicalSpace",
"Semifield.toDivisionSemiring",
"DifferentiableOn",
"DivisionSemiring.toSemiring",
"NontriviallyNormedField",
"NontriviallyNormedFie... | true |
ENNReal.Lp_add_le | Mathlib.Analysis.MeanInequalities | [
"ENNReal.coe_toNNReal",
"ENNReal.ofNNReal_finsetSum",
"Iff.mpr",
"Real.instIsOrderedRing",
"GroupWithZero.toMonoidWithZero",
"not_exists._simp_1",
"ENNReal.rpow_eq_zero_iff._simp_1",
"ENNReal.instAdd",
"False",
"Real.partialOrder",
"Real.instLE",
"Real",
"ENNReal.ofNNReal",
"DivInvMonoid.t... | true |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"CategoryTheory.Limits.WalkingMultispan.Hom.fst.elim",
"CategoryTheory.Limits.WalkingMultispan.Hom.ctorIdx",
"CategoryTheory.Limits.WalkingMultispan",
"CategoryTheory.Limits.MultispanShape.L",
"CategoryTheory.Limits.MultispanShape",
"CategoryTheory.Limits.WalkingMultispan.Hom.id.elim",
"dite",
"Catego... | false |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.isStarNormal_of_mem._simp_1_2 | Mathlib.Algebra.Star.SelfAdjoint | [
"Mul",
"Commute",
"Commute.neg_left",
"True",
"eq_true",
"HasDistribNeg",
"HasDistribNeg.toInvolutiveNeg",
"InvolutiveNeg.toNeg",
"Eq",
"Neg.neg"
] | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.or_neg._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | [
"Lean.RArray.leaf",
"False",
"CommRing",
"HMul.hMul",
"Int.Linear.norm_le",
"Lean.Grind.nestedProof",
"congrArg",
"CommSemiring.toSemiring",
"Int.Linear.le_unsat",
"Lean.Grind.not_or",
"RootPairing.Base",
"AddCommGroup.toAddCommMonoid",
"Classical.byContradiction",
"RootPairing.Base.height... | false |
CochainComplex.homologyMap_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
MeasureTheory.Integrable.bdd_mul' | Mathlib.MeasureTheory.Function.L1Space.Integrable | [
"MeasureTheory.ae",
"Norm.norm",
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"NormedRing.toRing",
"HMul.hMul",
"Filter.Eventually",
"PseudoMetricSpace.toUniformSpace",
"MeasureTheory.Integrable",
"MeasureTheory.Integrable.bdd_mul",
"NormedRing.toNonUnitalNormedRing",
"SeminormedAddGroup.... | true |
LinearMap.toMatrixₛₗ₂'_symm | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | [
"Pi.Function.module",
"LinearEquiv.symm",
"Semiring.toModule",
"Pi.addCommMonoid",
"Matrix.module",
"Matrix.toLinearMapₛₗ₂'",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"Matrix",
"LinearMap.instSMulCommClass",
"AddMonoid.toAddZeroClass",
"RingHom",
"AddZeroClass.toAddZero",... | true |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | [
"Equiv.Perm.SameCycle.symm",
"Equivalence",
"Equiv.Perm.SameCycle.trans",
"Equiv.Perm.SameCycle",
"Equiv.Perm.SameCycle.refl",
"Equiv.Perm",
"Equivalence.mk"
] | true |
CommHopfAlgCat.Hom.mk.inj | Mathlib.Algebra.Category.CommHopfAlgCat | [
"CommHopfAlgCat",
"CommRing",
"Coalgebra.toCoalgebraStruct",
"HopfAlgebraStruct.toBialgebra",
"Bialgebra.toCoalgebra",
"CommSemiring.toSemiring",
"CommHopfAlgCat.hopfAlgebra",
"CommHopfAlgCat.Hom.mk.noConfusion",
"CommHopfAlgCat.Hom.mk",
"Algebra.toModule",
"CommHopfAlgCat.commRing",
"BialgHom... | true |
lt_iff_le_and_ne' | Mathlib.Order.Basic | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"_private.Mathlib.Order.Basic.0.lt_iff_le_and_ne'.match_1_1",
"le_of_lt",
"Preorder.toLE",
"PartialOrder",
"ne_of_gt",
"Ne",
"LE.le",
"And",
"Iff",
"And.intro",
"LT.lt",
"Iff.intro",
"LE.le.lt_of_ne'"
] | true |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | [
"AntisymmRel.setoid",
"Preorder.toLT",
"Function.instTrichotomousSwapProp",
"Quot.sound",
"IsWellFounded.mk",
"Function.swap",
"InvImage",
"WellFoundedLT",
"PartialOrder.toPreorder",
"Quot.ind",
"Preorder.toLE",
"DFinsupp.lex_lt_of_lt_of_preorder",
"Exists",
"DFinsupp.instDFunLike",
"id"... | true |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | [
"CategoryTheory.Functor",
"HomologicalComplex.instCategory",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CochainComplex.shiftFunctorObjXIso._proof_1",
"CategoryTheory.Functor.category",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemig... | true |
Lean.Widget.PanelWidgetInstance.mk.injEq | Lean.Widget.UserWidget | [
"Eq.propIntro",
"String",
"Lean.injEq_helper",
"Lean.Widget.PanelWidgetInstance",
"Lean.Widget.PanelWidgetInstance.mk",
"Lean.Widget.WidgetInstance",
"And",
"Eq.ndrec",
"Eq.refl",
"Lean.Widget.PanelWidgetInstance.mk.inj",
"Lean.Lsp.Range",
"Eq",
"Option"
] | true |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | [
"Submonoid.mul",
"MulEquiv.submonoidCongr",
"Equiv.setCongr",
"Membership.mem",
"Subtype",
"SetLike.coe",
"MulEquiv.submonoidCongr._proof_1",
"MulEquiv",
"Eq.refl",
"Submonoid.instSetLike",
"MulOneClass",
"Eq",
"MulEquiv.mk",
"SetLike.instMembership",
"Submonoid",
"MulEquiv.submonoidCo... | true |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | [
"Rep.coinvariantsTensorIndHom._proof_3",
"Rep.instMonoidalCategory",
"Rep.V",
"CategoryTheory.Functor",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"Semiring.toModule",
"Finsupp.module",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"Rep.coinvariantsTensorIn... | true |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | [
"CategoryTheory.Over",
"SheafOfModules.LocalGeneratorsData.I",
"SheafOfModules.LocalGeneratorsData.X",
"AddCommGrpCat.instCategory",
"CategoryTheory.HasSheafify",
"AddMonoid.toAddZeroClass",
"RingCat.ring",
"AddCommGroup.toAddGroup",
"RingHom",
"AddCommGrpCat.instConcreteCategoryAddMonoidHomCarrie... | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findTactic?.merge._sparseCasesOn_3 | Lean.Server.CodeActions.Provider | [
"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"
] | false |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Functor",
"CategoryTheory.MorphismProperty.Comma.Hom.casesOn",
"CategoryTheory.Comma.right",
"CategoryTheory.Comma.left",
"CategoryTheory.CommaMorphism.right",
"CategoryTheory.MorphismProperty.Comma.toComma",
"CategoryTheory.CommaMorphism.left",
"Ca... | false |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.link",
"_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.filterMap._proof_9",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAd... | false |
LinearEquiv.domMulActCongrRight._proof_6 | Mathlib.Algebra.Module.Equiv.Basic | [
"Equiv.right_inv",
"RingHom",
"RingHomCompTriple",
"LinearMap.instAdd",
"Equiv.toFun",
"LinearMap",
"AddCommMonoid",
"RingHomInvPair",
"LinearEquiv.arrowCongrAddEquiv",
"RingHomInvPair.ids",
"LinearEquiv",
"Function.RightInverse",
"Semiring",
"LinearEquiv.refl",
"AddEquiv.toEquiv",
"Mo... | false |
MulZeroClass.rec | Mathlib.Algebra.GroupWithZero.Defs | [
"HMul.hMul",
"Mul",
"MulZeroClass",
"Zero.toOfNat0",
"MulZeroClass.mk",
"OfNat.ofNat",
"Eq",
"instHMul",
"Zero"
] | false |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | [
"Classical.not_not",
"propext",
"Eq",
"Not"
] | false |
CategoryTheory.toOverIsoToOverUnit_hom_app_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | [
"CategoryTheory.Over",
"CategoryTheory.equivToOverUnit",
"CategoryTheory.Functor",
"CategoryTheory.toOver",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.... | true |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | [
"Membership.mem",
"Subtype",
"LE.le",
"AddCommMonoid",
"Set.instLE",
"LinearIndependent",
"Semiring",
"Set.range",
"Module",
"Subtype.val",
"Eq",
"Set.instMembership",
"Set"
] | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_gt.match_1_1 | Init.Data.Nat.Bitwise.Lemmas | [
"instOfNatNat",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"Nat.casesOn"
] | false |
CategoryTheory.Coverage.mem_toGrothendieck | Mathlib.CategoryTheory.Sites.Coverage | [
"CategoryTheory.Coverage",
"Iff.rfl",
"Membership.mem",
"CategoryTheory.Sieve",
"Iff",
"CategoryTheory.Coverage.toGrothendieck",
"CategoryTheory.GrothendieckTopology",
"Set.instMembership",
"DFunLike.coe",
"CategoryTheory.Coverage.Saturate",
"CategoryTheory.GrothendieckTopology.instDFunLikeSetSi... | true |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.isMulCommutative_iSup._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | [
"SetLike",
"Membership.mem",
"SetLike.coe",
"SetLike.mem_coe",
"propext",
"Eq.symm",
"Eq",
"Set.instMembership",
"SetLike.instMembership",
"Set"
] | false |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | [
"Membership.mem",
"Subtype",
"ValuativeRel.ValueGroupWithZero.ind",
"Bot.bot",
"LE.le",
"MulZeroOneClass.toMulOneClass",
"instMulZeroOneClassOfSemiring",
"ValuativeRel.instLEValueGroupWithZero",
"Semiring",
"ValuativeRel.posSubmonoid",
"ValuativeRel",
"Submonoid.instSetLike",
"ValuativeRel.i... | false |
Lean.Elab.Tactic.Do.Internal.VCGen.State.invariants._default | Lean.Elab.Tactic.Do.Internal.VCGen.Context | [
"Lean.MVarId",
"id",
"List.toArray",
"Array",
"List.nil"
] | false |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | [
"Function.Injective.eq_iff",
"Function.Embedding",
"Iff",
"Function.Embedding.coe_injective",
"Function.instFunLikeEmbedding",
"Eq",
"DFunLike.coe"
] | false |
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | [
"RelIso.mk",
"Prod.instLE_mathlib",
"Fin.snocEquiv",
"Equiv",
"OrderIso",
"instOfNatNat",
"LE.le",
"LE",
"Pi.hasLe",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Fin.last",
"instAddNat",
"Fin.castSucc",
"Prod",
"OfNat.ofNat",
"Fin",
"Fin.snocOrderIso._proof_4"
] | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | [
"Iff.mpr",
"instHSMul",
"NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates",
"NumberField.instCommRingRingOfIntegers",
"CommSemiring.toSemiring",
"NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul",
"Membership.mem",
"nonZeroDivisors",
"Exists",
"Units",
"Set.Elem"... | false |
CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom | Mathlib.CategoryTheory.Limits.Presheaf | [
"CategoryTheory.Functor.op",
"CategoryTheory.categoryOfElements",
"CategoryTheory.Functor.Elements",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pres... | true |
Lean.Meta.Sym.State.casesOn | Lean.Meta.Sym.SymM | [
"Lean.MessageData",
"Lean.Meta.Sym.State.rec",
"Lean.Meta.Sym.ProofInstInfo",
"instHashableProd",
"Lean.PHashMap",
"Lean.Expr",
"Lean.FVarId",
"Lean.Meta.Sym.State.mk",
"Lean.Level",
"Array",
"List",
"Lean.Meta.Sym.Canon.State",
"Lean.Meta.Sym.instHashableExprPtr",
"instBEqProd",
"Bool",... | false |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.NameMap",
"Lean.TSyntax.getId",
"Lean.Elab.Term.LevelMVarErrorInfo",
"Lean.Elab.Term.Context.mk",
"Lean.Elab.Term.State.mk",
"Lean.MVarIdMap",
"String",
"Lean.Meta.S... | true |
HomotopicalAlgebra.Precylinder.symm_I | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | [
"HomotopicalAlgebra.Precylinder.symm",
"HomotopicalAlgebra.Precylinder.I",
"HomotopicalAlgebra.Precylinder",
"Eq.refl",
"Eq",
"CategoryTheory.Category"
] | true |
CategoryTheory.AddMonObj.ofIso | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.AddMonObj.ofIso._proof_7",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.AddMonObj.ofIso._proof_2",
"CategoryTheory.Iso",
"CategoryTheory.AddMonObj.add",
"CategoryTheory.AddMonObj.zero",
"CategoryTheory.AddMonObj.mk",
"CategoryTheory.AddMonObj.ofIso._proof_4",
"CategoryTheory.Ad... | true |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | [
"Filter.Realizer.mk",
"CFilter.toFilter",
"CompleteLattice.toConditionallyCompleteLattice",
"CFilter",
"CompleteBooleanAlgebra.toCompleteLattice",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"ConditionallyCompleteLattice.toConditionallyCompletePartialOrder",
"ConditionallyCompletePartialOrd... | false |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | [
"Lean.instBEqBinderInfo",
"Lean.Meta.ParamInfo",
"BEq.beq",
"Bool",
"Lean.BinderInfo",
"Lean.BinderInfo.strictImplicit",
"Lean.Meta.ParamInfo.binderInfo"
] | true |
instSemilatticeSupPrimeMultiset._proof_5 | Mathlib.Data.PNat.Factors | [
"LE.le",
"Nat.Primes",
"Multiset.instPartialOrder._proof_1",
"LE.mk",
"instSemilatticeSupPrimeMultiset._aux_1",
"PrimeMultiset"
] | false |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | [
"Std.Commutative",
"instHOrOfOrOp",
"BitVec.or_comm",
"BitVec.instOrOp",
"BitVec",
"HOr.hOr",
"Nat",
"Std.Commutative.mk"
] | true |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | [
"Iff.mpr",
"False",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddGroupWithOne.toAddGroup",
"congrArg",
"Matrix",
"AddSubgroup.Commensurable",
"PartialOrder.toPreorder",
"instDecidableEqFin",
"Nat.instAtLeastTwoHAddOfNat",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"Nat.instCharZero",
... | true |
SimpleGraph.FinsubgraphHom.restrict._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | [
"SimpleGraph.Subgraph.instPartialOrder",
"SimpleGraph.Subgraph",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Set.Finite",
"Membership.mem",
"HasSubset.Subset",
"LE.le",
"SimpleGraph",
"And.left",
"SimpleGraph.Finsubgraph",
"SimpleGraph.Subgraph.Adj",
"Subtype.val",
"Set.instMembership",
... | false |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | [
"FP.emin",
"HSub.hSub",
"Int",
"FP.FloatCfg",
"Nat.cast",
"instHSub",
"instOfNat",
"Eq.refl",
"Int.instSub",
"instNatCastInt",
"OfNat.ofNat",
"Eq",
"FP.FloatCfg.emax"
] | true |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | [
"MonoidWithZeroHom.funLike",
"MonoidWithZeroHom.monoidWithZeroHomClass",
"CommMonoidWithZero.toMonoidWithZero",
"MulZeroOneClass",
"MonoidWithZeroHomClass.toMonoidHomClass",
"MulZeroOneClass.toMulOneClass",
"MulOneClass.toMulOne",
"MonoidWithZeroHom",
"MonoidWithZero.toMulZeroOneClass",
"CommMonoi... | false |
IsRelUpperSet.iInter | Mathlib.Order.UpperLower.Relative | [
"Iff.mpr",
"Set.forall_mem_range",
"Set.iInter",
"Membership.mem",
"IsRelUpperSet",
"IsRelUpperSet.sInter",
"LE",
"Set.range_nonempty",
"Nonempty",
"Set.range",
"Set.instMembership",
"Set"
] | true |
List.Sublist.below | Init.Data.List.Basic | [
"List.Sublist.below.cons_cons",
"List.Sublist.below.cons",
"List.Sublist.below.slnil",
"List",
"List.Sublist"
] | true |
_private.Plausible.Attr.0.initFn._@.Plausible.Attr.3035915354._hygCtx._hyg.2 | Plausible.Attr | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Unit",
"Nat",
"Lean.Name.mkStr2",
"OfNat.ofNat",
"Bool.false"
] | false |
SSet.Subcomplex.Pairing.RankFunction.w_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | [
"SSet.Subcomplex.toSSet",
"CategoryTheory.Category.assoc",
"SSet.Subcomplex.Pairing.RankFunction.sigmaHorn",
"Preorder.toLT",
"Opposite",
"Order.succ",
"SSet.Subcomplex.Pairing.RankFunction.b",
"SSet.Subcomplex.Pairing.RankFunction.filtration",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom... | true |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone.extend",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Limits.Cocone.pt",
"CategoryTheory.Category"
] | true |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | [
"WithTop.some",
"Function.Embedding",
"Eq.refl",
"Function.instFunLikeEmbedding",
"Eq",
"DFunLike.coe",
"Function.Embedding.coeWithTop",
"WithTop"
] | true |
AddMonoid.Coprod.swap_comp_inr | Mathlib.GroupTheory.Coprod.Basic | [
"AddMonoid.Coprod.inr",
"AddZeroClass.toAddZero",
"AddZeroClass",
"AddMonoid.Coprod.instAddZeroClass",
"AddMonoid.Coprod.swap",
"AddMonoid.Coprod.inl",
"AddMonoid.Coprod",
"AddMonoidHom",
"Eq",
"AddMonoidHom.comp",
"rfl"
] | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | [
"ComplexShape.embeddingUpIntLE",
"Nat.instOne",
"AddGroupWithOne.toAddMonoidWithOne",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.instAddCancelCommMonoid",
"ComplexShape.notMem_range_embeddingUpIntLE_iff",
"Ne",
"Int",
"Int.instLTInt",
"AddMonoidWithOne.toOne",
"Int.instRing",
"Nat",
"LT.... | false |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | [
"Set.ext",
"And.comm",
"SetRel",
"SetRel.inv",
"HasSubset.Subset",
"Prod.fst",
"SetRel.image",
"SetRel.preimage",
"Prod.swap",
"Prod",
"Eq",
"Prod.snd",
"hausdorffEntourage",
"Set.instHasSubset",
"Set"
] | true |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | [
"CategoryTheory.Functor.op",
"CategoryTheory.Over",
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda._proof_5",
"Trans.trans",
"Opposite",
"CategoryTheory.Limits.colim",
"CategoryTheory.Iso.... | true |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact.Basic | [
"mem_closure_iff_nhds_zero",
"Filter.instMembership",
"NormedCommRing.toNormedRing",
"AddGroup.toSubtractionMonoid",
"UniformSpace",
"Eq.mpr",
"TotallyBounded",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"Real.partialOrder",
"Real",
"CompleteSpace",
"SeminormedAddCommGroup"... | true |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | [
"Rat.instOfNat",
"Eq.mpr",
"Rat.inv_mul_cancel",
"False",
"Rat.instMul",
"HMul.hMul",
"congrArg",
"False.elim",
"Rat",
"_private.Init.Data.Rat.Lemmas.0.Rat.inv_eq_of_mul_eq_one._simp_1_2",
"eq_false_of_decide",
"Rat.mul_one",
"Eq.mp",
"_private.Init.Data.Rat.Lemmas.0.Rat.inv_eq_of_mul_eq_o... | true |
Nat.lt_irrefl | Init.Prelude | [
"Nat",
"LT.lt",
"instLTNat",
"Not",
"Nat.not_succ_le_self"
] | true |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | [
"Fin.val_add",
"Eq.mpr",
"Decidable.casesOn",
"NeZero.mk",
"Fin.instSub",
"congrArg",
"Fin.neg",
"instDecidableEqFin",
"Zero.ofOfNat0",
"HSub.hSub",
"Decidable",
"id",
"Fin.instOfNat",
"Nat.instMod",
"instHMod",
"instSubNat",
"instOfNatNat",
"Fin.ext",
"if_pos",
"Fin.val",
"F... | true |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | [
"NegZeroClass.toNeg",
"Nat.instMulZeroClass",
"CommRing",
"Semiring.toModule",
"CommSemiring.toSemiring",
"MvPolynomial.homogeneousSubmodule",
"AddMonoidAlgebra.addAddCommGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"Submodule.neg_mem",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoi... | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | [
"Lean.Name.isPrefixOf",
"Array",
"Lean.Name",
"Option",
"Array.find?"
] | true |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | [
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Sieve.generateSingleton",
"CategoryTheory.Sieve.arrows",
"CategoryTheory.instCategoryOver",
"CategoryTheory.Over.left",
"CategoryTheory.Presieve.category... | false |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.wrapped._proof_1._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | [
"PartialOrder.toPreorder",
"PartialOrder",
"MeasureTheory.Filtration",
"MeasurableSpace",
"MeasureTheory.Filtration.definition._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8",
"Eq",
"rfl"
] | false |
_private.Mathlib.NumberTheory.LSeries.Convergence.0.LSeriesSummable_of_abscissaOfAbsConv_lt_re._simp_1_2 | Mathlib.NumberTheory.LSeries.Convergence | [
"sInf_lt_iff",
"Preorder.toLT",
"PartialOrder.toPreorder",
"Membership.mem",
"Exists",
"CompleteLattice.toCompleteSemilatticeInf",
"And",
"LT.lt",
"propext",
"CompleteLinearOrder",
"CompleteLattice.toCompleteSemilatticeSup",
"CompleteSemilatticeInf.toInfSet",
"CompleteSemilatticeSup.toPartia... | false |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"IsField.toSemifield._proof_8",
"AddMonoid.toZero",
"Classical.propDecidable",
"dif_pos",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"dite",
"instDistribOfSemiring",
"IsField",
"AddMonoidWithOne.toOne",
"Distrib.toMul",
"Semiring",
"C... | false |
Lean.Elab.ConfigEval.instEvalExprOccurrences | Lean.Elab.ConfigEval.MetaInstances | [
"Lean.Expr.const",
"Option.some",
"Lean.Name.mkStr3",
"Lean.Elab.ConfigEval.instEvalExprOccurrences.evalExpr",
"Lean.Expr",
"Lean.Level",
"Lean.Elab.ConfigEval.EvalExpr.mk",
"Lean.Elab.ConfigEval.EvalExpr",
"Lean.Meta.Occurrences",
"List.nil"
] | true |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone._proof_1 | Mathlib.CategoryTheory.Monad.Limits | [
"CategoryTheory.Comonad",
"Eq.mpr",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.Limits.PreservesLimit",
"CategoryTheory.Comonad.forget",
"CategoryTheory.Comonad.Coalgebra.Hom.mk",
"CategoryTheory.Comonad.ForgetCreatesLimits'.conePoint",
"... | false |
SimpleGraph.not_isUniform_iff | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | [
"Rat.instSub",
"_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.not_isUniform_iff._simp_1_2",
"Preorder.toLT",
"HMul.hMul",
"DivisionRing.toRatCast",
"Iff.of_eq",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"SimpleGraph.edgeDensity",
"Finset",
"LinearOrder",
... | true |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | [
"Std.TreeMap.inner",
"Ordering",
"Std.DTreeMap.foldl",
"Std.TreeMap"
] | true |
CategoryTheory.RetractArrow.unop_i | Mathlib.CategoryTheory.Retract | [
"CategoryTheory.RetractArrow.unop",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Arrow.Hom.right",
"Quiver.Hom.unop",
"CategoryTheory.Arrow.left",
"CategoryTheory.Retract.i",
"CategoryTheory.instCategoryArrow",
"CategoryTheory.RetractArro... | true |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | [
"Lean.Meta.Grind.GrindM",
"Lean.Meta.Grind.Goal",
"Lean.Meta.Grind.State",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"Lean.Meta.Sym.Context",
"ReaderT.instMonad",
"Lean.Meta.Grind.Context",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.Meta.Grind.add",
"Lean.FVarId",
"liftM... | true |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | [
"Nat.instMod",
"instHMod",
"Nat.mod_eq_of_lt",
"HMod.hMod",
"Nat.ModEq",
"Nat",
"LT.lt",
"instLTNat",
"Eq",
"Eq.trans"
] | true |
NonemptyInterval.mem_def | Mathlib.Order.Interval.Basic | [
"Iff.rfl",
"Preorder.toLE",
"Membership.mem",
"LE.le",
"Prod.fst",
"And",
"Iff",
"NonemptyInterval.instMembership",
"NonemptyInterval.toProd",
"Prod.snd",
"Preorder",
"NonemptyInterval"
] | true |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | [
"Dvd.dvd",
"HMul.hMul",
"Nat.decidable_dvd",
"InvImage",
"HSub.hSub",
"Nat.minFacAux._proof_1",
"WellFounded.Nat.fix",
"instSubNat",
"instMulNat",
"Nat.sqrt",
"instOfNatNat",
"dite",
"instHAdd",
"instHSub",
"Nat.instDvd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Nat.decLt",
"instAddNat",
... | true |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | [
"CategoryTheory.Limits.WalkingParallelFamily.one",
"PULift.up",
"CategoryTheory.Limits.WalkingParallelFamily",
"Nat",
"CategoryTheory.Limits.WalkingParallelFamily.ctorIdx",
"CategoryTheory.Limits.WalkingParallelFamily.ctorElim",
"Eq.symm",
"Eq"
] | false |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"AddMonoidAlgebra.semiring",
"Real",
"Algebra.to_smulCommClass",
"Continuous",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Equiv.instEquivLike",
"IsTopologicalRing.toIsTopologicalSemiring",
"MonoidHo... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"beqOfOrd",
"Ordering",
"Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false",
"Ordering.eq",
"Ne",
"Ord.compare",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"Eq"
] | false |
_private.Mathlib.Data.List.Sort.0.List.orderedInsert.match_1.eq_2 | Mathlib.Data.List.Sort | [
"_private.Mathlib.Data.List.Sort.0.List.orderedInsert.match_1",
"List.cons",
"List",
"Unit",
"Eq.refl",
"Eq",
"List.nil"
] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"Membership.mem",
"Bool.true",
"Std.DTreeMap.Internal.Impl.contains",
"propext",
"Bool",
"Std.DTreeMap.Internal.Impl.mem_iff_contains",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Std.DTreeMap.Internal.Impl.instMembershipOfOrd"
] | false |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | [
"le_refl",
"sup_le_sup",
"le_sup_left",
"ClosureOperator.le_closure_iff",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeSup.toMax",
"ClosureOperator.le_closure",
"le_sup_right",
"ClosureOperator.instFunLike",
"LE.le",
"ClosureOperator",
"le_imp_le_of_le_of_le",
"le_antisymm",
"... | true |
Ordnode.findLeAux._f | Mathlib.Data.Ordmap.Ordnode | [
"Ordnode.below",
"Ordnode",
"Ordering",
"Ordnode.mem.match_1",
"cmpLE",
"Ordnode.node",
"LE",
"DecidableLE",
"Unit",
"Nat",
"Ordnode.nil",
"Ordnode.findMin'.match_1"
] | false |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | [
"Lean.instBEqFVarId",
"Aesop.ForwardRuleMatches.unsafeMatches",
"Std.HashSet",
"Lean.FVarId",
"Aesop.ForwardRuleMatches.normMatches",
"Aesop.ForwardRuleMatches.safeMatches",
"Lean.instHashableFVarId",
"_private.Aesop.Tree.Data.ForwardRuleMatches.0.Aesop.ForwardRuleMatches.eraseHyps.go",
"Aesop.Forwa... | true |
List.IsSuffix.isInfix | Init.Data.List.Sublist | [
"Eq.mpr",
"congrArg",
"_private.Init.Data.List.Sublist.0.List.IsSuffix.isInfix.match_1_1",
"Exists",
"id",
"List.append_nil",
"List.IsInfix",
"instHAppendOfAppend",
"List",
"Exists.intro",
"List.IsSuffix",
"Eq.refl",
"List.instAppend",
"Eq",
"HAppend.hAppend",
"List.nil"
] | true |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ofNat_dvd.match_1_3 | Init.Data.Int.DivMod.Bootstrap | [
"Dvd.dvd",
"HMul.hMul",
"instMulNat",
"Exists.casesOn",
"Nat.instDvd",
"Nat",
"Exists.intro",
"Eq",
"instHMul"
] | false |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | [
"Submodule.module._proof_1",
"instSMulOfMul",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"IsScalarTower",
"MulOne.toMul",
"AddCommMonoid",
"CommSemiring",
"MulOneClass.toMulOne",
"Semiring.toMonoid",
"Monoid.toSemigroup",
"Module.toDistribMulAction",
"SemigroupAction.toSMul",
"AddC... | false |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | [
"instOfNatNat",
"FP.FloatCfg",
"LE.le",
"instLENat",
"Nat",
"LT.lt",
"instLTNat",
"FP.FloatCfg.mk",
"OfNat.ofNat"
] | true |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | [
"CategoryTheory.Comonad",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Cokleisli.category",
"CategoryTheory.Cokleisli.Hom.of",
"CategoryTheory.Comonad.δ",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.map",
"CategoryTheory.Comonad.toFunctor",
"CategoryTheory.Cat... | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.sub_mul_div_of_le.match_1_1 | Init.Data.Nat.Div.Basic | [
"instOfNatNat",
"Or.casesOn",
"GT.gt",
"Nat",
"Or.inl",
"Or",
"instLTNat",
"OfNat.ofNat",
"Eq",
"Or.inr"
] | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.uniq | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.Subobject.arrow",
"CategoryTheory.Subobject.underlying",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.IsPullback",
"PartialOrder.toPreorder",
"CategoryTheory.SubobjectRepresentableBy",
"Preorder.smallCategory",
"CategoryTheory.instP... | true |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | [
"MulOpposite",
"Function.Injective.eq_iff'",
"Bot.bot",
"Iff",
"Submonoid.unop_bot",
"Submonoid.unop_injective",
"MulOpposite.instMulOneClass",
"MulOneClass",
"Eq",
"Submonoid.unop",
"Submonoid.instBot",
"Submonoid"
] | true |
Std.ExtTreeMap.get!_eq_getElem! | Std.Data.ExtTreeMap.Lemmas | [
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtTreeMap.get!",
"Inhabited",
"Std.ExtTreeMap.instGetElem?Mem",
"Std.ExtTreeMap.instMembershipOfTransCmp",
"Eq",
"GetElem?.getElem!",
"rfl"
] | true |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | [
"Nat",
"Lean.MetavarContext.MkBindingM.Context"
] | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"Set.ext",
"False",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Set.univ",
"Classical.byContradiction",
"Classical.propDecidable",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"Lean.Grind.forall_imp... | false |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | [
"instHSMul",
"RelIso.ext",
"DivInvMonoid.toMonoid",
"FaithfulSMul",
"Group.toDivInvMonoid",
"RelIso",
"FaithfulSMul.mk",
"RelIso.applyMulAction",
"Monoid.toSemigroup",
"HSMul.hSMul",
"SemigroupAction.toSMul",
"RelIso.instGroup",
"MulAction.toSemigroupAction",
"Eq"
] | true |
ClusterPt | Mathlib.Topology.Defs.Filter | [
"Filter.NeBot",
"nhds",
"Filter.instInf",
"TopologicalSpace",
"Filter",
"Min.min"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.