name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
Std.Time.Weekday.instDecidableLeOrdinal | Std.Time.Date.Unit.Weekday | [
"Decidable",
"LE.le",
"Std.Time.Weekday.instDecidableLeOrdinal._aux_1",
"Std.Time.Weekday.Ordinal",
"Std.Time.Weekday.instLEOrdinal"
] | true |
TwoSidedIdeal.matrix_ringCon | Mathlib.LinearAlgebra.Matrix.Ideal | [
"NonUnitalNonAssocRing",
"Matrix.add",
"TwoSidedIdeal",
"Matrix.instMulOfFintypeOfAddCommMonoid",
"Matrix",
"RingCon.matrix",
"RingCon",
"Distrib.toAdd",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Fintype",
"Distrib.toMul",
"TwoSidedIde... | true |
CategoryTheory.Presheaf.instIsLocallyInjectiveOfIsIsoFunctorOpposite | Mathlib.CategoryTheory.Sites.LocallyInjective | [
"Eq.mpr",
"CategoryTheory.Functor",
"CategoryTheory.NatIso.isIso_app_of_isIso",
"CategoryTheory.IsIso",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Functor.category",
"inferInstance",
"TypeCat.ofHom",
... | true |
CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_iCycles_assoc_apply | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.ShortComplex",
"LinearMap.instFunLike",
"Eq.mp",
"id",
"ModuleCat.instConcreteCategoryLinearMapIdCarrier",
"LinearMap",
"Mat... | true |
String.Legacy.Iterator.ValidFor.casesOn | Batteries.Data.String.Lemmas | [
"String.Legacy.Iterator.mk",
"List.reverseAux",
"String.utf8Len",
"List",
"String.Pos.Raw.mk",
"String.Legacy.Iterator.ValidFor.rec",
"String.Legacy.Iterator",
"Char",
"String.Legacy.Iterator.ValidFor",
"String.Legacy.Iterator.ValidFor.mk",
"String.ofList"
] | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.reduceDiv._regBuiltin.Fin.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.3721631082._hygCtx._hyg.24 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | [
"IO",
"Bool.true",
"Unit",
"Lean.Meta.Simp.addSEvalprocBuiltinAttr",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Fin.reduceDiv",
"Lean.Name.mkStr2",
"Lean.Meta.Simp.Simproc"
] | false |
Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | [
"Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State",
"Lean.Expr",
"Int",
"Array",
"Nat",
"Prod",
"Eq",
"Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State.casesOn",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstr",
"Option"
] | false |
Lean.Meta.Sym.State.share._default | Lean.Meta.Sym.SymM | [
"id",
"Lean.Meta.Sym.instBEqAlphaKey",
"Lean.PHashSet",
"Lean.Meta.Sym.AlphaKey",
"Lean.Meta.Sym.AlphaShareCommon.State.mk",
"Lean.PersistentHashSet.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Lean.Meta.Sym.instHashableAlphaKey",
"Lean.Meta.Sym.AlphaShareCommon.State"
] | false |
Std.Iter.flatMap.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | [
"Pure.pure",
"Std.Iter.flatMapAfter",
"Monad.toApplicative",
"MonadLiftT.monadLift",
"instMonadLiftT",
"Std.Iter.toIterM",
"Id",
"Std.Iter.flatMap",
"Applicative.toPure",
"Std.Iterator",
"Option.none",
"Std.Iterators.instMonadPostconditionT",
"Std.Iter",
"Std.Iterators.Types.Map",
"Appli... | true |
Std.LawfulBEqCmp.compare_eq_iff_beq | Init.Data.Order.Ord | [
"Ordering",
"Ordering.eq",
"Bool.true",
"BEq.beq",
"Iff",
"Std.LawfulBEqCmp",
"Bool",
"BEq",
"Eq"
] | true |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.mul_aux_right.match_1_1 | Mathlib.FieldTheory.PerfectClosure | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommRing",
"Nat.Prime",
"CommSemiring.toSemiring",
"HEq.refl",
"PerfectClosure.R.casesOn",
"PerfectClosure.R.intro",
"AddGroupWithOne.toAddMonoidWithOne",
"RingHom",
"Fact",
"Prod.mk",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"f... | false |
LinearMap.concaveOn | Mathlib.Analysis.Convex.Function | [
"Eq.mpr",
"LinearMap.map_add",
"NonAssocSemiring.toAddCommMonoidWithOne",
"le_refl",
"instHSMul",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"LinearMap.instFunLike",
"Preorder.toLE",
"Membership.mem",
"AddZeroClass.toAddZero",
"Part... | true |
singleton_add_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | [
"Real",
"SeminormedAddCommGroup",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"Set.instSingletonSet",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"instHAdd",
"Set.add",
... | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.getContext | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | [
"Pure.pure",
"Lean.Meta.Grind.GrindM",
"Lean.Meta.Grind.Goal",
"Lean.Meta.Grind.Arith.CommRing.ProofM.Context",
"Lean.Meta.Grind.Arith.CommRing.RingM",
"Lean.Meta.Grind.Arith.CommRing.RingM.Context",
"instMonadReaderOfReaderTOfMonad",
"Lean.Meta.Grind.State",
"ReaderT",
"Lean.Meta.Sym.Context",
... | true |
CochainComplex.HomComplex.instAddCommGroupCochain._proof_20 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | [
"CochainComplex.HomComplex.Cochain._proof_1",
"AddMonoid.toAddSemigroup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Add.mk",
"CochainComplex.HomComplex.instAddCommGroupCochain._aux_8",
"AddGroupWithOne.toAddMonoidWithOne",
"CochainComplex.HomComplex.instAddCommGroupCochain._aux_4",
"A... | false |
PMF.toOuterMeasure_apply_fintype | Mathlib.Probability.ProbabilityMassFunction.Basic | [
"Finset.mem_univ",
"Finset.univ",
"ENNReal.instAddCommMonoid",
"PMF",
"Set.indicator",
"Finset",
"AddMonoid.toAddZeroClass",
"PMF.toOuterMeasure",
"PMF.instFunLike",
"Membership.mem",
"AddZeroClass.toAddZero",
"MeasureTheory.OuterMeasure",
"SummationFilter.instLeAtTopUnconditional",
"AddZe... | true |
Mathlib.Tactic.Abel.evalNeg | Mathlib.Tactic.Abel | [
"Mathlib.Tactic.Abel.NormalExpr.brecOn",
"Lean.Expr",
"Mathlib.Tactic.Abel.evalNeg._f",
"Prod",
"Mathlib.Tactic.Abel.M",
"Mathlib.Tactic.Abel.NormalExpr"
] | true |
Fin.natAdd_castLEEmb_apply_val | Mathlib.Data.Fin.Embedding | [
"HSub.hSub",
"instSubNat",
"LE.le",
"instLENat",
"Fin.val",
"Fin.natAdd_castLEEmb",
"Function.Embedding",
"instHAdd",
"instHSub",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"Function.instFunLikeEmbedding",
"Fin",
"Eq",
"DFunLike.coe"
] | true |
ZMod.sq_add_sq | Mathlib.FieldTheory.Finite.Basic | [
"one_pow",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Polynomial.C",
"Polynomial.eval",
"instNeZeroNatHAdd_1",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"IsDomain.to_noZeroDivisors",
"Nat.Prime.eq_two_or_odd",
"Nat.Prime",
"Fintype.elems",
"LinearOrderedCommMonoidWithZero.toIsBotZer... | true |
Lean.Server.statefulRequestHandlers | Lean.Server.Requests | [
"Classical.ofNonempty",
"String",
"instHashableString",
"instBEqOfDecidableEq",
"Lean.PersistentHashMap",
"_private.Lean.Server.Requests.0.Lean.Server.statefulRequestHandlers._proof_1",
"Lean.Server.StatefulRequestHandler",
"instDecidableEqString",
"IO.Ref"
] | true |
AddConstEquiv.symm_refl | Mathlib.Algebra.AddConstMap.Equiv | [
"AddConstEquiv.symm",
"AddConstEquiv",
"AddConstEquiv.refl",
"Eq",
"Add",
"rfl"
] | true |
CategoryTheory.FreeBicategory.id_def | Mathlib.CategoryTheory.Bicategory.Free | [
"CategoryTheory.FreeBicategory.categoryStruct",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.FreeBicategory.Hom.id",
"CategoryTheory.FreeBicategory",
"CategoryTheory.FreeBicategory.Hom",
"Quiver",
"Eq",
"rfl"
] | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.isRevMatch_iff_isRevMatch_decide.match_1_3 | Init.Data.String.Lemmas.Pattern.Pred | [
"String.Slice.Pattern.Model.IsRevMatch",
"String.Slice.Pattern.Model.IsRevMatch.casesOn",
"String.Slice.Pattern.Model.PatternModel.Matches",
"String.Slice.sliceFrom",
"String.Slice",
"String.Slice.copy",
"String.Slice.Pattern.Model.CharPred.instPatternModelForallCharBool",
"String.Slice.Pattern.Model.... | false |
Lean.Parser.Attr.sevalprocBuiltinAttr | Init.Simproc | [
"Lean.ParserDescr.nonReservedSymbol",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.Parser.Tactic.simpPre",
"Lean.ParserDescr.node",
"Nat",
"Lean.Parser.Tactic.simpPost",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
zpow_mul' | Mathlib.Algebra.Group.Basic | [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"zpow_mul",
"DivInvMonoid.toZPow",
"DivisionMonoid",
"id",
"Int",
"DivisionMonoid.toDivInvMonoid",
"Int.instMul",
"HPow.hPow",
"Eq.refl",
"Int.mul_comm",
"instHPow",
"Eq",
"instHMul"
] | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHomRight_hom_inv' | Mathlib.CategoryTheory.Monoidal.Action.Basic | [
"Eq.mpr",
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj",
"CategoryTheory.CategoryStruct.id",
"id",
"CategoryTheory.MonoidalCategory.MonoidalLeftActi... | true |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents | Mathlib.Tactic.WithoutCDot | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.optional",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.ppSpace",
"Unit",
"Nat",
"OfNat.ofNat",
"Lean.Parser.withoutForbidden",
"Lean.Parser.withoutPosition",
"Lean.Parser.instAndThenParser",
"Lean.Parse... | true |
Std.Iterators.Types.Empty.noConfusion | Std.Data.Iterators.Producers.Monadic.Empty | [
"Std.Iterators.Types.Empty",
"Std.Iterators.Types.Empty.casesOn",
"Std.Iterators.Types.Empty.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Eq"
] | false |
Int.neg_modEq_neg | Mathlib.Data.Int.ModEq | [
"Dvd.dvd",
"congrArg",
"_private.Mathlib.Data.Int.ModEq.0.Int.neg_modEq_neg._simp_1_3",
"HSub.hSub",
"_private.Mathlib.Data.Int.ModEq.0.Int.neg_modEq_neg._proof_1_2",
"Int.instNegInt",
"Int",
"Int.instDvd",
"iff_self",
"Iff",
"instHSub",
"Int.ModEq",
"congr",
"True",
"of_eq_true",
"Int... | true |
_private.Mathlib.Analysis.Convex.Combination.0.convex_iff_sum_mem._simp_1_3 | Mathlib.Analysis.Convex.Combination | [
"Finset",
"Membership.mem",
"Insert.insert",
"Finset.mem_insert",
"Finset.instInsert",
"Finset.instSetLike",
"propext",
"Or",
"Eq",
"SetLike.instMembership",
"DecidableEq"
] | false |
CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget_inv_app | Mathlib.CategoryTheory.Limits.ConeCategory | [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Under",
"CategoryTheory.Limits.C... | true |
convexHull_toCone_eq_sInf | Mathlib.Geometry.Convex.Cone.Basic | [
"IsGLB.sInf_eq",
"ConvexCone.instCompleteSemilatticeInf",
"ChainCompletePartialOrder.instOfCompleteLattice",
"ConvexCone.instPartialOrder",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"setOf",
"ConvexCone... | true |
top_unique | Mathlib.Order.BoundedOrder.Basic | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le.antisymm",
"PartialOrder",
"LE.le",
"OrderTop",
"OrderTop.toTop",
"le_top",
"Top.top",
"Eq"
] | true |
Lean.Grind.CommRing.Poly.cancelVar'._sunfold | Init.Grind.Ring.CommSolver | [
"Int.decidableDvd",
"cond",
"instPowNat",
"Int.instDiv",
"Dvd.dvd",
"instHDiv",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Poly.cancelVar'",
"Lean.Grind.CommRing.Mon.cancelVar",
"HDiv.hDiv",
"Bool.and",
"Lean.Grind.CommRing.Poly.denote.match_1",
"instOfNatNat",
"Int",
"Int.instNatP... | false |
PSet.mem_def | Mathlib.SetTheory.ZFC.PSet | [
"PSet.instMembership",
"Iff.rfl",
"PSet.Func",
"Membership.mem",
"Exists",
"PSet",
"Iff",
"PSet.Type",
"PSet.Equiv"
] | true |
ProjectiveSpectrum.sup_vanishingIdeal_le | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | [
"SetLike",
"Eq.mpr",
"Submodule",
"CommRing",
"Lattice.toSemilatticeSup",
"Semiring.toModule",
"HomogeneousIdeal._proof_1",
"AddMonoid.toAddSemigroup",
"instVAddOfAdd",
"ProjectiveSpectrum.mem_vanishingIdeal",
"congrArg",
"CommSemiring.toSemiring",
"Submodule.completeLattice",
"AddMonoid.t... | true |
instNonUnitalCommCStarAlgebraProd._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | [
"NonUnitalCommCStarAlgebra.toNonUnitalCStarAlgebra",
"NonUnitalCStarAlgebra.toNonUnitalNormedRing",
"instSMulOfMul",
"NonUnitalNonAssocRing.toMul",
"NonUnitalCommCStarAlgebra",
"AddCommGroup.toAddCommMonoid",
"IsScalarTower",
"NormedSpace.toModule",
"Complex.instNormedField",
"NormedField.toField"... | false |
AddEquiv.toMultiplicativeLeft_apply_apply | Mathlib.Algebra.Group.Equiv.TypeTags | [
"AddMonoidHom.toMultiplicativeLeft",
"MulEquiv.instEquivLike",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"Additive",
"AddEquiv.toAddMonoidHom",
"AddZeroClass.toAddZero",
"Multiplicative.mulOneClass",
"Equiv",
"MulOne.toMul",
"Additive.addZeroClass",
"Multiplicative",
"Mu... | true |
FractionalIdeal.ringEquivOfRingEquiv._proof_10 | Mathlib.RingTheory.FractionalIdeal.Operations | [
"_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.ringEquivOfRingEquiv._simp_5",
"Eq.mpr",
"Submodule",
"IsDomain",
"Subtype.mk.congr_simp",
"LinearEquiv.symm",
"CommRing",
"RingHomSurjective.instToRingHomRingEquiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Submodu... | false |
Std.HashMap.getElem_congr | Std.Data.HashMap.Lemmas | [
"GetElem?.toGetElem",
"Membership.mem",
"Std.DHashMap.Const.get_congr",
"Std.HashMap",
"Std.HashMap.mem_congr",
"LawfulHashable",
"GetElem.getElem",
"Bool.true",
"BEq.beq",
"EquivBEq",
"Iff.mp",
"Bool",
"Hashable",
"Std.HashMap.instGetElem?Mem",
"Std.HashMap.inner",
"BEq",
"Eq",
"S... | true |
Complex.sqrt._proof_1 | Mathlib.Analysis.RCLike.Sqrt | [
"Nat.instAtLeastTwoHAddOfNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Nat.AtLeastTwo"
] | false |
Finset.mem_addSpan._simp_1 | Mathlib.Combinatorics.Additive.Dissociation | [
"instHSMul",
"AddCommGroup.toAddCommMonoid",
"Finset",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Exists",
"AddCommGroup",
"Int.instNegInt",
"Int",
"Finset.mem_addSpan",
"And",
"Fintype",
"AddGroup.toSubNegMonoid",
"instOfNat",
"Finset.instSetLike",
"propext",
"HSMul.hSMul",
"Or... | false |
Subgroup.mem_ofUnits_iff_exists_isUnit | Mathlib.Algebra.Group.Submonoid.Units | [
"Monoid",
"Monoid.toMulOneClass",
"IsUnit",
"Membership.mem",
"Exists",
"Units",
"Subgroup.mem_ofUnits_of_isUnit_of_unit_mem",
"Subgroup",
"Units.instGroup",
"_private.Mathlib.Algebra.Group.Submonoid.Units.0.Subgroup.mem_ofUnits_iff_exists_isUnit.match_1_1",
"Iff",
"Subgroup.unit_mem_of_mem_of... | true |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.instHasProjectiveDimensionLTHAddNat._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | [
"Lean.RArray.leaf",
"False",
"Classical.byContradiction",
"Nat.not_le_eq",
"Lean.RArray.branch",
"id",
"False.casesOn",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.Linear.Expr.num",
"Bool.true",
"instHAdd",
"Nat.Linear.ExprCnstr.eq_false_of_isUnsat",
"HAdd.hAdd",
"Nat",
"Bool",
"Lea... | false |
Composition.reverse_eq_ones._simp_1 | Mathlib.Combinatorics.Enumerative.Composition | [
"Composition",
"Nat",
"propext",
"Composition.ones",
"Composition.reverse_eq_ones",
"Composition.reverse",
"Eq"
] | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to0.trCfg.match_1.splitter | Mathlib.Computability.TuringMachine.PostTuringMachine | [
"Turing.Tape",
"Turing.TM1.Cfg",
"Turing.TM1.Cfg.mk",
"Inhabited",
"Turing.TM1to0.trCfg.match_1",
"Option"
] | true |
Num.bit0 | Mathlib.Data.Num.Basic | [
"castNum.match_1",
"PosNum.bit0",
"Num",
"Unit",
"instZeroNum",
"Num.pos",
"Zero.toOfNat0",
"PosNum",
"OfNat.ofNat"
] | true |
Polynomial.natDegree_map_lt' | Mathlib.Algebra.Polynomial.Eval.Degree | [
"Eq.mpr",
"congrArg",
"Polynomial.instDecidableEq",
"Classical.propDecidable",
"RingHom",
"id",
"Polynomial.leadingCoeff",
"instOfNatNat",
"Polynomial.natDegree_zero",
"Polynomial",
"dite",
"RingHom.instFunLike",
"Nat",
"LT.lt",
"Semiring",
"Zero.toOfNat0",
"Polynomial.map",
"instL... | true |
AddCommGroup.modEq_iff_intModEq._simp_1 | Mathlib.Data.Int.ModEq | [
"Int.instAddCommMonoid",
"AddCommGroup.ModEq",
"Int",
"Int.ModEq",
"propext",
"AddCommGroup.modEq_iff_intModEq",
"Eq"
] | false |
SSet.π₀Functor_map | Mathlib.AlgebraicTopology.SimplicialSet.PiZero | [
"SSet.π₀Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"SSet.mapπ₀",
"CategoryTheory.Functor.category",
"TypeCat.ofHom",
"SSet",
"SSet.π₀",
"CategoryTheory.Functor.map",
"CategoryTheory.types",
"SimplexCategory",
"CategoryTheory.Category.opposite",
"Eq.refl",... | true |
Std.Format.FlattenBehavior.ctorIdx | Init.Data.Format.Basic | [
"Nat",
"Std.Format.FlattenBehavior.casesOn",
"Std.Format.FlattenBehavior"
] | false |
Equiv.preorder | Mathlib.Order.Lattice | [
"Equiv.preorder._proof_1",
"Preorder.toLT",
"Equiv.instEquivLike",
"Equiv.le",
"Preorder.toLE",
"Equiv",
"Equiv.preorder._proof_2",
"LE",
"Equiv.lt",
"Function.Injective.preorder",
"DFunLike.coe",
"Preorder",
"EquivLike.toFunLike",
"LT"
] | true |
Polynomial.roots_eq_of_degree_le_card_of_ne_zero | Mathlib.Algebra.Polynomial.Roots | [
"Iff.mpr",
"WithBot.addMonoidWithOne",
"WithBot.instPreorder",
"Polynomial.eval",
"WithBot.zeroLEOneClass",
"IsDomain",
"WithBot.addLeftMono",
"CommRing",
"WithBot",
"Polynomial.roots",
"Nat.instIsOrderedAddMonoid",
"AddMonoid.toAddSemigroup",
"CommSemiring.toSemiring",
"Finset",
"Polyno... | true |
CategoryTheory.Limits.Cone.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | [
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.ConeMorphism.w",
"CategoryTheory.Functor.category",
"CategoryTheory.CostructuredArrow.h... | false |
MeasureTheory.cylinderEvents_mono | Mathlib.MeasureTheory.Constructions.Cylinders | [
"MeasurableSpace.instLE",
"MeasurableSpace.comap",
"biSup_mono",
"Membership.mem",
"HasSubset.Subset",
"LE.le",
"MeasureTheory.cylinderEvents",
"MeasurableSpace",
"MeasurableSpace.instCompleteLattice",
"Set.instMembership",
"Set.instHasSubset",
"Set"
] | true |
Std.Iterators.Types.Flatten.instIterator | Init.Data.Iterators.Combinators.Monadic.FlatMap | [
"Std.Iterators.Types.Flatten.IsPlausibleStep.innerYield",
"Pure.pure",
"Std.Shrink.deflate",
"Std.Iterator.mk",
"Std.Shrink",
"Monad.toApplicative",
"Std.Iterators.Types.Flatten.IsPlausibleStep.outerDone",
"Std.PlausibleIterStep",
"Option.some",
"Std.IterM.IsPlausibleStep",
"Std.IterStep.skip",
... | true |
BoolAlg.Iso.mk._proof_6 | Mathlib.Order.Category.BoolAlg | [
"Lattice.toSemilatticeSup",
"BoolAlg.Iso.mk._proof_3",
"BoolAlg.carrier",
"SupHom.toFun",
"PartialOrder.toPreorder",
"BoolAlg",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"LatticeHom.map_inf'",
"OrderIso",
"BoolAlg.Iso.mk._proof_1",
"BiheytingAlgebra.toCoheytin... | false |
MeasureTheory.snd_integral_withLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | [
"Iff.mpr",
"WithLp",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"Prod.normedSpace",
"WithLp.instProdNormedAddCommGroup",
"CompleteSpace",
"Prod.normedAddCommGroup",
"WithLp.prodContinuousLinearEquiv",
"NormedSpace",
"WithLp.instProdTopologicalSpace",
... | true |
SemilatticeInf.ext_inf | Mathlib.Order.Lattice | [
"Eq.mpr",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"id",
"SemilatticeInf.toMin",
"LE.le",
"le_inf_iff",
"And",
"SemilatticeInf",
"Iff",
"propext",
"eq_of_forall_le_iff",
"Eq.symm",
"Eq",
"Min.min"
] | true |
Std.DTreeMap.Internal.Impl.balance!.match_1.congr_eq_5 | Std.Data.DTreeMap.Internal.Balancing | [
"Unit.unit",
"Std.DTreeMap.Internal.Impl.casesOn",
"Std.DTreeMap.Internal.Impl.inner",
"id",
"heq_of_eq",
"Unit",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Std.DTreeMap.Internal.Impl.balance!.match_1"
] | true |
List.Vector.sum_add_sum_eq_sum_zipWith | Mathlib.Data.Vector.Zip | [
"List.Vector.zipWith",
"AddMonoid.toAddZeroClass",
"List.sum",
"List.Vector",
"List.sum_add_sum_eq_sum_zipWith_of_length_eq",
"AddZeroClass.toAddZero",
"List.Vector.toList_length",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"Nat",
"AddZero.toAdd",
"AddCommMonoid.toAddMonoi... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.card_edgeFinset_turanGraph._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | [
"instPowNat",
"Lean.RArray.leaf",
"False",
"Nat.choose",
"instHDiv",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"HMul.hMul",
"Lean.Grind.CommRing.Expr.mul",
"Lean.Grind.CommRing.Expr.var",
"congrArg",
"Nat.instMonoid",
"Classical.byContradiction",
"HSub.hSub",
"Lean.Grind.Co... | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_6 | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Internal.Impl.inner",
"id",
"instOfNatNat",
"LE.le",
"instLENat",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Decidable.byContradiction",
"_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_5",
"OfNat.ofNat",
... | false |
intervalIntegral.integral_same | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | [
"Set.Ioc",
"Real",
"MeasureTheory.Measure",
"NormedSpace",
"sub_self",
"intervalIntegral",
"AddCommGroup.toAddGroup",
"MeasureTheory.Measure.restrict",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"Real.measurableSpace"... | true |
Std.TreeMap.Raw.Equiv.of_keysArray_unit_perm | Std.Data.TreeMap.Raw.Lemmas | [
"Iff.mpr",
"Ordering",
"Std.TreeMap.Raw.keysArray",
"Std.TreeMap.Raw.Equiv",
"Array.Perm",
"Std.TreeMap.Raw",
"Unit",
"Std.TreeMap.Raw.equiv_iff_keysArray_unit_perm"
] | true |
ONote.NFBelow.below.oadd' | Mathlib.SetTheory.Ordinal.Notation | [
"ONote.NFBelow.below",
"Preorder.toLT",
"Ordinal.partialOrder",
"ONote.oadd",
"PartialOrder.toPreorder",
"ONote.NFBelow.below.oadd'",
"ONote.NFBelow",
"ONote.repr",
"LT.lt",
"ONote",
"ONote.NFBelow.oadd'",
"Ordinal",
"PNat"
] | true |
instFiniteConjClasses | Mathlib.Algebra.Group.ConjFinite | [
"Monoid",
"Quotient.finite",
"IsConj.setoid",
"Finite",
"ConjClasses"
] | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr.0.Lean.Grind.Linarith.Expr.denoteExpr.go._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr | [
"instGetElem?OfGetElemOfDecidable",
"Pure.pure",
"Lean.mkNatLit",
"Lean.Grind.Linarith.Expr",
"Lean.Meta.Grind.Arith.Linear.LinExpr",
"Lean.Meta.Grind.Arith.Linear.Struct.subFn",
"_private.Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr.0.Lean.Grind.Linarith.Expr.denoteExpr.go.match_1",
"Lean.Persisten... | false |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.mk._flat_ctor | Lean.Meta.Sym.Simp.Forall | [
"_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo",
"Lean.Level",
"Lean.Name",
"Lean.BinderInfo",
"_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.mk"
] | false |
Batteries.TransOrd | Batteries.Classes.Deprecated | [
"Ord",
"Batteries.TransCmp",
"Ord.compare"
] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._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 |
MulEquiv.withOneCongr | Mathlib.Algebra.Group.WithOne.Basic | [
"WithOne",
"MulEquiv.toMulHom",
"MonoidHom.instFunLike",
"MonoidHom",
"MulEquiv.withOneCongr._proof_3",
"Mul",
"WithOne.mapMulHom",
"Equiv.mk",
"WithOne.instMulOneClass",
"MulOneClass.toMulOne",
"MulEquiv.withOneCongr._proof_1",
"MulEquiv.withOneCongr._proof_2",
"MulEquiv",
"MulEquiv.symm"... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.Connected.connected_delete_edge_of_not_isBridge._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | [
"False",
"Sym2.Rel",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"Sym2.mk",
"congrArg",
"Classical.byContradiction",
"SimpleGraph.Walk",
"Membership.mem",
"Eq.mp",
"Set.instSingletonSet",
"id",
"Prod.mk",
"SimpleGraph",
"List",
"Iff",
"Set.mem_singleton_iff",
"List.ins... | false |
FreeRing.hom_ext_iff | Mathlib.RingTheory.FreeRing | [
"FreeRing.of",
"HEq.refl",
"instRingFreeRing",
"RingHom",
"FreeRing.hom_ext",
"Eq.casesOn",
"Iff",
"RingHom.instFunLike",
"Iff.intro",
"FreeRing",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Eq.symm",
"Semiring.toNonAssocSemiring",
"Ring.toSemiring",
"Eq",
"DFunLike.coe",
"Ring"
] | true |
Int32.sub_eq_iff_eq_add | Init.Data.SInt.Lemmas | [
"Eq.mpr",
"Int32.toBitVec",
"congrArg",
"HSub.hSub",
"BitVec.instAdd",
"BitVec",
"BitVec.sub_eq_iff_eq_add",
"id",
"instOfNatNat",
"Int32.eq_iff_toBitVec_eq._simp_1",
"Int32.toBitVec_sub",
"instSubInt32",
"Int32.toBitVec_add",
"instHAdd",
"BitVec.instSub",
"Iff",
"instHSub",
"HAdd.... | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.reduceShiftLeft._regBuiltin.Fin.reduceShiftLeft.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.1443794988._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | [
"IO",
"Bool.true",
"Unit",
"Sum.inr",
"Lean.Meta.Simp.DSimproc",
"Lean.Name.mkStr2",
"Fin.reduceShiftLeft",
"Lean.Meta.Simp.addSimprocBuiltinAttr",
"Lean.Meta.Simp.Simproc"
] | false |
Std.Http.Status.loopDetected.elim | Std.Http.Data.Status | [
"PULift.up",
"Std.Http.Status.ctorIdx",
"Std.Http.Status.loopDetected",
"Std.Http.Status",
"Std.Http.Status.ctorElim",
"Nat",
"Eq.symm",
"Eq"
] | false |
_private.Mathlib.Combinatorics.Matroid.Minor.Restrict.0.Matroid.restrictIndepMatroid._simp_7 | Mathlib.Combinatorics.Matroid.Minor.Restrict | [
"HasSubset.Subset",
"And",
"Set.instLE",
"maximal_subset_iff",
"propext",
"Maximal",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
Submodule.FG.lTensor.directedSystem | Mathlib.RingTheory.TensorProduct.DirectLimitFG | [
"Submodule",
"CommSemiring.toSemiring",
"Submodule.addCommMonoid",
"TensorProduct.addCommMonoid",
"PartialOrder.toPreorder",
"LinearMap.instFunLike",
"Preorder.toLE",
"Membership.mem",
"LinearMap.lTensor",
"Subtype",
"Submodule.instPartialOrder",
"Submodule.module",
"LE.le",
"LinearMap",
... | true |
Lean.Syntax.instForInTopDownOfMonad.loop._unsafe_rec | Lean.Syntax | [
"Pure.pure",
"Lean.Syntax.instForInTopDownOfMonad.loop._unsafe_rec",
"instForInOfForIn'",
"Monad.toApplicative",
"Lean.SourceInfo",
"Array.instMembership",
"Option.some",
"ForInStep.done",
"Lean.Syntax",
"inferInstance",
"Bool.and",
"instDecidableEqBool",
"Prod.mk",
"ForIn.forIn",
"instO... | false |
div_div_self | Mathlib.Algebra.GroupWithZero.Basic | [
"Eq.mpr",
"instHDiv",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"Monoid.toMulOneClass",
"congrArg",
"GroupWithZero",
"div_div_eq_mul_div",
"id",
"MulOne.toMul",
"HDiv.hDiv",
"DivInvMonoid.toMonoid",
"DivisionMonoid.toDivInvMonoid",
"MulOneClass.toMulO... | true |
RingSeminorm.exists_index_pow_le | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | [
"Real.instIsOrderedRing",
"Real.instPow",
"Real.partialOrder",
"Real.instLE",
"Real",
"CommRing",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"RingSeminorm.ringSeminormClass",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"MulZeroClass.toMul",
"Nat.ble",
"Real.instZeroLEOne... | true |
_private.Mathlib.Topology.Category.Profinite.Nobeling.Span.0.Profinite.NobelingProof.GoodProducts.spanFin._simp_1_3 | Mathlib.Topology.Category.Profinite.Nobeling.Span | [
"Finsupp.mem_support_iff",
"Finsupp.instFunLike",
"Finset",
"Finsupp.support",
"Membership.mem",
"Ne",
"Finset.instSetLike",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"SetLike.instMembership",
"Finsupp",
"Zero"
] | false |
WittVector.wittPolyProdRemainder.congr_simp | Mathlib.RingTheory.WittVector.MulCoeff | [
"Nat.Prime",
"Fact",
"Eq.rec",
"instOfNatNat",
"Int",
"Nat",
"MvPolynomial",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Int.instCommSemiring",
"OfNat.ofNat",
"Fin",
"Eq",
"WittVector.wittPolyProdRemainder"
] | true |
CochainComplex.mappingCone.inl_snd_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | [
"Eq.mpr",
"HomologicalComplex.instCategory",
"CochainComplex.HomComplex.instAddCommGroupCochain",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CochainComplex.HomComplex.Cochain.comp",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup... | true |
_private.Lean.Meta.SizeOf.0.Lean.Meta.mkLocalInstances.loop | Lean.Meta.SizeOf | [
"Inhabited.default",
"Lean.Expr",
"Lean.Meta.MetaM",
"Array",
"Lean.Meta.instInhabitedMetaM",
"Nat"
] | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomLeft_tensor | Mathlib.CategoryTheory.Monoidal.Action.Basic | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_id",
"Quiver.Hom",
"congrArg",
"_private.Mathlib.CategoryTheory.Monoidal.Action.Basic.0.CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHomLeft_te... | true |
Lean.Expr.FindStep.noConfusionType | Lean.Util.FindExpr | [
"noConfusionTypeEnum",
"Lean.Expr.FindStep.ctorIdx",
"Nat",
"instDecidableEqNat",
"Lean.Expr.FindStep"
] | true |
MvPolynomial.mem_degreesLE | Mathlib.Algebra.MvPolynomial.Degrees | [
"Submodule",
"Nat.instMulZeroClass",
"Semiring.toModule",
"AddMonoidAlgebra.addAddCommMonoid",
"CommSemiring.toSemiring",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Multiset",
"LE.le",
"CommSemiring",
"Iff",
"Nat",
"Submodule.setLike",
"MvPolynomial",
"... | true |
SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint.inj₁ | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | [
"Finset",
"Membership.mem",
"SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint",
"Prod.mk",
"Finset.instSetLike",
"Prod",
"Eq",
"SetLike.instMembership"
] | true |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkLawfulDayConvolutionMonoidalCategoryStruct._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | [
"CategoryTheory.MonoidalCategory.DayConvolution.convolution",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.convolutions",
"CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkMonoidalCategoryStruct",
"Cat... | false |
Vector.length_iterM | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | [
"Pure.pure",
"Vector.iterM",
"Std.Iterators.Types.ArrayIterator",
"Vector",
"congrArg",
"Monad.toApplicative",
"Std.instLawfulIteratorLoopDefaultImplementation",
"Std.IterM.length",
"ULift",
"_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Vector.0.Vector.length_iterM._simp_1_1",
"Vector.to... | true |
Lean.IRPhases.comptime.sizeOf_spec | Lean.Setup | [
"Lean.IRPhases.comptime",
"instOfNatNat",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq",
"Lean.IRPhases",
"Lean.IRPhases._sizeOf_inst"
] | true |
CliffordAlgebra.EvenHom.mk.noConfusion | Mathlib.LinearAlgebra.CliffordAlgebra.Even | [
"CommRing",
"instHSMul",
"Semiring.toModule",
"HMul.hMul",
"CliffordAlgebra.EvenHom",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"HEq.refl",
"QuadraticForm",
"LinearMap.instFunLike",
"Algebra",
"RingHom",
"Algebra.toSMul",
"AddCommGroup",
"Algebra.... | false |
Insert.recOn | Init.Core | [
"Insert",
"Insert.mk",
"Insert.rec"
] | false |
ProbabilityTheory.Kernel.partialTraj.eq_1 | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | [
"MeasurableEquiv.instEquivLike",
"Nat.leRec",
"ProbabilityTheory.Kernel.comp",
"Finset",
"ProbabilityTheory.Kernel.map",
"PartialOrder.toPreorder",
"Nat.instLocallyFiniteOrder",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"LocallyFiniteOrder.toLocallyFiniteOrderBot",
"DistribLattice.toLat... | true |
List.Vector.instFintype | Mathlib.Data.Fintype.Vector | [
"Equiv.instEquivLike",
"Finset.univ",
"Equiv.vectorEquivFin",
"List.Vector.instFintype._proof_1",
"instDecidableEqFin",
"Pi.instFintype",
"List.Vector",
"List.Vector.instFintype._proof_2",
"Finset.map",
"Function.Embedding.mk",
"Equiv",
"Fin.fintype",
"Fintype",
"Nat",
"Fintype.mk",
"E... | true |
Std.PRange.instLawfulUpwardEnumerableInt | Init.Data.Range.Polymorphic.Int | [
"Eq.mpr",
"congrArg",
"Std.PRange.LawfulUpwardEnumerable.mk",
"Std.PRange.instUpwardEnumerableInt",
"Std.PRange.UpwardEnumerable.LT",
"Option.some.injEq",
"Option.some",
"Exists",
"Int.instDecidableEq",
"Option.bind",
"id",
"Ne",
"instOfNatNat",
"Int",
"Std.PRange.UpwardEnumerable.succ?"... | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul_smul_coe | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | [
"instHSMul",
"NumberField.instCommRingRingOfIntegers",
"CommSemiring.toSemiring",
"NumberField.mixedEmbedding.fundamentalCone.integerSetTorsionSMul",
"Membership.mem",
"Units",
"Set.Elem",
"Subtype",
"Subgroup",
"Units.instGroup",
"NumberField.mixedEmbedding.mixedSpace",
"CommRing.toCommSemiri... | true |
SimpleGraph.edgeFinset_eq_empty | Mathlib.Combinatorics.SimpleGraph.Finite | [
"Eq.mpr",
"SimpleGraph.edgeFinset_inj",
"congrArg",
"Finset",
"Iff.rfl",
"Set.Elem",
"id",
"Bot.bot",
"Finset.instEmptyCollection",
"SimpleGraph.edgeSet",
"SimpleGraph.edgeFinset",
"SimpleGraph",
"Iff",
"Fintype",
"SimpleGraph.edgeFinset_bot",
"propext",
"SimpleGraph.completeAtomicBo... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.