name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.antisymm_aux.match_1_1 | Mathlib.Combinatorics.Colex | [
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"PartialOrder",
"LE.le",
"And.casesOn",
"And",
"Exists.casesOn",
"Finset.instSetLike",
"And.intro",
"Exists.intro",
"Not",
"SetLike.instMembership"
] | false |
CategoryTheory.BiconeHom.decidableEq._proof_20 | Mathlib.CategoryTheory.Limits.Bicones | [
"CategoryTheory.Bicone.right",
"CategoryTheory.Bicone.diagram",
"CategoryTheory.BiconeHom.right",
"eq_of_heq",
"HEq",
"CategoryTheory.BiconeHom",
"Eq.symm",
"Eq",
"CategoryTheory.Category"
] | false |
CategoryTheory.IsRegularEpi.w | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | [
"CategoryTheory.IsRegularEpi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.IsRegularEpi.W",
"CategoryTheory.IsRegularEpi.getStruct",
"CategoryTheory.IsRegularEpi.right",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.IsRe... | true |
Algebra.TensorProduct.lift._proof_7 | Mathlib.RingTheory.TensorProduct.Maps | [
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Algebra",
"Algebra.toSMul",
"AddZeroClass.toAddZero",
"Algebra.toModule",
"DistribSMul.toSMulZeroClass",
"LinearMap.IsScalarTower.compatibleSMul",
"CommSemiring",
"NonUnitalNonAssocSemiri... | false |
TopologicalSpace.NonemptyCompacts.instDiscreteUniformity | Mathlib.Topology.UniformSpace.Closeds | [
"UniformSpace",
"TopologicalSpace.NonemptyCompacts.instSetLike",
"TopologicalSpace.NonemptyCompacts",
"TopologicalSpace.NonemptyCompacts.isUniformEmbedding_coe",
"TopologicalSpace.NonemptyCompacts.uniformSpace",
"IsUniformEmbedding.discreteUniformity",
"SetLike.coe",
"UniformSpace.hausdorff.instDiscre... | true |
CategoryTheory.Limits.limitConeOfEqualizerAndProduct._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | [
"CategoryTheory.Limits.limit.π",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.Fan.mk",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Limits.HasLimit",
"... | false |
Aesop.RuleResult.proved | Aesop.Search.Expansion | [
"Aesop.RappRef",
"Array",
"Aesop.RuleResult",
"Aesop.RuleResult.proved"
] | true |
Nat.log_zero_right | Mathlib.Data.Nat.Log | [
"Iff.mpr",
"Nat.log_eq_zero_iff",
"instOfNatNat",
"le_total",
"LE.le",
"instLENat",
"Nat",
"LT.lt",
"Or",
"instLTNat",
"Nat.log",
"OfNat.ofNat",
"Eq",
"Nat.instLinearOrder"
] | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.weierstrassP_add_coe_aux._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | [
"AddMonoid.toAddSemigroup",
"even_two",
"Nat.instAtLeastTwoHAddOfNat",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"AddSemigroup.toAdd",
"Nat.instNeZeroSucc",
"Nat",
"True",
"Even",
"eq_true",
"AddMonoidWithOne.toAddMonoid",
"OfNat.ofNat",
"Eq",
"instOfNatAtLeastTwo",
"AddMonoidWithO... | false |
Functor.map_map | Init.Control.Lawful.Basic | [
"LawfulFunctor",
"Functor",
"Function.comp",
"Eq.symm",
"Eq",
"Functor.map",
"LawfulFunctor.comp_map"
] | true |
Function.Embedding.swap_apply | Mathlib.Logic.Embedding.Basic | [
"Equiv.instEquivLike",
"Equiv.swap",
"Function.Embedding",
"Equiv.Perm",
"Function.Injective.swap_apply",
"Function.Embedding.injective",
"Function.instFunLikeEmbedding",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike",
"DecidableEq"
] | true |
CategoryTheory.PresheafIsFinite | Mathlib.CategoryTheory.Subfunctor.Finite | [
"CategoryTheory.Functor",
"Lattice.toSemilatticeSup",
"Opposite",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"CategoryTheory.instCompleteLatticeSubfunctor",
"CategoryTheory.Subfunctor",
"OrderTop.toTop",
"BoundedOrder.toOrderTop",
... | true |
lp.instInnerProductSpace._proof_3 | Mathlib.Analysis.InnerProductSpace.l2Space | [
"NormedCommRing.toSeminormedCommRing",
"Trans.trans",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"fact_one_le_two_ennreal",
"Inner.inner",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"IsSemitopologicalRing.toIsSemitopologicalSemiring",
"EMetricSpace.metrizableSpace",
"SummationFilter",
"Na... | false |
Set.mem_inv_smul_set_iff | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | [
"instHSMul",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"Group",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"Exists",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"iff_self",
"funext",
"And",
"Iff",
"Inv.inv",
"_private.Mathlib.Algebra.Group.A... | true |
AddGroupSeminorm.instMax | Mathlib.Analysis.Normed.Group.Seminorm | [
"AddGroupSeminorm.instMax._proof_3",
"Real",
"AddGroupSeminorm.instMax._proof_1",
"Max.mk",
"Max",
"AddGroupSeminorm.instMax._proof_2",
"AddGroupSeminorm.funLike",
"AddGroupSeminorm",
"AddGroup",
"Real.instMax",
"Pi.instMaxForall_mathlib",
"Max.max",
"AddGroupSeminorm.mk",
"DFunLike.coe"
] | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_of_lt._proof_1_5 | Init.Data.BitVec.Lemmas | [
"Lean.Omega.LinearCombo.coordinate_eval_6",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"HMul.hMul",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.a... | false |
Lean.Meta.FunInd.Collector.main | Lean.Meta.Tactic.FunIndCollect | [
"Pure.pure",
"Lean.MVarId.withContext",
"Lean.Meta.FunIndInfo",
"_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.Collector.main.go",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"instMonadControlTOfPure",
"Lean.Meta.State",
"instMonadLiftT",
"IO",
"Lean.MVarI... | true |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_3 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | [
"AddLeftMono",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"add_nonneg",
"LE.le",
"AddZero.toZero",
"instHAdd",
"AddZeroClass",
"HAdd.hAdd",
"True",
"eq_true",
"AddZero.toAdd",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Preorder"
] | false |
instDiscreteTopologySignType | Mathlib.Topology.Instances.Sign | [
"DiscreteTopology",
"TopologicalSpace",
"DiscreteTopology.mk",
"SignType",
"instTopologicalSpaceSignType",
"rfl"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling.0.SimpleGraph.EdgeLabeling.ext_get.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | [
"Subtype.casesOn",
"Membership.mem",
"Set.Elem",
"SimpleGraph.edgeSet",
"Subtype.mk",
"SimpleGraph",
"Set.instMembership",
"Sym2",
"Set"
] | false |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.nodes._f | Mathlib.Tactic.Widget.StringDiagram | [
"Mathlib.Tactic.BicategoryLike.WhiskerLeft.of",
"Mathlib.Tactic.BicategoryLike.Mor₂",
"Mathlib.Tactic.BicategoryLike.WhiskerLeft.below",
"instOfNatNat",
"List.cons",
"Mathlib.Tactic.BicategoryLike.Atom₁",
"List",
"instHAdd",
"Mathlib.Tactic.BicategoryLike.WhiskerLeft",
"HAdd.hAdd",
"Mathlib.Tact... | false |
Std.DHashMap.Internal.Raw₀.getKey!_inter_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Eq.mpr",
"Inhabited.default",
"Std.Internal.List.DistinctKeys",
"Std.Internal.List.getKey!",
"Std.DHashMap.Internal.Raw₀.inter",
"Std.DHashMap.Internal.Raw₀.contains",
"Std.DHashMap.Internal.Raw.WF.out",
"congrArg",
"Std.DHashMap.Raw",
"panicWithPosWithDecl",
"Std.DHash... | true |
_private.Init.Data.List.Nat.Erase.0.List.getElem?_eraseIdx._proof_1_3 | Init.Data.List.Nat.Erase | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval",
"Option.some",
"id",
"instDecida... | false |
Mathlib.Tactic.Ring.Common.ExBaseNat._sizeOf_inst | Mathlib.Tactic.Ring.Common | [
"Lean.Expr.const",
"Lean.Level",
"Mathlib.Tactic.Ring.Common.ExBaseNat",
"Qq.Quoted",
"SizeOf.mk",
"SizeOf",
"Lean.Name.mkStr1",
"Mathlib.Tactic.Ring.Common.ExBaseNat._sizeOf_1",
"List.nil"
] | false |
Std.DHashMap.Const.getKey!_unitOfList_of_mem | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.getKey!",
"List.Pairwise",
"Std.DHashMap.Const.unitOfList",
"Membership.mem",
"LawfulHashable",
"Bool.true",
"List",
"BEq.beq",
"Unit",
"EquivBEq",
"List.instMembership",
"Std.DHashMap.Internal.Raw₀.Const.getKey!_insertManyIfNewUnit_emptyWithCapacity_list_of_mem",
"Bool",
"In... | true |
contMDiff_finset_sum | Mathlib.Geometry.Manifold.Algebra.Monoid | [
"contMDiff_finsetSum",
"NormedSpace",
"ContMDiff",
"Finset",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddCommMonoid",
"TopologicalSpace",
"ModelWithCorners",
"Finset.instSetLike",
"ENat",
"NontriviallyNormedField",
"AddZero.toAdd",
"NontriviallyNormedField... | true |
_private.Mathlib.Algebra.MonoidAlgebra.Defs.0.AddMonoidAlgebra.isScalarTower._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | [
"AddMonoidAlgebra.addAddCommMonoid",
"SMulZeroClass",
"IsScalarTower",
"SMul",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddZero.toZero",
"AddMonoidAlgebra.smulZeroClass",
"Semiring",
"SMulZeroClass.toSMul",
"AddCommMonoid.toAddMonoid",
"AddMonoidAlgebra",
"Finsupp.isScalarTower... | false |
Mathlib.Tactic.BicategoryLike.HorizontalComp.of.injEq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | [
"Eq.propIntro",
"Mathlib.Tactic.BicategoryLike.WhiskerRight",
"Eq.ndrec",
"Mathlib.Tactic.BicategoryLike.HorizontalComp.of",
"Eq.refl",
"Mathlib.Tactic.BicategoryLike.HorizontalComp",
"Eq",
"Mathlib.Tactic.BicategoryLike.HorizontalComp.of.inj"
] | true |
Std.DHashMap.Raw.Const.any_eq_false_iff_forall_mem_get | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Std.DHashMap.Raw.Const.any_eq_false_iff_forall_contains_get",
"Std.DHashMap.Raw.Const.get",
"Std.DHashMap.Raw",
"LawfulBEq",
"Membership.mem",
"Iff",
"Bool",
"Hashable",
"Std.DHashMap.Raw.any",
"Bool.false",
"BEq",
"... | true |
_private.Batteries.Data.List.Lemmas.0.List.isPrefixOf.match_1.eq_3 | Batteries.Data.List.Lemmas | [
"List.isPrefixOf.match_1",
"List.cons",
"List",
"Eq.refl",
"Eq",
"List.nil"
] | true |
RatFunc.numDenom.eq_1 | Mathlib.FieldTheory.RatFunc.Basic | [
"Polynomial.C",
"RatFunc.numDenom",
"Polynomial.instOne",
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"CommSemiring.toSemiring",
"Polynomial.instDecidableEq",
"RatFunc.numDenom._proof_2",
"Classical.propDecidable",
"RingHom",
"CommSemiring... | true |
Std.DTreeMap.Internal.RciSlice | Std.Data.DTreeMap.Internal.Zipper | [
"Ord",
"Std.DTreeMap.Internal.RciSliceData",
"Std.Slice"
] | true |
Profinite.Extend.functor | Mathlib.Topology.Category.Profinite.Extend | [
"CategoryTheory.StructuredArrow.homMk",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"Finite",
"FintypeCat",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.... | true |
Lean.ImportM.Context.casesOn | Lean.Environment | [
"Lean.ImportM.Context",
"Lean.ImportM.Context.mk",
"Lean.ImportM.Context.rec",
"Lean.Options",
"Lean.Environment"
] | false |
_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.mkCnstr? | Lean.Meta.Tactic.Grind.Order.Internalize | [
"Pure.pure",
"Lean.Meta.Grind.Arith.CommRing.RingM.run",
"Lean.Meta.Grind.GrindM",
"Lean.Meta.Grind.Order.Struct",
"Lean.Meta.Grind.Goal",
"_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.mkCommRingCnstr?",
"Lean.Meta.Grind.State",
"_private.Lean.Meta.Tactic.Grind.Order.Inter... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertMany_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 |
FirstOrder.Language.BoundedFormula.IsPrenex.rec | Mathlib.ModelTheory.Complexity | [
"FirstOrder.Language.BoundedFormula.IsPrenex.ex",
"FirstOrder.Language.BoundedFormula.IsPrenex.of_isQF",
"instOfNatNat",
"FirstOrder.Language.BoundedFormula.IsQF",
"FirstOrder.Language.BoundedFormula.IsPrenex",
"FirstOrder.Language.BoundedFormula.IsPrenex.all",
"instHAdd",
"HAdd.hAdd",
"FirstOrder.L... | false |
Lean.Expr.collectMVars | Lean.Util.CollectMVars | [
"Lean.Expr",
"Lean.CollectMVars.visit",
"Lean.CollectMVars.State"
] | true |
List.any_eq_true | Init.Data.List.Lemmas | [
"congrArg",
"Membership.mem",
"Exists",
"instDecidableEqBool",
"iff_self",
"Bool.true",
"List",
"And",
"Iff",
"List.instMembership",
"List.decidableBEx",
"True",
"Bool",
"of_eq_true",
"List.any",
"congrFun'",
"decide_eq_true_eq",
"List.any_eq",
"Decidable.decide",
"Eq",
"Eq.t... | true |
Std.TreeSet.Raw.isSome_get?_iff_mem._simp_1 | Std.Data.TreeSet.Raw.Lemmas | [
"Membership.mem",
"Ordering",
"Std.TreeSet.Raw.instMembership",
"Std.TransCmp",
"Bool.true",
"Std.TreeSet.Raw",
"propext",
"Bool",
"Std.TreeSet.Raw.isSome_get?_iff_mem",
"Option.isSome",
"Eq",
"Std.TreeSet.Raw.get?",
"Std.TreeSet.Raw.WF"
] | false |
Set.range_eq_singleton_iff | Mathlib.Data.Set.Image | [
"Eq.mpr",
"_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_1",
"congrArg",
"Membership.mem",
"Exists",
"_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_2",
"Set.instSingletonSet",
"id",
"_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_6"... | true |
List.splitAtD.go._unsafe_rec | Batteries.Data.List.Basic | [
"List.replicate",
"List.splitAtD.go._unsafe_rec",
"List.reverseAux",
"Prod.mk",
"List.cons",
"List",
"Nat",
"List.reverse",
"List.splitAtD.go.match_1",
"Prod",
"List.nil"
] | false |
ContinuousAt.const_vadd | Mathlib.Topology.Algebra.ConstMulAction | [
"ContinuousConstVAdd",
"ContinuousAt",
"Filter.Tendsto.const_vadd",
"nhds",
"VAdd",
"HVAdd.hVAdd",
"TopologicalSpace",
"instHVAdd"
] | true |
Mathlib.Util.TermReduce.betaStx | Mathlib.Util.TermReduce | [
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
UInt16.toNat_not | Init.Data.UInt.Bitwise | [
"instPowNat",
"UInt16.toBitVec",
"Eq.mpr",
"congrArg",
"UInt16.size",
"HSub.hSub",
"UInt16.toBitVec_not",
"BitVec",
"id",
"instSubNat",
"instOfNatNat",
"BitVec.toNat",
"instNatPowNat",
"UInt16",
"instHSub",
"HPow.hPow",
"Nat",
"Complement.complement",
"BitVec.toNat_not",
"Eq.re... | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_12 | Init.Data.String.Pattern.String | [
"HSub.hSub",
"String.Slice",
"instSubNat",
"_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_2",
"instOfNatNat",
"LE.le",
"instLENat",
"Array",
"GetElem.getElem",
"instHSub",
"Array.instGetElemNatLtSize",
"Nat",
"LT.lt",
"_private.Init.... | false |
ManyOneDegree.le_add_right | Mathlib.Computability.Reduce | [
"ManyOneDegree.instLE",
"_private.Mathlib.Computability.Reduce.0.ManyOneDegree.le_refl",
"LE.le",
"ManyOneDegree.add_le",
"instHAdd",
"And",
"And.right",
"HAdd.hAdd",
"ManyOneDegree",
"Iff.mp",
"ManyOneDegree.instAdd"
] | true |
Finset.weightedVSubOfPoint_smul | Mathlib.LinearAlgebra.AffineSpace.Combination | [
"Pi.Function.module",
"Finset.weightedVSubOfPoint_apply",
"instHSMul",
"Semiring.toModule",
"Pi.addCommMonoid",
"DivInvOneMonoid.toInvOneClass",
"Ring.toNonAssocRing",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Finset",
"SMul",
"AddMonoid.toAddZeroClass",
... | true |
Set.instInhabited | Mathlib.Data.Set.Basic | [
"Set.instEmptyCollection",
"Inhabited",
"EmptyCollection.emptyCollection",
"Inhabited.mk",
"Set"
] | true |
AddOpposite.op.eq_1 | Mathlib.Algebra.Opposites | [
"AddOpposite",
"Eq.refl",
"PreOpposite.op'",
"Eq",
"AddOpposite.op"
] | true |
add_neg_neg_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"trans",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"AddRightStrictMono",
"AddZeroClass.toAddZero",
"id",
"IsPreorder.toIsTrans",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"zero_add",
... | true |
_private.Mathlib.NumberTheory.LSeries.Injectivity.0.LSeries.eq_of_LSeries_eventually_eq._simp_1_1 | Mathlib.NumberTheory.LSeries.Injectivity | [
"AddGroup.toSubtractionMonoid",
"sub_eq_zero",
"HSub.hSub",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubNegMonoid.toSub",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"NegZeroClass.toZero",
"Eq"
] | false |
PartOrdEmb.Hom._sizeOf_inst | Mathlib.Order.Category.PartOrdEmb | [
"PartOrdEmb.Hom._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"PartOrdEmb",
"PartOrdEmb.Hom"
] | false |
Lean.PersistentArray.Stats.mk.inj | Lean.Data.PersistentArray | [
"Lean.PersistentArray.Stats.mk",
"Lean.PersistentArray.Stats.mk.noConfusion",
"Lean.PersistentArray.Stats",
"And",
"Nat",
"And.intro",
"Eq"
] | true |
CategoryTheory.Abelian.Ext.mk₀_id_comp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | [
"CategoryTheory.ShiftedHom.mk₀.congr_simp",
"instCategoryDerivedCategory",
"DerivedCategory",
"CategoryTheory.Abelian.Ext.ext",
"congrArg",
"CategoryTheory.Abelian.Ext.mk₀_hom",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"CategoryTheory.Abelian",
"CategoryTheory.CategoryStruct.id",
"Catego... | true |
List.Nat.antidiagonalTuple._f | Mathlib.Data.Fin.Tuple.NatAntidiagonal | [
"List.map",
"Fin.cons",
"instOfNatNat",
"Prod.fst",
"List.cons",
"Nat.below",
"List",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"List.Nat.antidiagonalTuple.match_1",
"Matrix.vecEmpty",
"instAddNat",
"Prod",
"OfNat.ofNat",
"Fin",
"Nat.succ",
"Prod.snd",
"List.flatMap",
"List.Nat... | false |
Set.MapsTo.extendDomain | Mathlib.Data.Set.Function | [
"Equiv.instEquivLike",
"Equiv.Perm.extendDomain",
"congrArg",
"Function.comp",
"Membership.mem",
"Equiv.Perm.extendDomain_apply_image",
"id",
"Equiv",
"Subtype",
"And.casesOn",
"And",
"Exists.casesOn",
"Set.MapsTo",
"Equiv.Perm",
"DecidablePred",
"And.intro",
"True",
"eq_self",
"... | true |
Lean.Lsp.instFromJsonLeanFileProgressKind._sparseCasesOn_1 | Lean.Data.Lsp.Extra | [
"Except.ok",
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Except.error",
"Nat.hasNotBit",
"instOfNatNat",
"Nat.land",
"Nat",
"Bool",
"Eq.refl",
"Except.ctorIdx",
"Except",
"OfNat.ofNat",
"Bool.false",
"Except.rec"
] | false |
CategoryTheory.ChosenPullbacksAlong.Over.leftUnitor_inv_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | [
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.MonoidalCategoryStruct.leftUnitor",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.instCategoryOver",
"Categ... | true |
Std.DTreeMap.Internal.Impl.alter._proof_15 | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.Balanced.at_root",
"Std.DTreeMap.Internal.Impl.minView._proof_11",
"HSub.hSub",
"Std.DTreeMap.Internal.Impl.balance",
"_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_14",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.I... | false |
Vector.getElem_ofFn | Init.Data.Vector.OfFn | [
"Vector",
"congrArg",
"Vector.ofFn._proof_1",
"Vector.instGetElemNatLt",
"Array.ofFn",
"Array.size_ofFn",
"Eq.rec",
"Fin.mk",
"id",
"Vector.getElem_mk._proof_2",
"Array.getElem_ofFn",
"GetElem.getElem",
"Vector.mk",
"Nat",
"LT.lt",
"True",
"eq_self",
"of_eq_true",
"Eq.ndrec",
"... | true |
ByteArray.extract_add_left | Init.Data.ByteArray.Lemmas | [
"Nat.le_add_right._simp_1",
"Eq.mpr",
"ByteArray.extract",
"id",
"ByteArray.extract_eq_empty_iff._simp_1",
"ByteArray.empty",
"LE.le",
"instLENat",
"Nat.min_le_left",
"instHAdd",
"HAdd.hAdd",
"Nat.le_trans",
"Nat",
"of_eq_true",
"instAddNat",
"ByteArray",
"Eq",
"Min.min",
"instMi... | true |
CategoryTheory.Discrete.sumEquiv.match_3 | Mathlib.CategoryTheory.Discrete.SumsProducts | [
"Sum",
"CategoryTheory.Discrete.mk",
"CategoryTheory.Discrete.casesOn",
"CategoryTheory.Discrete"
] | false |
RingHom.smulOneHom_eq_algebraMap | Mathlib.Algebra.Algebra.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"IsScalarTower.right",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Algebra",
"RingHom",
"Algebra.toSMul",
"Algebra.toModule",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Algebra.algebraMap_eq_smul_one",
"RingHom.ext",
"CommSemirin... | true |
Nat.prime_five | Mathlib.Data.Nat.Prime.Defs | [
"Nat.Prime",
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Decidable.decide",
"Eq",
"Nat.decidablePrime"
] | true |
Lean.Diff.instBEqAction | Lean.Util.Diff | [
"Lean.Diff.Action",
"BEq.mk",
"Lean.Diff.instBEqAction.beq",
"BEq"
] | true |
MeasureTheory.Measure.measure_subtype_coe_eq_zero_of_comap_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | [
"Iff.mpr",
"MeasureTheory.Measure.measure_subtype_coe_le_comap",
"MeasureTheory.Measure",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"MeasureTheory.NullMeasurableSet",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"Subtype",
"Eq.le",
"Bot.bot",
"LE.le",
"MeasurableSpace",
"MeasureTheo... | true |
UInt16.ofNatLT_finVal | Init.Data.UInt.Lemmas | [
"UInt16.size",
"UInt16.ofNatLT",
"Fin.isLt",
"Fin.val",
"UInt16",
"Fin",
"Eq",
"UInt16.ofFin",
"rfl"
] | true |
_private.Mathlib.Tactic.Order.Preprocessing.0.Mathlib.Tactic.Order.preprocessFacts.match_1 | Mathlib.Tactic.Order.Preprocessing | [
"Unit.unit",
"Mathlib.Tactic.Order.OrderType",
"Mathlib.Tactic.Order.OrderType.casesOn",
"Unit",
"Mathlib.Tactic.Order.OrderType.lin",
"Mathlib.Tactic.Order.OrderType.pre",
"Mathlib.Tactic.Order.OrderType.part"
] | false |
MeasureTheory.integral_div_right_eq_self | Mathlib.MeasureTheory.Group.Integral | [
"Eq.mpr",
"Real",
"DivInvMonoid.toInv",
"MeasureTheory.Measure",
"instHDiv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"NormedSpace",
"MeasureTheory.integral_mul_right_eq_self",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
... | true |
CategoryTheory.IndParallelPairPresentation._sizeOf_1 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | [
"CategoryTheory.Functor",
"Opposite",
"Opposite._sizeOf_inst",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"instSizeOfDefault",
"CategoryTheory.Functor.comp",
"CategoryTheory.yoneda",
"CategoryTheory.Limits.IsColimit",
"CategoryTheory.Limits.Cocone.... | false |
CocompactMap.comp_apply | Mathlib.Topology.ContinuousMap.CocompactMap | [
"TopologicalSpace",
"CocompactMap.comp",
"CocompactMap.instFunLike",
"CocompactMap",
"Eq",
"DFunLike.coe",
"rfl"
] | true |
_private.Mathlib.RingTheory.GradedAlgebra.TensorProduct.0.GradedAlgebra.baseChange._simp_1 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | [
"Submodule",
"PartialOrder.toPreorder",
"Preorder.toLE",
"HasSubset.Subset",
"Submodule.instPartialOrder",
"LE.le",
"AddCommMonoid",
"SetLike.coe",
"Submodule.setLike",
"propext",
"Submodule.span",
"Semiring",
"Module",
"Eq",
"Submodule.span_le",
"Set.instHasSubset",
"Set"
] | false |
AddSubmonoid.toSubmonoid._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | [
"MulOne.toOne",
"Equiv.instEquivLike",
"Subsemigroup.mk",
"Submonoid.toSubsemigroup",
"Membership.mem",
"AddZeroClass.toAddZero",
"Multiplicative.mulOneClass",
"Equiv",
"MulOne.toMul",
"AddSubmonoid.toAddSubsemigroup",
"AddSubmonoid",
"AddSubmonoid.mk",
"AddSubsemigroup.mk",
"AddSubsemigro... | false |
continuous_of_discreteTopology | Mathlib.Topology.Order | [
"Iff.mpr",
"Continuous",
"DiscreteTopology",
"TopologicalSpace",
"Set.preimage",
"isOpen_discrete",
"IsOpen",
"continuous_def",
"Set"
] | true |
_private.Mathlib.Data.PNat.Find.0.PNat.find_le_iff._simp_1_1 | Mathlib.Data.PNat.Find | [
"Preorder.toLT",
"instLinearOrderPNat",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"instOfNatPNatOfNeZeroNat",
"instOfNatNat",
"LE.le",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"LT.lt",
"propext",
"PNat.lt_add_o... | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ_σ₀Iter._proof_1_11 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | [
"Fin.predAbove._proof_2",
"_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ_σ₀Iter._proof_1_5",
"Fin.instOfNat",
"Ne",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"SimplexCategory.mk",
"Nat",
"LT.lt",
"instLTFin",
"instAddNat",
"Fin.castSucc",
"OfNat.ofNat"... | false |
_private.Lean.DocString.Extension.0.Lean.builtinDocStrings._proof_1 | Lean.DocString.Extension | [
"Lean.NameMap",
"String",
"ST.instNonemptyRef",
"IO.RealWorld",
"instNonemptyOfInhabited",
"Lean.NameMap.instInhabited",
"Nonempty",
"ST.Ref"
] | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.instInhabited | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | [
"Array.replicate",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula",
"List.toArray",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.mk",
"Nat",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment",
"Inhabited",
"Std.Tactic.BVDecide.LRAT.Inter... | true |
Sigma.instVAddAssocClassOfVAdd | Mathlib.Algebra.Group.Action.Sigma | [
"Eq.mpr",
"congrArg",
"vadd_assoc",
"VAdd",
"id",
"Sigma.fst",
"HVAdd.hVAdd",
"VAddAssocClass.mk",
"Sigma.vadd_mk",
"instHVAdd",
"Eq.ndrec",
"Eq.refl",
"Sigma.mk",
"Sigma.casesOn",
"Eq.symm",
"Sigma.snd",
"Eq",
"Sigma",
"Sigma.VAdd",
"VAddAssocClass"
] | true |
Lean.Elab.RecKind.noConfusion | Lean.Elab.DeclModifiers | [
"noConfusionEnum",
"Lean.Elab.RecKind",
"Lean.Elab.RecKind.noConfusionType",
"Nat",
"instDecidableEqNat",
"Eq",
"Lean.Elab.RecKind.ctorIdx"
] | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.haarScalarFactor_eq_mul._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Unique | [
"Real",
"NNReal.eq_iff",
"NNReal",
"propext",
"Eq.symm",
"Eq",
"NNReal.toReal"
] | false |
Representation.Equiv.symm_apply_apply | Mathlib.RepresentationTheory.Intertwining | [
"Monoid",
"Representation.Equiv.symm",
"Representation",
"Representation.Equiv.instEquivLike",
"AddCommMonoid",
"Representation.Equiv.left_inv",
"Representation.Equiv",
"Semiring",
"Module",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Antivary.add_right | Mathlib.Algebra.Order.Monovary | [
"Preorder.toLT",
"Antivary",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"covariant_swap_add_of_covariant_add",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Di... | true |
PowerSeries.«_aux_Mathlib_RingTheory_PowerSeries_WeierstrassPreparation___macroRules_PowerSeries_term_/ʷ__1» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.instMonad"... | false |
Function.iterate_fixed | Mathlib.Logic.Function.Iterate | [
"Eq.mpr",
"congrArg",
"id",
"Nat.iterate",
"Nat",
"Function.iterate_succ_apply",
"Nat.zero",
"Eq.refl",
"Nat.recOn",
"Nat.succ",
"Eq",
"rfl"
] | true |
CommGrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | [
"CommGrpCat.instCategory",
"CategoryTheory.Limits.PreservesLimitsOfSize.mk",
"inferInstance",
"CommGrpCat.uliftFunctor_preservesLimitsOfShape",
"CommGrpCat.uliftFunctor",
"CommGrpCat",
"CategoryTheory.Limits.PreservesLimitsOfSize",
"CategoryTheory.Limits.PreservesLimitsOfShape",
"CategoryTheory.Cate... | true |
_private.Qq.Macro.0.Qq.Impl.makeZetaReduce.match_1 | Qq.Macro | [
"Unit.unit",
"Option.casesOn",
"Option.some",
"Option.none",
"Unit",
"Lean.LocalContext",
"Option"
] | false |
List.mapDiagM.go._unsafe_rec | Batteries.Data.List.Basic | [
"Pure.pure",
"List.mapDiagM.go._unsafe_rec",
"List.foldlM",
"Array.push",
"Monad.toApplicative",
"Applicative.toPure",
"Array.toList",
"Array",
"List",
"List.mapDiagM.go.match_1",
"Applicative.toFunctor",
"Monad.toBind",
"Bind.bind",
"Monad",
"Functor.map"
] | false |
Rep.invariantsAdjunction_homEquiv_apply_hom._proof_1 | Mathlib.RepresentationTheory.Invariants | [
"Submodule",
"Rep.V",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Rep.hV2",
"Module.End.instSemiring",
"LinearMap.instFunLike"... | false |
Nat.Linear.instBEqPolyCnstr.beq_spec_2 | Init.Data.Nat.Linear | [
"False",
"Nat.Linear.Poly",
"Eq.mp",
"Nat.Linear.instBEqPolyCnstr.beq",
"Nat.Linear.instBEqPolyCnstr.beq.eq_2",
"BEq.beq",
"Nat.Linear.PolyCnstr.mk",
"Bool",
"Eq.refl",
"Bool.false",
"Eq",
"Nat.Linear.instBEqPolyCnstr",
"Nat.Linear.PolyCnstr"
] | true |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.D₂_totalShift₁XIso_hom._proof_1_2 | Mathlib.Algebra.Homology.TotalComplexShift | [
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"congrArg",
"Int.Linear.eq_norm",
"Classical.byContradiction",
"AddGroupWithOne.toAddMonoidWithOne",
"Eq.mp",
"Lean.RArray.branch",
"Int.Linear.Expr.add",
"id",
"Lean.RArray",
"Int.instNegInt",... | false |
Array.mkArray8 | Init.Prelude | [
"Array.push",
"instOfNatNat",
"Array",
"Nat",
"OfNat.ofNat",
"Array.emptyWithCapacity"
] | true |
MonomialOrder.degree_X | Mathlib.RingTheory.MvPolynomial.MonomialOrder | [
"Nontrivial",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MonomialOrder.degree_monomial",
"Nat.instMulZeroClass",
"NeZero.one",
"Semiring.toModule",
"AddMonoidAlgebra.addAddCommMonoid",
"congrArg",
"CommSemiring.toSemiring",
"MvPolynomial.monomial",
"LinearMap.instFunLike",
"MvPoly... | true |
SSet.instUniqueHomOneTruncation₂ObjTruncatedOfNatNatTruncationSimplexCategoryStdSimplexMk._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | [
"SSet.OneTruncation₂",
"Inhabited.default",
"Opposite",
"CategoryTheory.Functor.category",
"SSet.Truncated",
"SSet.truncation",
"instOfNatNat",
"SSet",
"LE.le",
"SSet.stdSimplex",
"instLENat",
"SimplexCategory.mk",
"Nat",
"CategoryTheory.types",
"Unique.uniq",
"SimplexCategory",
"SSe... | false |
CategoryTheory.Aut.isoPerm._proof_9 | Mathlib.Algebra.Category.Grp.Basic | [
"MulOne.toOne",
"GrpCat",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"OneHom.mk",
"CategoryTheory.Aut.isoPerm._proof_6",
"CategoryTheory.CategoryStruct.id",
"id",
"DivInvMonoid.toMonoid",
"MonoidHom.mk",
"Equiv.toIso",
"Gro... | false |
Lean.Elab.Tactic.Do.countUsesDecl._unsafe_rec | Lean.Elab.Tactic.Do.LetElim | [
"Pure.pure",
"Lean.instBEqFVarId",
"Lean.Elab.Tactic.Do.countUses._unsafe_rec",
"Lean.KVMap.setNat",
"Lean.Meta.State",
"Lean.MData.empty",
"Lean.Elab.Tactic.Do.FVarUses",
"Option.some",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.FVarId",
"instDecidableEqBool",
"Std.HashMap.eras... | false |
Lean.Grind.ToInt.LE.rec | Init.Grind.ToInt | [
"Lean.Grind.ToInt.toInt",
"Lean.Grind.ToInt.LE",
"Lean.Grind.ToInt.LE.mk",
"Int",
"LE.le",
"LE",
"Iff",
"Lean.Grind.ToInt",
"Int.instLEInt",
"Lean.Grind.IntInterval"
] | false |
LightCondensed.lanLightCondSet | Mathlib.Condensed.Discrete.Colimit | [
"LightCondensed._proof_1",
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"CategoryTheory.Functor",
"Opposite",
"SecondCountableTopology",
"CategoryTheory.Functor.category",
"LightCondensed.lanPresheaf",
"LightCondensed.lanLightCondSet._proof_1",
"TotallyDisconnectedSpace",
"TopCat.str",
"A... | true |
Lean.PersistentHashMap.Entry.recOn | Lean.Data.PersistentHashMap | [
"Lean.PersistentHashMap.Entry.entry",
"Lean.PersistentHashMap.Entry",
"Lean.PersistentHashMap.Entry.ref",
"Lean.PersistentHashMap.Entry.null",
"Lean.PersistentHashMap.Entry.rec"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.