name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.BraidedCategory.hexagon_reverse_inv_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | [
"CategoryTheory.Category.assoc",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategory",
"Eq.mp",
"CategoryTheory.BraidedCategory.hexagon_reverse_inv",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
... | true |
Lean.getFieldInfo? | Lean.Structure | [
"Lean.StructureFieldInfo.lt",
"Inhabited.default",
"HSub.hSub",
"Array.binSearch",
"Lean.Expr",
"instSubNat",
"Lean.StructureFieldInfo.mk",
"instOfNatNat",
"Lean.instInhabitedBinderInfo",
"Lean.StructureFieldInfo",
"Lean.getStructureInfo?",
"Option.none",
"instHSub",
"Nat",
"Lean.Name",
... | true |
Complex.exp_ofReal_mul_I | Mathlib.Analysis.Complex.Trigonometric | [
"Real",
"HMul.hMul",
"Complex.cos",
"Real.cos",
"congrArg",
"Complex.sin",
"Complex.instMul",
"Complex.ofReal",
"instHAdd",
"HAdd.hAdd",
"congr",
"True",
"eq_self",
"Complex.ofReal_cos",
"Complex.exp",
"of_eq_true",
"Complex.ofReal_sin",
"congrFun'",
"Complex.instAdd",
"Complex... | true |
UniformEquiv.neg._proof_2 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | [
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"UniformContinuous",
"UniformSpace",
"Eq.mpr",
"SubtractionMonoid.toInvolutiveNeg",
"Equiv.instEquivLike",
"instReflLe",
"congrArg",
"Equiv.neg",
"Std.le_refl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"comap_neg_leftUniformSpace",
"Function.... | false |
Prod.instZeroLEOneClass | Mathlib.Algebra.Order.ZeroLEOne | [
"One",
"ZeroLEOneClass.mk",
"Prod.instLE_mathlib",
"ZeroLEOneClass",
"LE.le",
"Prod.fst",
"LE",
"zero_le_one",
"Prod.instZero",
"And.intro",
"One.toOfNat1",
"Zero.toOfNat0",
"Prod",
"OfNat.ofNat",
"Prod.snd",
"Prod.instOne",
"Zero"
] | true |
OpenPartialHomeomorph.symm_piecewise | Mathlib.Topology.OpenPartialHomeomorph.Constructions | [
"frontier",
"OpenPartialHomeomorph.IsImage.inter_eq_of_inter_eq_of_eqOn",
"Decidable",
"Membership.mem",
"OpenPartialHomeomorph.toFun'",
"Set.EqOn",
"Set.instInter",
"OpenPartialHomeomorph.IsImage",
"Inter.inter",
"OpenPartialHomeomorph.IsImage.symm_eqOn_of_inter_eq_of_eqOn",
"TopologicalSpace",... | true |
Finset.lt_sup'_iff | Mathlib.Data.Finset.Lattice.Fold | [
"Eq.mpr",
"WithBot.some",
"WithBot",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"WithBot.instLT",
"and_congr_right'",
"congrArg",
"WithBot.instOrderBot",
"Finset",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Function.comp",
"Membership.mem",
"Exists",
"SemilatticeIn... | true |
TannakaDuality.FiniteGroup.equivApp_hom | Mathlib.RepresentationTheory.Tannaka | [
"CommRing",
"MonoidHom.instFunLike",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"ModuleCat",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.InducedCategory.homMk",
"Module.End.instSemiring",
"Group",
"ModuleCat.isF... | true |
_private.Mathlib.Order.Filter.Subsingleton.0.Filter.subsingleton_iff_exists_le_pure._simp_1_1 | Mathlib.Order.Filter.Subsingleton | [
"Pure.pure",
"Exists",
"Filter.subsingleton_iff_bot_or_pure",
"Bot.bot",
"Filter.instPure",
"propext",
"Or",
"Eq",
"Filter.Subsingleton",
"Filter",
"Filter.instBot"
] | false |
fourierCoeffOn_of_hasDerivAt | Mathlib.Analysis.Fourier.AddCircle | [
"instInnerProductSpaceRealComplex",
"Int.cast",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Lattice.toSemilatticeSup",
"instHDiv",
"Real.pi",
"NormedSpace.toIsBoundedSMul",
"HMul.hMul",
"Real.lattice",
"Complex.instNormedAddCommGroup",
"Real.denselyNorm... | true |
Vector.findSomeRev?_push | Init.Data.Vector.Find | [
"Option.isNone",
"Eq.mpr",
"Vector.findSomeRev?_eq_findSome?_reverse",
"Vector.push",
"Vector",
"congrArg",
"Vector.findSomeRev?",
"Vector.findSomeRev?_push_of_isSome",
"Option.some",
"id",
"instOfNatNat",
"Option.or",
"Vector.findSomeRev?_push_of_isNone",
"Vector.reverse",
"Bool.true",
... | true |
CategoryTheory.IsComonHom.hom_comul_assoc | Mathlib.CategoryTheory.Monoidal.Comon_ | [
"CategoryTheory.ComonObj.comul",
"CategoryTheory.Category.assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.IsComonHom",
"CategoryTheory.IsComonHom.hom_comul",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.ComonObj",
"Eq.mp",
"id",
"Mathlib.Tactic... | true |
CategoryTheory.Limits.BinaryFan.IsLimit.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | [
"CategoryTheory.Limits.BinaryFan.fst",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.BinaryFan",
"CategoryTheory.Limits.WalkingPair.right",
"CategoryTheory.Limits.BinaryFan.mk",
"CategoryTheory.Limits.Cone.pt",
"CategoryTheory.Limits.WalkingPair",
"CategoryTheory.Dis... | false |
Aesop.Script.Step.mk | Aesop.Script.Step | [
"Lean.Meta.SavedState",
"Lean.MVarId",
"Array",
"Aesop.Script.Tactic",
"Aesop.GoalWithMVars",
"Aesop.Script.Step.mk",
"Aesop.Script.Step"
] | true |
Int64.ofInt_eq_iff_bmod_eq_toInt | Init.Data.SInt.Lemmas | [
"instPowNat",
"Int64.toInt",
"congrArg",
"Int64",
"instOfNatNat",
"Int",
"iff_self",
"instNatPowNat",
"Iff",
"HPow.hPow",
"Int.bmod",
"Nat",
"Int64.toInt_ofInt",
"True",
"of_eq_true",
"congrFun'",
"instHPow",
"Int64.size",
"Int64.ofInt",
"OfNat.ofNat",
"_private.Init.Data.SIn... | true |
Additive.toMul_le | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | [
"Equiv.instEquivLike",
"Additive",
"Iff.rfl",
"Preorder.toLE",
"Additive.toMul",
"Equiv",
"LE.le",
"Iff",
"instLEAdditive",
"DFunLike.coe",
"Preorder",
"EquivLike.toFunLike"
] | true |
CategoryTheory.Adjunction.Triple.leftToRight._proof_1 | Mathlib.CategoryTheory.Adjunction.Triple | [
"CategoryTheory.Functor",
"CategoryTheory.IsIso",
"CategoryTheory.Functor.isIso_whiskerRight",
"CategoryTheory.Adjunction.Triple.adj₁",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"CategoryTheory.Adjunction.Triple",... | false |
Units.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | [
"Monoid",
"Units.val",
"SMul",
"Units.instSMul",
"IsIsometricSMul",
"Units",
"PseudoEMetricSpace",
"IsIsometricSMul.isometry_smul",
"IsIsometricSMul.mk"
] | true |
FrameHom.instFunLike | Mathlib.Order.Hom.CompleteLattice | [
"FrameHom",
"Lattice.toSemilatticeSup",
"DFunLike.mk",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"InfHom.toFun",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder",
"FrameHom.instFunLike._proof_1",
"SemilatticeInf.toMin",
"FrameHom.toInfTopHom",
"OrderTop.toTop",
"BoundedOrder.t... | true |
_private.Mathlib.RingTheory.Coalgebra.TensorProduct.0.Coalgebra._aux_Mathlib_RingTheory_Coalgebra_TensorProduct___delab_app__private_Mathlib_RingTheory_Coalgebra_TensorProduct_0_Coalgebra_termμ_1 | Mathlib.RingTheory.Coalgebra.TensorProduct | [
"Pure.pure",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Name.mkNum",
"Mathlib.Notation3.MatchState.empty",
"Mathlib.Notation3.withHeadRefIfTagAppFns",
"Mathlib.Notation3.matchApp",
"Lean.PrettyPrinter.Delaborator.instMonadReaderOfSubExprDelabM",
"Lean.SourceInfo",
"Lean.PrettyPrinter.Delaborator.Contex... | false |
Turing.TM2to1.StAct.push.noConfusion | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"HEq.refl",
"id",
"Turing.TM2to1.StAct.noConfusion",
"Turing.TM2to1.StAct.push",
"heq_of_eq",
"Eq.refl",
"HEq",
"Turing.TM2to1.StAct",
"Eq"
] | false |
_private.Mathlib.MeasureTheory.Integral.IntegralEqImproper.0.MeasureTheory.tendsto_limUnder_of_hasDerivAt_of_integrableOn_Ioi._simp_1_3 | Mathlib.MeasureTheory.Integral.IntegralEqImproper | [
"Exists",
"propext",
"Classical.not_forall",
"Eq",
"Not"
] | false |
MulChar.mem_subgroupOrderIsoSubgroupMulChar_symm_iff._simp_1 | Mathlib.NumberTheory.MulChar.Duality | [
"OrderDual.instLE",
"OrderDual.toDual",
"Units.val",
"CommRing",
"Equiv.instEquivLike",
"Finite",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"Preorder.toLE",
"CommSemiring.toCommMonoidWithZero",
"Membership.mem",
"Units",
"Equiv",
"MulChar",
"OrderIso",
"MulChar.i... | false |
Lean.Elab.ChoiceInfo.ctorIdx | Lean.Elab.InfoTree.Types | [
"Lean.Elab.ChoiceInfo",
"Nat"
] | false |
AddSubmonoid.map._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | [
"AddSubmonoid.add_mem",
"Eq.mpr",
"congrArg",
"Membership.mem",
"AddZeroClass.toAddZero",
"map_add",
"id",
"AddMonoidHomClass",
"AddSubmonoid",
"And.casesOn",
"instHAdd",
"And",
"AddZeroClass",
"Exists.casesOn",
"SetLike.coe",
"HAdd.hAdd",
"AddMonoidHomClass.toAddHomClass",
"And.in... | false |
Polynomial.powAddExpansion._proof_1 | Mathlib.Algebra.Polynomial.Identities | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Trans.trans",
"HMul.hMul",
"CommSemiring.toSemiring",
"HSub.hSub",
"Distrib.toAdd",
"AddMonoidWithOne.toNatCast",
"instSubNat",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Nat.cast",
"instDistribOfSemiring",
"Monoid.toPow",
"instT... | false |
CategoryTheory.uniqueHomToTrivial | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | [
"CategoryTheory.SemiCartesianMonoidalCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Unique",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.Mon",
"CategoryTheory.Mon.instCategory",
"CategoryTheory.Mon.trivial",
"CategoryTheory.Mon.uniqueHomToT... | true |
OrderMonoidHom.noConfusionType | Mathlib.Algebra.Order.Hom.Monoid | [
"MulOne.toOne",
"OrderMonoidHom",
"MonoidHom",
"OrderMonoidHom.casesOn",
"Monotone",
"MulOneClass.toMulOne",
"OneHom.toFun",
"MonoidHom.toOneHom",
"HEq",
"MulOneClass",
"Preorder"
] | false |
openSegment_subset_iff | Mathlib.Analysis.Convex.Segment | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"Preorder.toLT",
"SMul",
"PartialOrder.toPreorder",
"_private.Mathlib.Analysis.Convex.Segment.0.openSegment_subset_iff.match_1_1",
"Membership.mem",
"Exists",
"Eq.rec",
"PartialOrder",
"Distrib.toAdd",
"HasSubset.Subset",
"AddCommMonoid... | true |
Compactum.continuous_of_hom | Mathlib.Topology.Category.Compactum | [
"Eq.mpr",
"Continuous",
"CategoryTheory.CategoryStruct.toQuiver",
"Ultrafilter.coe_map",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"Filter.map",
"PartialOrder.toPreorder",
"CategoryTheory.ofTypeMonad",
"Compactum.instTopologicalSpaceA",
"Preorder.toLE",
"nhds",
"Comp... | true |
Finset.sum_nonneg | Mathlib.Algebra.Order.BigOperators.Group.Finset | [
"Eq.mpr",
"le_refl",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"AddLeftMono",
"Preorder.toLE",
"Membership.mem",
"AddZeroClass.toAddZero",
"id",
"LE.le",
"Finset.sum_const_zero",
"AddCommMonoid",
"AddZero.toZero",
"Finset.instSetLike",
"AddZero.toAdd",
"Zero.toOfNat0",
"Fin... | true |
HomologicalComplex.extend.leftHomologyData._proof_4 | Mathlib.Algebra.Homology.Embedding.ExtendHomology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex.X₁",
"HomologicalComplex",
"ComplexShape",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"CategoryTheory.ShortComplex.zero",
"CategoryTheory.CategoryStruct.comp",
"Zero.t... | false |
String.Slice.Pattern.Model.ForwardStringSearcher.isLongestMatchAt_iff_isLongestMatchAt_toSlice | Init.Data.String.Lemmas.Pattern.String.Basic | [
"String.toSlice",
"Iff.mpr",
"String.Slice.Pos.sliceFrom",
"String.instLEPos_1",
"String.Slice.Pattern.Model.ForwardStringSearcher.instPatternModel",
"Iff.of_eq",
"congrArg",
"String",
"String.Slice.sliceFrom",
"_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.For... | true |
Fin.isSome_findSome?_iff._simp_1 | Batteries.Data.Fin.Lemmas | [
"Exists",
"Bool.true",
"Nat",
"Fin.findSome?",
"propext",
"Bool",
"Option.isSome",
"Fin.isSome_findSome?_iff",
"Fin",
"Eq",
"Option"
] | false |
FintypeCat.hom_apply | Mathlib.CategoryTheory.FintypeCat | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"Finite",
"FintypeCat",
"TypeCat.instFunLikeFun",
"CategoryTheory.ObjectProperty.FullSubcategory.concreteCategory",
"CategoryTheory.ObjectProperty.FullSubcategory.obj",
"TypeCat.Fun",
"CategoryTheory.typ... | true |
_private.Mathlib.CategoryTheory.MorphismProperty.IsSmall.0.CategoryTheory.MorphismProperty.isSmall_iSup.match_1 | Mathlib.CategoryTheory.MorphismProperty.IsSmall | [
"CategoryTheory.MorphismProperty",
"Set.Elem",
"CategoryTheory.MorphismProperty.toSet",
"CategoryTheory.Category.toCategoryStruct",
"Sigma.mk",
"CategoryTheory.Arrow",
"Sigma.casesOn",
"Sigma",
"CategoryTheory.Category"
] | false |
_private.Mathlib.Tactic.ProdAssoc.0.Lean.Expr.mkProdTree._sparseCasesOn_4 | Mathlib.Tactic.ProdAssoc | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... | false |
AddChar.toAddMonoidHomEquiv._proof_4 | Mathlib.Algebra.Group.AddChar | [
"Monoid",
"Monoid.toMulOneClass",
"ZeroHom.toFun",
"Additive",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.toZeroHom",
"AddZeroClass.toAddZero",
"Additive.addZeroClass",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd",
"AddMonoid",
"AddZero.toAdd",
"AddMonoidHom.map_add'",
"AddMonoidHom",
"Eq"... | false |
rootsOfUnityCircleEquiv._proof_2 | Mathlib.Analysis.SpecialFunctions.Complex.CircleAddChar | [
"Units.val",
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"Nat.instMulZeroClass",
"Subgroup.instSubgroupClass",
"MonoidHom.instFunLike",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"Complex.commRing",
"MonoidHom",
"rootsOfUnitytoCircle",
"Monoid.toMulOneClass",
"cong... | false |
CategoryTheory.End.group._proof_3 | Mathlib.CategoryTheory.Endomorphism | [
"Mul.mk",
"Semigroup.toMul",
"One.mk",
"HMul.hMul",
"CategoryTheory.Groupoid.inv",
"CategoryTheory.Groupoid",
"Int",
"CategoryTheory.End.monoid",
"npowRec",
"Nat.cast",
"CategoryTheory.End",
"One.one",
"Inv.mk",
"Mul.mul",
"Nat",
"zpowRec",
"Monoid.toSemigroup",
"Eq.refl",
"Monoi... | false |
guard_msgs.diff | Lean.Elab.GuardMsgs | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Option",
"Lean.instInhabitedOption",
"Bool"
] | true |
USize.ofFin_uint32ToFin | Init.Data.UInt.Lemmas | [
"UInt32.size",
"Fin.castLE",
"USize.ofFin",
"UInt32.size_le_usizeSize",
"UInt32.toUSize",
"UInt32",
"USize.size",
"UInt32.toFin",
"Eq",
"rfl",
"USize"
] | true |
T5Space.of_forall_isOpen_t4Space | Mathlib.Topology.Separation.Regular | [
"Iff.mpr",
"Membership.mem",
"Set.Elem",
"TopologicalSpace",
"T5Space",
"T4Space",
"IsOpen",
"instTopologicalSpaceSubtype",
"t5Space_iff_forall_isOpen_t4Space",
"Set.instMembership",
"Set"
] | true |
SheafOfModules.Presentation.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | [
"CategoryTheory.Functor",
"Opposite",
"AddCommGrpCat.hasLimitsOfShape",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"ModuleCat",
"CategoryTheory.Limits.WalkingParallelPair",
"AddCommGroup.toAddCommMonoid",
"HEq.refl",
"SheafOfModules.Presentation",
"Ad... | false |
Traversable.foldrm_toList | Mathlib.Control.Fold | [
"CategoryTheory.End.one",
"MulOne.toOne",
"CategoryTheory.KleisliCat.mk",
"CancelMonoid.toRightCancelMonoid",
"FreeMonoid",
"Traversable.foldMap_hom_free",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"Monoid.foldrM",
"CategoryTheory.Kleisl... | true |
BitVec.toFin_injective | Mathlib.Data.BitVec | [
"instPowNat",
"_private.Mathlib.Data.BitVec.0.BitVec.toFin_injective.match_1_1",
"BitVec.ofFin",
"BitVec",
"Fin.mk",
"BitVec.toFin",
"instOfNatNat",
"instNatPowNat",
"HPow.hPow",
"Nat",
"LT.lt",
"instHPow",
"Function.Injective",
"instLTNat",
"OfNat.ofNat",
"Fin",
"Eq",
"rfl"
] | true |
Std.DTreeMap.Internal.Impl.minView.induct | Std.Data.DTreeMap.Internal.Model | [
"Std.DTreeMap.Internal.Impl.minView._proof_9",
"Eq.mpr",
"Std.DTreeMap.Internal.Impl.Tree.mk",
"_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_1.splitter",
"Std.DTreeMap.Internal.Impl.View",
"Std.DTreeMap.Internal.Impl.minView",
"Std.DTreeMap.Internal.Impl.minView._... | true |
IsNormalClosure.lift | Mathlib.FieldTheory.Normal.Closure | [
"Lattice.toSemilatticeSup",
"Algebra.algebraMap",
"CompleteLattice.toLattice",
"iSup",
"IntermediateField",
"AlgHom",
"IsNormalClosure.adjoin_rootSet",
"PartialOrder.toPreorder",
"Polynomial.rootSet",
"Algebra",
"Preorder.toLE",
"Field.toDivisionRing",
"CompleteLattice.toConditionallyComplet... | true |
Lean.Parser.ParserAttributeHook.postAdd | Lean.Parser.Extension | [
"Lean.AttrM",
"Lean.Parser.ParserAttributeHook",
"Unit",
"Bool",
"Lean.Name"
] | true |
AEMeasurable.const_sup | Mathlib.MeasureTheory.Order.Lattice | [
"MeasurableSup.measurable_const_sup",
"MeasureTheory.Measure",
"AEMeasurable",
"Max",
"MeasurableSup",
"MeasurableSpace",
"Max.max",
"Measurable.comp_aemeasurable"
] | true |
Std.Internal.LawfulMonadLiftBindFunction.liftBind_bind | Init.Data.Iterators.Internal.LawfulMonadLiftFunction | [
"Std.Internal.LawfulMonadLiftBindFunction",
"Monad.toBind",
"Bind.bind",
"Monad",
"Eq"
] | true |
sign_nonneg_iff._simp_1 | Mathlib.Data.Sign.Defs | [
"sign_nonneg_iff",
"LinearOrder",
"PartialOrder.toPreorder",
"SignType.instLinearOrder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"LE.le",
"SignType.instZero",
"OrderHom.instFunLike",
"LinearOrder.toDecidableLT",
"propext",
"SignType",
"Zero.toOfNat0",
... | false |
Lean.LocalDecl.binderInfo | Lean.LocalContext | [
"Lean.LocalDeclKind",
"Lean.Expr",
"Lean.FVarId",
"Nat",
"_private.Lean.LocalContext.0.Lean.LocalDecl.index.match_1",
"Bool",
"Lean.Name",
"Lean.BinderInfo.default",
"Lean.LocalDecl",
"Lean.BinderInfo"
] | true |
MeasureTheory.locallyIntegrable_of_norm_le_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Integral | [
"MeasureTheory.ae",
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"locallyCompact_of_proper",
"Real.instPow",
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"SeminormedAddGroup.toAddGroup",
"HMul.hMul",
"NormedSpace",
"IsCompact.isBounded... | true |
Char.notLTTrans | Init.Data.Char.Lemmas | [
"_private.Init.Data.Char.Lemmas.0.Char.notLTTrans._proof_1",
"Trans",
"LT.lt",
"Char",
"Trans.mk",
"Not",
"Char.instLT"
] | true |
_private.Init.Data.Int.Order.0.Int.sign_sign.match_1_1 | Init.Data.Int.Order | [
"Unit.unit",
"Int.casesOn",
"Int.ofNat",
"Int",
"Unit",
"instOfNat",
"Nat",
"Int.negSucc",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
Std.Iter.allM_eq_forIn | Init.Data.Iterators.Lemmas.Consumers.Loop | [
"Pure.pure",
"Monad.toApplicative",
"Std.IteratorLoop",
"ForInStep.done",
"Std.Iterators.Finite",
"instDecidableEqBool",
"LawfulMonad",
"ForIn.forIn",
"Id",
"Applicative.toPure",
"Std.Iter.allM",
"ForInStep",
"Std.Iterator",
"Bool.true",
"Std.Iter",
"Std.LawfulIteratorLoop",
"Std.ins... | true |
PresheafOfModules.Monoidal.tensorObjMap._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | [
"PresheafOfModules.map",
"Eq.mpr",
"CategoryTheory.Functor",
"instHSMul",
"CommRingCat.Hom.hom",
"Opposite",
"CommRingCat.carrier",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"CommSemiring.toSemiring",
"CategoryTheory.ConcreteCategor... | false |
Lean.Parser.Tactic.MRefinePat.tuple.elim | Std.Tactic.Do.Syntax | [
"Lean.Parser.Tactic.MRefinePat.ctorElim",
"PULift.up",
"Lean.Parser.Tactic.MRefinePat.tuple",
"List",
"Lean.Parser.Tactic.MRefinePat",
"Nat",
"Lean.Parser.Tactic.MRefinePat.ctorIdx",
"Eq.symm",
"Eq"
] | false |
DifferentiableWithinAt.of_dslope | Mathlib.Analysis.Calculus.DSlope | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"instHSMul",
"Semiring.toModule",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"NormedSpace",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroC... | true |
iter_deriv_inv' | Mathlib.Analysis.Calculus.Deriv.ZPow | [
"NormedCommRing.toNormedRing",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"Semiring.toModule",
"NormedRing.toRing",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"deriv",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"PseudoMetricSp... | true |
Set.bijOn_empty_iff_right | Mathlib.Data.Set.Function | [
"Set.bijOn_empty",
"Set.SurjOn",
"Eq.mp",
"Set.BijOn.surjOn",
"Iff",
"Iff.intro",
"Set.BijOn",
"Set.instEmptyCollection",
"Eq.ndrec",
"EmptyCollection.emptyCollection",
"Eq.symm",
"Eq",
"Set.surjOn_empty_iff._simp_1",
"Set"
] | true |
CategoryTheory.Mon.monMonoidalStruct_tensorObj_X | Mathlib.CategoryTheory.Monoidal.Mon | [
"CategoryTheory.MonoidalCategory",
"CategoryTheory.BraidedCategory",
"CategoryTheory.Mon",
"CategoryTheory.Mon.X",
"CategoryTheory.Mon.instCategory",
"CategoryTheory.MonoidalCategoryStruct.tensorObj",
"Eq.refl",
"CategoryTheory.MonoidalCategory.toMonoidalCategoryStruct",
"CategoryTheory.Mon.monMonoi... | true |
RootPairing.weylGroup.induction | Mathlib.LinearAlgebra.RootSystem.WeylGroup | [
"Eq.mpr",
"CommRing",
"Subgroup.instSubgroupClass",
"RootPairing.weylGroup",
"RootPairing.Equiv.reflection",
"RootPairing.weylGroup_toSubmonoid",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.to... | true |
Poly.instOne | Mathlib.NumberTheory.Dioph | [
"One",
"One.mk",
"Poly",
"Int",
"Poly.const",
"instOfNat",
"OfNat.ofNat"
] | true |
Std.DTreeMap.Raw.Const.mem_alter | Std.Data.DTreeMap.Raw.Lemmas | [
"instDecidableEqOrdering",
"Std.DTreeMap.Internal.Impl.Const.mem_alter!",
"Std.DTreeMap.Raw.instMembership",
"Ord.mk",
"Membership.mem",
"Ordering",
"Ordering.eq",
"Std.TransCmp",
"Bool.true",
"Iff",
"Std.DTreeMap.Raw.Const.get?",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Bool"... | true |
Representation.coindV._proof_3 | Mathlib.RepresentationTheory.Coinduced | [
"Monoid",
"Pi.Function.module",
"instHSMul",
"Representation",
"MonoidHom.instFunLike",
"Pi.addCommMonoid",
"SemilinearMapClass.toMulActionSemiHomClass",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"Module.End.... | false |
Quaternion.imK_star | Mathlib.Algebra.Quaternion | [
"NegZeroClass.toNeg",
"CommRing",
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"AddMonoidWithOne.toOne",
"CommRing.toCommSemiring",
"Quaternion.instStar",
"... | true |
Finsupp.mem_support_iff._simp_1 | Mathlib.Data.Finsupp.Defs | [
"Finsupp.mem_support_iff",
"Finsupp.instFunLike",
"Finset",
"Finsupp.support",
"Membership.mem",
"Ne",
"Finset.instSetLike",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"DFunLike.coe",
"SetLike.instMembership",
"Finsupp",
"Zero"
] | false |
CommRing.Pic.mapAlgebra_self_apply | Mathlib.RingTheory.PicardGroup | [
"Iff.mpr",
"SemimoduleCat.isModule",
"Units.val",
"SemimoduleCat.moduleCategory",
"MonoidHom.instFunLike",
"Semiring.toModule",
"Equiv.instEquivLike",
"IsScalarTower.right",
"Module.Invertible.inst",
"MonoidHom",
"Monoid.toMulOneClass",
"SemimoduleCat.isAddCommMonoid",
"CommSemiring.toSemiri... | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.getCaseGoals.showTagName | Lean.Elab.Tactic.BuiltinTactic | [
"Lean.MessageData",
"String",
"Lean.MessageData.instAppend",
"Lean.instToMessageDataString",
"instHAppendOfAppend",
"Lean.ToMessageData.toMessageData",
"Lean.Name",
"Lean.instToMessageDataName",
"HAppend.hAppend"
] | true |
LieModule.Weight.coe_weight_mk | Mathlib.Algebra.Lie.Weights.Basic | [
"CommRing",
"LieModule.Weight.instFunLike",
"LieSubmodule.instBot",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"LieRing.IsNilpotent",
"LieSubmodule",
"AddCommGroup",
"Ne",
"Bot.bot",
"LieModule.Weight.mk",
"LieRing",
"CommRing.toCommSemiring",
"LieRingModule",
"LieAlgebra... | true |
IsIdempotentElem.one_sub_iff._simp_1 | Mathlib.Algebra.Ring.Idempotent | [
"AddGroupWithOne.toAddGroup",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"NonAssocRing",
"NonAssocRing.toNonUnitalNonAssocRing",
"SubNegMonoid.toSub",
"AddMonoidWithOne.toOne",
"NonAssocRing.toAddCommGroupWithOne",
"instHSub",
"IsIdemp... | false |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.evalCast._proof_7 | Mathlib.Tactic.Algebra.Basic | [
"Qq.QuotedDefEq",
"Lean.Expr.const",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"Qq.Quoted",
"Qq.Quoted.unsafeMk",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Lean.Level.succ",
"Lean.Name.mkStr1",
"Qq.QuotedDefEq.unsafeIntro",
"List.nil"
] | false |
mul_inv_lt_iff₀' | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"CommMonoid.toCommSemigroup",
"DivInvOneMonoid.toInvOneClass",
"MulZeroClass.toMul",
"congrArg",
"mul_inv_lt_iff... | true |
AddMonoidHom.coe_finsuppSum | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"Finsupp.instFunLike",
"Pi.addCommMonoid",
"AddMonoid.toAddZeroClass",
"Finsupp.sum",
"Finsupp.support",
"AddZeroClass.toAddZero",
"AddMonoidHom.instAddCommMonoid",
"AddCommMonoid",
"AddZeroClass",
"AddCommMonoid.toAddMonoid",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"Eq",
"DFunLike.coe... | true |
CategoryTheory.instMonoidalCategoryHom._proof_1 | Mathlib.CategoryTheory.Bicategory.End | [
"CategoryTheory.instCategoryEndMonoidal",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Bicategory.whiskerRight",
"id",
"CategoryTheory.Bicategory.toCategoryStruct",
"CategoryTheory.Bicategory",
"CategoryTheory.CategoryStruct.comp",
"Eq.refl",
"CategoryTheory.Category.toC... | false |
derivWithin_congr_set' | Mathlib.Analysis.Calculus.Deriv.Basic | [
"NormedCommRing.toNormedRing",
"NormedCommRing.toSeminormedCommRing",
"Semiring.toModule",
"NormedRing.toRing",
"NormedSpace",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Compl.compl",
"ContinuousLinearMap.funLike",
"nhdsWithin",
"NormedSpace.toModule",
"EMetricSpace.metrizableSpace",
"AddG... | true |
UInt64.toUInt8_toUSize | Init.Data.UInt.Lemmas | [
"instPowNat",
"UInt64.toNat_toUInt8",
"UInt64.toUSize",
"UInt8.toNat.inj",
"USize.toUInt8",
"congrArg",
"UInt8.size",
"UInt64",
"Nat.instMod",
"instHMod",
"instOfNatNat",
"UInt64.toNat",
"instNatPowNat",
"UInt64.toUInt8",
"System.Platform.numBits",
"UInt64.toNat_toUSize",
"HMod.hMod"... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.toArray_filter._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 |
Int.natBitwise.eq_1 | Mathlib.Data.Int.Bitwise | [
"cond",
"Int.natBitwise",
"Bool.not",
"Int",
"Nat.cast",
"Nat.bitwise",
"Nat",
"Bool",
"Eq.refl",
"instNatCastInt",
"Int.negSucc",
"Bool.false",
"Eq"
] | true |
_private.Mathlib.RingTheory.Localization.Basic.0.IsLocalization.commutes._simp_1_1 | Mathlib.RingTheory.Localization.Basic | [
"HMul.hMul",
"Mul",
"MulHomClass",
"map_mul",
"Eq.symm",
"Eq",
"DFunLike.coe",
"FunLike",
"instHMul"
] | false |
AddSubsemigroup.equivMapOfInjective.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | [
"AddSubsemigroup.equivMapOfInjective._proof_1",
"AddSubsemigroup.instSetLike",
"AddHom",
"Equiv.Set.image",
"Membership.mem",
"AddSubsemigroup.instAddMemClass",
"Subtype",
"AddHom.funLike",
"SetLike.coe",
"AddMemClass.add",
"AddSubsemigroup.equivMapOfInjective",
"AddEquiv.mk",
"AddSubsemigro... | true |
UInt8.toUSize_shiftRight | Init.Data.UInt.Bitwise | [
"instPowNat",
"BitVec.setWidth",
"BitVec.instHShiftRight",
"BitVec.instHShiftRightNat",
"Dvd.dvd",
"of_decide_eq_true",
"BitVec.instOfNat",
"USize.toBitVec_mod",
"congrArg",
"Nat.decidable_dvd",
"UInt8.toUSize",
"UInt8.toBitVec_shiftRight",
"instShiftRightUInt8",
"instModUSize",
"BitVec"... | true |
ModuleCat.coprodIsoDirectSum | Mathlib.Algebra.Category.ModuleCat.Products | [
"CategoryTheory.Limits.colimit.isoColimitCocone",
"ModuleCat",
"DirectSum.instModule",
"AddCommGroup.toAddCommMonoid",
"ModuleCat.coproductCoconeIsColimit",
"CategoryTheory.Discrete.functor",
"ModuleCat.coproductCocone",
"CategoryTheory.Iso",
"DirectSum.instAddCommGroup",
"CategoryTheory.Limits.Ha... | true |
Std.HashMap.mem_insertManyIfNewUnit_list._simp_1 | Std.Data.HashMap.Lemmas | [
"instForInOfForIn'",
"List.contains",
"Membership.mem",
"inferInstance",
"Std.HashMap",
"Id",
"Membership",
"LawfulHashable",
"Bool.true",
"List",
"Unit",
"EquivBEq",
"List.instMembership",
"propext",
"Bool",
"Id.instMonad",
"Std.HashMap.insertManyIfNewUnit",
"Hashable",
"Std.Has... | false |
Std.HashSet.forIn_eq_forIn_toList | Std.Data.HashSet.Lemmas | [
"Std.HashMap.forIn_eq_forIn_keys",
"instForInOfForIn'",
"Std.HashSet.toList",
"Std.HashSet",
"inferInstance",
"LawfulMonad",
"ForIn.forIn",
"Membership",
"ForInStep",
"List",
"Unit",
"Std.HashSet.inner",
"List.instMembership",
"Std.HashSet.instForInOfMonad",
"Hashable",
"Monad",
"BEq... | true |
_private.Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.0.Mathlib.Tactic.Linarith.CertificateOracle.simplexAlgorithmDense.match_1 | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm | [
"Prod.mk",
"instOfNatNat",
"Mathlib.Tactic.Linarith.Comp",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Prod",
"Prod.casesOn",
"OfNat.ofNat",
"List.length",
"Mathlib.Tactic.Linarith.SimplexAlgorithm.DenseMatrix"
] | false |
Lean.Server.Completion.ContextualizedCompletionInfo.ctx | Lean.Server.Completion.CompletionUtils | [
"Lean.Elab.ContextInfo",
"Lean.Server.Completion.ContextualizedCompletionInfo"
] | true |
CategoryTheory.Monad.beckAlgebraCoequalizer._proof_3 | Mathlib.CategoryTheory.Monad.Coequalizer | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Monad",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Monad.Algebra.a",
"CategoryTheory.Limits.WalkingParallelPair",
"congrArg",
"CategoryTheory.Monad.FreeCoequalizer.topMap",
"CategoryTheory.Functor.comp",
"Cat... | false |
List.dropLastTR | Init.Data.List.Impl | [
"Array.pop",
"Array.toList",
"List.toArray",
"List"
] | true |
CategoryTheory.Functor.ranCounit_app_whiskerLeft_ranAdjunction_unit_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | [
"CategoryTheory.Functor.liftOfIsRightKanExtension_fac",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Adjunction.unit",
"CategoryTheory.Functor.id",
"CategoryTheory.Cat... | true |
_private.Std.Internal.Http.Data.URI.Encoding.0.Std.Http.URI.IsAllowedEncodedQueryChars.push | Std.Internal.Http.Data.URI.Encoding | [
"Eq.mpr",
"Std.Http.URI.IsAllowedEncodedQueryChars",
"Array.all_congr",
"Array.all",
"Array.push",
"congrArg",
"ByteArray.push",
"Bool.and_true",
"id",
"Bool.and",
"instOfNatNat",
"Array.all_push'",
"Array",
"Bool.true",
"instHAdd",
"Nat.add_left_cancel_iff._simp_1",
"HAdd.hAdd",
"... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go_get_aux._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const | [
"LE.le",
"instLENat",
"Std.Sat.AIG",
"Nat",
"LT.lt",
"_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go_get_aux._proof_1",
"Decidable.byContradiction",
"Nat.decLt",
"Hashable",
"instLTNat",
"Not",
"DecidableEq"
] | false |
instDecidableEqZNum.decEq._proof_4 | Mathlib.Data.Num.Basic | [
"False",
"ZNum.ctorIdx",
"False.elim",
"noConfusion_of_Nat",
"ZNum.zero",
"ZNum",
"PosNum",
"ZNum.neg",
"Eq",
"Not"
] | false |
_private.Mathlib.MeasureTheory.Measure.SubFinite.0.MeasureTheory.Measure.withDensity_sub._simp_1_3 | Mathlib.MeasureTheory.Measure.SubFinite | [
"Compl.compl",
"Membership.mem",
"Set.instCompl",
"propext",
"Eq",
"Set.instMembership",
"Not",
"Set.mem_compl_iff",
"Set"
] | false |
CategoryTheory.locallyDiscreteBicategory._proof_10 | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | [
"CategoryTheory.LocallyDiscrete.categoryStruct",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.LocallyDiscrete.eq_of_hom",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.locallyDiscreteBicategory._proof_1",
"CategoryTheory.eqToIso",
"inferInstance",
"CategoryTheory... | false |
NormedAddGroup.ofSeparation.eq_1 | Mathlib.Analysis.Normed.Group.Defs | [
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Real",
"SeminormedAddGroup.toAddGroup",
"Real.instZero",
"NormedAddGroup.mk",
"SeminormedAddGroup",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"NormedAddGroup.ofSeparation._proof_1",
"Sem... | true |
Module.Flat.top_mul_submoduleAlgebra | Mathlib.RingTheory.PicardGroup | [
"Submodule.mulMap",
"Eq.mpr",
"Submodule",
"RingHomSurjective.ids",
"Submodule.module._proof_1",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"instSMulOfMul",
"HMul.hMul",
"IsScalarTower.right",
"Submodule.topEquiv",
"LinearMap.ext",
"congrArg",
"CommSemiring.toSemiring",
"LinearEqui... | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.mkSimpOnly.match_3 | Lean.Elab.Tactic.Simp | [
"Unit.unit",
"Bool.true",
"Unit",
"Bool.casesOn",
"Bool",
"Bool.false"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.