name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Mathlib.Tactic.Ring.ExProd.cast._unsafe_rec | Mathlib.Tactic.Ring.Basic | [
"Mathlib.Tactic.Ring.RatCoeff",
"Lean.Expr.const",
"Rat",
"Lean.Expr",
"Mathlib.Tactic.Ring.ExBase",
"Sigma.fst",
"Mathlib.Tactic.Ring.ExProd",
"Lean.Expr.sort",
"Lean.Level",
"Mathlib.Tactic.Ring.ExBase.cast._unsafe_rec",
"List.cons",
"Mathlib.Tactic.Ring.Common.ExBase",
"Mathlib.Tactic.Rin... | false |
Std.DHashMap.Raw.get!_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.get!.congr_simp",
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Eq.mpr",
"Std.DHashMap.Internal.Raw₀.inter",
"Std.DHashMap.Internal.Raw₀.contains",
"Std.DHashMap.Internal.Raw.inter_eq",
"congrArg",
"Std.DHashMap.Raw",
"LawfulBEq",
"Membership.mem",
... | true |
NumberField.mixedEmbedding.convexBodySum.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | [
"Real",
"NumberField.mixedEmbedding.convexBodySum",
"Eq.rec",
"NumberField.mixedEmbedding.mixedSpace",
"Eq.refl",
"Eq",
"Field",
"NumberField"
] | true |
AntivaryOn.neg_left | Mathlib.Algebra.Order.Monovary | [
"Iff.mpr",
"NegZeroClass.toNeg",
"Pi.instNeg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"PartialOrder",
"AddCommGroup",
"MonovaryOn",
"SubtractionMonoid.toSubNegZeroMonoid",
"AntivaryOn",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"monov... | true |
_private.Lean.Elab.Tactic.Change.0.Lean.Elab.Tactic.evalChange.match_1 | Lean.Elab.Tactic.Change | [
"Lean.MVarId",
"Lean.Expr",
"Prod.mk",
"List",
"Prod",
"Prod.casesOn"
] | false |
Lean.Parser.Term.debugAssert._regBuiltin.Lean.Parser.Term.debugAssert.parenthesizer_11 | Lean.Parser.Term | [
"Lean.Name.mkStr5",
"IO",
"Lean.PrettyPrinter.Parenthesizer",
"Lean.PrettyPrinter.parenthesizerAttribute",
"Unit",
"Lean.Parser.Term.debugAssert.parenthesizer",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
GrpCat.limitGroup._proof_3 | Mathlib.Algebra.Category.Grp.Limits | [
"GrpCat.instConcreteCategoryMonoidHomCarrier",
"CategoryTheory.Functor",
"Mul.mk",
"GrpCat",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"HMul.hMul",
"CategoryTheory.Limits.Types.Small.limitCone",
"MonoidHom",
"GrpCat.str",
"Monoid.toMulOneClass",
"GrpCat.limitGroup._aux_1",
"CategoryThe... | false |
Ideal.IsHomogeneous.iSup₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | [
"SetLike",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semiring.toModule",
"iSup",
"Submodule.completeLattice",
"AddMonoid.toAddZeroClass",
"AddSubmonoidClass",
"CompleteLattice.toConditionallyCompleteLattice",
"Ideal.IsHomogeneous.iSup",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Ideal.IsHomog... | true |
List.max?.eq_1 | Init.Data.List.MinMax | [
"Max",
"List.max?",
"Option.none",
"Eq.refl",
"Eq",
"List.nil",
"Option"
] | true |
Equiv.Perm.toList_ne_singleton | Mathlib.GroupTheory.Perm.Cycle.Concrete | [
"Equiv.Perm.instDecidableRelSameCycle",
"Equiv.Perm.toList",
"Equiv.Perm.support",
"False",
"congrArg",
"False.elim",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Equiv.Perm.toList_ne_singleton._simp_1_1",
"Eq.mp",
"Ne",
"instOfNatNat",
... | true |
CategoryTheory.Limits.IsZero.iso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.IsZero.to_",
"CategoryTheory.Limits.IsZero.eq_of_src",
"CategoryTheory.Limits.IsZero.from_",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Limits.IsZero",
"CategoryTheory.Catego... | false |
LowerSet.instDiv._proof_1 | Mathlib.Algebra.Order.UpperLower | [
"instHDiv",
"IsOrderedMonoid",
"Preorder.toLE",
"HDiv.hDiv",
"CommGroup",
"LowerSet.carrier",
"Group.toDivInvMonoid",
"SetLike.coe",
"IsLowerSet",
"DivInvMonoid.toDiv",
"Set.div",
"CommGroup.toGroup",
"LowerSet.lower'",
"IsLowerSet.div_right",
"LowerSet",
"Preorder",
"CommGroup.toCom... | false |
_private.Mathlib.Algebra.Free.0.FreeMagma.length_pos.match_1_1 | Mathlib.Algebra.Free | [
"FreeMagma.of",
"FreeMagma.mul",
"FreeMagma",
"FreeMagma.casesOn"
] | false |
Membership.mem.out | Mathlib.Data.Set.Operations | [
"setOf",
"Membership.mem",
"Set.mem_setOf",
"Iff.mp",
"Set.instMembership",
"Set"
] | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | [
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.Limits.PullbackCone.fst",
"CategoryTheory.Limits.pullbackConeOfLeftIso",
"CategoryTheory.Limits.Cone.pt",
"CategoryTheory.Limits.WalkingPair",
"Category... | true |
QuotientAddGroup.lift._proof_2 | Mathlib.GroupTheory.QuotientGroup.Defs | [
"AddMonoidHom.normal_ker",
"AddCon",
"QuotientAddGroup.lift._proof_1",
"AddMonoidHom.instAddMonoidHomClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"Eq.rec",
"AddZeroClass.toAddZero",
"AddCon.instLE",
"LE.le",
"AddSubgroup",
... | false |
SignType.ofNat | Mathlib.Data.Sign.Defs | [
"cond",
"Nat.ble",
"SignType.pos",
"SignType.neg",
"SignType.zero",
"Nat",
"SignType"
] | true |
Filter.Germ.instSemigroup._proof_1 | Mathlib.Order.Filter.Germ.Basic | [
"Semigroup",
"Filter.Germ.ofFun",
"Semigroup.toMul",
"HMul.hMul",
"congrArg",
"mul_assoc",
"Filter.germSetoid",
"Filter.Germ.instMul",
"Quotient.inductionOn₃'",
"Filter.Germ",
"Pi.semigroup",
"Eq",
"Filter",
"instHMul"
] | false |
Int.mul_tmod_left | Init.Data.Int.DivMod.Lemmas | [
"Int.tmod",
"Eq.mpr",
"Int.mul_tdiv_cancel",
"HMul.hMul",
"Int.tmod_def",
"congrArg",
"Int.tmod_zero",
"HSub.hSub",
"Int.instDecidableEq",
"id",
"Int",
"dite",
"Int.instMul",
"Int.tdiv",
"instHSub",
"instOfNat",
"Int.mul_zero",
"congr",
"True",
"Int.sub_self",
"eq_self",
"o... | true |
Lean.Lsp.ReferenceContext.rec | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.ReferenceContext",
"Bool",
"Lean.Lsp.ReferenceContext.mk"
] | false |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.signVariations_eraseLead_mul_X_sub_C._abel_1_6 | Mathlib.Algebra.Polynomial.RuleOfSigns | [
"Mathlib.Tactic.Abel.const_add_termg",
"Polynomial.C",
"Mathlib.Tactic.Abel.term_atomg",
"NegZeroClass.toNeg",
"Mathlib.Meta.NormNum.instAddMonoidWithOne",
"Semiring.toModule",
"Polynomial.instNeg",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommG... | false |
Mathlib.Meta.Positivity.evalFinsetSum | Mathlib.Tactic.Positivity.Finset | [
"Qq.QuotedDefEq",
"Pure.pure",
"Lean.instantiateMVars",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Meta.mkFreshLevelMVar",
"Qq.trySynthInstanceQ",
"Mathlib.Meta.monadLiftOptionMetaM",
"Lean.MetavarKind.natural",
"Mathlib.Meta.Positivity.Strictness",
"Lean.MetavarKind.syn... | true |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.le_offset._proof_1_1 | Init.Grind.Offset | [
"Nat.lt_of_not_le",
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Int.natCast_add",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.ev... | false |
CategoryTheory.CommGrp.forget₂Grp_obj_one | Mathlib.CategoryTheory.Monoidal.CommGrp_ | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CommGrp.instCategory",
"CategoryTheory.Grp.instCategory",
"CategoryTheory.GrpObj.toMonObj",
"CategoryTheory.Grp.grp",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.CommGrp.forget₂Grp",
"Categ... | true |
FiniteField.instFieldExtension._proof_22 | Mathlib.FieldTheory.Finite.Extension | [
"Monoid.npow_zero._autoParam",
"Nat.Prime",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"One.mk",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"instFieldGaloisField._proof_22",
"AddGroupWithOne.toAddMonoidWithOne",
"Field.toDivisionRing",
"Fact",
"Algebra.toModule",
"NonUnitalNonAssocRing... | false |
AffineBasis.tot | Mathlib.LinearAlgebra.AffineSpace.Basis | [
"AffineBasis.instFunLike",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"AddCommGroup.toAddCommMonoid",
"AffineBasis.tot'",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"CompleteLattice.toBoundedOrder",
"AddCommGroup",
"AffineSubspace.instCompleteLattice",
... | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | [
"Set.Ioi_inter_Iic",
"Set.Ioc",
"Set.Ioi",
"Set.instInter",
"Inter.inter",
"Set.Iic",
"Eq.symm",
"Eq",
"Preorder",
"Set"
] | false |
AddCommGrpCat.forget_commGrp_preserves_epi | Mathlib.Algebra.Category.Grp.EpiMono | [
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.PreservesEpimorphisms",
"AddCommGroup.toAddGroup",
"AddCommGrpCat.instConcreteCategoryA... | true |
IsAdicComplete.toIsPrecomplete | Mathlib.RingTheory.AdicCompletion.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"Ideal",
"IsPrecomplete",
"IsAdicComplete",
"CommRing.toCommSemiring",
"Module"
] | true |
CategoryTheory.RegularMono._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | [
"CategoryTheory.Limits.WalkingParallelPair._sizeOf_inst",
"CategoryTheory.Limits.Fork.ofι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Limits.IsLimit._sizeOf_inst",
"instSizeOfDefault",
"CategoryTheory.Limits.walkingParallelPair... | false |
FirstOrder.Language.PartialEquiv.mk.inj | Mathlib.ModelTheory.PartialEquiv | [
"FirstOrder.Language.Equiv",
"FirstOrder.Language.Substructure.inducedStructure",
"Membership.mem",
"FirstOrder.Language.Substructure.instSetLike",
"Subtype",
"FirstOrder.Language.Substructure",
"FirstOrder.Language.PartialEquiv.mk.noConfusion",
"FirstOrder.Language.PartialEquiv.mk",
"And",
"First... | true |
Condensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | [
"LocallyConstant.mk",
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"Finite",
"FintypeCat",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"TypeCat.ofHom",
"CategoryTheory.Iso",
"CategoryTheory.Iso.mk",
"Condensed.locallyConstantPresheaf",
"TotallyDisc... | true |
CategoryTheory.Limits.Concrete.initial_of_empty_of_reflects | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | [
"Iff.mpr",
"CategoryTheory.Limits.Types.initial_iff_empty",
"CategoryTheory.Limits.IsInitial",
"PEmpty",
"IsEmpty",
"CategoryTheory.Limits.IsInitial.isInitialOfObj",
"CategoryTheory.ConcreteCategory",
"CategoryTheory.discreteCategory",
"CategoryTheory.Functor.empty",
"CategoryTheory.Limits.Reflect... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsCycles.other_adj_of_adj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | [
"SimpleGraph.Adj",
"Membership.mem",
"SimpleGraph.neighborSet",
"SimpleGraph.mem_neighborSet",
"SimpleGraph",
"propext",
"Eq.symm",
"Eq",
"Set.instMembership",
"Set"
] | false |
AddCommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | [
"Lattice",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddLeftMono",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddZeroClass.toAddZero",
"AddCommGroup",
"DistribLattice",
"AddGroup.toSubNegMonoid",
"AddCommGroup.toDistribLattice._proof_1",
"AddC... | true |
Aesop.instInhabitedMVarClusterData.default | Aesop.Tree.Data | [
"Inhabited.default",
"instInhabitedBool",
"Aesop.MVarClusterData.mk",
"Array",
"instInhabitedOption",
"Array.instInhabited",
"Aesop.MVarClusterData",
"Aesop.instInhabitedNodeState",
"Bool",
"IO.Ref",
"Aesop.NodeState",
"Option"
] | true |
ContinuousAffineMap.decompEquiv_symm_apply | Mathlib.Topology.Algebra.ContinuousAffineMap | [
"Equiv.instEquivLike",
"AddMonoid.toAddSemigroup",
"AddCommGroup.toAddCommMonoid",
"IsTopologicalAddTorsor",
"ContinuousLinearMap.funLike",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Equiv",
"ContinuousAffineMap",
"addGroupIsAddTorsor",
"Prod.fst",
"HVAdd.hVAdd",
"ContinuousLinearMap",
"T... | true |
instNonUnitalNonAssocRingCommutatorRing._proof_28 | Mathlib.Algebra.Lie.NonUnitalNonAssocAlgebra | [
"NonUnitalNonAssocRing",
"HMul.hMul",
"instNonUnitalNonAssocRingCommutatorRing._aux_1",
"instNonUnitalNonAssocRingCommutatorRing._proof_3",
"SubNegMonoid.mk",
"AddMonoid.toZero",
"instNonUnitalNonAssocRingCommutatorRing._proof_20",
"AddMonoid.mk",
"AddCommGroup.toAddGroup",
"CommutatorRing",
"in... | false |
Lean.Elab.Term.SyntheticMVarKind.typeClass.inj | Lean.Elab.Term.TermElabM | [
"Lean.MessageData",
"Lean.Elab.Term.SyntheticMVarKind.typeClass.noConfusion",
"Lean.Elab.Term.SyntheticMVarKind",
"Lean.Elab.Term.SyntheticMVarKind.typeClass",
"Eq",
"Option"
] | true |
Lean.PrefixTreeNode.below_2 | Lean.Data.PrefixTree | [
"Lean.PrefixTreeNode",
"Ordering",
"Std.TreeMap.Raw",
"PProd",
"PUnit",
"Nat",
"Std.DTreeMap.Internal.Impl",
"Lean.PrefixTreeNode.rec_2",
"Option",
"Std.DTreeMap.Raw"
] | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_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 |
Mathlib.Notation3.MatchState.noConfusion | Mathlib.Util.Notation3 | [
"Lean.TSyntax",
"Mathlib.Notation3.MatchState",
"Mathlib.Notation3.MatchState.noConfusionType",
"Lean.Name.mkStr3",
"Std.HashMap",
"Lean.Syntax.Term",
"List.cons",
"Array",
"Mathlib.Notation3.MatchState.casesOn",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.LocalInstances",
"Lean.SubExpr",
... | false |
_private.Mathlib.Algebra.Polynomial.Degree.Units.0.Polynomial.isUnit_iff.match_1_1 | Mathlib.Algebra.Polynomial.Degree.Units | [
"Polynomial.C",
"IsUnit",
"RingHom",
"Exists",
"Polynomial",
"And.casesOn",
"And",
"RingHom.instFunLike",
"Exists.casesOn",
"Polynomial.semiring",
"And.intro",
"Semiring.toMonoid",
"Exists.intro",
"Semiring",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe"
] | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk.noConfusion | Mathlib.Tactic.Linter.FindDeprecations | [
"_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo",
"_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.noConfusion",
"String",
"_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk",
"id",
"Lean.Position",
"Lea... | false |
CategoryTheory.Functor.IsRepresentedBy.representableBy | Mathlib.CategoryTheory.RepresentedBy | [
"CategoryTheory.Functor",
"Opposite",
"Equiv.instEquivLike",
"CategoryTheory.Functor.RepresentableBy.equivUliftYonedaIso",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.Functor.IsRepresentedBy",
"Equiv",
"CategoryTheory.Iso",
"CategoryTheory.Functor.Representabl... | true |
integrable_cexp_quadratic' | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | [
"instInnerProductSpaceRealComplex",
"NormedCommRing.toNormedRing",
"Complex.exp_ne_zero._simp_1",
"Eq.mpr",
"inv_eq_zero._simp_1",
"GroupWithZero.toMonoidWithZero",
"InnerProductSpace.toNormedSpace",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"le_refl",
"False",
"Real",
"Di... | true |
Ordinal.IsFundamentalSeq.id | Mathlib.SetTheory.Ordinal.FundamentalSequence | [
"IsCofinal.univ._simp_1",
"Ordinal.IsFundamentalSeq.mk",
"Ordinal.partialOrder",
"congrArg",
"Set.univ",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Set.Elem",
"id",
"LE.le",
"Cardinal.ord",
"strictMono_id",
"Ordinal.IsFundamentalSeq",
"True",
"Set.range_id",
"Ordi... | true |
Lean.Doc.Inline.emph.injEq | Lean.DocString.Types | [
"Eq.propIntro",
"Array",
"Lean.Doc.Inline.emph.inj",
"Lean.Doc.Inline.emph",
"Eq.ndrec",
"Eq.refl",
"Eq",
"Lean.Doc.Inline"
] | true |
CategoryTheory.Functor.toPrefunctor | Mathlib.CategoryTheory.Functor.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Functor.map",
"Prefunctor",
"CategoryTheory.Category.toCategoryStruct",
"Prefunctor.mk",
"CategoryTheory.Functor.obj",
"CategoryTheory.Category"
] | true |
Lean.Meta.saveState | Lean.Meta.Basic | [
"Pure.pure",
"Lean.Meta.SavedState",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"ReaderT",
"Lean.Meta.State",
"Lean.Core.saveState",
"instMonadLiftT",
"MonadState.get",
"IO",
"StateRefT'.instMonadStateOfOfMonadLiftTST",
"Lean.Meta.MetaM",
"IO.RealWorld",
"EIO",
... | true |
AffineSubspace.map_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | [
"Lattice.toSemilatticeSup",
"AffineMap.instFunLike",
"CompleteLattice.toLattice",
"AffineSubspace.map",
"AddCommGroup.toAddCommMonoid",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"CompleteLattice.toBoundedOrder",
"AddCommGroup",
"Bot.bot",
"Affin... | true |
Lean.Constructor.mk.injEq | Lean.Declaration | [
"Lean.Constructor.mk.inj",
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Expr",
"And",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Constructor",
"Eq",
"Lean.Constructor.mk"
] | true |
Filter.eventually_bind._simp_1 | Mathlib.Order.Filter.Map | [
"Filter.eventually_bind",
"Filter.Eventually",
"Filter.bind",
"propext",
"Eq",
"Filter"
] | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | [
"Std.IterStep",
"Std.IterM.IsPlausibleStep",
"Std.IterStep.skip",
"Std.Iterator",
"Subtype.mk",
"_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_1",
"Std.IterStep.yield",
"Std.IterM.Step",
"Std.IterStep.done",
"Eq.refl",
"Std.IterM",
"Eq"
] | true |
CategoryTheory.MorphismProperty.isLocal_antitone | Mathlib.CategoryTheory.ObjectProperty.Local | [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
"CategoryTheory.CategoryStruct.toQuiver",
"_private.Mathlib.CategoryTheory.ObjectProperty.Local.0.CategoryTheory.MorphismProperty.isLocal_iff._simp_1",
"Quiver.Hom",
"CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra",
"Prop.le",
"PartialOrder.toPr... | true |
Irrational.of_mul_ratCast | Mathlib.NumberTheory.Real.Irrational | [
"Real",
"HMul.hMul",
"Real.instRatCast",
"Rat",
"Rat.cast",
"Irrational",
"Rat.not_irrational",
"Real.instMul",
"Irrational.mul_cases",
"Or.resolve_right",
"instHMul"
] | true |
Set.Finite.cast_ncard_eq | Mathlib.Data.Set.Card | [
"Eq.mpr",
"Set.encard",
"ENat.instNatCast",
"instTopENat",
"Classical.not_not",
"congrArg",
"Set.Finite",
"Set.encard_eq_top_iff",
"id",
"Ne",
"ne_eq",
"Nat.cast",
"ENat.coe_toNat_eq_self",
"Nat",
"ENat",
"propext",
"Set.Infinite.eq_1",
"ENat.toNat",
"Top.top",
"Set.ncard",
"... | true |
LinearMap.transvection.comp_of_left_eq | Mathlib.LinearAlgebra.Transvection.Basic | [
"LinearMap.transvection",
"Semiring.toModule",
"LinearMap.transvection.comp_of_left_eq_apply",
"LinearMap.ext",
"congrArg",
"LinearMap.instFunLike",
"LinearMap",
"AddCommMonoid",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"LinearMap.comp",
"instHAdd",
"HAdd.hAdd",
"NonAssocSemiring.toNonUn... | true |
AlgebraicGeometry.instIsLocallyArtinianFiberOfLocallyQuasiFinite | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | [
"AlgebraicGeometry.instLocallyQuasiFiniteSndScheme",
"instIsPrincipalIdealRingOfIsSemisimpleRing",
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.Scheme",
"Semiring.toModule",
"CommRingCat.carrier",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | true |
ENNReal.mul_eq_left | Mathlib.Data.ENNReal.Operations | [
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"Eq.mp",
"Ne",
"ENNReal.instCommSemiring",
"MulZeroOneClass.toMulOneClass",
"instDistribOfSemiring",
"instMulZeroOneClassOfSemiring",
"ENNReal.mul_right_inj",
"Iff",
"Distrib.toMul",
"ENNReal",
"One.toOfNat1",
"Zero.toOfNat0",
"ENNRea... | true |
Equiv.piOptionEquivProd_apply | Mathlib.Logic.Equiv.Basic | [
"Equiv.instEquivLike",
"Equiv.piOptionEquivProd",
"Option.some",
"Equiv",
"Prod.mk",
"Option.none",
"Eq.refl",
"Prod",
"Eq",
"DFunLike.coe",
"EquivLike.toFunLike",
"Option"
] | true |
MeasureTheory.ae_eq_comp | Mathlib.MeasureTheory.Measure.Restrict | [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"AEMeasurable",
"Function.comp",
"Filter.EventuallyEq",
"MeasurableSpace",
"MeasureTheory.Measure.map",
"MeasureTheory.Measure.AbsolutelyContinuous.rfl",
"MeasureTheory.ae_eq_comp'",
"MeasureTheory.Measure.instFunLike",
"MeasureTheory.Measure.instOute... | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic.0.isCyclic_iff_exists_orderOf_eq_natCard._simp_1_2 | Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic | [
"Finite",
"Group",
"Membership.mem",
"Subtype",
"Nat.card",
"Subgroup",
"Nat",
"propext",
"Subgroup.instTop",
"Top.top",
"Eq.symm",
"Eq",
"SetLike.instMembership",
"Subgroup.instSetLike",
"Subgroup.card_eq_iff_eq_top"
] | false |
ByteArray.ofFn | Batteries.Data.ByteArray | [
"ByteArray.emptyWithCapacity",
"ByteArray.push",
"Fin.foldl",
"Nat",
"ByteArray",
"UInt8",
"Fin"
] | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_17 | Mathlib.Analysis.Distribution.TestFunction | [
"BoundedContinuousMapClass.map_bounded",
"NormedCommRing.toSeminormedCommRing",
"Real.instLE",
"Real",
"instHSMul",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"TestFunction.toTestFunctionClass",
"DistribMulAction.toDistribSMul",
"AddCommGro... | false |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1 | Mathlib.NumberTheory.Cyclotomic.Basic | [
"And",
"and_assoc",
"propext",
"Eq"
] | false |
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | [
"Mathlib.Meta.NormNum.isInt_pow",
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"Semigroup.toMul",
"Mathlib.Meta.NormNum.instAddMonoidWithOne",
"Dvd.d... | true |
IsManifold.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | [
"NormedSpace",
"contDiffGroupoid",
"HasGroupoid",
"IsManifold",
"IsManifold.rec",
"IsManifold.mk",
"TopologicalSpace",
"ModelWithCorners",
"ENat",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"NormedAddCommGroup",
"WithT... | false |
MeasureTheory.VectorMeasure.of_biUnion_finset | Mathlib.MeasureTheory.VectorMeasure.Basic | [
"Eq.mpr",
"SetLike.mem_coe._simp_1",
"MeasureTheory.VectorMeasure.empty",
"False",
"_private.Mathlib.MeasureTheory.VectorMeasure.Basic.0.MeasureTheory.VectorMeasure.of_biUnion_finset._proof_1_4",
"ChainCompletePartialOrder.instOfCompleteLattice",
"MeasurableSet",
"eq_false",
"CompleteBooleanAlgebra.... | true |
Set.powersetCard.ofFinEmb.eq_1 | Mathlib.Data.Set.PowersetCard | [
"Set.powersetCard.ofFinEmb",
"Finset.univ",
"Finset",
"Membership.mem",
"Set.Elem",
"Fin.fintype",
"Function.Embedding",
"Subtype.mk",
"Nat",
"Eq.refl",
"Set.powersetCard.map",
"Fin",
"Eq",
"Set.instMembership",
"Set.powersetCard",
"Set.powersetCard.ofFinEmb._proof_1",
"Set"
] | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1 | Init.Data.BitVec.Lemmas | [
"ite_eq_left_iff",
"Decidable",
"propext",
"Eq",
"Not",
"ite"
] | false |
UniformSpace.Completion.ring._proof_26 | Mathlib.Topology.Algebra.UniformRing | [
"AddMonoidWithOne.unary",
"UniformSpace.Completion.ring._proof_6",
"UniformSpace",
"Mul.mk",
"One.mk",
"HMul.hMul",
"UniformSpace.Completion.mul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"IsTopologicalAddGroup.regularSpace",
"instTopologicalSpaceProd",
"Semigroup.mk",
"Mul",
"... | false |
ModuleCat.instModuleCarrierObjRestrictScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | [
"MulOne.toOne",
"instHSMul",
"ModuleCat",
"Monoid.toMulOneClass",
"AddCommGroup.toAddCommMonoid",
"RingHom",
"ModuleCat.restrictScalars",
"SemigroupAction.mk",
"ModuleCat.instModuleCarrierObjRestrictScalars._proof_3",
"MulOneClass.toMulOne",
"ModuleCat.isAddCommGroup",
"ModuleCat.moduleCategor... | false |
Std.Http.Method.noConfusion | Std.Internal.Http.Data.Method | [
"Std.Http.Method",
"noConfusionEnum",
"Std.Http.Method.noConfusionType",
"Std.Http.Method.ctorIdx",
"Nat",
"instDecidableEqNat",
"Eq"
] | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars | Lean.Elab.MutualInductive | [
"Lean.Expr",
"_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext",
"Array"
] | true |
TopModuleCat.instAddCommGroupHom | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | [
"TopModuleCat.instCategory",
"TopModuleCat.instAddCommGroupHom._proof_3",
"TopModuleCat.instAddCommGroupHom._proof_4",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"TopModuleCat.continuousSMul",
"AddCommGroup.toAddCommMonoid",
"SubNegMonoid.mk",
"ContinuousLinearMap.funLike",
"Add.mk",
... | true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Internal.Lemmas | [
"Std.DTreeMap.Internal.Impl.toListModel_erase",
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"Ord",
"Std.instLawfulBEqOrd",
"congrArg",
"beqOfOrd",
"Std.Internal.List.minKey?_le_minKey?_eraseKey",
"Std.DTreeMap.Internal.Impl.Ordered.distinctKeys"... | true |
Filter.covariant_vadd | Mathlib.Order.Filter.Pointwise | [
"CovariantClass.mk",
"Filter.instVAdd",
"PartialOrder.toPreorder",
"Preorder.toLE",
"VAdd",
"LE.le",
"HVAdd.hVAdd",
"instHVAdd",
"Filter.map₂_mono_left",
"Filter",
"CovariantClass",
"Filter.instPartialOrder"
] | true |
grade_strictMono | Mathlib.Order.Grade | [
"StrictMono",
"GradeOrder.grade_strictMono",
"grade",
"Preorder",
"GradeOrder"
] | true |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | [
"Array.eraseIdx_set_lt",
"Vector",
"congrArg",
"Array.set",
"Vector.eraseIdx",
"Vector.set_mk._proof_2",
"HSub.hSub",
"Vector.casesOn",
"instSubNat",
"instOfNatNat",
"Vector.getElem_mk._proof_2",
"Array",
"Array.eraseIdx_set_lt._proof_3",
"Vector.eraseIdx_set_lt._proof_2",
"instHSub",
... | true |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | [
"Action.FunctorCategoryEquivalence.functor._proof_3",
"Monoid",
"Action.FunctorCategoryEquivalence.functor",
"CategoryTheory.Functor",
"MonoidHom.instFunLike",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"Monoid.toMulOneClass",
"CategoryTheory.Functor.mk",
"CategoryTheor... | true |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | [
"PartialOrder.ofSetLike",
"PartialOrder",
"Subfield.instSetLike",
"DivisionRing",
"Subfield"
] | true |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | [
"setOf",
"CategoryTheory.Bundled.structure",
"FirstOrder.Language.Embedding",
"FirstOrder.Language.Structure.FG",
"And",
"FirstOrder.Language.Structure",
"CategoryTheory.Bundled.α",
"CategoryTheory.Bundled",
"Nonempty",
"FirstOrder.Language",
"Set"
] | true |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | [
"ContinuousMap",
"ContinuousMap.comp",
"TopologicalSpace",
"ContinuousMap.instZero",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"rfl",
"Zero"
] | true |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | [
"Std.Do.PredTrans.Conjunctive",
"Std.Do.PostCond",
"Std.Do.Assertion",
"Std.Do.PostShape",
"Prod.fst",
"Std.Do.SPred.bientails",
"of_eq_true",
"Std.Do.SPred.and",
"Std.Do.PostShape.args",
"Std.Do.SPred.bientails.refl._simp_1",
"Std.Do.ExceptConds"
] | false |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | [
"pow_pos",
"Preorder.toLT",
"PartialOrder.toPreorder",
"IsStrictOrderedRing",
"PartialOrder",
"Subtype",
"Monoid.toPow",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"LT.lt",
"Semiring",
"Zero.toOfNat0",
"instHPow",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Subtype... | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_430 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select.match_5 | Mathlib.Tactic.MkIffOfInductiveProp | [
"Unit.unit",
"_private.Mathlib.Tactic.MkIffOfInductiveProp.0.Mathlib.Tactic.MkIff.select._sparseCasesOn_5",
"Nat.hasNotBit",
"instOfNatNat",
"Unit",
"Nat",
"Nat.ctorIdx",
"Nat.zero",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
NNRat.nndist_eq._simp_1 | Mathlib.Topology.Instances.Rat | [
"NNDist.nndist",
"Rat",
"PseudoMetricSpace.toNNDist",
"NNRat.instMetricSpace",
"NNRat",
"NNReal",
"Rat.instNNRatCast",
"NNRat.nndist_eq",
"MetricSpace.toPseudoMetricSpace",
"Rat.instMetricSpace",
"Eq.symm",
"NNRat.cast",
"Eq"
] | false |
List.Sublist.tail | Init.Data.List.Sublist | [
"_private.Init.Data.List.Sublist.0.List.Sublist.tail.match_1_1",
"List.tail",
"List.tail_sublist",
"List.cons",
"List",
"Unit",
"List.Sublist.slnil",
"List.Sublist.trans",
"List.Sublist"
] | true |
«term_<|_» | Init.Notation | [
"Lean.ParserDescr.trailingNode",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1",
"Lean.TrailingParserDescr"
] | true |
CategoryTheory.Under.map.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.id",
"CategoryTheory.Under",
"CategoryTheory.Discrete.natTrans",
"CategoryTheory.discreteCategory",
"CategoryTheory.Comma.mapLeft",
"PUnit",
"Eq.refl",
... | true |
Lean.Compiler.LCNF.Simp.FunDeclInfoMap.format | Lean.Compiler.LCNF.Simp.FunDeclInfo | [
"Pure.pure",
"Lean.instBEqFVarId",
"Std.instToFormatString",
"Std.Format.nil",
"Lean.Compiler.LCNF.Simp.FunDeclInfo",
"Std.Format.instAppend",
"instForInOfForIn'",
"String",
"Lean.Compiler.LCNF.Simp.FunDeclInfoMap.map",
"inferInstance",
"Std.HashMap.toList",
"IO.RealWorld",
"Lean.FVarId",
... | true |
smul_nonneg_iff_neg_imp_nonpos | Mathlib.Algebra.Order.Module.Defs | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"instHSMul",
"Preorder.toLT",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"instIsLeftCancelAddOfAddLeftReflectLE",
"neg_smul_neg",
"LinearOrd... | true |
Projectivization.logHeight_mk | Mathlib.NumberTheory.Height.Projectivization | [
"Projectivization.mk",
"Pi.Function.module",
"Real",
"Semiring.toModule",
"Finite",
"Field.toDivisionRing",
"DivisionRing.toDivisionSemiring",
"Height.AdmissibleAbsValues",
"Pi.instZero",
"Ne",
"DivisionRing.toRing",
"Field.toSemifield",
"Height.logHeight",
"Projectivization.logHeight",
... | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.hasLimit_cospan_forget_of_right' | Mathlib.Geometry.RingedSpace.OpenImmersion | [
"AlgebraicGeometry.SheafedSpace.IsOpenImmersion",
"AlgebraicGeometry.SheafedSpace",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingCospan.Hom.inl",
"CategoryTheory.Limits.WalkingCospan.right",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.HasLimit",
"Ca... | true |
if_true_right._simp_1 | Init.PropLemmas | [
"Decidable",
"if_true_right",
"True",
"propext",
"Eq",
"ite"
] | false |
ENat.forall_natCast_le_iff_le | Mathlib.Data.ENat.Basic | [
"ENat.instNatCast",
"LE.le",
"Nat.instNoMaxOrder",
"instNoTopOrderOfNoMaxOrder",
"Nat.cast",
"instLEENat",
"Iff",
"WithTop.forall_coe_le_iff_le",
"Nat.instPreorder",
"Nat",
"ENat"
] | true |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_33 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"False",
"False.elim",
"Std.Tactic.BVDecide.BVUnOp",
"noConfusion_of_Nat",
"Nat",
"Std.Tactic.BVDecide.BVUnOp.reverse",
"Std.Tactic.BVDecide.BVUnOp.ctorIdx",
"Std.Tactic.BVDecide.BVUnOp.arithShiftRightConst",
"Eq",
"Not"
] | false |
Plausible.Testable.mk | Plausible.Testable | [
"Plausible.Testable",
"Plausible.TestResult",
"Plausible.Testable.mk",
"Plausible.Configuration",
"Bool",
"Plausible.Gen"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.