name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
IsOfFinOrder.val_unit | Mathlib.GroupTheory.OrderOfElement | [
"Monoid",
"Units.val",
"IsOfFinOrder.unit",
"Eq.refl",
"Eq",
"IsOfFinOrder"
] | true |
UInt16.toUSize_sub | Init.Data.UInt.Lemmas | [
"congrArg",
"HSub.hSub",
"USize.toUInt16",
"instModUSize",
"USize.toUInt16_sub",
"instHMod",
"UInt16.toUSize",
"HMod.hMod",
"UInt16",
"instHSub",
"_private.Init.Data.UInt.Lemmas.0.UInt16.toUSize_sub._simp_1_1",
"congr",
"True",
"eq_self",
"of_eq_true",
"instSubUSize",
"instSubUInt16"... | true |
Lean.Parser.Term.doSeqBracketed | Lean.Parser.Do | [
"Lean.Parser.Term.doSeqItem",
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Nat",
"Lean.Parser.ppLine",
"Lean.Parser.withCache",
"Lean.Parser.many1",
"... | true |
MeasureTheory.StronglyAdapted.measurable_upcrossingsBefore | Mathlib.Probability.Martingale.Upcrossing | [
"Eq.mpr",
"WithTop.charZero",
"WithTop.instPartialOrder",
"Nat.instMulZeroClass",
"Real",
"Preorder.toLT",
"DiscreteUniformity.instCompleteSpace",
"Nat.instIsOrderedAddMonoid",
"MeasureTheory.StronglyAdapted.isStoppingTime_upperCrossingTime",
"MeasurableSet",
"Nat.instOne",
"AddMonoid.toAddSem... | true |
IsAbelianGalois.recOn | Mathlib.FieldTheory.Galois.Abelian | [
"Monoid.toMulOneClass",
"Algebra",
"MulOne.toMul",
"IsGalois",
"DivInvMonoid.toMonoid",
"IsAbelianGalois",
"Field.toSemifield",
"IsAbelianGalois.mk",
"Group.toDivInvMonoid",
"IsMulCommutative",
"MulOneClass.toMulOne",
"Semifield.toDivisionSemiring",
"AlgEquiv",
"IsAbelianGalois.rec",
"Al... | false |
ContinuousLinearEquiv.isUniformEmbedding | Mathlib.Topology.Algebra.Module.Equiv | [
"UniformSpace",
"ContinuousLinearEquiv.symm",
"Equiv.isUniformEmbedding",
"ContinuousLinearEquiv.toLinearEquiv",
"AddCommGroup.toAddCommMonoid",
"IsUniformEmbedding",
"ContinuousLinearMap.uniformContinuous",
"AddCommGroup.toAddGroup",
"RingHom",
"AddCommGroup",
"ContinuousLinearEquiv.equivLike",... | true |
Nat.Partrec.Code.eval._sunfold | Mathlib.Computability.PartrecCode | [
"Pure.pure",
"Part",
"Nat.rfind",
"PFun",
"Nat.unpair",
"Monad.toApplicative",
"PFun.monad",
"Nat.Partrec.Code",
"Nat.rec",
"instOfNatNat",
"Seq.seq",
"Applicative.toPure",
"Prod.fst",
"Nat.pair",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"Nat.Partrec.Code.encodeCode.match_1",
"N... | false |
Lean.Compiler.LCNF.LitValue.uint64.inj | Lean.Compiler.LCNF.Basic | [
"Lean.Compiler.LCNF.LitValue",
"UInt64",
"Lean.Compiler.LCNF.LitValue.uint64.noConfusion",
"Lean.Compiler.LCNF.LitValue.uint64",
"Eq"
] | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | [
"CategoryTheory.GrothendieckTopology.superset_covering",
"CategoryTheory.GrothendieckTopology.OneHypercover.mem₀",
"CategoryTheory.PreZeroHypercover.sieve₀",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toConditio... | false |
_private.Mathlib.Computability.NFA.0.NFA.mem_evalFrom_iff_nonempty_path.match_1_3 | Mathlib.Computability.NFA | [
"NFA.step",
"NFA.evalFrom",
"NFA",
"Membership.mem",
"Exists",
"Set.instSingletonSet",
"And.casesOn",
"List",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Singleton.singleton",
"Set.instMembership",
"Set"
] | false |
AddMonCat.adjoinZeroAdj.eq_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | [
"AddMonCat.instConcreteCategoryAddMonoidHomCarrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Equiv.trans",
"AddSemigrp.str",
"AddHom",
"AddMonoid.toAddZeroClass",
"AddMonCat.adjoinZero",
"AddMonCat.hasForgetToAddSemigroup",
"AddZeroClass.toAddZero",
"AddMonCat.adjoinZeroAdj",
... | true |
MeasureTheory.measureReal_union_congr_of_subset._auto_3 | Mathlib.MeasureTheory.Measure.Real | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
convex_iff_segment_subset | Mathlib.Analysis.Convex.Basic | [
"SMul",
"Membership.mem",
"PartialOrder",
"starConvex_iff_segment_subset",
"HasSubset.Subset",
"segment",
"AddCommMonoid",
"Iff",
"forall₂_congr",
"Convex",
"Semiring",
"Set.instMembership",
"StarConvex",
"Set.instHasSubset",
"Set"
] | true |
Action.functorCategoryEquivalenceFunctorMonoidal._proof_8 | Mathlib.CategoryTheory.Action.Monoidal | [
"Monoid",
"CategoryTheory.Functor",
"Action.functorCategoryEquivalenceFunctorMonoidal._aux_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Action.FunctorCategoryEquivalence.functorMonoidal._proof_8",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.category",
"CategoryTheory.C... | false |
OpenSubgroup.instInhabited.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | [
"OpenSubgroup",
"Group",
"OpenSubgroup.instInhabited",
"TopologicalSpace",
"OpenSubgroup.instTop",
"Inhabited",
"Eq.refl",
"Top.top",
"Eq",
"Inhabited.mk"
] | true |
Std.HashSet.get?_filter | Std.Data.HashSet.Lemmas | [
"Std.HashSet.filter",
"Std.HashSet",
"Std.HashMap.getKey?_filter_key",
"LawfulHashable",
"Unit",
"Option.filter",
"EquivBEq",
"Std.HashSet.inner",
"Bool",
"Hashable",
"BEq",
"Eq",
"Std.HashSet.get?",
"Option"
] | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.le.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | [
"Lean.Meta.Grind.Arith.Cutsat.UnsatProof.le.inj",
"Eq.propIntro",
"Lean.Meta.Grind.Arith.Cutsat.LeCnstr",
"Lean.Meta.Grind.Arith.Cutsat.UnsatProof",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Meta.Grind.Arith.Cutsat.UnsatProof.le"
] | true |
WithCStarModule.inner_single_left | Mathlib.Analysis.CStarAlgebra.Module.Constructions | [
"Eq.mpr",
"NonUnitalCStarAlgebra.toStarModule",
"False",
"NonUnitalNormedRing.toNorm",
"NonUnitalCStarAlgebra.toNonUnitalNormedRing",
"Equiv.instEquivLike",
"Finset.univ",
"eq_false",
"Inner.inner",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Finset",
"SMul",
"NormedSpace.toModule",
"Pi... | true |
Lean.Elab.Tactic.GuardExpr.MatchKind.ctorIdx | Lean.Elab.Tactic.Guard | [
"Lean.Elab.Tactic.GuardExpr.MatchKind",
"Lean.Meta.TransparencyMode",
"Lean.Elab.Tactic.GuardExpr.MatchKind.casesOn",
"Nat",
"Lean.Meta.TransparencyMode.reducible",
"optParam"
] | false |
CategoryTheory.Limits.ColimitPresentation.instLocallySmallTotal | Mathlib.CategoryTheory.Presentable.ColimitPresentation | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.LocallySmall",
"CategoryTheory.Limits.ColimitPresentation.Total.Hom.hom",
"CategoryTheory.instSmallHomOfLocallySmall",
"CategoryTheory.Limits.ColimitPresentation.Total.Hom.base",
"small_of_injective",
"... | true |
SimpleGraph.walkLengthTwoEquivCommonNeighbors._proof_4 | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | [
"SimpleGraph.Adj.toWalk",
"SimpleGraph.Adj.symm",
"SimpleGraph.Walk.length",
"SimpleGraph.Adj",
"SimpleGraph.Walk",
"Membership.mem",
"SimpleGraph.neighborSet",
"Set.Elem",
"SimpleGraph.commonNeighbors",
"Subtype",
"instOfNatNat",
"SimpleGraph.Walk.concat",
"Subtype.mk",
"SimpleGraph",
"... | false |
CategoryTheory.Pi.equivalenceOfEquiv_functor | Mathlib.CategoryTheory.Pi.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Pi.equivalenceOfEquiv._proof_1",
"Equiv.instEquivLike",
"CategoryTheory.Pi.equivalenceOfEquiv",
"CategoryTheory.Pi.eval",
"CategoryTheory.Functor.comp",
"Equiv",
"CategoryTheory.Equivalence.functor",
"CategoryTheory.pi",
"CategoryTheory.Pi.eqToEquivalence"... | true |
LieAlgebra.IsKilling.eq_neg_one_or_eq_zero_or_eq_one_of_eq_smul | Mathlib.Algebra.Lie.Weights.RootSystem | [
"Int.instAddCommGroup",
"LieAlgebra.toModule",
"Nontrivial",
"Iff.mpr",
"LieSubalgebra.lieAlgebra",
"AddGroup.toSubtractionMonoid",
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"Int.cast_neg",
"Int.cast",
"Eq.mpr",
"Pi.Function.module",
"NegZeroClass.toNeg",
"NonAssocSemiring... | true |
CategoryTheory.WithTerminal.opEquiv._proof_29 | Mathlib.CategoryTheory.WithTerminal.Basic | [
"Eq.mpr",
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.WithTerminal.opEquiv.match_9",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.WithTerminal.opEquiv.match_13",
"CategoryTheory.WithInitial.of",
"CategoryTheory.CategoryStruct.opposite",
"congrArg... | false |
Con.submonoid._proof_1 | Mathlib.GroupTheory.Congruence.Basic | [
"Con.mul",
"HMul.hMul",
"MulOne.toMul",
"Prod.fst",
"MulOneClass.toMulOne",
"Con",
"MulOneClass",
"Prod",
"Con.instFunLikeForallProp",
"Prod.snd",
"DFunLike.coe",
"instHMul"
] | false |
Matrix.linearIndependent_rows_of_det_ne_zero | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | [
"Pi.Function.module",
"IsDomain",
"Mathlib.Tactic.Contrapose.contrapose₂",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"Matrix",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring... | true |
Std.DTreeMap.Internal.Impl.link2.match_1 | Std.Data.DTreeMap.Internal.Operations | [
"Std.DTreeMap.Internal.Impl.Tree.casesOn",
"Std.DTreeMap.Internal.Impl.Tree.mk",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.size",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq",
"Std.DTreeMap.Internal.Impl.Tree",
"Std.DTreeMap.Internal.Impl"
] | false |
Std.Internal.IO.Async.System.UserId.ctorIdx | Std.Internal.Async.System | [
"Nat",
"Std.Internal.IO.Async.System.UserId"
] | false |
ONote.fastGrowing.eq_1 | Mathlib.SetTheory.Ordinal.Notation | [
"Preorder.toLT",
"ONote.fastGrowing",
"Option.some",
"Sum",
"Sum.inl",
"Nat.iterate",
"ONote.fundamentalSequence",
"Option.none",
"ONote.fastGrowing.match_1",
"ONote.fastGrowing._proof_6",
"Sum.inr",
"Nat",
"LT.lt",
"ONote.FundamentalSequenceProp",
"Eq.refl",
"ONote.instPreorder",
"O... | true |
CategoryTheory.Monad._sizeOf_inst | Mathlib.CategoryTheory.Monad.Basic | [
"CategoryTheory.Monad",
"CategoryTheory.Monad._sizeOf_1",
"SizeOf.mk",
"SizeOf",
"CategoryTheory.Category"
] | false |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory.liftHom.match_1.eq_1 | Mathlib.CategoryTheory.Bicategory.Free | [
"CategoryTheory.FreeBicategory.Hom.comp",
"Quiver.Hom",
"CategoryTheory.FreeBicategory.quiver",
"CategoryTheory.FreeBicategory.Hom.id",
"CategoryTheory.FreeBicategory",
"CategoryTheory.FreeBicategory.Hom",
"CategoryTheory.FreeBicategory.liftHom.match_1",
"Quiver",
"Eq.refl",
"CategoryTheory.FreeBi... | true |
Lean.Grind.CommRing.instReprExpr.repr._unsafe_rec | Init.Grind.Ring.CommSolver | [
"Std.Format.instAppend",
"Lean.Grind.CommRing.Expr",
"Std.Format.line",
"_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instHashableExpr.hash.match_1",
"Std.Format.group",
"Lean.Grind.CommRing.instReprExpr.repr._unsafe_rec",
"GE.ge",
"instOfNatNat",
"Int",
"instLENat",
"Lean.Grind.Com... | false |
Order.IsNormal.strictMono | Mathlib.Order.IsNormal | [
"StrictMono",
"LinearOrder",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"instDistribLatticeOfLinearOrder",
"Order.IsNormal",
"Lattice.toSemilatticeInf"
] | true |
edist_toMul | Mathlib.Topology.EMetricSpace.Defs | [
"Equiv.instEquivLike",
"Additive",
"instEDistAdditive",
"Additive.toMul",
"Equiv",
"ENNReal",
"EDist.edist",
"EDist",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike"
] | true |
List.tail_zip | Init.Data.List.Zip | [
"congrArg",
"List.zip",
"List.tail",
"List.cons",
"List",
"congr",
"True",
"List.casesOn",
"eq_self",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Eq.symm",
"List.zip_nil_right",
"Eq",
"Eq.trans",
"List.nil"
] | true |
ModuleCat.projectiveShortComplex._proof_1 | Mathlib.Algebra.Category.ModuleCat.Ext.DimensionShifting | [
"CommRing",
"CommSemiring.toSemiring",
"RingHomInvPair",
"CommRing.toCommSemiring",
"RingHomInvPair.ids",
"RingHom.id",
"Semiring.toNonAssocSemiring"
] | false |
CategoryTheory.Equivalence.functor_unitIso_comp | Mathlib.CategoryTheory.Equivalence | [
"CategoryTheory.Functor",
"CategoryTheory.Equivalence.unitIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Equivalence",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.E... | true |
Affine.Simplex.instFintypePointsWithCircumcenterIndex._proof_7 | Mathlib.Geometry.Euclidean.Circumcenter | [
"Unit.unit",
"Function.LeftInverse",
"Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_3",
"Sum.casesOn",
"Sum",
"instOfNatNat",
"Sum.inl",
"Affine.Simplex.PointsWithCircumcenterIndex.pointIndex",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Sum.inr",
"Nat",
"Affine.Simplex.instFintypePoin... | false |
Behrend.sphere_zero_right | Mathlib.Combinatorics.Additive.AP.Three.Behrend | [
"Finset.univ",
"congrArg",
"Behrend.sphere",
"Finset",
"Nat.instMonoid",
"Finset.filter_empty",
"Behrend.box",
"Finset.filter.congr_simp",
"instOfNatNat",
"Finset.instEmptyCollection",
"Fin.fintype",
"Monoid.toPow",
"instHAdd",
"HPow.hPow",
"HAdd.hAdd",
"Behrend.box_zero",
"Nat",
"... | true |
UInt32.ofFin_shiftRight | Init.Data.UInt.Bitwise | [
"UInt32.size",
"congrArg",
"UInt32.toFin_inj",
"UInt32.toFin_shiftRight",
"instOfNatNat",
"Fin.val",
"instHShiftRightOfShiftRight",
"HShiftRight.hShiftRight",
"UInt32.ofFin",
"Nat",
"congr",
"LT.lt",
"True",
"eq_self",
"Iff.mp",
"of_eq_true",
"UInt32",
"UInt32.toFin_ofFin",
"inst... | true |
MeasureTheory.IntegrableOn.locallyIntegrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | [
"Filter.instMembership",
"MeasureTheory.Measure",
"nhdsWithin",
"Membership.mem",
"MeasureTheory.IntegrableOn",
"ContinuousENorm",
"MeasurableSpace",
"TopologicalSpace",
"And",
"self_mem_nhdsWithin",
"And.intro",
"Exists.intro",
"MeasureTheory.LocallyIntegrableOn",
"Set.instMembership",
... | true |
DoubleCentralizer.instMul._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | [
"NormedField.toField",
"RingHomCompTriple",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"DivisionSemiring.toSemiring",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"RingHom.id",
"RingHomCompTriple.ids",
"Semiring.toNonAssocSemiring"
] | false |
SSet.Subcomplex.Pairing.RankFunction.Cell.index._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | [
"Equiv.instEquivLike",
"SSet.Subcomplex.Pairing.isUniquelyCodimOneFace",
"LinearOrder",
"SSet.Subcomplex.Pairing.p",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"SSet.Subcomplex.Pairing.RankFunction.Cell.s",
"SSet.Subcomplex.N",
"Set.Elem",
"DistribLattice.toLattice",
"Equiv",
"SSet.Sub... | false |
SSet.Truncated.Path₁.arrow | Mathlib.AlgebraicTopology.SimplicialSet.Path | [
"CategoryTheory.ObjectProperty.FullSubcategory.mk",
"Opposite",
"SSet.Truncated",
"SSet.Truncated.Path₁._proof_2",
"instOfNatNat",
"LE.le",
"instLENat",
"SSet.Truncated.Path₁",
"SimplexCategory.mk",
"Opposite.op",
"Nat",
"CategoryTheory.types",
"SimplexCategory",
"CategoryTheory.Category.o... | true |
ISize.ofNat_int8ToNatClampNeg | Init.Data.SInt.Lemmas | [
"instPowNat",
"Eq.mpr",
"of_decide_eq_true",
"congrArg",
"Int8.toISize",
"Int8",
"ISize.ofNat",
"Int8.toInt",
"id",
"ISize.toInt.inj",
"instOfNatNat",
"Int",
"LE.le",
"instLENat",
"Nat.cast",
"instNatPowNat",
"Bool.true",
"HPow.hPow",
"Int8.toNatClampNeg",
"Nat",
"instLEInt8"... | true |
Std.Time.Weekday.toNat | Std.Time.Date.Unit.Weekday | [
"instOfNatNat",
"Unit",
"_private.Std.Time.Date.Unit.Weekday.0.Std.Time.instReprWeekday.repr.match_1",
"Nat",
"OfNat.ofNat",
"Std.Time.Weekday"
] | true |
CategoryTheory.Limits.Cofan.ext | Mathlib.CategoryTheory.Limits.Shapes.Products | [
"CategoryTheory.Limits.Cofan.ext._auto_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.Cofan",
"CategoryTheory.Limits.Cofan.ext._proof_1",
"CategoryTheory.Limits.Cocone.ext",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Iso",
"autoParam",
"CategoryTheory.Li... | true |
Int.neg_mul_tmod_left | Init.Data.Int.DivMod.Lemmas | [
"Int.tmod",
"HMul.hMul",
"congrArg",
"Int.neg_tmod",
"Int.instNegInt",
"Int",
"Int.instMul",
"instOfNat",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Int.mul_tmod_left",
"OfNat.ofNat",
"Eq",
"Neg.neg",
"Eq.trans",
"instHMul"
] | true |
_private.Mathlib.Order.Monotone.Extension.0.MonotoneOn.exists_monotone_extension._simp_1_2 | Mathlib.Order.Monotone.Extension | [
"Std.Refl",
"True",
"eq_true",
"refl",
"Eq"
] | false |
_private.Lean.Elab.Tactic.Grind.SimprocDSLBuiltin.0.Lean.Elab.Tactic.Grind.elabSimprocNone | Lean.Elab.Tactic.Grind.SimprocDSLBuiltin | [
"Pure.pure",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"Lean.Meta.Sym.Simp.MethodsRef",
"Lean.Meta.Sym.Context",
"Lean.Syntax",
"ReaderT.instMonad",
"Lean.Elab.Tactic.Grind.Context",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Applicative.toPure",
"Lean.Meta.Sym.SymM",
"Lean.Met... | true |
_private.Mathlib.Order.Interval.Set.OrderIso.0.OrderIso.preimage_Icc._simp_1_1 | Mathlib.Order.Interval.Set.OrderIso | [
"Set.Ici",
"Set.instInter",
"Inter.inter",
"Set.Icc",
"Set.Iic",
"Eq.symm",
"Eq",
"Preorder",
"Set.Ici_inter_Iic",
"Set"
] | false |
AddMonoidAlgebra.uniqueAlgEquiv.eq_1 | Mathlib.Algebra.MonoidAlgebra.Basic | [
"AddMonoidAlgebra.semiring",
"RingEquiv.toEquiv",
"Unique",
"AddMonoidAlgebra.algebra",
"AddMonoidAlgebra.uniqueAlgEquiv._proof_1",
"Algebra",
"Distrib.toAdd",
"AlgEquiv.mk",
"AddMonoidAlgebra.uniqueAlgEquiv._proof_3",
"instDistribOfSemiring",
"CommSemiring",
"Unique.instSubsingleton",
"AddM... | true |
Polynomial.IsMonicOfDegree.monic | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | [
"Polynomial",
"Polynomial.Monic",
"Nat",
"Semiring",
"Polynomial.IsMonicOfDegree"
] | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp_hom_app_snd_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | [
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.snd",
"CategoryTheory.Functor",
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.instCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory... | true |
Lean.Firefox.ThreadWithCollideMaps.resourceTable._inherited_default | Lean.Util.Profiler | [
"Lean.Json",
"Lean.Firefox.ResourceTable.mk",
"id",
"instOfNatNat",
"List.toArray",
"Nat",
"Lean.Firefox.ResourceTable",
"OfNat.ofNat",
"List.nil"
] | false |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.realSize.match_1.eq_2 | Batteries.Data.BinomialHeap.Basic | [
"Batteries.BinomialHeap.Imp.Heap",
"Batteries.BinomialHeap.Imp.HeapNode",
"Batteries.BinomialHeap.Imp.Heap.cons",
"Batteries.BinomialHeap.Imp.Heap.nil",
"Unit",
"Batteries.BinomialHeap.Imp.Heap.realSize.match_1",
"Nat",
"Eq.refl",
"Eq"
] | true |
ContinuousAt.finset_sup' | Mathlib.Topology.Order.Lattice | [
"congrArg",
"ContinuousAt",
"Finset",
"Membership.mem",
"SemilatticeSup.toMax",
"Eq.mp",
"TopologicalSpace",
"Pi.instSemilatticeSup",
"funext",
"Finset.instSetLike",
"_private.Mathlib.Topology.Order.Lattice.0.ContinuousAt.finset_sup'._simp_1_1",
"ContinuousAt.finset_sup'_apply",
"Finset.None... | true |
PresentedMonoid.ext_iff | Mathlib.Algebra.PresentedMonoid.Basic | [
"Monoid",
"PresentedMonoid",
"FreeMonoid",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"PresentedMonoid.of",
"HEq.refl",
"PresentedMonoid.ext",
"Eq.casesOn",
"MulOneClass.toMulOne",
"Iff",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"PresentedMonoid.instMonoid",
"E... | true |
Path.map'._proof_3 | Mathlib.Topology.Path | [
"Set.mem_range_self",
"Real",
"Continuous",
"ContinuousOn.comp_continuous",
"PseudoMetricSpace.toUniformSpace",
"Function.comp",
"Membership.mem",
"Set.Elem",
"TopologicalSpace",
"Path.continuous",
"Path.instFunLike",
"Path",
"ContinuousOn",
"Real.pseudoMetricSpace",
"instTopologicalSpac... | false |
Polynomial.nextCoeff_map_of_leadingCoeff_ne_zero | Mathlib.Algebra.Polynomial.Eval.Degree | [
"RingHom",
"Polynomial.leadingCoeff",
"Ne",
"Polynomial",
"Polynomial.nextCoeff",
"RingHom.instFunLike",
"Semiring",
"Zero.toOfNat0",
"_private.Mathlib.Algebra.Polynomial.Eval.Degree.0.Polynomial.nextCoeff_map_of_leadingCoeff_ne_zero._proof_1_1",
"Polynomial.map",
"OfNat.ofNat",
"Semiring.toNo... | true |
Lean.Parser.Term.explicitUniv | Lean.Parser.Term | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.Term.isIdent",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.trailingNode",
"Lean.Parser.sepBy1",
"Lean.Parser.symbol",
"Lean.Parser.TrailingParser",
"Lean.Parser.checkNoWsBefore",
"Unit",
"Nat",
"Lean.Parser.levelParser",
"Le... | true |
ShowMessageParams.noConfusionType | Lean.Data.Lsp.Window | [
"ShowMessageParams",
"String",
"ShowMessageParams.casesOn",
"MessageType",
"Eq"
] | false |
EuclideanDomain.gcd_eq_left | Mathlib.Algebra.EuclideanDomain.Basic | [
"Iff.mpr",
"Eq.mpr",
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"semigroupDvd",
"SemigroupWithZero.toSemigroup",
"id",
"instHMod",
"NonUnitalSemiring.toSemigroupWithZero",
"EuclideanDomain.gcd_zero_left",
"NonUnitalCommSemiring.toNonUnitalSemiring",
"... | true |
CliffordAlgebra.EvenHom.bilin | Mathlib.LinearAlgebra.CliffordAlgebra.Even | [
"CommRing",
"CliffordAlgebra.EvenHom",
"Ring.toNonAssocRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"QuadraticForm",
"Algebra",
"AddCommGroup",
"Algebra.toModule",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"LinearMap.module",
"LinearMap",
"NonAssocRing.toNonUn... | true |
CategoryTheory.CoreHom.iso | Mathlib.CategoryTheory.Core | [
"CategoryTheory.Iso",
"CategoryTheory.CoreHom",
"CategoryTheory.Core.of",
"CategoryTheory.Core",
"CategoryTheory.Category"
] | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey!_erase_eq_of_not_compare_maxKey!_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 |
Batteries.Tactic.Cache.get.match_3 | Batteries.Util.Cache | [
"Except.ok",
"Except.error",
"Except.casesOn",
"Except",
"Lean.Exception"
] | false |
MonCat.Colimits.Relation.below.rec | Mathlib.Algebra.Category.MonCat.Colimits | [
"MonCat.Colimits.Relation.mul_2",
"MulOne.toOne",
"CategoryTheory.Functor",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonCat.Colimits.Relation.below.symm",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"MonCat.Colimits.Relation.one_mul",
"MonCat.Colimits.Relation.below",
"M... | false |
AlgCat.instRingObjForgetAlgHomCarrier | Mathlib.Algebra.Category.AlgCat.Basic | [
"CommRing",
"AlgCat.instCategory",
"AlgHom",
"AlgCat.instConcreteCategoryAlgHomCarrier",
"AlgHom.funLike",
"AlgCat",
"CommRing.toCommSemiring",
"AlgCat.carrier",
"CategoryTheory.types",
"CategoryTheory.forget",
"AlgCat.isAlgebra",
"Ring.toSemiring",
"Ring",
"CategoryTheory.Functor.obj",
... | true |
Mathlib.Tactic._aux_Mathlib_Tactic_Linarith_Frontend___elabRules_Mathlib_Tactic_linarith_1 | Mathlib.Tactic.Linarith.Frontend | [
"cond",
"Lean.Syntax.TSepArray.mk",
"Lean.TSyntax",
"Lean.Elab.Tactic.instMonadExceptExceptionTacticM",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Syntax.getArgs",
"Lean.Elab.Tactic.SavedState",
"Mathlib.Tactic.Linarith.LinarithConfig",
"Lean.Meta.State",
"Mathlib.Tactic.Linarith... | false |
Std.ExtTreeMap.ext_getKey_getElem?_iff | Std.Data.ExtTreeMap.Lemmas | [
"HEq.refl",
"Membership.mem",
"Ordering",
"Eq.casesOn",
"Std.TransCmp",
"Std.ExtTreeMap.getKey",
"And.casesOn",
"And",
"Iff",
"Std.ExtTreeMap",
"Std.ExtTreeMap.ext_getKey_getElem?",
"And.intro",
"Iff.intro",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Std.ExtTreeMap.instGetElem?Mem",
"Std.ExtTr... | true |
Lean.Grind.CommRing.Poly.denote'.go.eq_def | Init.Grind.Ring.CommSolver | [
"Int.cast",
"Eq.mpr",
"Lean.Grind.CommRing.Poly.rec",
"False",
"Lean.Grind.CommRing.Poly",
"_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.denote'.go.match_1.eq_1",
"Lean.Grind.CommRing.denoteTerm",
"Lean.Grind.CommRing.Poly.add",
"congrArg",
"Lean.Grind.CommRing.Poly.denote'.go._f... | true |
WithBot.bot_add | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | [
"WithBot",
"Bot.bot",
"instHAdd",
"HAdd.hAdd",
"WithBot.add",
"Eq",
"WithBot.bot",
"Add",
"rfl"
] | true |
subsetConditionallyCompleteLinearOrder._proof_4 | Mathlib.Order.CompleteLatticeIntervals | [
"Inhabited.default",
"False",
"Lattice.toSemilatticeSup",
"eq_false",
"congrArg",
"bddBelow_empty._simp_1",
"PartialOrder.toPreorder",
"Subtype.instLinearOrder",
"false_and",
"Classical.propDecidable",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"DistribLattice.toLattice",
"Conditiona... | false |
instCommGroupClassGroup._proof_6 | Mathlib.RingTheory.ClassGroup | [
"IsDomain",
"MonoidHom.range",
"FractionRing.field",
"Mul.mk",
"Semigroup.toMul",
"CommRing",
"One.mk",
"HMul.hMul",
"OreLocalization.instAlgebra",
"instCommGroupClassGroup._proof_3",
"CommSemiring.toSemiring",
"instCommGroupClassGroup._aux_1",
"instCommGroupClassGroup._aux_4",
"ClassGroup... | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.localization_comap_isInducing._simp_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | [
"PrimeSpectrum.isClosed_iff_zeroLocus",
"PrimeSpectrum.zeroLocus",
"Exists",
"CommSemiring",
"IsClosed",
"propext",
"PrimeSpectrum",
"Eq",
"PrimeSpectrum.zariskiTopology",
"Set"
] | false |
_private.Mathlib.CategoryTheory.SmallRepresentatives.0.CategoryTheory.CoreSmallCategoryOfSet.arrowEquiv._simp_1 | Mathlib.CategoryTheory.SmallRepresentatives | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.eqToHom",
"Exists",
"propext",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Arrow",
"CategoryTheory.Arrow.mk",
"Eq.symm",
"Eq",
"CategoryTheory.Category",
"CategoryThe... | false |
CategoryTheory.FreeBicategory.Hom₂.noConfusion | Mathlib.CategoryTheory.Bicategory.Free | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"CategoryTheory.FreeBicategory.Hom₂.casesOn",
"CategoryTheory.FreeBicategory.categoryStruct",
"CategoryTheory.FreeBicategory.Hom₂.noConfusionType",
"CategoryTheory.FreeBicategory.quiver",
"CategoryTheory.FreeBicategory",
"CategoryTh... | false |
Lean.instFromJsonSubtypeOfDecidablePred_mathlib | Mathlib.Lean.Json | [
"Pure.pure",
"Lean.Json",
"instMonadExceptOfExcept",
"instMonadExceptOfMonadExceptOf",
"Monad.toApplicative",
"String",
"MonadExcept.throw",
"Lean.FromJson.fromJson?",
"Subtype",
"Applicative.toPure",
"Except.instMonad",
"dite",
"Subtype.mk",
"Lean.FromJson",
"Lean.FromJson.mk",
"Decid... | true |
Function.FromTypes.curry_apply_cons | Mathlib.Data.Fin.Tuple.Curry | [
"Fin.succ",
"Function.dcomp",
"Fin.cons",
"Function.FromTypes",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Function.FromTypes.curry",
"instAddNat",
"OfNat.ofNat",
"Fin",
"Matrix.vecTail",
"Eq",
"Matrix.vecCons",
"rfl"
] | true |
RCLike.copy_of_normedField._proof_5 | Mathlib.Analysis.RCLike.Basic | [
"NormedCommRing.toSeminormedCommRing",
"MulOne.toOne",
"Real",
"RCLike.toNormedAlgebra",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"SeminormedRing.toRing",
"RingHom",
"NormedField.toField",
"NonAssocSemiring.toMulZeroOneClass",
"Field.toSemifield",
"NormedField",
"RCLike.toDenselyNorm... | false |
Traversable.map_traverse | Mathlib.Control.Traversable.Lemmas | [
"Pure.pure",
"Traversable.toFunctor",
"Eq.mpr",
"Functor.Comp.applicative_comp_id",
"LawfulTraversable.comp_traverse",
"congrArg",
"HEq.refl",
"Monad.toApplicative",
"Function.comp",
"Functor.Comp.instApplicativeComp",
"id",
"Id.run",
"Id",
"Applicative.toPure",
"CommApplicative.toLawful... | true |
DistribMulActionHom.map_smulₑ | Mathlib.GroupTheory.GroupAction.Hom | [
"Monoid",
"instHSMul",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"DistribMulActionHom",
"MulActionSemiHomClass.map_smulₛₗ",
"DistribMulActionHom.instFunLike",
"MulOneClass.toMulOne",
"AddMonoid",
"DistribMulActionHom.instAddDistribAddActionSemiHomClassCoeAddMonoidHom",
"Mon... | true |
Mathlib.Tactic.BicategoryLike.Mor₂.coherenceComp.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | [
"Mathlib.Tactic.BicategoryLike.Mor₂",
"Mathlib.Tactic.BicategoryLike.CoherenceHom",
"Mathlib.Tactic.BicategoryLike.Mor₂.noConfusion",
"Lean.Expr",
"id",
"Mathlib.Tactic.BicategoryLike.Mor₁",
"Mathlib.Tactic.BicategoryLike.IsoLift",
"Mathlib.Tactic.BicategoryLike.Mor₂.coherenceComp",
"Eq",
"Option"... | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction.0.UpperHalfPlane.linear_ne_zero_of_im._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | [
"HMul.hMul",
"MulZeroClass.toMul",
"MulZeroClass",
"mul_eq_zero",
"NoZeroDivisors",
"propext",
"Zero.toOfNat0",
"Or",
"OfNat.ofNat",
"Eq",
"MulZeroClass.toZero",
"instHMul"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.ball_two._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Metric | [
"propext",
"Or",
"or_comm",
"Eq"
] | false |
MeasureTheory.Lp.instNNNorm._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | [
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"Real.instZero",
"MeasureTheory.AEEqFun.cast",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"Membership.mem",
"SeminormedAddGroup.toContinuousENorm",
"Subtype",
"ENNReal.toReal_nonneg",
"LE.le",
"MeasureTheory.Lp",
"MeasureT... | false |
Lean.Parser.Tactic.rcasesPat.clear | Init.RCases | [
"Lean.Name.mkStr5",
"instOfNatNat",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"OfNat.ofNat"
] | true |
CategoryTheory.Limits.FintypeCat.inclusionCreatesFiniteLimits._proof_1 | Mathlib.CategoryTheory.Limits.FintypeCat | [
"CategoryTheory.Functor",
"Finite",
"FintypeCat",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.HasLimit",
"UnivLE.small",
"CategoryTheory.SmallCategory",
"CategoryTheory.Limits.Types.hasLimit",
"FintypeCat.incl",
"UnivLE.self",
"CategoryTheory.types",
"CategoryTheory.ObjectProperty.Fu... | false |
Polynomial.Monic.natDegree_mul | Mathlib.Algebra.Polynomial.Monic | [
"Nontrivial",
"NonAssocSemiring.toAddCommMonoidWithOne",
"False",
"Polynomial.natDegree_of_subsingleton",
"NeZero.one",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"Polynomial.natDegree_mul'",
"one_ne_zero._simp_1",
"Polynomial.leadingCoeff",
"Ne",
"instOfNatN... | true |
Subgroup.unop_normalizer | Mathlib.Algebra.Group.Subgroup.MulOpposite | [
"Eq.mpr",
"congrArg",
"MulOpposite",
"Group",
"Subgroup.op_normalizer",
"id",
"Subgroup",
"MulOpposite.instGroup",
"Subgroup.op",
"Subgroup.normalizer",
"SetLike.coe",
"propext",
"Subgroup.op_unop",
"Eq.refl",
"Eq.symm",
"Eq",
"Subgroup.unop",
"Subgroup.instSetLike",
"Subgroup.op... | true |
CategoryTheory.Limits.ChosenPullback.hp₂_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | [
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryTheory.Limits.ChosenPullback.p₂",
"CategoryTheory.Limits.ChosenPullback.hp₂",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.C... | true |
FirstOrder.Language.orderLHom_leSymb | Mathlib.ModelTheory.Order | [
"FirstOrder.Language.LHom.onRelation",
"FirstOrder.Language.orderLHom",
"instOfNatNat",
"FirstOrder.Language.IsOrdered.leSymb",
"Nat",
"FirstOrder.Language.Relations",
"FirstOrder.Language.order",
"FirstOrder.Language.IsOrdered",
"FirstOrder.Language",
"OfNat.ofNat",
"Eq",
"rfl",
"FirstOrder... | true |
_private.Lean.Meta.Injective.0.Lean.Meta.getCtorAppIndices?._sparseCasesOn_1 | Lean.Meta.Injective | [
"Lean.ConstantInfo.recInfo",
"Lean.ConstantInfo.defnInfo",
"Lean.ConstructorVal",
"Nat.ne_of_beq_eq_false",
"Lean.QuotVal",
"Lean.ConstantInfo.inductInfo",
"Lean.ConstantInfo.opaqueInfo",
"Nat.shiftRight",
"Lean.ConstantInfo.thmInfo",
"Nat.hasNotBit",
"Lean.ConstantInfo.rec",
"instOfNatNat",
... | false |
_private.Mathlib.Order.PropInstances.0.Pi.isCompl_iff._simp_1_1 | Mathlib.Order.PropInstances | [
"Codisjoint",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"PartialOrder",
"isCompl_iff",
"And",
"IsCompl",
"BoundedOrder.toOrderTop",
"BoundedOrder.toOrderBot",
"propext",
"BoundedOrder",
"Eq"
] | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.matchConstAux.match_4 | Lean.Meta.WHNF | [
"Lean.Expr.const",
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Level",
"List",
"_private.Lean.Meta.WHNF.0.Lean.Meta.matchConstAux._sparseCasesOn_4",
"Lean.Name",
"Lean.Expr.ctorIdx"
] | false |
Char.toLower_eq_of_isUpper | Batteries.Data.Char.AsciiCasing | [
"_private.Batteries.Data.Char.AsciiCasing.0.Char.toLower_eq_of_isUpper._simp_1_3",
"dite_cond_eq_true",
"Eq.mpr",
"UInt32.toNat",
"UInt32.ofNat_add",
"congrArg",
"and_self",
"Decidable.decide.congr_simp",
"Char.ext",
"HSub.hSub",
"Char.toNat",
"Bool.decide_and",
"Char.ofNat_toNat_eq_val",
... | true |
Set.pi_univ_Ioc_update_right | Mathlib.Order.Interval.Set.Pi | [
"Iff.mpr",
"Set.Ioi_inter_Iic",
"Eq.mpr",
"Set.Ioc",
"Set.Ioi",
"Function.update",
"congrArg",
"Compl.compl",
"Set.singleton_pi'",
"Set.Iic_subset_Iic",
"Set.univ",
"Set.inter_left_comm",
"setOf",
"Preorder.toLE",
"Membership.mem",
"Set.instSingletonSet",
"id",
"HasSubset.Subset",
... | true |
UInt8.toFin_xor | Init.Data.UInt.Bitwise | [
"Nat.instXorOp",
"UInt8.toFin",
"congrArg",
"UInt8.size",
"Fin.val",
"Nat",
"congr",
"True",
"UInt8.toFin_val",
"HXor.hXor",
"eq_self",
"Iff.mp",
"of_eq_true",
"Fin.instXorOp",
"UInt8.toNat_xor",
"UInt8.toNat",
"instXorOpUInt8",
"UInt8",
"Fin",
"Eq",
"Fin.val_inj",
"instHXo... | true |
CliffordAlgebraComplex.reverse_eq_id | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | [
"LinearMap.id",
"Real",
"CliffordAlgebra.reverse",
"Semiring.toModule",
"Ring.toNonAssocRing",
"LinearMap.ext",
"CommSemiring.toSemiring",
"CliffordAlgebra",
"CliffordAlgebraComplex.Q",
"instAlgebraCliffordAlgebra",
"Algebra.toModule",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"Re... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.