name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.GroupTheory.OrderOfElement.0.IsOfFinAddOrder.mem_multiples_iff_mem_zmultiples.match_1_1 | Mathlib.GroupTheory.OrderOfElement | [
"instHSMul",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Membership.mem",
"AddSubmonoid",
"AddGroup",
"Exists.casesOn",
"AddGroup.toSubNegMonoid",
"Nat",
"AddSubmonoid.multiples",
"Exists.intro",
"HSMul.hSMul",
"SubNegMonoid.toAddMonoid",
"AddSubmonoid.instSetLike",
"Eq",
"SetLik... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_insert._simp_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | [
"Membership.mem",
"instHAppendOfAppend",
"List",
"List.mem_append",
"List.instMembership",
"propext",
"Or",
"List.instAppend",
"Eq",
"HAppend.hAppend"
] | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.mem_carrier_iff_of_mem | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | [
"GradedRing.toGradedMonoid",
"SetLike",
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"DirectSum.decompose_of_mem_same",
"DirectSum.decomposeRingEquiv",
"Subtype.mk.congr_simp",
"Submodule.addSubmonoidClass",
"CommRing",
"AlgebraicGeometry.ProjIsoSpecTop... | true |
Filter.Tendsto.eventually_intervalIntegrable | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | [
"MeasureTheory.ae",
"Set.Ioc",
"Real",
"MeasureTheory.Measure",
"IntervalIntegrable",
"Filter.instCompleteLatticeFilter",
"Filter.Eventually",
"PseudoMetricSpace.toUniformSpace",
"nhds",
"CompleteLattice.toConditionallyCompleteLattice",
"StronglyMeasurableAtFilter",
"NormedAddGroup.toENormedAd... | true |
_private.Std.Time.Notation.0.Std.Time.convertOffsetZ | Std.Time.Notation | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.ident",
"String",
"Lean.SourceInfo",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"ReaderT.instMonad",
"Lean.Macro.instMonadQuotationMacroM",
"Lean.Macro.instMonadRefMacroM",
"Lean.MacroM",
"Appl... | true |
Units.le_of_one_le_inv | Mathlib.Algebra.Order.Monoid.Unbundled.Units | [
"Monoid",
"Units.val",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Units",
"MulLeftMono",
"MulOne.toMul",
"Units.one_le_inv",
"LE.le",
"LE",
"MulOneClass.toMulOne",
"Inv.inv",
"Iff.mp",
"One.toOfNat1",
"OfNat.ofNat",
"Units.instInv"
] | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.exists_subalgebra_fg._simp_1_3 | Mathlib.RingTheory.Smooth.NoetherianDescent | [
"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 |
Std.DTreeMap.Internal.Impl.brecOn | Std.Data.DTreeMap.Internal.Def | [
"Std.DTreeMap.Internal.Impl.brecOn.go",
"Std.DTreeMap.Internal.Impl.below",
"Std.DTreeMap.Internal.Impl"
] | false |
Sym2.other_invol' | Mathlib.Data.Sym.Sym2 | [
"PSigma.snd",
"Eq.mpr",
"Sym2.Rel",
"Quot.liftIndepPr1",
"Sym2.rec.match_1",
"ite_eq_right_iff._simp_1",
"Sym2.mem_iff._simp_1",
"Sym2.mk",
"congrArg",
"ite_self",
"instInhabitedTrue",
"Membership.mem",
"Eq.mp",
"Quot.lift",
"id",
"forall_prop_decidable",
"ite_eq_left_iff._simp_1",
... | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.specializes_of_subset_closure._simp_1_1 | Mathlib.Topology.Sets.VietorisTopology | [
"TopologicalSpace.vietoris.specializes_iff",
"Specializes",
"TopologicalSpace.vietoris",
"Membership.mem",
"Exists",
"HasSubset.Subset",
"TopologicalSpace",
"And",
"closure",
"propext",
"Eq",
"Set.instMembership",
"Set.instHasSubset",
"Set"
] | false |
Lean.instHashableExtraModUse | Lean.ExtraModUses | [
"Hashable.mk",
"Lean.instHashableExtraModUse.hash",
"Hashable",
"Lean.ExtraModUse"
] | true |
SSet.horn₃₂.desc.multicofork_π_one._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | [
"False",
"congrArg",
"Compl.compl",
"instDecidableEqFin",
"eq_false_of_decide",
"Membership.mem",
"Set.instSingletonSet",
"instOfNatNat",
"Set.instCompl",
"instHAdd",
"Set.mem_compl_iff._simp_1",
"HAdd.hAdd",
"SimplexCategory.mk",
"Nat",
"True",
"Bool",
"of_eq_true",
"instAddNat",
... | false |
Matrix.diagonalLinearMap | Mathlib.Data.Matrix.Basic | [
"Pi.Function.module",
"Matrix.diagonalAddMonoidHom",
"Pi.addCommMonoid",
"Matrix.module",
"ZeroHom.toFun",
"Matrix",
"AddMonoid.toAddZeroClass",
"Matrix.diagonalLinearMap._proof_2",
"AddMonoidHom.toZeroHom",
"AddZeroClass.toAddZero",
"Matrix.addCommMonoid",
"LinearMap",
"AddCommMonoid",
"A... | true |
Cardinal.preAleph_nat | Mathlib.SetTheory.Cardinal.Aleph | [
"Eq.mpr",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"OrderIso",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"Cardinal.instLE",
"Ordinal.addMonoidWithOne",
"Cardinal.preAleph",
"Ordinal.card",
"instFunLikeOrderIso",
"Nat",
"Ordinal... | true |
FunLike.subNegMonoid | Mathlib.Data.FunLike.Group | [
"FunLike.subNegMonoid._proof_3",
"IsZeroApply",
"IsSMulApply",
"FunLike.subNegMonoid._proof_6",
"SMul",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"SubNegMonoid",
"AddZeroClass.toAddZero",
"Int",
"SubNegMonoid.toSub",
"AddZero.toZero",
"Neg",
"Function.Injective.subNegMonoid",
"Fun... | true |
MeasureTheory.diracProbaEquiv.eq_1 | Mathlib.MeasureTheory.Measure.DiracProba | [
"MeasureTheory.diracProba",
"Membership.mem",
"Equiv.mk",
"MeasureTheory.diracProbaEquiv._proof_1",
"Set.Elem",
"Equiv",
"MeasureTheory.ProbabilityMeasure",
"MeasureTheory.diracProbaEquiv._proof_2",
"MeasureTheory.diracProbaEquiv",
"Subtype.mk",
"MeasureTheory.diracProbaInverse",
"MeasurableSp... | true |
ModuleCat.hom_smul | Mathlib.Algebra.Category.ModuleCat.Basic | [
"Monoid",
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LinearMap",
"AddZero.... | true |
Aesop.BaseRuleSetMember.safeForwardRule.noConfusion | Aesop.RuleSet.Member | [
"Aesop.ForwardRule",
"Aesop.SafeRule",
"id",
"Aesop.BaseRuleSetMember.safeForwardRule",
"Aesop.BaseRuleSetMember",
"Aesop.BaseRuleSetMember.noConfusion",
"Eq"
] | false |
DiscreteQuotient.instSubsingletonQuotientTop | Mathlib.Topology.DiscreteQuotient | [
"trivial",
"DiscreteQuotient.instOrderTop",
"DiscreteQuotient.toSetoid",
"PartialOrder.toPreorder",
"Quot.ind",
"Preorder.toLE",
"DiscreteQuotient",
"TopologicalSpace",
"Subsingleton.intro",
"OrderTop.toTop",
"Quotient",
"Subsingleton",
"DiscreteQuotient.instPartialOrder",
"Quotient.sound"... | true |
Nat.Partrec.Code.evaln._unary._proof_2 | Mathlib.Computability.PartrecCode | [
"Lean.RArray.leaf",
"invImage",
"Nat.Partrec.Code._sizeOf_inst",
"Nat.Linear.ExprCnstr.eq_true_of_isValid",
"Nat.Partrec.Code",
"Lean.RArray.branch",
"PSigma.casesOn",
"id",
"Prod.Lex",
"Prod.mk",
"instOfNatNat",
"LE.le",
"sizeOfWFRel",
"instLENat",
"Nat.Linear.Expr.num",
"Prod.Lex.rig... | false |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_divisors._simp_1_2 | Mathlib.NumberTheory.Divisors | [
"Finset",
"Membership.mem",
"And",
"Finset.instSetLike",
"DecidablePred",
"propext",
"Finset.mem_filter",
"Finset.filter",
"Eq",
"SetLike.instMembership"
] | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.closure_singleton_one._simp_1_2 | Mathlib.Algebra.Group.Submonoid.Membership | [
"Monoid",
"Monoid.toMulOneClass",
"Membership.mem",
"Exists",
"Set.instSingletonSet",
"Submonoid.mem_closure_singleton",
"Monoid.toPow",
"HPow.hPow",
"Nat",
"Submonoid.closure",
"propext",
"Submonoid.instSetLike",
"instHPow",
"Singleton.singleton",
"Eq",
"SetLike.instMembership",
"Su... | false |
CategoryTheory.Pseudofunctor.DescentData.comp_hom | Mathlib.CategoryTheory.Sites.Descent.DescentData | [
"Opposite",
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.Pseudofunctor.DescentData.Hom.hom",
"CategoryTheory.Pseudofunctor.DescentData.obj",
"CategoryTheory.Cat.str",
"CategoryTheory.Pseudofun... | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceTo_le_iff._simp_1_2 | Init.Data.String.Lemmas.Order | [
"String.instLEPos_1",
"String.Slice.Pos.ofSliceTo",
"String.Slice",
"Exists",
"LE.le",
"String.Slice.Pos.sliceTo",
"LT.lt",
"String.instLTPos_1",
"String.Slice.Pos.lt_ofSliceTo_iff",
"propext",
"String.Slice.Pos",
"Eq",
"String.Slice.sliceTo"
] | false |
Algebra.WeaklyQuasiFiniteAt.comap_algEquiv | Mathlib.RingTheory.QuasiFinite.Weakly | [
"AlgEquiv.instEquivLike",
"RingHom.instRingHomClass",
"CommRing",
"Semiring.toModule",
"AlgHom.algHomClass",
"AlgEquiv.toAlgHom",
"AlgEquiv.symm",
"congrArg",
"CommSemiring.toSemiring",
"RingHom.surjectiveOnStalks_of_surjective",
"AlgHom",
"AlgHom.funLike",
"Algebra",
"RingHom",
"Members... | true |
lowerSemicontinuousOn_iff_frequently | Mathlib.Topology.Semicontinuity.Defs | [
"LowerSemicontinuousOn",
"Preorder.toLT",
"congrArg",
"LinearOrder",
"nhdsWithin",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"LE.le",
"Filter.Frequently",
"iff_self",
"TopologicalSpace",
"not_lt._simp_1",
... | true |
MeasureTheory.SimpleFunc.coe_const | Mathlib.MeasureTheory.Function.SimpleFunc | [
"MeasureTheory.SimpleFunc.const",
"MeasureTheory.SimpleFunc",
"MeasureTheory.SimpleFunc.instFunLike",
"MeasurableSpace",
"Function.const",
"Eq",
"DFunLike.coe",
"rfl"
] | true |
Structomorph.symm._proof_1 | Mathlib.Geometry.Manifold.HasGroupoid | [
"congrArg",
"OpenPartialHomeomorph.trans",
"Membership.mem",
"Eq.mp",
"StructureGroupoid",
"OpenPartialHomeomorph.trans_assoc",
"instMembershipOpenPartialHomeomorphStructureGroupoid",
"TopologicalSpace",
"Homeomorph.symm",
"OpenPartialHomeomorph.trans_symm_eq_symm_trans_symm",
"Structomorph",
... | false |
_private.Aesop.Search.Expansion.Norm.0.Aesop.runNormSteps._proof_9 | Aesop.Search.Expansion.Norm | [
"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",
"Fin.isLt",
"id",... | false |
IsFundamentalDomain.AddQuotientMeasureEqMeasurePreimage_AddHaarMeasure | Mathlib.MeasureTheory.Measure.Haar.Quotient | [
"Eq.mpr",
"MeasureTheory.Measure",
"instSeparatelyContinuousAddOfContinuousAdd",
"MeasurableSet",
"interior_subset",
"AddMonoid.toAddSemigroup",
"MeasureTheory.AddQuotientMeasureEqMeasurePreimage",
"congrArg",
"isOpen_interior",
"SecondCountableTopology",
"MeasurableVAdd.toMeasurableConstVAdd",
... | true |
Lean.Omega.LinearCombo.recOn | Init.Omega.LinearCombo | [
"Lean.Omega.LinearCombo.rec",
"Int",
"Lean.Omega.LinearCombo",
"Lean.Omega.Coeffs",
"Lean.Omega.LinearCombo.mk"
] | false |
AffineSubspace.coe_inclusion_apply | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | [
"Submodule",
"AffineMap.instFunLike",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"AffineSubspace.inclusion",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"Membership.mem",
"AddCommGroup",
"Set.Elem",
"Subtype",
"Submodule.module",
"LE.le",
"AffineMap",
"AffineSubspace.toAd... | true |
EuclideanGeometry.Sphere.power.eq_1 | Mathlib.Geometry.Euclidean.Sphere.Power | [
"Real",
"Real.instSub",
"EuclideanGeometry.Sphere",
"HSub.hSub",
"EuclideanGeometry.Sphere.power",
"instOfNatNat",
"Monoid.toPow",
"Real.instMonoid",
"EuclideanGeometry.Sphere.center",
"instHSub",
"HPow.hPow",
"MetricSpace",
"Nat",
"Eq.refl",
"MetricSpace.toPseudoMetricSpace",
"Dist.di... | true |
CategoryTheory.HasSubobjectClassifier | Mathlib.CategoryTheory.Subobject.Classifier.Defs | [
"CategoryTheory.HasSubobjectClassifier.mk",
"CategoryTheory.Category"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Walk.exists_adj_adj_not_adj_ne._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Metric | [
"Lean.RArray.leaf",
"False",
"Lean.Grind.not_not",
"SimpleGraph.dist",
"Lean.Grind.not_and",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"SimpleGraph.Walk.length",
"SimpleGraph.Adj",
"Classical.byContradiction",
"Nat.ToInt.add_congr",
"Lean.Grind.Nat.lt_eq",
"SimpleGraph.... | false |
Lean.Grind.instCommRingUInt64 | Init.GrindInstances.Ring.UInt | [
"UInt64.pow_zero",
"Int.cast",
"UInt64.one_mul",
"UInt64.instOfNat",
"instMulUInt64",
"Lean.Grind.instCommRingUInt64._proof_2",
"HMul.hMul",
"instAddUInt64",
"UInt64",
"UInt64.mul_add",
"Lean.Grind.instCommRingUInt64._proof_3",
"UInt64.intCast",
"Lean.Grind.instCommRingUInt64._proof_4",
"U... | true |
Std.Do.ExceptConds.and_elim_right | Std.Do.PostCond | [
"Std.Do.SPred.entails",
"Std.Do.PostShape.rec",
"Std.Do.PostShape.except",
"Std.Do.Assertion",
"Std.Do.PostShape.arg",
"Std.Do.PostShape",
"Std.Do.PostShape.pure",
"Std.Do.ExceptConds.entails",
"Prod.fst",
"Std.Do.ExceptConds.and",
"And.intro",
"Std.Do.PostShape.args",
"Prod.snd",
"Std.Do.... | true |
InverseSystem.piLTLim | Mathlib.Order.DirectedInverseSystem | [
"Preorder.toLT",
"Order.IsSuccPrelimit",
"InverseSystem.piLTLim._proof_3",
"InverseSystem.piLTLim._proof_5",
"LinearOrder",
"PartialOrder.toPreorder",
"InverseSystem.limit",
"Membership.mem",
"Order.IsSuccPrelimit.mid",
"SemilatticeInf.toPartialOrder",
"Equiv.mk",
"Set.Elem",
"DistribLattice... | true |
Lean.Parser.Tactic.introMatch._regBuiltin.Lean.Parser.Tactic.introMatch.formatter_7 | Lean.Parser.Tactic | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Parser.Tactic.introMatch.formatter",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
CategoryTheory.Comonad.ComonadicityInternal.counitFork | Mathlib.CategoryTheory.Monad.Comonadicity | [
"CategoryTheory.Comonad.ComonadicityInternal.counitFork._proof_1",
"CategoryTheory.Functor",
"CategoryTheory.Comonad.Coalgebra.a",
"CategoryTheory.Limits.Fork.ofι",
"CategoryTheory.Limits.equalizer",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"Categ... | true |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'_fac_assoc | Mathlib.Algebra.Homology.ExactSequenceFour | [
"CategoryTheory.Category.assoc",
"CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_2",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_8",
"CategoryTheory.Limits.WalkingParallelPai... | true |
CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence._proof_3 | Mathlib.CategoryTheory.Limits.IsLimit | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"CategoryTheory.Limits.Cone.equivalenceOfReindexing",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Equi... | false |
DirectSum.GNonUnitalNonAssocSemiring.noConfusion | Mathlib.Algebra.DirectSum.Ring | [
"HEq.refl",
"AddMonoid.toAddZeroClass",
"DirectSum.GNonUnitalNonAssocSemiring.casesOn",
"AddZeroClass.toAddZero",
"GradedMonoid.GMul.mul",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"DirectSum.GNonUnitalNonAssocSemiring",
"HAdd.hAdd",
"DirectSum.GNonUnitalNonAssocSemiring.noConfusionType",
... | false |
Std.Time.Modifier.Qorq.injEq | Std.Time.Format.Basic | [
"Eq.propIntro",
"Std.Time.Modifier.Qorq",
"Sum",
"Std.Time.Modifier.Qorq.inj",
"Std.Time.Number",
"Eq.ndrec",
"Eq.refl",
"Std.Time.Text",
"Std.Time.Modifier",
"Eq"
] | true |
Profinite.NobelingProof.Nobeling_aux | Mathlib.Topology.Category.Profinite.Nobeling.Induction | [
"Int.instAddCommGroup",
"Int.instAddCommMonoid",
"LinearEquiv.symm",
"LocallyConstant.instAddCommGroup",
"Preorder.toLT",
"Semiring.toModule",
"Pi.topologicalSpace",
"LocallyConstant.instAddCommMonoid",
"LinearOrder",
"WellFoundedLT",
"PartialOrder.toPreorder",
"instTopologicalSpaceBool",
"M... | true |
_private.Mathlib.Data.Nat.Sqrt.0.Nat.iter_fp_bound._proof_1_1 | Mathlib.Data.Nat.Sqrt | [
"Lean.Grind.CommRing.le_norm_expr",
"Lean.Grind.instOrderedRingInt",
"Lean.RArray.leaf",
"Int.instDiv",
"False",
"dite_congr",
"instHDiv",
"Lean.Grind.CommRing.Expr.var",
"Lean.Grind.Order.eq_of_le_of_le_0",
"congrArg",
"Lean.Grind.Order.le_of_eq_2_k",
"Std.IsLinearPreorder.toIsPreorder",
"C... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_ratUnits._proof_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | [
"Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.assignments",
"Lean.Grind.Nat.lt_eq",
"Membership.mem",
"Array.modify",
"Prod.mk",
"instOfNatNat",
"LE.le",
"instLENat",
"Prod.fst",
"Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula",
"List.cons",
"Array",
"List.Nodup",
"Bool.true",
"Opt... | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.congrHash.goEq | Lean.Meta.Tactic.Grind.Types | [
"mixHash",
"UInt64.decLt",
"UInt64",
"instLTUInt64",
"Lean.Expr",
"_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.hashRoot",
"GT.gt",
"Lean.Meta.Grind.ENodeMap",
"ite"
] | true |
_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.coverToFun_surjective._proof_1_10 | Mathlib.Condensed.Light.Sequence | [
"of_eq_false",
"False",
"forall_not_of_not_exists",
"eq_false",
"Lean.Grind.iff_eq",
"Classical.byContradiction",
"_private.Mathlib.Condensed.Light.Sequence.0.InternalProjectivityProof.mem_fibres_iff",
"Option.some",
"Membership.mem",
"Exists",
"Eq.mp",
"False.casesOn",
"Prod.fst",
"Lean.G... | false |
Pi.Colex.instCompleteLinearOrderColexForall._proof_3 | Mathlib.Order.CompleteLattice.PiLex | [
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"Pi.Colex.completeLattice",
"Colex",
"CompleteLattice.toLattice",
"LinearOrder",
"WellFoundedGT",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"LE.le",
"SemilatticeSup.sup_le",
"Complet... | false |
Lean.Elab.DecreasingBy.tactic | Lean.Elab.PreDefinition.TerminationHint | [
"Lean.TSyntax",
"List.cons",
"Lean.SyntaxNodeKind",
"Lean.Name.mkStr4",
"Lean.Elab.DecreasingBy",
"List.nil"
] | true |
MeasurableEquiv.coe_piCurry | Mathlib.MeasureTheory.MeasurableSpace.Embedding | [
"MeasurableEquiv.instEquivLike",
"Sigma.fst",
"MeasurableSpace",
"Sigma.curry",
"MeasurableSpace.pi",
"MeasurableEquiv.piCurry",
"MeasurableEquiv",
"Sigma.snd",
"Eq",
"DFunLike.coe",
"Sigma",
"rfl",
"EquivLike.toFunLike"
] | true |
LocallyConstant.congr_arg | Mathlib.Topology.LocallyConstant.Basic | [
"LocallyConstant",
"TopologicalSpace",
"LocallyConstant.instFunLike",
"Eq",
"DFunLike.coe",
"DFunLike.congr_arg"
] | true |
Subring.mem_toSubsemiring | Mathlib.Algebra.Ring.Subring.Defs | [
"Subring.toSubsemiring",
"Subsemiring.instSetLike",
"Subring.instSetLike",
"Iff.rfl",
"Membership.mem",
"NonAssocRing",
"Subsemiring",
"Iff",
"Subring",
"NonAssocRing.toNonAssocSemiring",
"SetLike.instMembership"
] | true |
CategoryTheory.uliftYonedaIsoShrinkYoneda._proof_3 | Mathlib.CategoryTheory.ShrinkYoneda | [
"CategoryTheory.LocallySmall",
"UnivLE.self",
"CategoryTheory.locallySmall_of_univLE",
"CategoryTheory.Category",
"univLE_of_max"
] | false |
Vector.mem_toArray_iff._simp_1 | Init.Data.Vector.Basic | [
"Vector.instMembership",
"Vector",
"Array.instMembership",
"Membership.mem",
"Array",
"Vector.mem_toArray_iff",
"Nat",
"propext",
"Eq",
"Vector.toArray"
] | false |
Complex.cos_nat_mul_two_pi_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Complex.cos_antiperiodic",
"Real.pi",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Complex.cos",
"congrArg",
"AddMonoid.toAddZeroClass",
"Nat.instAtLeastTwoHAddOfNat",
"AddGroupWithOne.toAddMonoidWithOne",
"Function.Periodic.nat_mul",
"Complex.instMul",... | true |
Finset.preimage_mul_left_one' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"Eq.mpr",
"Finset.preimage_mul_left_one",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Function.Injective.injOn",
"Finset",
"CancelMonoid.toLeftCancelMonoid",
"InvolutiveInv.toInv",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoi... | true |
Lean.Grind.Linarith.Expr.denoteN.match_1 | Init.Grind.Module.NatModuleNorm | [
"Lean.Grind.Linarith.Expr.zero",
"Lean.Grind.Linarith.Expr",
"Unit.unit",
"Lean.Grind.Linarith.Expr.neg",
"Lean.Grind.Linarith.Expr.intMul",
"Lean.Grind.Linarith.Expr.natMul",
"Lean.Grind.Linarith.Expr.sub",
"Int",
"Lean.Grind.Linarith.Var",
"Unit",
"Lean.Grind.Linarith.Expr.add",
"Nat",
"Le... | false |
List.sbtw_four | Mathlib.Analysis.Convex.BetweenList | [
"Eq.mpr",
"False",
"_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_four._simp_1_3",
"eq_false",
"and_true",
"List.Pairwise",
"IsOrderedRing",
"congrArg",
"and_self",
"List.Sbtw",
"AddCommGroup.toAddCommMonoid",
"False.elim",
"Wbtw",
"List.Triplewise.nil._simp_1",
"forall_eq_or_... | true |
Lean.Doc.instBEqMathMode.beq | Lean.DocString.Types | [
"Lean.Doc.MathMode.ctorIdx",
"instBEqOfDecidableEq",
"Lean.Doc.MathMode",
"BEq.beq",
"Nat",
"Bool",
"instDecidableEqNat"
] | true |
FirstOrder.Language.Hom.id._proof_1 | Mathlib.ModelTheory.Basic | [
"Function.comp",
"FirstOrder.Language.Structure",
"Nat",
"FirstOrder.Language.Functions",
"Eq.refl",
"FirstOrder.Language",
"FirstOrder.Language.Structure.funMap",
"Fin",
"Eq"
] | false |
Std.ExtDTreeMap.Const.get_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Std.ExtDTreeMap.Const.get._proof_3",
"Quot.pliftOn._proof_2",
"Std.ExtDTreeMap.inductionOn₂",
"Membership.mem",
"Ordering",
"Std.DTreeMap.union",
"Std.TransCmp",
"Std.ExtDTreeMap.union",
"Std.DTreeMap.isSetoid",
"Std.DTreeMap.Const.get",
"Std.ExtDTreeMa... | true |
_private.Lean.Elab.Tactic.NormCast.0.Lean.Elab.Tactic.NormCast.initFn._@.Lean.Elab.Tactic.NormCast.1508164376._hygCtx._hyg.2 | Lean.Elab.Tactic.NormCast | [
"Lean.Name.mkNum",
"IO",
"Lean.Name.mkStr",
"instOfNatNat",
"Lean.registerTraceClass",
"Lean.Name.anonymous",
"Unit",
"Nat",
"Lean.Name.mkStr2",
"OfNat.ofNat",
"Bool.false"
] | false |
UniformSpace.Completion.induction_on | Mathlib.Topology.UniformSpace.Completion | [
"UniformSpace",
"UniformSpace.Completion.coe'",
"setOf",
"UniformSpace.Completion.denseRange_coe",
"IsClosed",
"UniformSpace.Completion.uniformSpace",
"isClosed_property",
"UniformSpace.toTopologicalSpace",
"UniformSpace.Completion"
] | true |
MeasureTheory.Measure.addHaar_singleton_add_smul_div_singleton_add_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.addHaar_singleton_add_smul_div_singleton_add_smul._simp_1_4",
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring... | true |
Lean.Elab.DerivingClassView.cls | Lean.Elab.Deriving.Basic | [
"Lean.Syntax.Term",
"Lean.Elab.DerivingClassView"
] | true |
Polynomial.Bivariate.swap_swap_apply | Mathlib.Algebra.Polynomial.Bivariate | [
"CommSemiring.toSemiring",
"Polynomial.algebraOfAlgebra",
"Algebra.id",
"Polynomial",
"CommSemiring",
"AlgEquiv.symm_apply_apply",
"AlgEquiv",
"Polynomial.semiring",
"Polynomial.Bivariate.swap",
"Eq",
"DFunLike.coe",
"AlgEquiv.instFunLike"
] | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback_obj_obj_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.instCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.fst",
"CategoryTheory.Limits.CategoricalPullback.fst",
"CategoryTheory.Limits.CategoricalPullback",
"CategoryTheor... | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.ciSup_subtype.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | [
"Subtype.casesOn",
"Subtype",
"Subtype.mk"
] | false |
CategoryTheory.AddGrp.instAddMonObj._proof_7 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | [
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.AddGrp.instMonoidalCategory",
"CategoryTheory.IsAddMonHom",
"CategoryTheory.AddGrp",
"CategoryTheory.AddMon.instCategory",
"CategoryTheory.AddMon.monMonoidal",
"... | false |
Subalgebra.mk.congr_simp | Mathlib.Algebra.Algebra.Subalgebra.Lattice | [
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Submonoid.toSubsemigroup",
"Algebra",
"RingHom",
"Membership.mem",
"Eq.rec",
"MulOne.toMul",
"NonAssocSemiring.toMulZeroOneClass",
"Subsemiring.toSubmonoid",
"Subsemiring",
"MulZeroOneClass.toMulOneClass",
"CommSemiring",
"MulOneClass.toMul... | true |
map_nonpos | Mathlib.Algebra.Order.Hom.Monoid | [
"Eq.mpr",
"congrArg",
"Preorder.toLE",
"ZeroHomClass",
"map_zero",
"id",
"OrderHomClass.mono",
"LE.le",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"DFunLike.coe",
"OrderHomClass",
"Preorder",
"FunLike",
"Zero"
] | true |
Std.DTreeMap.maxKey?_eq_none_iff | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.isEmpty",
"Std.DTreeMap.maxKey?",
"Ord.mk",
"Ordering",
"Std.DTreeMap.Internal.Impl.maxKey?_eq_none_iff",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Bool.true",
"Option.none",
"Iff",
"Std.DTreeMap.wf",
"Bool",
"Eq",
"Option"
] | true |
Lean.Language.ProcessingContext._sizeOf_inst | Lean.Language.Basic | [
"SizeOf.mk",
"Lean.Language.ProcessingContext._sizeOf_1",
"SizeOf",
"Lean.Language.ProcessingContext"
] | false |
TensorProduct.AlgebraTensorModule.rightComm | Mathlib.LinearAlgebra.TensorProduct.Tower | [
"TensorProduct.AlgebraTensorModule.rightComm._proof_3",
"TensorProduct.AlgebraTensorModule.rightComm._proof_31",
"TensorProduct.AlgebraTensorModule.rightComm._proof_24",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"TensorProduct.addCommMonoid",
"TensorProduct.AlgebraT... | true |
AddCon.mapGen.eq_1 | Mathlib.GroupTheory.Congruence.Hom | [
"AddCon.instFunLikeForallProp",
"AddCon",
"addConGen",
"AddCon.mapGen",
"Eq.refl",
"Eq",
"DFunLike.coe",
"Add",
"Relation.Map"
] | true |
RingEquiv.op_apply_apply | Mathlib.Algebra.Ring.Equiv | [
"RingEquiv.op",
"Equiv.instEquivLike",
"RingEquiv.instEquivLike",
"MulOpposite",
"Mul",
"Equiv",
"MulOpposite.instAdd",
"Eq.refl",
"MulOpposite.unop",
"RingEquiv",
"Eq",
"DFunLike.coe",
"Add",
"EquivLike.toFunLike",
"MulOpposite.instMul",
"MulOpposite.op"
] | true |
ApproximatesLinearOn.toPartialEquiv._proof_3 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | [
"AddCommGroup.toAddGroup",
"AddTorsor.nonempty",
"NormedAddTorsor.toAddTorsor",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"SeminormedAddCommGroup.toNormedAddTorsor",
"SeminormedAddCommGroup.toAddCommGroup",
"Nonempty",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"NormedAddCommGroup"
] | false |
ZMod.cast_descFactorial | Mathlib.Data.ZMod.Factorial | [
"neg_add_rev",
"CharP.cast_eq_zero",
"Iff.mpr",
"Distrib.leftDistribClass",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"MulOne.toOne",
"Nat.instOrderedSub",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"List.mem_range",
"HMul.hMul",
"Com... | true |
Configuration.HasLines.hasPoints._proof_1 | Mathlib.Combinatorics.Configuration | [
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"Fintype.one_lt_card",
"Configuration.HasLines.toNondegenerate",
"Configuration.Nondegenerate.eq_or_eq",
"Configuration.lineCount",
"Subtype.casesOn",
"Classical.propDecidable",
"Membership.mem",
"Exists",
"Subtype.fintype",
"Eq.mp",
"Fintype.card",
"Co... | false |
Lean.Parser.Command.GrindCnstr.notStrictValue | Lean.Meta.Tactic.Grind.Parser | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"Lean.Parser.optional",
"Lean.Parser.nonReservedSymbol",
"instHAndThenOfAndThen",
"Lean.Name.mkStr5",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Nat",
"Lean.Parser.ident",
"... | true |
Std.TreeMap.getElem?_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | [
"Std.TreeMap.instSDiff",
"Std.TreeMap.inner",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"SDiff.sdiff",
"Std.TreeMap.instMembership",
"Std.TreeMap.instGetElem?Mem",
"GetElem?.getElem?",
"Std.DTreeMap.Const.get?_diff_of_not_mem_right",
"Eq",
"Not",
"Std.TreeMap",
"Option"
] | true |
LinearMap.rank_zero | Mathlib.LinearAlgebra.Dimension.LinearMap | [
"Nontrivial",
"Eq.mpr",
"Submodule",
"Cardinal",
"rank_bot",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"LinearMap.range_zero",
"Membership.mem",
"LinearMap.range",
"AddCommGroup",
"id",
"Subtype",
"Bot.bot",
"Submodule.module",
"LinearMap",
"LinearMap.r... | true |
CategoryTheory.SpectralSequence.instCategory._proof_7 | Mathlib.Algebra.Homology.SpectralSequence.Basic | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Category.assoc",
"HomologicalComplex.instCategory",
"_private.Mathlib.Algebra.Homology.SpectralSequence.Basic.0.CategoryTheory.SpectralSequence.instCategory._proof_6",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Ho... | false |
Std.DTreeMap.Raw.getKey?_eq_some_getKey! | Std.Data.DTreeMap.Raw.Lemmas | [
"Std.DTreeMap.Raw.instMembership",
"Ord.mk",
"Option.some",
"Membership.mem",
"Ordering",
"Std.DTreeMap.Raw.getKey?",
"Std.TransCmp",
"Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey!",
"Std.DTreeMap.Raw.getKey!",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Inhabited",
"Eq",
"S... | true |
CompHaus.epi_iff_surjective | Mathlib.Topology.Category.CompHaus.Basic | [
"ULift.topologicalSpace",
"Mathlib.Tactic.Push.not_forall_eq",
"Mathlib.Tactic.Push.not_exists._simp_1",
"Set.mem_range_self",
"Iff.mpr",
"ContinuousMap.continuous",
"Set.mem_singleton",
"Real.instIsOrderedRing",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"CompHausLike.ofHom",
"Categ... | true |
Finset.mulSpan.eq_1 | Mathlib.Combinatorics.Additive.Dissociation | [
"Finset",
"DivInvMonoid.toZPow",
"Int.instDecidableEq",
"Insert.insert",
"Int.instNegInt",
"Int",
"CommGroup",
"Finset.instInsert",
"Fintype.piFinset",
"Finset.prod",
"Group.toDivInvMonoid",
"Fintype",
"HPow.hPow",
"instOfNat",
"Eq.refl",
"instHPow",
"CommGroup.toGroup",
"Finset.in... | true |
Std.DTreeMap.Const.minKey?_alter_eq_self | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap",
"Std.DTreeMap.Internal.Impl.Const.minKey?_alter_eq_self",
"Ord.mk",
"Option.some",
"Membership.mem",
"Ordering",
"Std.DTreeMap.Const.get?",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Bool.true",
"And",
"Iff",
"Std.DTreeMap.wf",
"Std.DTreeMap.min... | true |
CategoryTheory.Limits.CatCospanTransform.whiskerleft_id | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"id",
"CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft",
"CategoryTheory.Limits.CatCospanTransform.comp",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Categ... | true |
Std.IterM.DefaultConsumers.forIn'.wf._unary._proof_6 | Init.Data.Iterators.Consumers.Monadic.Loop | [
"Std.IterStep",
"Std.IterStep.successor",
"Std.IterM.IsPlausibleIndirectOutput.indirect",
"invImage",
"Std.IteratorLoop.WithWF.instWellFoundedRelation",
"Std.IteratorLoop.WellFounded",
"Std.IterM.DefaultConsumers.forIn'.wf._unary._proof_5",
"Option.some",
"Exists",
"Std.IterM.IsPlausibleStep",
"... | false |
_private.Init.Data.Array.Find.0.Array.finIdxOf?.eq_1 | Init.Data.Array.Find | [
"instOfNatNat",
"Array",
"Nat",
"Array.finIdxOf?",
"Eq.refl",
"Array.idxOfAux",
"OfNat.ofNat",
"Fin",
"BEq",
"Eq",
"Array.size",
"Option"
] | true |
ValuationSubring.unitGroupMulEquiv._proof_4 | Mathlib.RingTheory.Valuation.ValuationSubring | [
"Units.val",
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"MulOne.toOne",
"ValuationSubring.unitGroup",
"MonoidHom.instFunLike",
"Units.coeHom",
"HMul.hMul",
"ValuationSubring.valuation_unit",
"MonoidHom",
"Monoid.toMulOneClass",
"Valuat... | false |
Set.prod_eq | Mathlib.Data.Set.Operations | [
"Set.instSProd",
"SProd.sprod",
"Set.instInter",
"Prod.fst",
"Inter.inter",
"Set.preimage",
"Prod",
"Eq",
"Prod.snd",
"rfl",
"Set"
] | true |
_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.match_3 | Lean.Elab.Tactic.Split | [
"Option.ctorIdx",
"Option.some",
"Lean.MVarId",
"Nat.hasNotBit",
"_private.Lean.Elab.Tactic.Split.0.Lean.Elab.Tactic.evalSplit.mkCasesHint._sparseCasesOn_4",
"List",
"Option"
] | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.Internal.optionPelim'.match_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | [
"Option.casesOn",
"Option.some",
"Option.none",
"Eq",
"Option"
] | false |
_private.Mathlib.Order.Notation.0.Top.ext.match_1 | Mathlib.Order.Notation | [
"Top.mk",
"Top.casesOn",
"Top"
] | false |
instMonadEIO._aux_13 | Init.System.IO | [
"EST.bind",
"IO.RealWorld",
"EIO"
] | false |
isPiSystem_image_Iio | Mathlib.MeasureTheory.PiSystem | [
"Lattice.toSemilatticeSup",
"LinearOrder",
"PartialOrder.toPreorder",
"IsPiSystem",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"SemilatticeInf.toMin",
"Set.instInter",
"Inter.inter",
"And.casesOn",
"And",
"Set.Nonempty",
"Exists.casesOn",
"And.intro",
... | true |
OrderAddMonoidIso.refl.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | [
"OrderAddMonoidIso",
"OrderAddMonoidIso.refl",
"AddEquiv.refl",
"Eq.refl",
"OrderAddMonoidIso.refl._proof_1",
"Eq",
"OrderAddMonoidIso.mk",
"Add",
"Preorder"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.