name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
OrderHom.noConfusion | Mathlib.Order.Hom.Basic | [
"HEq.refl",
"OrderHom.casesOn",
"Monotone",
"OrderHom.noConfusionType",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Eq",
"OrderHom",
"Preorder"
] | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst.go_denote_eq._proof_1_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval",
"Option.some",
"Lean.Omega.LinearCombo.coordinate_eval_2",
"Lean.Omega.combo_... | false |
Std.Tactic.BVDecide.Normalize.BitVec.mul_ones | Std.Tactic.BVDecide.Normalize.BitVec | [
"Eq.mpr",
"BitVec.mul_neg",
"HMul.hMul",
"congrArg",
"BitVec",
"id",
"instOfNatNat",
"BitVec.ofNat",
"BitVec.instNeg",
"Nat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Eq",
"BitVec.instMul",
"Neg.neg",
"Eq.trans",
"BitVec.mul_one",
"instHMul"
] | true |
HomotopicalAlgebra.ModelCategory.categoryWithFibrations._autoParam | Mathlib.AlgebraicTopology.ModelCategory.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
AffineBasis.linear_eq_sumCoords | Mathlib.LinearAlgebra.AffineSpace.Basis | [
"Semiring.toModule",
"AddGroupWithOne.toAddGroup",
"AddCommGroup.toAddCommMonoid",
"AffineBasis.coord",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Subtype",
"addGroupIsAddTorsor",
"Ne",
"LinearMap",
"Module.Basis.sumCoords",
"AffineBasis",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Non... | true |
TensorProduct.finsuppLeft._proof_4 | Mathlib.LinearAlgebra.DirectSum.Finsupp | [
"Finsupp.smulZeroClass",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Algebra",
"Algebra.toSMul",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"AddCommMonoid",
"CommSemiring",
"AddZero.toZero",
"Semiring.toMonoid",
"... | false |
HomologicalComplex.mapBifunctorMapHomotopy.hom₁.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | [
"CategoryTheory.Functor",
"HomologicalComplex.instCategory",
"instHSMul",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Functor.category",
"CategoryTheory.functorCategoryPreadditive",
"Units.instSMul",
"AddC... | true |
List.flatMapM_subtype | Init.Data.List.Monadic | [
"Pure.pure",
"List.unattach",
"congrArg",
"Monad.toApplicative",
"LawfulMonad.bind_pure_comp",
"Subtype",
"LawfulMonad",
"List.rec",
"Applicative.toPure",
"List.cons",
"Subtype.mk",
"funext",
"instHAppendOfAppend",
"List",
"congr",
"True",
"eq_self",
"of_eq_true",
"Applicative.to... | true |
CategoryTheory.AddMod.Hom.mk.inj | Mathlib.CategoryTheory.Monoidal.Mod | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.AddMod.addMod",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.AddMod",
"CategoryTheory.IsAddModHom",
"CategoryTheory.MonoidalCategory.MonoidalLeftAction",
"CategoryTheory.AddMonObj",
"CategoryTheory.AddMod.Hom.mk.noConfusio... | true |
CompHausLike.HasExplicitPullbacks.hasProp | Mathlib.Topology.Category.CompHausLike.Limits | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompHausLike",
"CompHausLike.HasExplicitPullbacks",
"CompHausLike.category",
"CategoryTheory.Category.toCategoryStruct",
"TopCat",
"CompHausLike.HasExplicitPullback"
] | true |
Std.IterM.DefaultConsumers.forIn'_eq_wf | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"Pure.pure",
"PSigma.snd",
"Eq.mpr",
"bind_congr",
"Std.IterStep",
"Std.IterM.DefaultConsumers.forIn'.match_1",
"congrArg",
"Std.Shrink",
"Std.IterM.DefaultConsumers.forIn'",
"Monad.toApplicative",
"Std.IterM.DefaultConsumers.forIn'.wf",
"InvImage",
"Std.IteratorLoop.WellFounded",
"Std.Pla... | true |
_private.Mathlib.Analysis.BoxIntegral.Integrability.0.BoxIntegral.HasIntegral.of_aeEq_zero._simp_1_1 | Mathlib.Analysis.BoxIntegral.Integrability | [
"Real",
"Membership.mem",
"Exists",
"BoxIntegral.TaggedPrepartition.mem_iUnion",
"BoxIntegral.TaggedPrepartition.instMembershipBox",
"BoxIntegral.TaggedPrepartition.iUnion",
"And",
"BoxIntegral.Box.instMembershipForallReal",
"propext",
"Eq",
"Set.instMembership",
"BoxIntegral.TaggedPrepartitio... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.forIn_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"beqOfOrd",
"Ordering",
"Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false",
"Ordering.eq",
"Ne",
"Ord.compare",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"Eq"
] | false |
Lean.Parser.Module.import.formatter | Lean.Parser.Module.Syntax | [
"Lean.Parser.Module.public.formatter",
"Lean.PrettyPrinter.Formatter",
"Lean.Parser.Module.all.formatter",
"Lean.Parser.withCache.formatter",
"Lean.Parser.leadingNode.formatter",
"instOfNatNat",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Lean.Parser.symbol.formatter",
"Bool.true",
"Le... | true |
Function.rightInverse_iff_comp | Mathlib.Logic.Function.Basic | [
"Function.comp",
"Function.RightInverse.comp_eq_id",
"id",
"Iff",
"Iff.intro",
"Function.RightInverse",
"congr_fun",
"Eq"
] | true |
MeasureTheory.eLpNorm'_const | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | [
"MeasureTheory.lintegral_const",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"ENNReal.rpow_mul",
"MulOne.toOne",
"Real.partialOrder",
"Real.instLE",
"Real",
"DivInvMonoid.toInv",
"MeasureTheory.Measure",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
"mul_inv_cancel₀",
"MulZero... | true |
Lean.Grind.CommRing.instLawfulBEqPower | Init.Grind.Ring.CommSolver | [
"Lean.Grind.CommRing.Power",
"Lean.Grind.CommRing.Power.casesOn",
"Eq.mpr",
"congrArg",
"LawfulBEq",
"id",
"Bool.and",
"imp_self._simp_1",
"instBEqOfDecidableEq",
"Lean.Grind.CommRing.instBEqPower.beq_spec_1",
"Lean.Grind.CommRing.Var",
"Lean.Grind.CommRing.instBEqPower",
"Bool.true",
"Equ... | true |
_private.Mathlib.Data.List.OfFn.0.List.find?_ofFn_eq_some_of_injective._simp_1_1 | Mathlib.Data.List.OfFn | [
"List.find?",
"List.ofFn",
"Option.some",
"Exists",
"List.find?_ofFn_eq_some",
"Bool.true",
"And",
"Nat",
"LT.lt",
"instLTFin",
"propext",
"Bool",
"Fin",
"Eq",
"Not",
"Option"
] | false |
CategoryTheory.functorProdFunctorEquiv_counitIso | Mathlib.CategoryTheory.Products.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.prodFunctorToFunctorProd",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.Iso",
"CategoryTheory.functorProdToProdFunctor",
"CategoryTheory.prod'",
"Eq.refl",
"CategoryTheory.functorProdFunctor... | true |
Lean.Meta.ReduceMatcherResult.reduced.inj | Lean.Meta.WHNF | [
"Lean.Expr",
"Lean.Meta.ReduceMatcherResult.reduced",
"Lean.Meta.ReduceMatcherResult.reduced.noConfusion",
"Lean.Meta.ReduceMatcherResult",
"Eq"
] | true |
_private.Mathlib.Analysis.Fourier.Inversion.0.Real.tendsto_integral_cexp_sq_smul._simp_1_2 | Mathlib.Analysis.Fourier.Inversion | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"AddMonoid.toAddZeroClass",
"AddLeftMono",
"Left.neg_nonpos_iff",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNegZeroMonoid.toNegZeroClass",
"LE",
"AddGroup",
"AddGroup.toSubNegMonoid",
"propext",
"Add... | false |
CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt._aux_1",
"Opposite",
"CategoryTheory.Pretriangulated.Opposite.commShiftFunctorOpInt._proof_6",
"Int",
"Int.instAddMonoid",
"CategoryTheory.Pretriangulated.Opposite.instHasShiftOpposite... | true |
Std.DTreeMap.Internal.Impl.Balanced.leaf._simp_1 | Std.Data.DTreeMap.Internal.Balanced | [
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.leaf",
"True",
"eq_true",
"Eq",
"Std.DTreeMap.Internal.Impl.Balanced.leaf"
] | false |
CategoryTheory.Limits.PreservesLimitsOfSize.preservesLimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.PreservesLimitsOfSize",
"CategoryTheory.Limits.PreservesLimitsOfShape",
"CategoryTheory.Category"
] | true |
mulRightLinearMap_eq_zero_iff._simp_1 | Mathlib.Data.Matrix.Bilinear | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instSMulOfMul",
"Matrix.module",
"DistribMulAction.toDistribSMul",
"Matrix",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"Matrix.addCommMonoid",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"mul... | false |
Nat.xor_mod_two_pow | Init.Data.Nat.Bitwise.Lemmas | [
"instPowNat",
"bne",
"Nat.instXorOp",
"Nat.instMod",
"instDecidableEqBool",
"instHMod",
"instOfNatNat",
"instBEqOfDecidableEq",
"Nat.bitwise_mod_two_pow",
"instNatPowNat",
"HMod.hMod",
"HPow.hPow",
"Nat",
"HXor.hXor",
"Bool",
"Eq.refl",
"instHPow",
"OfNat.ofNat",
"Bool.false",
... | true |
Mathlib.Tactic.Order.Edge.mk._flat_ctor | Mathlib.Tactic.Order.Graph.Basic | [
"Lean.Expr",
"Mathlib.Tactic.Order.Edge",
"Nat",
"Mathlib.Tactic.Order.Edge.mk"
] | false |
AddOpposite.instDivisionSemiring._proof_9 | Mathlib.Algebra.Field.Opposite | [
"Semiring.toNatCast",
"instHDiv",
"AddOpposite.instSemiring",
"DivisionSemiring.toGroupWithZero",
"AddOpposite",
"GroupWithZero.toDiv",
"HDiv.hDiv",
"NNRat",
"NNRat.num",
"Nat.cast",
"DivisionSemiring.toNNRatCast",
"AddOpposite.instGroupWithZero",
"DivisionSemiring",
"NNRat.den",
"Divisi... | false |
Set.Iic_ofDual | Mathlib.Order.Interval.Set.Basic | [
"OrderDual.toDual",
"Equiv.instEquivLike",
"Set.Ici",
"OrderDual.ofDual",
"Equiv",
"Set.preimage",
"Set.Iic",
"OrderDual",
"OrderDual.instPreorder",
"Eq",
"DFunLike.coe",
"rfl",
"Preorder",
"EquivLike.toFunLike",
"Set"
] | true |
Equiv.generalizedBooleanAlgebra._proof_2 | Mathlib.Order.BooleanAlgebra.Basic | [
"Preorder.toLT",
"Equiv.instEquivLike",
"Iff.rfl",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"Equiv",
"GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra",
"Iff",
"GeneralizedBooleanAlgebra",
"LT.lt",
"GeneralizedCoheytingAlgebra.toLattice",
"DFunLike.coe",
"Lattice.to... | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.splitRevInTwo'._proof_3 | Init.Data.List.Sort.Impl | [
"Eq.mpr",
"instHDiv",
"congrArg",
"List.length_reverse",
"List.MergeSort.Internal.splitRevAt",
"id",
"Subtype",
"HDiv.hDiv",
"Prod.mk",
"instOfNatNat",
"Prod.fst",
"List.length_take",
"List",
"List.MergeSort.Internal.splitRevAt_eq",
"List.drop",
"Nat",
"Nat.instDiv",
"List.reverse"... | false |
AddAction.prodOfVAddCommClass | Mathlib.Algebra.Group.Action.Prod | [
"AddAction.mk",
"AddMonoid.toAddSemigroup",
"VAdd.mk",
"Prod.fst",
"HVAdd.hVAdd",
"AddAction",
"AddAction.toAddSemigroupAction",
"AddAction.prodOfVAddCommClass._proof_1",
"AddSemigroupAction.mk",
"AddSemigroupAction.toVAdd",
"AddAction.prodOfVAddCommClass._proof_2",
"AddMonoid",
"instHVAdd",... | true |
Lean.Lsp.WindowClientCapabilities.noConfusionType | Lean.Data.Lsp.Capabilities | [
"Lean.Lsp.WindowClientCapabilities.casesOn",
"Lean.Lsp.ShowDocumentClientCapabilities",
"Eq",
"Lean.Lsp.WindowClientCapabilities",
"Option"
] | false |
Prime.exists_mem_multiset_dvd | Mathlib.Algebra.BigOperators.Associated | [
"CommMonoidWithZero.toCommMonoid",
"Dvd.dvd",
"HMul.hMul",
"Prime.dvd_or_dvd",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"congrArg",
"False.elim",
"Multiset.prod_cons",
"Multiset.prod",
"semigroupDvd",
"Prime",
"Multiset.mem_cons_of_mem",
"_private.Mathlib.Algebra.BigOperators.Associat... | true |
_private.Mathlib.ModelTheory.Order.0.FirstOrder.Language.dlo_isComplete._simp_1_1 | Mathlib.ModelTheory.Order | [
"Cardinal.instOne",
"Cardinal",
"Cardinal.aleph0",
"LE.le",
"Cardinal.instLE",
"True",
"eq_true",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"Cardinal.one_le_aleph0"
] | false |
Mathlib.Tactic.Bicategory.Context.ctorIdx | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | [
"Mathlib.Tactic.Bicategory.Context",
"Nat"
] | false |
CategoryTheory.Limits.StrongEpiMonoFactorisation.toMonoIsImage._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | [
"CategoryTheory.Limits.MonoFactorisation.I",
"CategoryTheory.Limits.MonoFactorisation.m_mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.sq_hasLift_of_hasLiftingProperty",
"CategoryTheory.CommSq.lift",
"CategoryTheory.Limits.StrongEpiMonoFactorisation",
"Cat... | false |
Lean.Parser.Command.declVal._regBuiltin.Lean.Parser.Command.declVal.docString_1 | Lean.Parser.Command | [
"Lean.addBuiltinDocString",
"IO",
"Unit",
"Lean.Name.mkStr4"
] | false |
Continuous.nsmul | Mathlib.Topology.Algebra.Monoid | [
"continuous_nsmul",
"instHSMul",
"Continuous",
"AddMonoid.toAddZeroClass",
"Continuous.comp",
"AddMonoid.toNSMul",
"AddZeroClass.toAddZero",
"TopologicalSpace",
"Nat",
"AddMonoid",
"AddZero.toAdd",
"HSMul.hSMul",
"ContinuousAdd"
] | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rii.mem_iff_mem_rci._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | [
"Std.PRange.UpwardEnumerable",
"Std.PRange.UpwardEnumerable.LE",
"Std.PRange.LawfulUpwardEnumerableLeast?",
"Nonempty.intro",
"Std.PRange.UpwardEnumerable.least_le",
"Std.PRange.UpwardEnumerable.least",
"True",
"eq_true",
"Std.PRange.Least?",
"Eq"
] | false |
_private.Lean.Data.SMap.0.Lean.SMap.insert.match_1 | Lean.Data.SMap | [
"Lean.PHashMap",
"Std.HashMap",
"Lean.SMap.mk",
"Bool.true",
"Bool.casesOn",
"Lean.SMap",
"Lean.SMap.casesOn",
"Bool",
"Hashable",
"Bool.false",
"BEq"
] | false |
SemimoduleCat.rec | Mathlib.Algebra.Category.ModuleCat.Semi | [
"SemimoduleCat",
"AddCommMonoid",
"Semiring",
"Module",
"_private.Mathlib.Algebra.Category.ModuleCat.Semi.0.SemimoduleCat.mk"
] | false |
PartOrd.hom_id | Mathlib.Order.Category.PartOrd | [
"OrderHom.id",
"PartOrd.instCategory",
"PartOrd.str",
"PartialOrder.toPreorder",
"CategoryTheory.CategoryStruct.id",
"PartOrd",
"PartOrd.carrier",
"PartOrd.Hom.hom",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"OrderHom",
"rfl"
] | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm._sparseCasesOn_1 | Lean.Meta.Sym.Simp.App | [
"Nat.ne_of_beq_eq_false",
"Lean.LOption.undef",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.LOption.some",
"Lean.LOption.none",
"Nat.land",
"Nat",
"Lean.LOption.ctorIdx",
"Bool",
"Eq.refl",
"Lean.LOption.rec",
"OfNat.ofNat",
"Bool.false",
"Lean.LOption"
] | false |
CategoryTheory.GrothendieckTopology.Cover.oneHypercover._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.GrothendieckTopology.Cover.preOneHypercover",
"congrArg",
"CategoryTheory.PreZeroHypercover.sieve₀",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_sieve₀",
"Membership.mem",
"CategoryTheory.Sieve",
"Subtype.coe_prop._... | false |
sSup_sUnion | Mathlib.Data.Set.Lattice | [
"Iff.of_eq",
"congrArg",
"iSup",
"Set.sUnion",
"Membership.mem",
"Set.sUnion_eq_biUnion",
"iSup_iUnion",
"funext",
"sSup_eq_iSup",
"iSup_congr_Prop",
"congr",
"True",
"eq_self",
"of_eq_true",
"CompleteSemilatticeSup.toSupSet",
"Eq.refl",
"CompleteLattice.toCompleteSemilatticeSup",
... | true |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset.match_1 | Lean.Meta.Sym.Offset | [
"OptionT",
"Option.ctorIdx",
"Option.some",
"_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1",
"Nat.hasNotBit",
"Id",
"Nat"
] | false |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._simp_1 | Mathlib.Algebra.Category.ModuleCat.Biproducts | [
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"ModuleCat.mono_iff_injective",
"ModuleCat.instConcreteCategoryLinearMapIdCarrier",
"LinearMap",
"ModuleCat.... | false |
exteriorPower.basis_repr | Mathlib.LinearAlgebra.ExteriorPower.Basis | [
"Finsupp.instFunLike",
"Submodule",
"False",
"CommRing",
"exteriorPower.basis_repr_ne",
"Semiring.toModule",
"Finsupp.single_eq_same",
"Finsupp.module",
"QuadraticMap.instZero",
"Finsupp.ext",
"eq_false",
"LinearOrder.toDecidableEq",
"Ring.toNonAssocRing",
"ExteriorAlgebra",
"congrArg",
... | true |
frattini_le_coatom | Mathlib.GroupTheory.Frattini | [
"PartialOrder.toPreorder",
"Group",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"Order.radical_le_coatom",
"Subgroup",
"LE.le",
"IsCoatom",
"frattini",
"BoundedOrder.toOrderTop",
"Subgroup.instPartialOrder",
"Subgroup.instCompleteLattice"
] | true |
SSet.Subcomplex.unionProd.symmIso_hom | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | [
"SSet.Subcomplex.unionProd.symmIso",
"SSet.Subcomplex.toSSet",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.typesCartesianMonoidalCategory",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"SSet.Subcomplex.unionProd.symmIso._proof_1",
"CategoryTheory.Monoidal.functorCategor... | true |
ULift.seminormedRing._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | [
"SubNegMonoid.sub_eq_add_neg",
"AddMonoid.toAddSemigroup",
"NonUnitalNonAssocRing.toAddCommGroup",
"ULift",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"ULift.nonUnitalSeminormedRing",
"NonUnitalRing.toNonUnitalNonAssocRing",
"SubNegMonoid.toSub",
"instHAdd",
"AddSemigroup.toAdd",
"instHSub",
"A... | false |
_private.Mathlib.Order.WithBot.0.WithBot.decidableLT.match_1.eq_1 | Mathlib.Order.WithBot | [
"WithBot",
"Option.some",
"WithBot.decidableLT.match_1",
"Option.none",
"Eq.refl",
"Eq"
] | true |
min_inv_inv_le | Mathlib.Algebra.Order.Group.MinMax | [
"Lattice.toSemilatticeSup",
"Inv",
"congrArg",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"DistribLattice.toLattice",
"inf_le_left._simp_1",
"le_total",
"SemilatticeInf.toMin",
"LE.le",
"Or.casesOn",
"sup_of_le_righ... | true |
dotProductEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.Dual | [
"Pi.Function.module",
"NonAssocSemiring.toAddCommMonoidWithOne",
"LinearEquiv.symm",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"dotProductEquiv",
"Pi.addCommMonoid",
"CommSemiring.toSemiring",
"Pi.module",
"LinearMap.instFunLike",
"LinearMap.single",
"Algebra.id",
"AddCommMonoidWithOn... | true |
instNonUnitalCommCStarAlgebraProd._proof_9 | Mathlib.Analysis.CStarAlgebra.Classes | [
"NonUnitalCommCStarAlgebra.toNonUnitalCStarAlgebra",
"NonUnitalCStarAlgebra.toNonUnitalNormedRing",
"HMul.hMul",
"NonUnitalNonAssocRing.toMul",
"NonUnitalCommCStarAlgebra",
"AddMonoid.toZero",
"NonUnitalNonAssocRing.toAddCommGroup",
"AddCommGroup.toAddGroup",
"NonUnitalRing.toNonUnitalNonAssocRing",... | false |
Commute.units_inv_right | Mathlib.Algebra.Group.Commute.Units | [
"Monoid",
"Units.val",
"Monoid.toMulOneClass",
"Commute",
"Units",
"MulOne.toMul",
"MulOneClass.toMulOne",
"Inv.inv",
"Units.instInv",
"SemiconjBy.units_inv_right"
] | true |
Std.Internal.List.keys_eq_map | Std.Data.Internal.List.Associative | [
"congrArg",
"List.map",
"Sigma.fst",
"List.rec",
"List.cons",
"List",
"True",
"eq_self",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Std.Internal.List.keys",
"Eq",
"Sigma",
"Eq.trans",
"List.nil"
] | true |
Nat.Prime.dvd_choose_self | Mathlib.Data.Nat.Choose.Dvd | [
"Nat.zero_le",
"Nat.Prime",
"Dvd.dvd",
"Nat.choose",
"le_rfl",
"Nat.Prime.dvd_choose",
"Nat.sub_lt",
"Ne",
"instOfNatNat",
"Nat.zero_lt_of_ne_zero",
"Nat.instDvd",
"Nat.instPreorder",
"Nat",
"LT.lt",
"instLTNat",
"OfNat.ofNat",
"LE.le.trans_lt"
] | true |
MapClusterPt.tendsto_comp | Mathlib.Topology.ClusterPt | [
"MapClusterPt.tendsto_comp'",
"Filter.map",
"Filter.instCompleteLatticeFilter",
"Function.comp",
"nhds",
"CompleteLattice.toConditionallyCompleteLattice",
"Filter.instInf",
"TopologicalSpace",
"Filter.Tendsto",
"MapClusterPt",
"Filter.Tendsto.mono_left",
"inf_le_left",
"ConditionallyComplete... | true |
SimpleGraph.mulCayley_empty | Mathlib.Combinatorics.SimpleGraph.Cayley | [
"HMul.hMul",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"SimpleGraph.Adj",
"PartialOrder.toPreorder",
"setOf",
"Mul",
"SemilatticeInf.toPartialOrder",
"BiheytingAlgebra.toHeytingAlgebra",
"Ne",
"Bot.bot",
"BiheytingAlgebra.toCoheytingAlgebra",
"SimpleGraph.mulCayley_gc",
"SimpleGraph... | true |
Lean.Elab.InfoState.rec | Lean.Elab.InfoTree.Types | [
"Lean.Elab.InfoState.mk",
"Task",
"Lean.instBEqMVarId",
"Lean.Elab.InfoState",
"Lean.Elab.InfoTree",
"Lean.MVarId",
"Lean.PersistentArray",
"Lean.PersistentHashMap",
"Lean.instHashableMVarId",
"Bool"
] | false |
_private.Lean.Meta.Basic.0.Lean.Meta.withLocalDecls.loop._unsafe_rec | Lean.Meta.Basic | [
"instInhabitedProd",
"Array.push",
"instInhabitedOfMonad",
"Lean.LocalDeclKind",
"Lean.Expr",
"Lean.Meta.MetaM",
"Pi.instInhabited",
"Lean.instInhabitedBinderInfo",
"Array",
"Lean.instInhabitedExpr",
"MonadControlT",
"_private.Lean.Meta.Basic.0.Lean.Meta.withLocalDecls.loop._unsafe_rec",
"Na... | false |
MonadWriter.mk | Mathlib.Control.Monad.Writer | [
"outParam",
"MonadWriter.mk",
"MonadWriter",
"PUnit",
"Prod"
] | true |
CategoryTheory.Oplax.LaxTrans.Modification.id_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | [
"CategoryTheory.Oplax.LaxTrans.instCategoryStructOplaxFunctor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.OplaxFunctor.toPrelaxFunctor",
"CategoryTheory.Oplax.LaxTrans.Modification.app",
"CategoryTheory.Bicategory.toCategoryStruct",
"Ca... | true |
CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | [
"CategoryTheory.Functor",
"CategoryTheory.PreZeroHypercover.f",
"Opposite",
"CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"Categor... | false |
_private.Mathlib.CategoryTheory.Limits.Indization.FilteredColimits.0.CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux._aux_Mathlib_CategoryTheory_Limits_Indization_FilteredColimits___macroRules__private_Mathlib_CategoryTheory_Limits_Indization_FilteredColimits_0_CategoryTheory_Limits_IndizationClosedUnder... | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Name.mkNum",
"Lean.Syntax.ident",
"instMonadExceptOfMonadExceptOf",
"String",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Synta... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_none_of_contains_eq_false._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"beqOfOrd",
"Ordering",
"Std.DTreeMap.Internal.Impl.compare_ne_iff_beq_eq_false",
"Ordering.eq",
"Ne",
"Ord.compare",
"BEq.beq",
"propext",
"Bool",
"Bool.false",
"Eq"
] | false |
MvPolynomial.mem_support_iff | Mathlib.Algebra.MvPolynomial.Basic | [
"Finsupp.instFunLike",
"Nat.instMulZeroClass",
"congrArg",
"CommSemiring.toSemiring",
"Finset",
"Finsupp.mem_support_iff._simp_1",
"Membership.mem",
"Ne",
"MvPolynomial.support",
"MvPolynomial.coeff",
"iff_self",
"CommSemiring",
"Iff",
"Finset.instSetLike",
"Nat",
"True",
"MvPolynomi... | true |
Lean.Grind.CommRing.Expr.toPoly.match_4.congr_eq_5 | Init.Grind.Ring.CommSolver | [
"Lean.Grind.CommRing.Expr",
"Lean.Grind.CommRing.Expr.mul",
"Lean.Grind.CommRing.Expr.var",
"Lean.Grind.CommRing.Expr.toPoly.match_4",
"Lean.Grind.CommRing.Expr.sub",
"Lean.Grind.CommRing.Expr.natCast",
"Lean.Grind.CommRing.Expr.neg",
"id",
"Int",
"Lean.Grind.CommRing.Expr.casesOn",
"Lean.Grind.... | true |
CategoryTheory.Bicategory.RightAdjoint.ctorIdx | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory",
"Nat",
"CategoryTheory.Bicategory.RightAdjoint"
] | false |
RingHom.prod._proof_2 | Mathlib.Algebra.Ring.Prod | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"RingHomClass.toAddMonoidHomClass",
"AddMonoid.toAddZeroClass",
"RingHom",
"AddZeroClass.toAddZero",
"AddMonoidHomClass",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"NonAssocSemiring",
"RingHom.instFunLike",
"AddMonoidWithOne... | false |
IsSimpleGroup.prime_card | Mathlib.GroupTheory.SpecificGroups.Cyclic | [
"Nat.gcd",
"Mathlib.Tactic.Push.not_forall_eq",
"Nontrivial",
"Iff.mpr",
"Eq.mpr",
"orderOf_eq_card_of_forall_mem_zpowers",
"Nat.Coprime",
"Nat.Coprime.symm",
"MulOne.toOne",
"False",
"Nat.Prime",
"Dvd.dvd",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Nat.gcd_zero_right",
"I... | true |
Lean.Meta.setPostponed | Lean.Meta.Basic | [
"Lean.Meta.State.mk",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"modify",
"Lean.Meta.State.mctx",
"Lean.Meta.State",
"instMonadLiftT",
"IO",
"StateRefT'.instMonadStateOfOfMonadLiftTST",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Lean.PersistentArray",
"ReaderT.instMonad... | true |
ProbabilityTheory.Kernel.iIndepFun.indepFun_sub_sub | Mathlib.Probability.Independence.Kernel.IndepFun | [
"MeasureTheory.Measure",
"ProbabilityTheory.Kernel.iIndepFun.indepFun_prodMk_prodMk",
"Measurable",
"HSub.hSub",
"MeasurableSub₂",
"MeasurableSub₂.measurable_sub",
"Prod.mk",
"Ne",
"ProbabilityTheory.Kernel.IndepFun.comp",
"ProbabilityTheory.Kernel.IndepFun",
"Prod.fst",
"MeasurableSpace",
"... | true |
_private.Mathlib.Algebra.Group.Units.Defs.0.isUnit_iff_exists.match_1_1 | Mathlib.Algebra.Group.Units.Defs | [
"Monoid",
"Units.val",
"IsUnit",
"Units",
"Exists.casesOn",
"Exists.intro",
"Eq"
] | false |
disjointed | Mathlib.Order.Disjointed | [
"Lattice.toSemilatticeSup",
"Finset.Iio",
"LocallyFiniteOrderBot",
"GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra",
"SDiff.sdiff",
"GeneralizedBooleanAlgebra.toOrderBot",
"GeneralizedBooleanAlgebra",
"Finset.sup",
"GeneralizedCoheytingAlgebra.toLattice",
"GeneralizedBooleanAlgebra.toSDif... | true |
of_addIrreducible_add | Mathlib.Algebra.Group.Irreducible.Defs | [
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"IsAddUnit",
"AddIrreducible",
"_private.Mathlib.Algebra.Group.Irreducible.Defs.0.of_addIrreducible_add.match_1_1",
"instHAdd",
"HAdd.hAdd",
"AddMonoid",
"AddZero.toAdd",
"Or",
"Eq",
"Not",
"rfl"
] | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.op._proof_4 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ShortComplex.LeftHomologyMapData",
"Opposite",
"CategoryTheory.ShortComplex.LeftHomologyData",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortC... | false |
FirstOrder.Language.realize_term_substructure | Mathlib.ModelTheory.ElementaryMaps | [
"FirstOrder.Language.StrongHomClass.homClass",
"FirstOrder.Language.Substructure.inducedStructure",
"Function.comp",
"Membership.mem",
"FirstOrder.Language.Substructure.instSetLike",
"FirstOrder.Language.Term",
"Subtype",
"FirstOrder.Language.Embedding",
"FirstOrder.Language.Embedding.strongHomClass... | true |
_private.Mathlib.Data.Sum.Interval.0.Finset.inl_mem_sumLexLift._simp_1_1 | Mathlib.Data.Sum.Interval | [
"Finset",
"Membership.mem",
"Exists",
"Sum",
"Sum.inl",
"And",
"Finset.instSetLike",
"Sum.inr",
"Finset.mem_sumLexLift",
"propext",
"Or",
"Eq",
"Finset.sumLexLift",
"SetLike.instMembership"
] | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.aux_pid_of_ufd_of_unique_irreducible._simp_1_4 | Mathlib.RingTheory.DiscreteValuationRing.Basic | [
"Monoid",
"Dvd.dvd",
"HMul.hMul",
"Monoid.toMulOneClass",
"semigroupDvd",
"IsUnit",
"MulOne.toMul",
"MulOneClass.toMulOne",
"propext",
"Monoid.toSemigroup",
"IsUnit.dvd_mul_right",
"Eq",
"instHMul"
] | false |
_private.Init.Data.Int.Gcd.0.Int.gcd_le_right._proof_1_2 | Init.Data.Int.Gcd | [
"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.LinearCombo.eval",
"Option.some",
"id",
"instDecidableEqBool",
"Int.instNegInt"... | false |
MonoidWithZeroHom.inr_apply_unit | Mathlib.Algebra.GroupWithZero.ProdHom | [
"Units.val",
"GroupWithZero.toMonoidWithZero",
"of_eq_false",
"MulOne.toOne",
"MulEquiv.instEquivLike",
"MonoidHom.inr",
"MulZeroClass.toMul",
"congrArg",
"GroupWithZero",
"MonoidWithZeroHom.funLike",
"WithZero.withZeroUnitsEquiv",
"Prod.instMulOneClass",
"Units",
"WithZero.instMulZeroOneC... | true |
_private.Mathlib.Order.Filter.SmallSets.0.Filter.eventually_smallSets_eventually._simp_1_2 | Mathlib.Order.Filter.SmallSets | [
"Filter.instMembership",
"Filter.eventually_inf",
"Filter.Eventually",
"Membership.mem",
"Exists",
"Set.instInter",
"Filter.instInf",
"Inter.inter",
"And",
"propext",
"Eq",
"Set.instMembership",
"Filter",
"Min.min",
"Set"
] | false |
Batteries.RBMap.instForInProdOfMonad | Batteries.Data.RBMap.Basic | [
"Batteries.RBMap",
"Ordering",
"ForIn.mk",
"Batteries.RBMap.instForInProdOfMonad._aux_1",
"ForIn",
"Prod",
"Monad"
] | true |
_private.Mathlib.Algebra.Order.Field.Basic.0.sub_inv_antitoneOn_Icc_right._simp_1_1 | Mathlib.Algebra.Order.Field.Basic | [
"Set.Subsingleton.antitoneOn",
"True",
"Set.Subsingleton",
"eq_true",
"AntitoneOn",
"Eq",
"Preorder",
"Set"
] | false |
Submodule.inclusion._proof_1 | Mathlib.Algebra.Module.Submodule.LinearMap | [
"Submodule",
"Submodule.addCommMonoid",
"PartialOrder.toPreorder",
"LinearMap.instFunLike",
"Preorder.toLE",
"Membership.mem",
"Subtype",
"Submodule.instPartialOrder",
"Submodule.module",
"LE.le",
"LinearMap",
"AddCommMonoid",
"Subtype.mk",
"Submodule.setLike",
"Submodule.subtype",
"Se... | false |
Bialgebra.TensorProduct.counitAlgHom_def | Mathlib.RingTheory.Bialgebra.TensorProduct | [
"Semiring.toModule",
"IsScalarTower.right",
"AlgEquiv.toAlgHom",
"CommSemiring.toSemiring",
"Algebra.TensorProduct.map",
"AlgHom",
"IsScalarTower",
"Algebra",
"Algebra.toSMul",
"Algebra.toModule",
"Algebra.id",
"TensorProduct.instBialgebra",
"Algebra.TensorProduct.leftAlgebra",
"Bialgebra.... | true |
_private.Lean.Server.CodeActions.UnknownIdentifier.0.Lean.Server.FileWorker.waitAllUnknownIdentifierMessageRanges.match_1 | Lean.Server.CodeActions.UnknownIdentifier | [
"Lean.Server.Snapshots.Snapshot",
"Prod.mk",
"List",
"IO.Error",
"Prod",
"Prod.casesOn",
"Option"
] | false |
CategoryTheory.Under.mapCongr_inv_app | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.eqToHom",
"CategoryTheory.Functor.category",
"CategoryTheory.Under",
"CategoryTheory.Under.mapCongr",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Cate... | true |
_private.Lean.Widget.Diff.0.Lean.Widget.instEmptyCollectionExprDiff | Lean.Widget.Diff | [
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.mk",
"EmptyCollection.mk",
"Ord.compare",
"Lean.SubExpr.Pos",
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiffTag",
"_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff",
"Std.TreeMap.instEmptyCollection",
"EmptyCollection",
"EmptyCollection.emptyColle... | true |
CategoryTheory.Limits.biprod.opIso_hom_fst | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | [
"CategoryTheory.Limits.BinaryBicone.fst",
"CategoryTheory.Limits.getBinaryBiproductData",
"CategoryTheory.Limits.HasZeroMorphisms",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.opposite",
"Quiver.Hom.op",
"CategoryTheory.Limits.biprod.opIso",
"... | true |
_private.Mathlib.Data.List.Sublists.0.List.revzip_sublists'._simp_1_7 | Mathlib.Data.List.Sublists | [
"exists_eq_right_right",
"Exists",
"And",
"propext",
"Eq"
] | false |
CharP.congr | Mathlib.Algebra.CharP.Defs | [
"Eq.rec",
"Nat",
"CharP",
"Eq",
"AddMonoidWithOne"
] | true |
Set.disjoint_univ | Mathlib.Data.Set.Disjoint | [
"disjoint_top",
"Set.univ",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Set.instDistribLattice",
"Iff",
"Set.instBoundedOrder",
"BoundedOrder.toOrderBot",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
... | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | [
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe",
"id",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.noConfusion",
"Lean.Meta.Grind.Arith.Cutsat.LeCnstr",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof",
"Eq"
] | false |
CategoryTheory.Iso.symm_self_id | Mathlib.CategoryTheory.Iso | [
"CategoryTheory.Iso.inv_hom_id",
"CategoryTheory.Iso.refl",
"CategoryTheory.Iso",
"CategoryTheory.Iso.trans",
"CategoryTheory.Iso.symm",
"CategoryTheory.Iso.ext",
"Eq",
"CategoryTheory.Category"
] | true |
_private.Mathlib.CategoryTheory.ObjectProperty.Basic.0.CategoryTheory.ObjectProperty.strictMap_ofObj._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | [
"CategoryTheory.ObjectProperty.ofObj",
"CategoryTheory.ObjectProperty.ofObj_iff",
"Exists",
"propext",
"CategoryTheory.CategoryStruct",
"Eq"
] | false |
Function.support_pow' | Mathlib.Algebra.GroupWithZero.Indicator | [
"MulZeroClass.toMul",
"Function.support_pow",
"Pi.instPow",
"Ne",
"instOfNatNat",
"Monoid.toPow",
"MonoidWithZero",
"NoZeroDivisors",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Function.support",
"Nat",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Eq",
"Monoid... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.