name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
StarAlgHom.toNonUnitalStarAlgHom._proof_1 | Mathlib.Algebra.Star.StarAlgHom | [
"instHSMul",
"SemilinearMapClass.toMulActionSemiHomClass",
"NonUnitalAlgHomClass.instLinearMapClass",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"Algebra",
"AddZeroClass.toAddZero",
"StarAlgHom.instFunLike",
"Algebra.toModule",
"DistribSMul.toSMulZer... | false |
Set.Nontrivial.preimage | Mathlib.Data.Set.Image | [
"Membership.mem",
"Exists",
"mt",
"Ne",
"And.casesOn",
"congr_arg",
"And",
"Exists.casesOn",
"Set.preimage",
"And.intro",
"Exists.intro",
"Eq.ndrec",
"Set.Nontrivial",
"Eq",
"Set.instMembership",
"Function.Surjective",
"Set"
] | true |
tsub_tsub_le_tsub_add | Mathlib.Algebra.Order.Sub.Defs | [
"Iff.mpr",
"le_refl",
"Trans.trans",
"add_assoc",
"HSub.hSub",
"AddLeftMono",
"Preorder.toLE",
"OrderedSub",
"add_le_add_right",
"LE.le",
"AddCommSemigroup.toAddSemigroup",
"tsub_le_iff_right",
"le_imp_le_of_le_of_le",
"instHAdd",
"AddSemigroup.toAdd",
"instHSub",
"HAdd.hAdd",
"ins... | true |
ProofWidgets.Jsx.proofWidgetsJsxAttrVal_ | ProofWidgets.Data.Html | [
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.const",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
CategoryTheory.Limits.Types.instHasImageMapsType | Mathlib.CategoryTheory.Limits.Types.Images | [
"CategoryTheory.Limits.MonoFactorisation.I",
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Arrow.Hom.right",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Limits.Types.instHasImagesType",
"TypeCat.instFunLikeFun",
"Membership.mem",
"Catego... | true |
Std.TreeMap.instEmptyCollection | Std.Data.TreeMap.Basic | [
"Ordering",
"EmptyCollection.mk",
"Std.TreeMap.empty",
"EmptyCollection",
"Std.TreeMap"
] | true |
div_div_div_cancel_left | Mathlib.Algebra.Group.Basic | [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"CommMonoid.toCommSemigroup",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"DivisionMonoid.toDivInvOneMonoid",
"id",
"MulOne.toMul",
"HDiv.hDiv",
"DivInvMonoid.toMonoid",... | true |
Lean.IR.LocalContextEntry.param.injEq | Lean.Compiler.IR.Basic | [
"Eq.propIntro",
"Lean.IR.LocalContextEntry",
"Lean.IR.IRType",
"Eq.ndrec",
"Eq.refl",
"Lean.IR.LocalContextEntry.param",
"Eq",
"Lean.IR.LocalContextEntry.param.inj"
] | true |
Std.Iter.Equiv.foldM_eq | Std.Data.Iterators.Lemmas.Consumers.Loop | [
"Std.Iter.foldM_eq_forIn",
"congrArg",
"Monad.toApplicative",
"Std.Iter.foldM",
"Std.IteratorLoop",
"Std.Iterators.Finite",
"LawfulMonad",
"ForIn.forIn",
"Id",
"ForInStep",
"Std.Iterator",
"Std.Iter",
"congr",
"Std.Iter.Equiv",
"True",
"Std.LawfulIteratorLoop",
"eq_self",
"Std.inst... | true |
Matrix.updateRow_subsingleton | Mathlib.LinearAlgebra.Matrix.RowCol | [
"Matrix.submatrix",
"congrArg",
"Matrix",
"id",
"Fin.instOfNat",
"instOfNatNat",
"decidableEq_of_subsingleton",
"Nat.instNeZeroSucc",
"congrFun",
"Nat",
"Matrix.updateRow.congr_simp",
"True",
"eq_self",
"Function.const",
"of_eq_true",
"Subsingleton",
"Eq.refl",
"Matrix.replicateRow... | true |
IsAddRegular.nsmul | Mathlib.Algebra.Regular.Basic | [
"instHSMul",
"IsAddRegular.mk",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"IsAddRegular.right",
"IsAddRightRegular.nsmul",
"Nat",
"IsAddRegular",
"IsAddLeftRegular.nsmul",
"AddMonoid",
"AddZero.toAdd",
"HSMul.hSMul",
"IsAddRegular.left"
] | true |
LocallyConstant.coe_inv | Mathlib.Topology.LocallyConstant.Algebra | [
"Inv",
"Pi.instInv",
"LocallyConstant.instInv",
"LocallyConstant",
"TopologicalSpace",
"Inv.inv",
"LocallyConstant.instFunLike",
"Eq",
"DFunLike.coe",
"rfl"
] | true |
DoubleCentralizer.instCStarAlgebraComplex | Mathlib.Analysis.CStarAlgebra.Multiplier | [
"DoubleCentralizer.instCStarAlgebraComplex._proof_2",
"NonUnitalCStarAlgebra.toStarModule",
"NonUnitalCStarAlgebra.toNonUnitalNormedRing",
"DoubleCentralizer.instCStarAlgebraComplex._proof_1",
"Complex.instDenselyNormedField",
"CStarAlgebra.mk",
"DoubleCentralizer.instCStarAlgebraComplex._proof_6",
"N... | true |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.not_tendsto_iff_exists_frequently_notMem._simp_1_2 | Mathlib.Order.Filter.Tendsto | [
"Exists",
"propext",
"Classical.not_forall",
"Eq",
"Not"
] | false |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.gluedCocone._simp_1 | Mathlib.AlgebraicGeometry.ColimitsOver | [
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq.symm",
"Eq",
"CategoryTheory.Category"
] | false |
_private.Batteries.Data.List.Lemmas.0.List.countBefore_cons_succ_of_not_beq._proof_1_1 | Batteries.Data.List.Lemmas | [
"False",
"of_decide_eq_true",
"eq_false",
"congrArg",
"Classical.byContradiction",
"HSub.hSub",
"Lean.Grind.Bool.ne_of_eq_false_of_eq_true",
"Eq.mp",
"id",
"instDecidableEqBool",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"List.countBefore_cons",
"List.cons",
"Nat.Simproc.ad... | false |
TrivSqZeroExt.instL1SeminormedRing.match_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | [
"TrivSqZeroExt",
"Prod.mk",
"Prod.casesOn"
] | false |
CategoryTheory.MonadicRightAdjoint.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Adjunction | [
"CategoryTheory.Functor",
"CategoryTheory.Monad.comparison",
"CategoryTheory.MonadicRightAdjoint.mk",
"CategoryTheory.MonadicRightAdjoint",
"CategoryTheory.Adjunction",
"CategoryTheory.Functor.IsEquivalence",
"CategoryTheory.Adjunction.toMonad",
"CategoryTheory.Monad.Algebra.eilenbergMoore",
"Catego... | false |
Std.Do.SPred.bientails.of_eq | Std.Do.SPred.DerivedLaws | [
"Eq.rec",
"Std.Do.SPred.bientails",
"List",
"Std.Do.SPred",
"Eq",
"Std.Do.SPred.bientails.rfl"
] | true |
MeasureTheory.predictablePart_add_ae_eq | Mathlib.Probability.Martingale.Centering | [
"MeasureTheory.ae",
"Eq.mpr",
"Real",
"MeasureTheory.Measure",
"CompleteSpace",
"MeasureTheory.SigmaFiniteFiltration",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"NormedSpace",
"MeasureTheory.martingalePart",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"MeasureTheory.Martingale",
"setOf",
... | true |
Nat.exists_eq_add_one._simp_1 | Init.Data.Nat.Lemmas | [
"Exists",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"propext",
"instAddNat",
"Nat.exists_eq_add_one",
"instLTNat",
"OfNat.ofNat",
"Eq"
] | false |
Lean.Meta.Grind.AC.EqCnstrProof.erase0.injEq | Lean.Meta.Tactic.Grind.AC.Types | [
"Lean.Meta.Grind.AC.EqCnstr",
"Eq.propIntro",
"Lean.Meta.Grind.AC.EqCnstrProof.erase0.inj",
"Lean.Meta.Grind.AC.EqCnstrProof",
"Eq.ndrec",
"Eq.refl",
"Lean.Meta.Grind.AC.EqCnstrProof.erase0",
"Eq"
] | true |
Std.AnyAsyncStream.casesOn | Std.Sync.StreamMap | [
"Std.AnyAsyncStream.rec",
"Std.AnyAsyncStream.mk",
"Std.AnyAsyncStream",
"Std.Internal.Async.IO.AsyncStream"
] | false |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.«_aux_Std_Data_DHashMap_Internal_RawLemmas___macroRules_Std_DHashMap_Internal_Raw₀_tacticSimp_to_model[_]Using__1»._sparseCasesOn_1 | Std.Data.DHashMap.Internal.RawLemmas | [
"Nat.ne_of_beq_eq_false",
"Option.ctorIdx",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"Option.rec",
"instOfNatNat",
"Nat.land",
"Option.none",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false",
"Option"
] | false |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.addMatchCondsToSplitter._sunfold | Lean.Meta.Tactic.Grind.CasesMatch | [
"Pure.pure",
"_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.isMatchCondCandidate.go.match_1",
"Monad.toApplicative",
"HSub.hSub",
"Lean.Expr.updateForallE!",
"_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.addMatchCondsToAlt",
"Lean.Expr",
"instDecidableEqBool",
"instSub... | false |
DividedPowers.ideal_from_ringHom._proof_1 | Mathlib.RingTheory.DividedPowers.DPMorphism | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"RingHomClass.toAddMonoidHomClass",
"Semiring.toModule",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.mem_map_of_mem",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"setOf",
"Preorder.toLE... | false |
CategoryTheory.Limits.colimitIsoSwapCompColim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | [
"CategoryTheory.Functor.flip",
"CategoryTheory.Functor",
"CategoryTheory.Limits.hasColimitOfHasColimitsOfShape",
"CategoryTheory.Limits.HasColimitsOfShape",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.colim",
"CategoryTheory.Functor.category",
"CategoryTheory.Funct... | true |
Array.mem_map | Init.Data.Array.Lemmas | [
"congrArg",
"List.map",
"Array.instMembership",
"Membership.mem",
"Exists",
"Array.map",
"Array.toList",
"Array",
"iff_self",
"funext",
"List",
"And",
"Iff",
"List.instMembership",
"congr",
"True",
"of_eq_true",
"Array.toList_map",
"_private.Init.Data.Array.Lemmas.0.Array.mem_map... | true |
Action.actionPUnitEquivalence | Mathlib.CategoryTheory.Action.Basic | [
"Action.actionPUnitEquivalence._proof_2",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"Action.actionPUnitEquivalence._proof_8",
"Action.mkIso",
"CategoryTheory.Functor.mk",
"PUnit.commRing",
"Action.Hom.mk",
"Action.ac... | true |
Lean.Parser.Term.logNamedWarningAtMacro.parenthesizer | Lean.Parser.Term | [
"Lean.Parser.withCache.parenthesizer",
"Lean.Parser.mkAntiquot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer",
"instOfNatNat",
"Lean.Parser.identWithPartialTrailingDot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.leadingNode.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.andthen.parenthesize... | true |
CategoryTheory.WithTerminal.liftStar_inv | Mathlib.CategoryTheory.WithTerminal.Basic | [
"CategoryTheory.WithTerminal.lift",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.WithTerminal",
"CategoryTheory.Functor.map",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.WithTerminal.star",
"Eq.refl"... | true |
StalkSkyscraperPresheafAdjunctionAuxs.counit_app | Mathlib.Topology.Sheaves.Skyscraper | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopCat.instCategoryPresheaf",
"Decidable",
"CategoryTheory.Functor.comp",
"TopologicalSpace.Opens",
"Membership.mem",
"CategoryTheory.Functor.id",
"TopCat.Presheaf",
"skyscraperPresheafStalkOfSpecializes",
"TopCat.Presheaf.stalk",
"skysc... | true |
Aesop.EqualUpToIds.Unsafe.localDeclsEqualUpToIdsCore | Aesop.Util.EqualUpToIds | [
"Pure.pure",
"Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₁",
"ReaderT",
"_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.localDeclsEqualUpToIdsCore.match_1",
"Lean.LocalDeclKind",
"ReaderT.instMonad",
"Lean.instBEqBinderInfo",
"Bool.and",
"Lean.LocalDecl.value",
"Applicative.toPur... | true |
ZeroAtInftyContinuousMap.instStar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | [
"ContinuousMap.mk",
"ContinuousStar",
"AddMonoid.toAddZeroClass",
"ZeroAtInftyContinuousMap.instStar._proof_2",
"AddZeroClass.toAddZero",
"ZeroAtInftyContinuousMap.instFunLike",
"StarAddMonoid.toInvolutiveStar",
"ZeroAtInftyContinuousMap.instStar._proof_1",
"TopologicalSpace",
"AddZero.toZero",
... | true |
Fin.lt_of_lt_of_le | Init.Data.Fin.Lemmas | [
"LE.le",
"Fin.val",
"instLEFin",
"Nat",
"LT.lt",
"instLTFin",
"Fin",
"Nat.lt_of_lt_of_le"
] | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_leftAdjointMate_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
Std.Time.Weekday.instTransOrdOrdinal | Std.Time.Date.Unit.Weekday | [
"Std.TransOrd",
"_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.instTransOrdOrdinal._proof_1",
"Std.Time.Weekday.instOrdOrdinal",
"Std.Time.Weekday.Ordinal"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise.0.Finpartition.equitabilise_aux._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | [
"And",
"and_assoc",
"propext",
"Eq"
] | false |
FormalMultilinearSeries.compContinuousLinearMap_apply | Mathlib.Analysis.Calculus.FormalMultilinearSeries | [
"FormalMultilinearSeries",
"DistribMulAction.toDistribSMul",
"ContinuousLinearMap.funLike",
"AddMonoid.toAddZeroClass",
"FormalMultilinearSeries.compContinuousLinearMap",
"ContinuousMultilinearMap",
"Function.comp",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"ContinuousMultilinearMap... | true |
Lean.Compiler.LCNF.SpecState.mk.injEq | Lean.Compiler.LCNF.SpecInfo | [
"Lean.Compiler.LCNF.SpecState",
"Eq.propIntro",
"Lean.PHashMap",
"Lean.Compiler.LCNF.SpecState.mk",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Compiler.LCNF.SpecState.mk.inj",
"Eq",
"Lean.Name.instBEq",
"Lean.Compiler.LCNF.SpecEntry",
"Lean.instHashableName"
] | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.relativeGluingData._proof_1 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | [
"CategoryTheory.Functor.op",
"CategoryTheory.Over",
"AlgebraicGeometry.Spec.reflective",
"CategoryTheory.Functor",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.Scheme.AffineZariskiSite",
"Opposite",
"CategoryTheory.NatTrans.Equif... | false |
LocallyConstant.instAddCommGroup._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | [
"AddCommGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"LocallyConstant",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"TopologicalSpace",
"LocallyConstant.instZero",
"Zero.toOfNat0",
"LocallyConstant.instFunLike",
"AddCommGroup.toDivisionAddCommMonoid",
"OfNa... | false |
AddSubgroup.IsSubnormal.brecOn | Mathlib.GroupTheory.IsSubnormal | [
"AddSubgroup.IsSubnormal.below.step",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"AddSubgroup.IsSubnormal",
"Preorder.toLE",
"AddSubgroup.toAddGroup",
"Membership.mem",
"AddSubgroup.IsSubnormal.below",
"Subtype",
"LE.le",
"AddSubgroup",
"AddSubgroup.Normal",
"AddSubgroup.IsSu... | true |
CategoryTheory.Limits.WalkingSpan.Hom.snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | [
"CategoryTheory.Limits.WalkingSpan",
"CategoryTheory.Limits.WidePushoutShape.struct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WidePushoutShape.Hom.init",
"CategoryTheory.Limits.WalkingPair.right",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.Limits.Walkin... | true |
FiniteField.frobeniusAlgEquiv_symm_apply | Mathlib.FieldTheory.Finite.Basic | [
"PerfectRing",
"CommRing",
"AlgEquiv.symm",
"CommSemiring.toSemiring",
"AlgHom",
"AlgEquiv.ofBijective._proof_2",
"AlgHom.funLike",
"AddGroupWithOne.toAddMonoidWithOne",
"Algebra",
"RingHom",
"ExpChar",
"Function.surjInv",
"Field.toSemifield",
"Monoid.toPow",
"CommRing.toCommSemiring",
... | true |
Lean.Meta.SolveByElim.initFn._@.Lean.Meta.Tactic.SolveByElim.1979843508._hygCtx._hyg.2 | Lean.Meta.Tactic.SolveByElim | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr3",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Unit",
"Nat",
"OfNat.ofNat",
"Bool.false"
] | false |
ProfiniteGrp.limit | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | [
"CategoryTheory.Functor",
"ProfiniteGrp.limitConePtAux",
"Pi.topologicalSpace",
"ProfiniteGrp.limit._proof_1",
"ProfiniteGrp.limit._proof_2",
"ProfiniteGrp.group",
"ProfiniteGrp.of",
"Membership.mem",
"ProfiniteGrp",
"Subtype",
"Pi.group",
"Subgroup",
"CategoryTheory.SmallCategory",
"Total... | true |
AddMonoidAlgebra.single_commute_single | Mathlib.Algebra.MonoidAlgebra.Defs | [
"HMul.hMul",
"congrArg",
"Commute",
"AddCommute",
"instDistribOfSemiring",
"AddMonoidAlgebra.instMul",
"instHAdd",
"AddMonoidAlgebra.single_mul_single",
"Distrib.toMul",
"HAdd.hAdd",
"congr",
"AddCommute.eq",
"True",
"eq_self",
"of_eq_true",
"Semiring",
"AddMonoidAlgebra",
"AddMono... | true |
Ordinal.veblen_zero_le_veblen_zero._simp_1 | Mathlib.SetTheory.Ordinal.Veblen | [
"Ordinal.veblen",
"Ordinal.partialOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"Ordinal.veblen_zero_le_veblen_zero",
"Ordinal.zero",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Ordinal"
] | false |
_private.Mathlib.Tactic.Linter.DocString.0.Mathlib.Linter.lintVersoSyntax | Mathlib.Tactic.Linter.DocString | [
"Pure.pure",
"String.toSlice",
"String.Slice.Subslice",
"Bool.not",
"String.Slice.Pattern.CharPred.instToForwardSearcherForallCharBoolDefaultForwardSearcher",
"String.Slice.Subslice.toSlice",
"Monad.toApplicative",
"String",
"Std.Iterators.Types.Map.instIterator",
"MonadLiftT.monadLift",
"instMo... | true |
CategoryTheory.Limits.BinaryBicone.isBilimitOfKernelInl._proof_3 | Mathlib.CategoryTheory.Preadditive.Biproducts | [
"CategoryTheory.Limits.BinaryBicone.fst",
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.BinaryBicone.inl_fst",
"CategoryTheory.Limits.BinaryBicone.toCone",
"CategoryTheory.Limits.BinaryFan.fst",
"CategoryTheory.Limits.BinaryBicone.inr_sn... | false |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux.match_3 | Mathlib.Tactic.TermCongr | [
"_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux._sparseCasesOn_4",
"Lean.Expr.letE",
"_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux._sparseCasesOn_5",
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Expr.mdata",
"Lean.Expr.forallE",
"Lean.MData",
"Lean.Expr... | false |
Submodule.IsCompl.projection_apply_left | Mathlib.LinearAlgebra.Projection | [
"Submodule",
"Submodule.projection",
"AddCommGroup.toAddCommMonoid",
"Submodule.completeLattice",
"LinearMap.instFunLike",
"Membership.mem",
"CompleteLattice.toBoundedOrder",
"AddCommGroup",
"Subtype",
"Submodule.instPartialOrder",
"Submodule.projection_apply_left",
"LinearMap",
"IsCompl",
... | true |
_private.Mathlib.Order.LiminfLimsup.0.Filter.HasBasis.liminf_eq_ciSup_ciInf._simp_1_4 | Mathlib.Order.LiminfLimsup | [
"HasSubset.Subset",
"True",
"Set.empty_subset",
"eq_true",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
AntivaryOn.neg_right | Mathlib.Algebra.Order.Monovary | [
"Iff.mpr",
"NegZeroClass.toNeg",
"Pi.instNeg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"PartialOrder",
"AddCommGroup",
"MonovaryOn",
"SubtractionMonoid.toSubNegZeroMonoid",
"AntivaryOn",
"monovaryOn_neg_right",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSu... | true |
Finsupp.mem_supported | Mathlib.LinearAlgebra.Finsupp.Supported | [
"Submodule",
"Finsupp.module",
"Finset",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"Finsupp.supported",
"Finsupp.support",
"Membership.mem",
"AddZeroClass.toAddZero",
"HasSubset.Subset",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"AddZero.toZero",
"Iff",
"SetLike.coe",
"Finset.instSetL... | true |
ContinuousLinearMap.piEquivL._proof_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | [
"Pi.addGroup",
"Pi.topologicalSpace",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"TopologicalSpace",
"Pi.topologicalAddGroup",
"IsTopologicalAddGroup"
] | false |
Equiv.Perm.OnCycleFactors.coe_toPermHom | Mathlib.GroupTheory.Perm.Centralizer | [
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"HMul.hMul",
"Equiv.Perm.instInv",
"MonoidHom",
"Monoid.toMulOneClass",
"Finset",
"Subgroup.centralizer",
"Equiv.Perm.cycleFactorsFinset",
"Membership.mem",
"Set.instSingletonSet",
"Subtype",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDi... | true |
Lean.Order.MonoBind.mk._flat_ctor | Init.Internal.Order.Basic | [
"Lean.Order.PartialOrder.rel",
"Lean.Order.PartialOrder",
"Bind.bind",
"Lean.Order.MonoBind.mk",
"Bind",
"Lean.Order.MonoBind"
] | false |
Lean.Exception.casesOn | Lean.Exception | [
"Lean.MessageData",
"Lean.Exception.internal",
"Lean.Exception.error",
"Lean.Syntax",
"Lean.Exception.rec",
"Lean.InternalExceptionId",
"Lean.KVMap",
"Lean.Exception"
] | false |
OrderIso.sumLexAssoc_symm_apply_inl | Mathlib.Data.Sum.Order | [
"OrderIso.sumLexAssoc",
"Sum.Lex.LE",
"Lex",
"Sum",
"OrderIso",
"Sum.inl",
"OrderIso.symm",
"LE",
"instFunLikeOrderIso",
"Eq",
"DFunLike.coe",
"rfl"
] | true |
_private.Mathlib.MeasureTheory.Function.L1Space.Integrable.0.MeasureTheory.Integrable.real_toNNReal._simp_1_1 | Mathlib.MeasureTheory.Function.L1Space.Integrable | [
"NegZeroClass.toNeg",
"abs",
"AddCommGroup.toAddCommMonoid",
"abs_le",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddCommGroup",
"DistribLattice.toLattice",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNeg... | false |
Matroid.delete_eq_delete_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | [
"Eq.mpr",
"Matroid.delete_inter_ground_eq",
"congrArg",
"Matroid.E",
"HEq.refl",
"Eq.mp",
"Eq.casesOn",
"id",
"Set.instInter",
"Inter.inter",
"SDiff.sdiff",
"Iff",
"congr",
"Iff.intro",
"Set.diff_diff_cancel_left",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"SDiff",
"Eq.symm"... | true |
BialgCat.hasForgetToCoalgebra._proof_3 | Mathlib.Algebra.Category.BialgCat.Basic | [
"BialgCat.instBialgebra",
"CommRing",
"Coalgebra.toCoalgebraStruct",
"BialgCat",
"Bialgebra.toCoalgebra",
"BialgHom.funLike",
"Algebra.toModule",
"BialgHom",
"BialgHom.bialgHomClass",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"CoalgHomClass",
"CommRing.toCommSemiring",
"BialgCat.instRing"... | false |
Module.support | Mathlib.RingTheory.Support | [
"Nontrivial",
"CommRing",
"LocalizedModule",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"setOf",
"AddCommGroup",
"Module.support._proof_1",
"CommRing.toCommSemiring",
"PrimeSpectrum",
"Ideal.primeCompl",
"Module",
"PrimeSpectrum.asIdeal",
"Set"
] | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux._proof_2 | Mathlib.RingTheory.AdicCompletion.Exactness | [
"Function.Exact",
"Submodule",
"Exists.choose_spec",
"CommRing",
"instHSMul",
"Semiring.toModule",
"IsScalarTower.right",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"AddCommGroup"... | false |
SlashInvariantForm.quotientFunc | Mathlib.NumberTheory.ModularForms.NormTrace | [
"Real",
"Subgroup.subgroupOf",
"Matrix",
"instDecidableEqFin",
"AddGroupWithOne.toAddMonoidWithOne",
"Membership.mem",
"QuotientGroup.leftRel",
"Real.semiring",
"Complex.addGroupWithOne",
"SlashInvariantFormClass",
"Subtype",
"QuotientGroup.instHasQuotientSubgroup",
"Subgroup",
"instOfNatN... | true |
Lean.Server.Watchdog.ReferenceData.mk | Lean.Server.Watchdog | [
"Ord.compare",
"Array",
"Lean.Lsp.DocumentUri",
"Unit",
"Lean.Server.ServerTask",
"Nat",
"Lean.Server.Watchdog.ReferenceData.mk",
"String.instOrd",
"Lean.Server.Watchdog.ReferenceData",
"Std.TreeMap",
"Lean.Server.Watchdog.WaitForILeanRequest",
"Lean.Server.References"
] | true |
Lean.Elab.InlayHintTextEdit.toLspTextEdit | Lean.Server.FileWorker.InlayHints | [
"Lean.FileMap.utf8RangeToLspRange",
"String",
"Lean.FileMap",
"Lean.Elab.InlayHintTextEdit",
"Lean.Lsp.SnippetString",
"Lean.Elab.InlayHintTextEdit.newText",
"Lean.Lsp.TextEdit.mk",
"Lean.Elab.InlayHintTextEdit.range",
"Lean.Lsp.TextEdit",
"Option.none"
] | true |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor_obj_left_left_as | Mathlib.CategoryTheory.GuitartExact.Opposite | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Comma.left",
"Quiver.Hom.unop",
"CategoryTheory.TwoSquare.StructuredArrowRightwards",
"CategoryTheory.CostructuredArrow",
"CategoryTheory.... | true |
FiniteGaloisIntermediateField.instOrderBot._proof_1 | Mathlib.FieldTheory.Galois.GaloisClosure | [
"IntermediateField.instPartialOrder",
"IntermediateField",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Algebra",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"Bot.bot",
"LE.le",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"BoundedOrder.toOrderBot",
"DivisionSemiring.toSemiri... | false |
LaurentPolynomial.toLaurent_support | Mathlib.Algebra.Polynomial.Laurent | [
"LaurentPolynomial.T",
"Polynomial.toLaurent_eq_zero",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"AddMonoidAlgebra.semiring",
"Finset.insert_eq",
"RingHomClass.toAddMonoidHomClass",
"Semiring.toModule",
"HMul.hMul",
"Finset.instUnion",
"congrArg",
"Poly... | true |
_private.Mathlib.RingTheory.MvPowerSeries.GaussNorm.0.MvPowerSeries.gaussNorm_add_le_max._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.GaussNorm | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeSup.toMax",
"sup_eq_left",
"LE.le",
"Max.max",
"propext",
"SemilatticeSup.toPartialOrder",
"Eq",
"SemilatticeSup"
] | false |
Vector.lt_of_le_of_lt' | Init.Data.Vector.Lex | [
"Vector",
"Std.IsLinearOrder.of_lt",
"inferInstance",
"Std.Trichotomous",
"Std.LawfulOrderLT.of_lt",
"LE.le",
"Trans",
"Std.Asymm",
"Vector.instLE",
"Nat",
"Array.lt_of_le_of_lt",
"LT.lt",
"Not",
"Vector.toArray",
"LE.ofLT",
"LT",
"Vector.instLT"
] | true |
GenContFract.exists_conts_a_of_num | Mathlib.Algebra.ContinuedFractions.Translations | [
"Eq.mpr",
"GenContFract.Pair.a",
"congrArg",
"Exists",
"Eq.mp",
"id",
"GenContFract.conts",
"GenContFract",
"GenContFract.Pair",
"And",
"GenContFract.nums",
"And.right",
"And.left",
"Nat",
"And.intro",
"True",
"Iff.intro",
"eq_self",
"propext",
"Exists.intro",
"DivisionRing",... | true |
Affine.Triangle.equilateral_iff_dist_01_eq_02_and_dist_01_eq_12 | Mathlib.Analysis.Normed.Affine.Simplex | [
"instDecidableNot",
"instNeZeroNatHAdd_1",
"Affine.Simplex.points",
"Real",
"SeminormedAddCommGroup",
"of_decide_eq_true",
"AddCommGroup.toAddCommMonoid",
"instDecidableEqFin",
"id",
"Fin.instOfNat",
"Ne",
"instOfNatNat",
"Affine.Simplex.Equilateral",
"Bool.true",
"instHAdd",
"And",
... | true |
SupClosed.iSup_mem | Mathlib.Order.SupClosed | [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"iSup",
"Finite",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toBoundedOrder",
"isEmpty_or_nonempty",
"id",
... | true |
_private.Mathlib.LinearAlgebra.SesquilinearForm.Basic.0.LinearMap.isPairSelfAdjoint_equiv._simp_1_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | [
"LinearMap.isAdjointPair_iff_comp_eq_compl₂",
"LinearMap.IsAdjointPair",
"CommSemiring.toSemiring",
"LinearMap.instFunLike",
"RingHom",
"LinearMap.module",
"LinearMap",
"smulCommClass_self",
"AddCommMonoid",
"CommSemiring",
"LinearMap.comp",
"CommMonoid.toMonoid",
"LinearMap.addCommMonoid",
... | false |
instMulSemiringActionSubtypeMemSubalgebraIntegralClosure._proof_6 | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | [
"Subalgebra.instSetLike",
"CommRing",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"AlgHom.algHomClass",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AlgHom",
"AlgHom.funLike",
"AddMonoid.toAddZeroClass",
"AddGrou... | false |
Lean.Parser.Termination.partialFixpoint.formatter | Lean.Parser.Term | [
"Lean.PrettyPrinter.Formatter",
"Lean.PrettyPrinter.Formatter.checkColGt.formatter",
"Lean.Parser.withCache.formatter",
"Lean.Parser.leadingNode.formatter",
"instOfNatNat",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Lean.Parser.symbol.formatter",
"Bool.true",
"Nat",
"Lean.Parser.withP... | true |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Module.isPrincipal_submodule_iff.match_1_2 | Mathlib.LinearAlgebra.Span.Defs | [
"Submodule",
"instHSMul",
"DistribMulAction.toDistribSMul",
"Submodule.addCommMonoid",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"Exists",
"AddZeroClass.toAddZero",
"Subtype",
"DistribSMul.toSMulZeroClass",
"Submodule.module",
"AddCommMonoid",
"Subtype.mk",
"AddZero.toZero",
"Exists.... | false |
seminormFromConst._proof_4 | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | [
"add_mul",
"Eq.mpr",
"pow_pos",
"Real.partialOrder",
"Real.instLE",
"Real",
"CommRing",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"_private.Mathlib.Analysis.Normed.Unbundled.SeminormFromConst.0.seminormFromConst._simp_3",
"RingSeminorm.ringSeminormClass",
"div_le_div_of_nonn... | false |
AlgebraicGeometry.Scheme.stalkMapIsoOfIsPullback._proof_5 | Mathlib.AlgebraicGeometry.OpenImmersion | [
"AlgebraicGeometry.Scheme",
"CategoryTheory.IsIso",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"CommRingCat",
"TopCat.instCategory",
"ContinuousMap",
"CommRingCat.instCategory",
"AlgebraicGeometry.Lo... | false |
openSegment_symm | Mathlib.Analysis.Convex.Segment | [
"Set.ext",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"Preorder.toLT",
"SMul",
"PartialOrder.toPreorder",
"_private.Mathlib.Analysis.Convex.Segment.0.openSegment_symm.match_1_1",
"Membership.mem",
"Exists",
"_private.Mathlib.Analysis.Convex.Segment.0.openSegment_symm.match_1_3",
"Pa... | true |
Int.le_refl | Init.Data.Int.Order | [
"Int.le.intro",
"Int",
"LE.le",
"Int.add_zero",
"Int.instLEInt"
] | true |
Set.mem_graphOn._simp_1 | Mathlib.Data.Set.Prod | [
"Membership.mem",
"Prod.fst",
"And",
"Set.graphOn",
"Set.mem_graphOn",
"propext",
"Prod",
"Eq",
"Set.instMembership",
"Prod.snd",
"Set"
] | false |
_private.Mathlib.Algebra.Ring.IsFormallyReal.0.IsFormallyReal.of_eq_zero_of_mul_self_of_eq_zero_of_add._proof_1_3 | Mathlib.Algebra.Ring.IsFormallyReal | [
"Lean.Grind.Linarith.Expr.zero",
"IsSumNonzeroSq",
"of_eq_false",
"Lean.RArray.leaf",
"False",
"Lean.Grind.not_not",
"HMul.hMul",
"eq_false",
"Zero.zero",
"AddMonoid.toAddZeroClass",
"Classical.byContradiction",
"Lean.Grind.eq_false_of_imp_eq_true",
"IsSumNonzeroSq.isSumSq",
"Mul",
"AddZ... | false |
Filter.eventually_all_finset._simp_1 | Mathlib.Order.Filter.Finite | [
"Finset",
"Filter.Eventually",
"Membership.mem",
"Filter.eventually_all_finset",
"Finset.instSetLike",
"propext",
"Eq",
"SetLike.instMembership",
"Filter"
] | false |
Function.Injective.commMonoid | Mathlib.Algebra.Group.InjSurj | [
"Monoid",
"Function.Injective.monoid",
"MulOne.toOne",
"One",
"HMul.hMul",
"CommMonoid.toCommSemigroup",
"Monoid.toMulOneClass",
"Pow",
"CommSemigroup.mul_comm",
"Mul",
"MulOne.toMul",
"Monoid.toPow",
"CommSemigroup",
"MulOneClass.toMulOne",
"HPow.hPow",
"CommMonoid.toMonoid",
"Funct... | true |
Std.DTreeMap.Internal.Impl.Const.minEntry?.eq_1 | Std.Data.DTreeMap.Internal.Model | [
"Std.DTreeMap.Internal.Impl.Const.minEntry?.eq_def",
"Option.some",
"Std.DTreeMap.Internal.Impl.inner",
"Prod.mk",
"Option.none",
"Unit",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Eq.refl",
"Prod",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Std.DTreeMap.Internal.Impl.Const.minEntry?",
"Eq.trans... | true |
CauSeq.const_inv | Mathlib.Algebra.Order.CauSeq.Basic | [
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"CauSeq.inv",
"LinearOrder",
"IsStrictOrderedRing",
"DivisionSemiring.toGroupWithZero",
"DivisionMonoid.toDivInvOneMonoid",
"SemilatticeInf.toPartialOrder",
"DivisionRing.toDivisionSemiring",
"DistribLattice.toLattice",
"Ne",
"... | true |
Filter.map_eval_pi | Mathlib.Order.Filter.Pi | [
"Filter.instMembership",
"congrArg",
"Filter.map",
"Filter.NeBot",
"Set.Finite",
"Membership.mem",
"Exists",
"Eq.mp",
"HasSubset.Subset.trans",
"Set.instIsTransSubset",
"HasSubset.Subset",
"Filter.nonempty_of_mem",
"Filter.instNeBotForallPi",
"Function.eval",
"And.casesOn",
"le_antisym... | true |
CategoryTheory.Limits.pullbackDiagonalMapIdIso._proof_13 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | [
"CategoryTheory.Limits.pullback",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.instIsRegularMonoOfIsSplitMono",
"CategoryTheory.IsIso.inv_isIso",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.HasPullback",
"C... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list._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.Mathlib.CategoryTheory.Comma.Over.OverClass.0.CategoryTheory.instIsIsoOverInferInstanceOverClass._proof_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | [
"CategoryTheory.IsIso",
"CategoryTheory.instOverClass",
"inferInstance",
"CategoryTheory.over",
"CategoryTheory.OverClass",
"CategoryTheory.IsIso.id",
"CategoryTheory.Category"
] | false |
Polynomial.aeval_eq_smeval | Mathlib.Algebra.Polynomial.Smeval | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Algebra.algebraMap_eq_smul_one'",
"instHSMul",
"HMul.hMul",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"Polynomial.sum",
"Module.toMulActionWithZero",
"Algebra... | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.eqvTypes._sparseCasesOn_1 | Lean.Compiler.LCNF.InferType | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... | false |
Std.ExtHashMap.size_alter_eq_self_of_not_mem | Std.Data.ExtHashMap.Lemmas | [
"Option.isNone",
"Std.ExtHashMap.inner",
"Membership.mem",
"Std.ExtHashMap.alter",
"LawfulHashable",
"Std.ExtHashMap.size",
"Std.ExtHashMap",
"Bool.true",
"EquivBEq",
"Nat",
"Bool",
"Hashable",
"GetElem?.getElem?",
"Std.ExtHashMap.instGetElem?Mem",
"Std.ExtHashMap.instMembershipOfEquivBE... | true |
NonemptyInterval.instPartialOrder | Mathlib.Order.Interval.Basic | [
"NonemptyInterval.instPreorder",
"NonemptyInterval.instPartialOrder._proof_1",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"PartialOrder.mk",
"NonemptyInterval"
] | true |
CategoryTheory.Pi.laxMonoidalPi'_μ | Mathlib.CategoryTheory.Pi.Monoidal | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pi.monoidalCategory",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.pi",
"CategoryTheory.Functor.LaxMonoidal.μ",
"CategoryTheory.MonoidalCategoryStruct.tensorObj",
"Eq.refl",
"CategoryTheory.Mono... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.