name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.PrettyPrinter.Delaborator.delabLam._regBuiltin.Lean.PrettyPrinter.Delaborator.delabLam_1 | Lean.PrettyPrinter.Delaborator.Builtins | [
"IO",
"Lean.PrettyPrinter.Delaborator.Delab",
"Unit",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.PrettyPrinter.Delaborator.delabAttribute",
"Lean.PrettyPrinter.Delaborator.delabLam",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
SimpleGraph.Walk.mapToSubgraph.eq_def | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | [
"SimpleGraph.Walk.map",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"SimpleGraph.Walk.mapToSubgraph._proof_2",
"le_sup_left",
"Sym2.mk",
"congrArg",
"SimpleGraph.Subgraph",
"HEq.refl",
"CompletelyDistribLattice.toCompleteLattice",
"SimpleGraph.Adj",
"SimpleGraph.Subgraph.instCompletelyDistribLattice... | true |
Std.TreeMap.Raw.getKeyLED | Std.Data.TreeMap.Raw.Basic | [
"Ordering",
"Std.TreeMap.Raw.inner",
"Std.TreeMap.Raw",
"Std.DTreeMap.Raw.getKeyLED"
] | true |
DiffeologicalSpace.recOn | Mathlib.Geometry.Diffeology.Basic | [
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"PiLp.normedSpace",
"fact_one_le_two_ennreal",
"Real.denselyNormedField",
"instTopENat",
"Real.instRCLike",
"TopologicalSpace.IsOpen",
"DiffeologicalSpace.mk",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",... | false |
GenContFract.s | Mathlib.Algebra.ContinuedFractions.Basic | [
"Stream'.Seq",
"GenContFract",
"GenContFract.Pair"
] | true |
VectorBundleCore.inCoordinates_eq | Mathlib.Topology.VectorBundle.Basic | [
"ContinuousLinearMap.comp",
"ContinuousLinearMap.inCoordinates._proof_4",
"Eq.mpr",
"VectorBundleCore.trivializationAt_symmL",
"VectorBundleCore.Fiber",
"NormedSpace",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.inCoordinates._proof_2",
"VectorBundleCore.toTopologicalSpace",
... | true |
CategoryTheory.GrothendieckTopology.Cover.Relation.ext_iff | Mathlib.CategoryTheory.Sites.Grothendieck | [
"CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation",
"CategoryTheory.GrothendieckTopology.Cover.Relation.ext",
"HEq.refl",
"Eq.casesOn",
"HEq.rfl",
"And.casesOn",
"And",
"Iff",
"CategoryTheory.GrothendieckTopology.Cover.Arrow",
"CategoryTheory.GrothendieckTopology.Cover",
"CategoryTheory.... | true |
FractionalIdeal.coeFun_mapEquiv | Mathlib.RingTheory.FractionalIdeal.Operations | [
"CommRing",
"FractionalIdeal.instAdd",
"AlgEquiv.toAlgHom",
"CommSemiring.toSemiring",
"RingEquiv.instEquivLike",
"Algebra",
"FractionalIdeal.mapEquiv",
"FractionalIdeal.instMul",
"MulZeroOneClass.toMulOneClass",
"instMulZeroOneClassOfSemiring",
"FractionalIdeal",
"CommRing.toCommSemiring",
... | true |
PiTensorProduct.liftAlgHom_apply | Mathlib.RingTheory.PiTensorProduct | [
"PiTensorProduct.instModule",
"NonAssocSemiring.toAddCommMonoidWithOne",
"PiTensorProduct.liftAlgHom._proof_3",
"HMul.hMul",
"PiTensorProduct.liftAlgHom",
"CommSemiring.toSemiring",
"AlgHom",
"MultilinearMap.addCommMonoid",
"AlgHom.funLike",
"LinearMap.instFunLike",
"Algebra",
"Algebra.toModul... | true |
Lean.Elab.Info.ofDocElabInfo | Lean.Elab.InfoTree.Types | [
"Lean.Elab.Info.ofDocElabInfo",
"Lean.Elab.Info",
"Lean.Elab.DocElabInfo"
] | true |
Std.ExtDTreeMap.get?_union_of_not_mem_right | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Std.ExtDTreeMap.instUnionOfTransCmp",
"Std.ExtDTreeMap.inductionOn₂",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.LawfulEqCmp",
"Std.ExtDTreeMap",
"Union.union",
"Std.ExtDTreeMap.get?",
"Eq",
"Std.ExtDTreeMap.instMembershipOfTransCmp",
"Not",
... | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | [
"le_iff_eq_or_lt",
"Iff.mpr",
"Eq.mpr",
"instDecidableNot",
"False",
"Nat.instMulZeroClass",
"Nat.instOrderedSub",
"Preorder.toLT",
"instDecidableTrue",
"eq_false",
"Nat.instOne",
"and_true",
"_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities... | true |
Cycle.Chain.nil._simp_1 | Mathlib.Data.List.Cycle | [
"Cycle.Chain.nil",
"Cycle.Chain",
"True",
"eq_true",
"Eq",
"Cycle.nil"
] | false |
FirstOrder.Language.Theory.ModelType.leftStructure | Mathlib.ModelTheory.Bundled | [
"FirstOrder.Language.Theory.ModelType",
"FirstOrder.Language.Theory.ModelType.struc",
"FirstOrder.Language.LHom.reduct",
"FirstOrder.Language.Theory",
"FirstOrder.Language.Structure",
"FirstOrder.Language.Theory.ModelType.Carrier",
"FirstOrder.Language.sum",
"FirstOrder.Language",
"FirstOrder.Langua... | true |
Lean.Lsp.instToJsonLeanDiagnosticTag | Lean.Data.Lsp.Diagnostics | [
"Lean.JsonNumber.fromNat",
"Lean.Json",
"Lean.Lsp.instToJsonLeanDiagnosticTag.match_1",
"instOfNatNat",
"Unit",
"Nat",
"Lean.Lsp.LeanDiagnosticTag",
"Lean.ToJson.mk",
"Lean.ToJson",
"OfNat.ofNat",
"Lean.Json.num"
] | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_spanning_iff._simp_1_7 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | [
"Subalgebra.instSetLike",
"IsDomain",
"CommRing",
"Subalgebra.mem_algebraicClosure",
"IsAlgebraic",
"CommSemiring.toSemiring",
"Algebra",
"Membership.mem",
"CommRing.toCommSemiring",
"propext",
"CommRing.toRing",
"Subalgebra",
"Eq",
"SetLike.instMembership",
"Subalgebra.algebraicClosure"... | false |
RCLike.cauSeqIm | Mathlib.Analysis.RCLike.Basic | [
"NormedCommRing.toNormedRing",
"Norm.norm",
"Real",
"NormedRing.toRing",
"Real.lattice",
"AddMonoid.toAddSemigroup",
"Real.instAddMonoid",
"abs",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"NormedField.toField",
"AddZeroClass.toAddZero",
"NormedField.toNorm",
"Real.instAddGroup",
"R... | true |
Std.Internal.IO.Async.System.instDecidableEqCPUInfo.decEq | Std.Internal.Async.System | [
"Decidable.isTrue",
"_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.instDecidableEqCPUInfo.decEq._proof_1",
"Std.Internal.IO.Async.System.CPUInfo.mk",
"String",
"_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.instDecidableEqCPUInfo.decEq._proof_4",
"Decidable",
"Std... | true |
Mathlib.Tactic.Module.matchScalarsAux | Mathlib.Tactic.Module | [
"Pure.pure",
"Mathlib.Tactic.Module.reduceCoefficientwise",
"Lean.MessageData",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Mathlib.Tactic.Module.qNF.toNF",
"Lean.Meta.whnf",
"Lean.instMonadMCtxOfMonadLift",
"Mathlib.Tactic.Module.qNF",
"instInhabitedOfMonad",
"ReaderT",
"Le... | true |
Metric.closedBall_disjoint_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | [
"Iff.mpr",
"Real",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"Set.disjoint_left",
"covariant_swap_add_of_covariant_add",
"add_le_add",
"PartialOrder.toPreorder",
"Real.instLT",
"Preorder.toLE",
"Disjoint",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"CompleteLattice.toConditi... | true |
Batteries.Tactic.instNonemptyCache | Batteries.Util.Cache | [
"_private.Batteries.Util.Cache.0.Batteries.Tactic.instNonemptyCache._proof_1",
"Batteries.Tactic.Cache",
"Nonempty"
] | true |
_private.Mathlib.RingTheory.Valuation.Discrete.RankOne.0.Valuation.IsRankOneDiscrete.generator_eq_exp_neg_one_of_mem_range._simp_1_2 | Mathlib.RingTheory.Valuation.Discrete.RankOne | [
"Units.val",
"GroupWithZero.toMonoidWithZero",
"HMul.hMul",
"MulZeroClass.toMul",
"Membership.mem",
"Exists",
"Units",
"Subgroup",
"Ne",
"Units.instGroup",
"MonoidWithZeroHomClass",
"And",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"CommGroupWithZero",
"propext",
"MonoidWi... | false |
Fin.rev_lt_rev._simp_1 | Init.Data.Fin.Lemmas | [
"Fin.rev",
"Nat",
"LT.lt",
"instLTFin",
"propext",
"Fin",
"Eq",
"Fin.rev_lt_rev"
] | false |
TruncatedWittVector.out.eq_1 | Mathlib.RingTheory.WittVector.Truncated | [
"TruncatedWittVector.coeff",
"CommRing",
"CommSemiring.toSemiring",
"Fin.mk",
"dite",
"CommRing.toCommSemiring",
"WittVector",
"Nat",
"LT.lt",
"TruncatedWittVector.out",
"WittVector.mk'",
"Nat.decLt",
"Zero.toOfNat0",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
"Eq",
"Not",
"MulZeroCl... | true |
PeriodPair.derivWeierstrassP_neg | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"AddGroup.toSubtractionMonoid",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"Mathlib.Tactic.Ring.Common.neg_mul",
"SubtractionMonoid.t... | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.noConfusionType | Lean.Meta.IndPredBelow | [
"Lean.FVarId",
"_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl",
"Array",
"Nat",
"Lean.Name",
"Lean.LocalDecl",
"Eq",
"_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.casesOn"
] | false |
MonomialOrder.degree_pow_of_pow_leadingCoeff_ne_zero | Mathlib.RingTheory.MvPolynomial.MonomialOrder | [
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"instHSMul",
"MvPolynomial.mem_support_iff",
"congrArg",
"CommSemiring.toSemiring",
"MonomialOrder.leadingCoeff",
"Finset",
"MonomialOrder.syn",
"AddMonoid.toAddZeroClass",
"MonomialOrder.le_degree",
"Finsupp.instAddMonoid",
"N... | true |
FractionalIdeal.coe_spanSingleton | Mathlib.RingTheory.FractionalIdeal.Operations | [
"Eq.mpr",
"Submodule",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"FractionalIdeal.spanSingleton",
"CommRing.toNonUnitalCommRing",
"IsLocalization",
"congrArg",
"CommSemiring.toSemiring",
"IsFractional",
"Algebra",
"Algebra.toModule",
"Set.instSingletonSet",
"id",
"NonU... | true |
Ideal.span_singleton_mul_right_inj | Mathlib.RingTheory.Ideal.Operations | [
"IsDomain",
"Semiring.toModule",
"HMul.hMul",
"IsScalarTower.right",
"congrArg",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Algebra.id",
"Set.instSingletonSet",
"Ne",
"Submodule.instPartialOrder",
"LE.le",
"Ideal",
"Submodule.mul",
"iff_self",
"CommSemiri... | true |
Lean.Parser.Term.doTry._regBuiltin.Lean.Parser.Term.doTry.formatter_19 | Lean.Parser.Do | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Lean.Parser.Term.doTry.formatter",
"Unit",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.Grind.setConfigField._sparseCasesOn_4 | Lean.Elab.Tactic.Grind.Config | [
"Lean.DataValue.ofInt",
"Nat.ne_of_beq_eq_false",
"Lean.DataValue.rec",
"String",
"Nat.shiftRight",
"Lean.DataValue.ctorIdx",
"Lean.Syntax",
"Nat.hasNotBit",
"instOfNatNat",
"Int",
"Nat.land",
"Nat",
"Lean.DataValue.ofBool",
"Lean.DataValue.ofString",
"Bool",
"Lean.Name",
"Eq.refl",
... | false |
_private.Mathlib.Analysis.Analytic.ConvergenceRadius.0.FormalMultilinearSeries.isLittleO_of_lt_radius._simp_1_7 | Mathlib.Analysis.Analytic.ConvergenceRadius | [
"False",
"eq_false",
"pow_ne_zero",
"Ne",
"Monoid.toPow",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"Zero.toOfNat0",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq",
"MonoidWithZero.toMonoid",
"MulZeroClass.toZero",
"IsReduced"
] | false |
Std.DTreeMap.Internal.Impl.size_inter_le_size_left | Std.Data.DTreeMap.Internal.Lemmas | [
"Eq.mpr",
"List.length_filter_le",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"beqOfOrd",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.size",
"id",
"Sigma.fst",
"LE.le",
"Std.DTreeMap.Internal.Impl.WF",
"instLENat",
"Std.DTreeMap.Internal.Impl.WF.balanced",
"List.Perm.length_eq",
"Std.I... | true |
CategoryTheory.Bicategory.LeftLift.ofIdComp_hom | Mathlib.CategoryTheory.Bicategory.Extension | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Comma.hom",
"CategoryTheory.Bicategory.LeftLift.lift",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory.postcomp",
"CategoryTheory.Bicategory.leftUnitor",
"CategoryTheo... | true |
AlgebraicTopology.AlternatingCofaceMapComplex.obj.eq_1 | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | [
"CategoryTheory.CosimplicialObject",
"Nat.instOne",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.instAddCancelCommMonoid",
"AlgebraicTopology.AlternatingCofaceMapComplex.d_squared",
"CategoryTheory.Preadditive",
"SimplexCategory.mk",
"CochainComplex",
"Nat",
"SimplexCategory",
"CategoryTheory.... | true |
Lean.Elab.DocElabInfo | Lean.Elab.InfoTree.Types | [
"Lean.Elab.DocElabInfo.mk"
] | true |
lipschitzGroup.coe_mem_iff_mem | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | [
"Units.val",
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"CommRing",
"MonoidHom.instFunLike",
"Units.coeHom",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"CliffordAlgebra",
"QuadraticForm",
"Membership.mem",
"Exists",
"Units... | true |
mul_sub_right_distrib | Mathlib.Algebra.Ring.Defs | [
"add_mul",
"NonUnitalNonAssocRing",
"Eq.mpr",
"NegZeroClass.toNeg",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGroup",
"sub_eq_add_neg",
"HSub.hSub",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"AddCommGroup.toAddGroup",
"Distrib.rightDistribClass",
... | true |
cyclotomicCharacter.toFun_spec | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | [
"Units.val",
"Eq.mpr",
"IsDomain",
"CommRing",
"Nat.Prime",
"MonoidHom.instFunLike",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"ZMod.commRing",
"PadicInt",
"Nat.instOne",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"modularCyclotomicCharacter.spe... | true |
Polynomial.isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub | Mathlib.RingTheory.Polynomial.Nilpotent | [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Eq.mpr",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"AddMonoid.toAddZeroClass",
"Poly... | true |
CategoryTheory.CommGrp | Mathlib.CategoryTheory.Monoidal.CommGrp_ | [
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.CartesianMonoidalCategory",
"CategoryTheory.BraidedCategory",
"CategoryTheory.CommGrp.mk",
"CategoryTheory.Category",
"CategoryTheory.CartesianMonoidalCategory.toSemiCartesianMonoidalCategory"
] | true |
isLindelof_iff_countable_subcover | Mathlib.Topology.Compactness.Lindelof | [
"Membership.mem",
"Exists",
"HasSubset.Subset",
"isLindelof_of_countable_subcover",
"TopologicalSpace",
"And",
"Iff",
"Iff.intro",
"IsLindelof.elim_countable_subcover",
"IsOpen",
"IsLindelof",
"Set.Countable",
"Set.instMembership",
"Set.iUnion",
"Set.instHasSubset",
"Set"
] | true |
Std.DHashMap.Internal.Raw₀.getEntryₘ | Std.Data.DHashMap.Internal.Model | [
"Std.DHashMap.Internal.AssocList.getEntry",
"Std.DHashMap.Raw",
"instOfNatNat",
"Std.DHashMap.Internal.Raw₀.replaceₘ._proof_2",
"Bool.true",
"Std.DHashMap.Internal.Raw₀.containsₘ",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Bool",
"Std.DHashMap.Internal.bucket",
"Std.DHashMap.Internal.AssocL... | true |
AddCon.addMonoid | Mathlib.GroupTheory.Congruence.Defs | [
"AddCon",
"instHSMul",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"AddCon.addSemigroup",
"AddMonoid.mk",
"AddZeroClass.toAddZero",
"AddCon.zero",
"AddCon.addMonoid._proof_2",
"AddZero.toZero",
"AddCon.nsmul",
"AddCon.toSetoid",
"Nat",
"AddCon.addMonoid._... | true |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_9 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | [
"CategoryTheory.Limits.FormalCoproduct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Function.Pullback",
"CategoryTheory.eqToHom",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.Limits.PullbackCone.fst",
"Prod.mk",
"CategoryTheory.Limits.Cone.pt",
"CategoryTheory.... | false |
RootPairing.ker_polarization_eq_ker_rootForm | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | [
"Submodule",
"_private.Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear.0.RootPairing.ker_polarization_eq_ker_rootForm._simp_1_1",
"CommRing",
"Semiring.toModule",
"RootPairing.RootForm",
"LinearMap.BilinForm",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddMon... | true |
Lean.Meta.DSimp.Config.zetaHave | Init.MetaTypes | [
"Lean.Meta.DSimp.Config",
"Bool"
] | true |
Std.Tactic.BVDecide.Return.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred | [
"Std.Sat.AIG.Entrypoint.aig",
"Std.Sat.AIG.Decl",
"Std.Sat.AIG.Entrypoint",
"LE.le",
"instLENat",
"Std.Sat.AIG",
"Std.Tactic.BVDecide.Return.mk",
"Nat",
"Std.Sat.AIG.ExtendingEntrypoint",
"Std.Tactic.BVDecide.BVExpr.Cache",
"Std.Tactic.BVDecide.instDecidableEqBVBit",
"Std.Tactic.BVDecide.Retur... | true |
ComplexShape.instTotalComplexShape._proof_3 | Mathlib.Algebra.Homology.ComplexShapeSigns | [
"ComplexShape.ε_succ",
"Eq.mpr",
"ComplexShape.ε",
"MulOne.toOne",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"congrArg",
"Units.instNeg",
"Units",
"neg_neg",
"id",
"MulOne.toMul",
"Prod.mk",
"Int",
"ComplexShape",
"Units.instOne",
... | false |
Int.gcd_mul_right_right | Init.Data.Int.Gcd | [
"Nat.gcd",
"Int.gcd",
"Nat.gcd_mul_right_right",
"HMul.hMul",
"Int.natAbs_mul",
"congrArg",
"instMulNat",
"Int",
"Int.instMul",
"Nat",
"True",
"Int.natAbs",
"eq_self",
"of_eq_true",
"congrFun'",
"Eq",
"Eq.trans",
"instHMul"
] | true |
Monotone.functor | Mathlib.CategoryTheory.Category.Preorder | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Monotone.functor._proof_3",
"CategoryTheory.Functor.mk",
"Monotone",
"Preorder.smallCategory",
"CategoryTheory.homOfLE",
"CategoryTheory.Category.toCategoryStruct",
"Monotone.functor._proof_1",
"Preorder",
"Mono... | true |
Lean.Environment.unlockAsync | Lean.Environment | [
"_private.Lean.Environment.0.Lean.Environment.importRealizationCtx?",
"Lean.Environment.checked",
"_private.Lean.Environment.0.Lean.Environment.asyncConstsMap",
"_private.Lean.Environment.0.Lean.AsyncContext",
"Option.none",
"_private.Lean.Environment.0.Lean.Environment.serverBaseExts",
"Lean.Environmen... | true |
SemidirectProduct.instGroup._proof_16 | Mathlib.GroupTheory.SemidirectProduct | [
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"SemidirectProduct",
"MulAut.instGroup",
"SemidirectProduct.instMul",
"Group",
"MulAut",
"MulOne.toMul",
"SemidirectProduct.instInv",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"SemidirectProduct.instGroup._pro... | false |
Nat.isLE_compare | Init.Data.Nat.Compare | [
"Ordering.gt",
"Eq.mpr",
"False",
"Decidable.casesOn",
"congrArg",
"False.elim",
"iff_true",
"Decidable",
"noConfusion_of_Nat",
"Ordering",
"Ordering.eq",
"Eq.mp",
"id",
"LE.le",
"instLENat",
"false_iff",
"if_pos",
"Ord.compare",
"Nat.not_le._simp_1",
"Bool.ctorIdx",
"Bool.tr... | true |
_private.Std.Data.Iterators.Lemmas.Combinators.DropWhile.0.Std.Iter.step_intermediateDropWhile.match_3.eq_2 | Std.Data.Iterators.Lemmas.Combinators.DropWhile | [
"Std.IterStep",
"Std.IterStep.skip",
"Id",
"Std.Iterator",
"Subtype.mk",
"Std.Iter",
"Std.IterStep.yield",
"Std.Iter.step_intermediateDropWhile.match_3",
"Std.Iter.IsPlausibleStep",
"Std.IterStep.done",
"Eq.refl",
"Eq",
"Std.Iter.Step"
] | true |
Subalgebra.rank_top | Mathlib.LinearAlgebra.Dimension.Constructions | [
"Subalgebra.instSetLike",
"Eq.mpr",
"Submodule",
"Lattice.toSemilatticeSup",
"Cardinal",
"CompleteLattice.toLattice",
"congrArg",
"CommSemiring.toSemiring",
"Submodule.addCommMonoid",
"PartialOrder.toPreorder",
"Algebra.instCompleteLatticeSubalgebra",
"Algebra",
"Preorder.toLE",
"Membershi... | true |
Lean.Grind.Linarith.Poly.denote_combine | Init.Grind.Ordered.Linarith | [
"Nat.blt",
"Std.Commutative",
"Lean.Grind.AddCommMonoid.add_left_comm",
"Lean.Grind.Linarith.Poly.denote",
"Eq.mpr",
"False",
"instHSMul",
"Lean.Grind.Linarith.Poly.combine",
"Lean.Data.AC.Expr.var",
"congrArg",
"Lean.Grind.Linarith.Context",
"Lean.Grind.IntModule.toNatModule",
"Lean.Grind.A... | true |
_private.Mathlib.RingTheory.LocalProperties.InjectiveDimension.0.ModuleCat.injectiveDimension_le_injectiveDimension_of_isLocalizedModule._simp_1_4 | Mathlib.RingTheory.LocalProperties.InjectiveDimension | [
"ModuleCat.isZero_iff_subsingleton",
"ModuleCat",
"ModuleCat.moduleCategory",
"ModuleCat.carrier",
"propext",
"CategoryTheory.Limits.IsZero",
"Subsingleton",
"Eq",
"Ring"
] | false |
_private.Init.Data.Order.Ord.0.Std.instTransCmpCompareLex._simp_1 | Init.Data.Order.Ord | [
"Ordering",
"Ordering.then",
"Bool.true",
"And",
"Ordering.isLE_then_iff_and",
"Ordering.lt",
"propext",
"Bool",
"Or",
"Ordering.isLE",
"Eq"
] | false |
SupConvergenceClass.casesOn | Mathlib.Topology.Order.MonotoneConvergence | [
"SupConvergenceClass.mk",
"Preorder.toLE",
"Membership.mem",
"nhds",
"Subtype",
"SupConvergenceClass",
"Filter.atTop",
"TopologicalSpace",
"Filter.Tendsto",
"IsLUB",
"SupConvergenceClass.rec",
"Subtype.val",
"Set.instMembership",
"Preorder",
"Subtype.preorder",
"Set"
] | false |
LeftCancelSemigroup.casesOn | Mathlib.Algebra.Group.Defs | [
"Semigroup",
"Semigroup.toMul",
"LeftCancelSemigroup.rec",
"IsLeftCancelMul",
"LeftCancelSemigroup",
"LeftCancelSemigroup.mk"
] | false |
IsSelfAdjoint.norm_eq_max_norm_posPart_negPart._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Isometric | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
CategoryTheory.Retract.ofIso | Mathlib.CategoryTheory.Retract | [
"CategoryTheory.Iso",
"CategoryTheory.Retract",
"CategoryTheory.Retract.mk",
"CategoryTheory.Iso.hom",
"CategoryTheory.Iso.inv",
"CategoryTheory.Retract.ofIso._proof_2",
"CategoryTheory.Category"
] | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.Path.listL.match_1.eq_3 | Batteries.Data.RBMap.Lemmas | [
"Batteries.RBNode",
"Batteries.RBNode.Path",
"Batteries.RBNode.Path.root",
"Unit",
"Batteries.RBColor",
"Batteries.RBNode.Path.listL.match_1",
"Eq.refl",
"Batteries.RBNode.Path.right",
"Eq",
"Batteries.RBNode.Path.left"
] | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | [
"Unit.unit",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst._proof_4",
"False",
"Mul.mk",
"List.zipWith",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"HMul.hMul",
"Int.natCast_add",
"Nat.ne_of_beq_eq_false",
"of_decide_eq_true",
"le_of_le_of_eq",
"Std.Sat.AIG.RefVec.push",
"... | false |
NumberField.RingOfIntegers.restrict.eq_1 | Mathlib.NumberTheory.NumberField.Basic | [
"Subalgebra.instSetLike",
"NumberField.RingOfIntegers.restrict",
"CommSemiring.toSemiring",
"Membership.mem",
"Field.toDivisionRing",
"DivisionRing.toRing",
"Int",
"Field.toCommRing",
"Subtype.mk",
"CommRing.toCommSemiring",
"IsIntegral",
"Int.instCommRing",
"integralClosure",
"Ring.toIntA... | true |
BddDistLat.Hom.rec | Mathlib.Order.Category.BddDistLat | [
"_private.Mathlib.Order.Category.BddDistLat.0.BddDistLat.Hom.mk",
"BddDistLat.isBoundedOrder",
"BddDistLat.instDistribLatticeCarrier",
"BddDistLat.Hom",
"BddDistLat",
"DistribLattice.toLattice",
"BoundedLatticeHom",
"BddDistLat.toDistLat",
"DistLat.carrier"
] | false |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars.match_1 | Lean.Meta.Tactic.Cleanup | [
"Lean.CollectFVars.State",
"Prod.mk",
"Unit",
"Prod",
"Prod.casesOn"
] | false |
Finset.exists_not_mem_of_card_lt_enatCard | Mathlib.Data.Set.Card | [
"Mathlib.Tactic.Push.not_exists._simp_1",
"Eq.mpr",
"Set.encard",
"Preorder.toLT",
"ENat.instNatCast",
"instLinearOrderENat",
"instReflLe",
"congrArg",
"Finset",
"Set.univ",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Std.le_refl._simp_1",
"Membership.mem",
"Exists",
"instPreorderENat... | true |
mem_nullAddSubgroup_iff | Mathlib.Analysis.Normed.Group.NullSubmodule | [
"Norm.norm",
"Real",
"SeminormedAddCommGroup",
"Real.instZero",
"Iff.rfl",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddSubgroup",
"SeminormedAddCommGroup.toNorm",
"Iff",
"SeminormedAddCommGroup.toAddCommGroup",
"AddSubgroup.instSetLike",
"Zero.toOfNat0",
"nullAddSubgroup",
"OfNat.of... | true |
addAddMonoidHom._proof_2 | Mathlib.Algebra.Group.Prod | [
"addAddHom",
"Prod.instAdd",
"AddHom.map_add'",
"AddCommMonoid",
"instHAdd",
"HAdd.hAdd",
"AddCommSemigroup.toAddCommMagma",
"Prod",
"AddCommMonoid.toAddCommSemigroup",
"Eq",
"AddHom.toFun",
"AddCommMagma.toAdd"
] | false |
CategoryTheory.Limits.image.ι_zero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | [
"CategoryTheory.Limits.MonoFactorisation.I",
"Eq.mpr",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.comp_zero",
"CategoryTheory.Limits.image.ι",
"id",
"CategoryTheory.Limits.image.lift_fac",
"CategoryTheory.L... | true |
isTop_ofDual_iff | Mathlib.Order.Max | [
"OrderDual.instLE",
"Equiv.instEquivLike",
"OrderDual.ofDual",
"Iff.rfl",
"IsBot",
"Equiv",
"LE",
"Iff",
"IsTop",
"OrderDual",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
addOrderOf_smul_dvd | Mathlib.GroupTheory.OrderOfElement | [
"Eq.mpr",
"instHSMul",
"Dvd.dvd",
"congrArg",
"AddMonoid.toAddZeroClass",
"addOrderOf",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"nsmul_zero",
"id",
"AddZero.toZero",
"addOrderOf_dvd_iff_nsmul_eq_zero",
"Nat.instDvd",
"addOrderOf_nsmul_eq_zero",
"Nat",
"AddMonoid",
"propext",
... | true |
_private.Lean.Util.Diff.0.Lean.Diff.lcs.match_1 | Lean.Util.Diff | [
"Unit.unit",
"Subarray",
"Option.casesOn",
"Option.some",
"Prod.mk",
"Option.none",
"Unit",
"Std.Slice.Internal.SubarrayData",
"Nat",
"Std.Slice.size",
"Subarray.instSliceSizeSubarrayData",
"Prod",
"Prod.casesOn",
"Fin",
"Option"
] | false |
ContinuousAlternatingMap.mk.noConfusion | Mathlib.Topology.Algebra.Module.Alternating.Basic | [
"HEq.refl",
"ContinuousAlternatingMap.mk",
"AddMonoid.toAddZeroClass",
"ContinuousMultilinearMap",
"ContinuousAlternatingMap.noConfusion",
"AddZeroClass.toAddZero",
"id",
"Ne",
"AddCommMonoid",
"TopologicalSpace",
"AddZero.toZero",
"heq_of_eq",
"MultilinearMap.toFun",
"ContinuousMultilinea... | false |
CoxeterMatrix.reindexGroupEquiv_apply_simple | Mathlib.GroupTheory.Coxeter.Basic | [
"CoxeterMatrix.simple",
"MulEquiv.instEquivLike",
"Equiv.instEquivLike",
"CoxeterMatrix.reindex",
"Monoid.toMulOneClass",
"CoxeterMatrix.Group",
"Equiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"CoxeterMatrix",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"CoxeterMatrix.instGroupGroup",
... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_erase._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"LawfulBEq",
"Ne",
"beq_eq_false_iff_ne",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"BEq",
"Eq"
] | false |
Mathlib.Tactic.DepRewrite.visitInner | Mathlib.Tactic.DepRewrite | [
"Inhabited.default",
"Lean.Core.instMonadLiftIOCoreM",
"instInhabitedOfMonad",
"IO.instMonadLiftSTRealWorldBaseIO",
"Lean.Meta.State",
"IO",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.MonadCacheT",
"ReaderT.instMonadLift",
"Lean.MonadCacheT.instMonad",
"ST",
"Lean.Core.CoreM",
... | true |
Std.DTreeMap.Internal.Impl.getKey.eq_1 | Std.Data.DTreeMap.Internal.Model | [
"Ordering.gt",
"Ord",
"Std.DTreeMap.Internal.Impl.getKey",
"Ordering",
"Ordering.eq",
"Std.DTreeMap.Internal.Impl.inner",
"Ord.compare",
"Bool.true",
"Std.DTreeMap.Internal.Impl.contains",
"Ordering.lt",
"Nat",
"Bool",
"Eq.refl",
"Std.DTreeMap.Internal.Impl.getKey._proof_4",
"Eq",
"Std... | true |
Algebra.prod_embeddings_eq_finrank_pow | Mathlib.RingTheory.Norm.Basic | [
"PowerBasis",
"Eq.mpr",
"PowerBasis.AlgHom.fintype",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Fintype.prod_equiv",
"CommRing.toNonUnitalCommRing",
"Finset.univ",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"Finset",
"IsScalarTower",
"algHomEquivSigma",
... | true |
CategoryTheory.MonoidalCategory.whiskerLeftIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Category | [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Iso",
"CategoryTheory.MonoidalCategory.whiskerLeft_hom_inv",
"CategoryTheory.MonoidalCategor... | false |
SimplexCategoryGenRel.IsAdmissible.pairwise | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | [
"List.SortedLT",
"List",
"Nat.instPreorder",
"Nat",
"SimplexCategoryGenRel.IsAdmissible.sortedLT",
"SimplexCategoryGenRel.IsAdmissible"
] | true |
AddOpposite.instAddAction.eq_1 | Mathlib.Algebra.Group.Action.Opposite | [
"AddAction.mk",
"AddMonoid.toAddSemigroup",
"AddOpposite.instAddAction",
"AddOpposite",
"AddAction",
"AddAction.toAddSemigroupAction",
"AddSemigroupAction.mk",
"AddSemigroupAction.toVAdd",
"AddMonoid",
"AddOpposite.instAddAction._proof_1",
"Eq.refl",
"AddOpposite.instVAdd",
"AddOpposite.inst... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_union._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 |
Small.recOn | Mathlib.Logic.Small.Defs | [
"Small.rec",
"Exists",
"Equiv",
"Small.mk",
"Nonempty",
"Small"
] | false |
LinearEquiv.arrowCongr._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | [
"Equiv.right_inv",
"CommSemiring.toSemiring",
"RingHom",
"RingHomCompTriple",
"LinearMap.instAdd",
"Equiv.toFun",
"LinearMap",
"AddCommMonoid",
"RingHomInvPair",
"CommSemiring",
"LinearEquiv.arrowCongrAddEquiv",
"LinearEquiv",
"Function.RightInverse",
"Semiring",
"AddEquiv.toEquiv",
"M... | false |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctor₁₂BifunctorMapObj._proof_13 | Mathlib.CategoryTheory.GradedObject.Trifunctor | [
"CategoryTheory.GradedObject.BifunctorComp₁₂IndexData",
"congrArg",
"CategoryTheory.GradedObject.BifunctorComp₁₂IndexData.I₁₂",
"Membership.mem",
"Eq.mp",
"Set.instSingletonSet",
"id",
"Prod.mk",
"Set.mem_preimage._simp_1",
"Prod.fst",
"CategoryTheory.GradedObject.isColimitCofan₃MapBifunctor₁₂Bi... | false |
FormalMultilinearSeries.instAddCommGroup._proof_9 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | [
"AddMonoid.toAddSemigroup",
"FormalMultilinearSeries",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"ContinuousMultilinearMap.instAddCommGroup",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"ContinuousMultilinearMap",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Pi.s... | false |
Multiset.fst_prod | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | [
"MonoidHom.instMonoidHomClass",
"MonoidHom.instFunLike",
"Multiset.map",
"MonoidHom",
"Monoid.toMulOneClass",
"Multiset.prod",
"Prod.instMulOneClass",
"Multiset",
"Prod.fst",
"map_multiset_prod",
"MulOneClass.toMulOne",
"CommMonoid.toMonoid",
"MonoidHom.fst",
"Prod",
"Prod.instCommMonoid... | true |
Finset.vadd_stabilizer_of_no_doubling | Mathlib.Combinatorics.Additive.VerySmallDoubling | [
"AddMonoid.toAddSemigroup",
"instVAddOfAdd",
"Finset",
"Finset.addActionFinset",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddOpposite",
"Set.vaddSet",
"LE.le",
"instLENat",
"HVAdd.hVAdd",
"_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.vadd... | true |
Equiv.Set.sep | Mathlib.Logic.Equiv.Set | [
"setOf",
"Membership.mem",
"Set.Elem",
"Equiv",
"Subtype",
"And",
"Equiv.subtypeSubtypeEquivSubtypeInter",
"Equiv.symm",
"Subtype.val",
"Set.instMembership",
"Set"
] | true |
CategoryTheory.Limits.pullbackDiagonalMapIdIso._proof_10 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.CategoryStruct.id",
"id",
"CategoryTheory.Limits.HasPullback",
"CategoryTheory.Category.comp_id",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory... | false |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar.typeToCharP._sparseCasesOn_4 | Mathlib.Tactic.ReduceModChar | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
Topology.IsScott.isOpen_iff_scottContinuous_mem | Mathlib.Topology.Order.ScottTopology | [
"Eq.mpr",
"isOpen_iff_continuous_mem",
"Continuous",
"congrArg",
"scottContinuousOn_univ",
"Set.univ",
"ScottContinuous",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Prop.instCompleteLinearOrder",
"id",
"instIsUpperProp",
"LE.le",
"TopologicalSpace",
"Topology.IsScot... | true |
_private.Lean.Meta.Tactic.Simp.Attr.0.Lean.Meta.addDeclToUnfold._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Attr | [
"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 |
HomologicalComplex.op._proof_1 | Mathlib.Algebra.Homology.Opposite | [
"Eq.mpr",
"CategoryTheory.Limits.HasZeroMorphisms",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Quiver.Hom.op",
"HomologicalComplex",
"id",
"ComplexShape",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"Opposite.op",
"CategoryTheory.... | false |
ZMod.toAddCircle_injective | Mathlib.Topology.Instances.AddCircle.Real | [
"Iff.mpr",
"Real.instIsOrderedRing",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"instHDiv",
"Real.instArchimedean",
"Nat.cast_pos",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"GroupWithZero.toDivInvMonoi... | true |
WithBot.instMonoidWithZero | Mathlib.Algebra.Order.Ring.WithTop | [
"WithBot.instMonoidWithZero._proof_8",
"Nontrivial",
"WithBot.instMonoidWithZero._proof_6",
"WithBot.instMonoidWithZero._proof_5",
"MulOne.toOne",
"WithBot",
"MulZeroClass.toMul",
"WithBot.zero",
"WithBot.instMonoidWithZero._aux_3",
"SemigroupWithZero.toSemigroup",
"WithBot.instMonoidWithZero._p... | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.bitwise_lt_two_pow._simp_1_1 | Init.Data.Nat.Bitwise.Lemmas | [
"instPowNat",
"instOfNatNat",
"instNatPowNat",
"_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.eq_0_of_lt",
"HPow.hPow",
"Nat",
"LT.lt",
"propext",
"instHPow",
"instLTNat",
"OfNat.ofNat",
"Eq"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.