name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.pullback.congrHom._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Category.comp_id",
"congr",
"True",
"eq_self",
"CategoryTheory.CategoryStruct.comp",
"of_eq_true",
"CategoryTheory.Category.toCategoryStruct",
"congrFun'",
"Eq",
"Eq.tran... | false |
_private.Mathlib.RingTheory.Multiplicity.0.Int.finiteMultiplicity_iff_finiteMultiplicity_natAbs._simp_1_1 | Mathlib.RingTheory.Multiplicity | [
"Monoid",
"Dvd.dvd",
"semigroupDvd",
"Exists",
"instOfNatNat",
"Monoid.toPow",
"instHAdd",
"HPow.hPow",
"HAdd.hAdd",
"Nat",
"FiniteMultiplicity.def",
"FiniteMultiplicity",
"propext",
"Monoid.toSemigroup",
"instAddNat",
"instHPow",
"OfNat.ofNat",
"Eq",
"Not"
] | false |
CategoryTheory.IsGrothendieckAbelian.hasSeparator._autoParam | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Std.ExtDTreeMap.not_mem_diff_of_mem_right | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.mk",
"Std.DTreeMap",
"Std.ExtDTreeMap.inductionOn₂",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.DTreeMap.not_mem_diff_of_mem_right",
"Std.ExtDTreeMap.instSDiffOfTransCmp",
"SDiff.sdiff",
"Std.ExtDTreeMap",
"Std.ExtDTreeMap.instMembershipOfTransCmp",
"Not"
] | true |
Orientation.oangle_add_right_smul_rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | [
"LinearIsometryEquiv.instEquivLike",
"Iff.mpr",
"AlternatingMap.instAddCommGroup",
"AddGroup.toSubtractionMonoid",
"AlternatingMap",
"Norm.norm",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"SubtractionMonoid.toI... | true |
essInf_mono_ae._auto_1 | Mathlib.MeasureTheory.Function.EssSup | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Set.nonempty_compl_of_nontrivial | Mathlib.Order.BooleanAlgebra.Set | [
"Nontrivial",
"Compl.compl",
"Set.instSingletonSet",
"exists_ne",
"Set.instCompl",
"Set.Nonempty",
"Singleton.singleton",
"Set"
] | true |
_private.Init.Data.Array.Erase.0.Array.eraseP_filterMap.match_1.eq_2 | Init.Data.Array.Erase | [
"Unit.unit",
"Option.some",
"Option.none",
"Unit",
"Array.eraseP_filterMap.match_1",
"Eq.refl",
"Eq",
"Option"
] | true |
Lean.Meta.Grind.EMatchTheorem.cnstrs | Lean.Meta.Tactic.Grind.Extension | [
"Lean.Meta.Grind.EMatchTheoremConstraint",
"Lean.Meta.Grind.EMatchTheorem",
"List"
] | true |
LinearPMap.supSpanSingleton._proof_1 | Mathlib.LinearAlgebra.LinearPMap | [
"Submodule",
"False",
"AddCommGroup.toAddCommMonoid",
"RingHom",
"Membership.mem",
"Eq.rec",
"DivisionRing.toDivisionSemiring",
"AddCommGroup",
"DivisionRing.toRing",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"Line... | false |
Asymptotics.IsBigOWith.eq_zero_imp | Mathlib.Analysis.Asymptotics.Defs | [
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"Eq.mpr",
"Real.instLE",
"Real",
"HMul.hMul",
"Asymptotics.IsBigOWith",
"norm_le_zero_iff._simp_1",
"Real.instZero",
"congrArg",
"Filter.Eventually",
"norm_zero",
"Real.semiring",
"Eq.mp",
"id",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.... | true |
ComplexShape.embeddingUp'Add | Mathlib.Algebra.Homology.Embedding.Basic | [
"IsRightCancelAdd",
"ComplexShape.Embedding.mk'",
"ComplexShape.embeddingUp'Add._proof_1",
"ComplexShape.embeddingUp'Add._proof_3",
"instHAdd",
"HAdd.hAdd",
"ComplexShape.up'",
"ComplexShape.Embedding",
"AddCommSemigroup.toAddCommMagma",
"AddCommSemigroup",
"Eq",
"AddCommMagma.toAdd"
] | true |
Order.instPreorderPartialIso._aux_1 | Mathlib.Order.CountableDenseLinearOrder | [
"Preorder.toLT",
"Finset",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Ordering",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Subtype",
"Finset.partialOrder",
"LE.le",
"cmp",
"Prod.fst",
"Finset.instSetLike",
"LinearOrder.toDecidableL... | false |
AddCircle.setAddOrderOfEquiv | Mathlib.Topology.Instances.AddCircle.Defs | [
"Nat.gcd",
"Preorder.toLT",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"LinearOrder",
"AddCommMagma.to_isCommutative",
"PartialOrder.toPreorder",
"addOrderOf",
"setOf",
"AddGroupWithOne.toAddMonoidWithOne",
"IsStrictOrderedRing",... | true |
CategoryTheory.Under.pushoutComp | Mathlib.CategoryTheory.Comma.Over.Pullback | [
"CategoryTheory.instCategoryUnder",
"CategoryTheory.Functor",
"Equiv.instEquivLike",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Under.mapComp",
"CategoryTheory.conjugateIsoEquiv",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.HasPushoutsAlong",
"CategoryThe... | true |
Std.Tactic.BVDecide.BVBinPred.toString.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"Unit.unit",
"Std.Tactic.BVDecide.BVBinPred.ult",
"Std.Tactic.BVDecide.BVBinPred.casesOn",
"Std.Tactic.BVDecide.BVBinPred.eq",
"Unit",
"Std.Tactic.BVDecide.BVBinPred"
] | false |
Std.PRange.UpwardEnumerable.succMany?_succ | Init.Data.Range.Polymorphic.UpwardEnumerable | [
"Std.PRange.UpwardEnumerable.succMany?_add_one",
"Std.PRange.UpwardEnumerable",
"Option.bind",
"instOfNatNat",
"Std.PRange.UpwardEnumerable.succ?",
"instHAdd",
"Std.PRange.UpwardEnumerable.succMany?",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Eq",
"Std.PRange.LawfulUpwardEnumerable",... | true |
Combinatorics.Additive.«termσₘ[_]» | Mathlib.Combinatorics.Additive.DoublingConst | [
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
_private.Init.Data.List.Sublist.0.List.cons_subset._simp_1_5 | Init.Data.List.Sublist | [
"forall_eq",
"propext",
"Eq"
] | false |
List.isChain_append_cons_cons._simp_1 | Mathlib.Data.List.Chain | [
"List.IsChain",
"List.cons",
"instHAppendOfAppend",
"List",
"And",
"propext",
"List.isChain_append_cons_cons",
"List.instAppend",
"Eq",
"HAppend.hAppend",
"List.nil"
] | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabMutualDef.match_3 | Lean.Elab.MutualDef | [
"Unit.unit",
"Subarray",
"Lean.Elab.ExpandDeclIdResult",
"Option.casesOn",
"Option.some",
"Prod.mk",
"Option.none",
"Unit",
"Prod",
"Prod.casesOn",
"Option"
] | false |
Std.Http.Header.Value.mk | Std.Internal.Http.Data.Headers.Value | [
"Std.Http.Header.Value.mk",
"String",
"autoParam",
"Std.Http.Header.Value",
"Std.Http.Header.IsValidHeaderValue",
"Std.Http.Header.Value.isValidHeaderValue._autoParam"
] | true |
Fintype.card_quotient_le | Mathlib.Data.Fintype.Card | [
"Quotient.fintype",
"DecidableRel",
"Fintype.card",
"Setoid",
"Quotient.mk'_surjective",
"LE.le",
"instLENat",
"Fintype",
"Quotient",
"HasEquiv.Equiv",
"Quotient.mk'",
"Nat",
"instHasEquivOfSetoid",
"Fintype.card_le_of_surjective"
] | true |
_private.Mathlib.Order.RelIso.Basic.0.RelEmbedding.isWellOrder.match_1_1 | Mathlib.Order.RelIso.Basic | [
"IsWellOrder",
"RelEmbedding"
] | false |
Topology.IsOpenEmbedding.restrictPreimage | Mathlib.Topology.LocalAtTarget | [
"Set.restrictPreimage",
"Set.restrictPreimage_isOpenEmbedding",
"Membership.mem",
"Set.Elem",
"TopologicalSpace",
"Set.preimage",
"Topology.IsOpenEmbedding",
"instTopologicalSpaceSubtype",
"Set.instMembership",
"Set"
] | true |
Matroid.eRank | Mathlib.Combinatorics.Matroid.Rank.ENat | [
"Set.encard",
"instCompleteLinearOrderENat",
"iSup",
"Matroid.IsBase",
"Subtype",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"CompleteLinearOrder.toConditionallyCompleteLinearOrderBot",
"ENat",
"ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder",
"Condi... | true |
CategoryTheory.Sieve.sInf_apply | Mathlib.CategoryTheory.Sites.Sieves | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Iff.rfl",
"Membership.mem",
"CategoryTheory.Sieve.arrows",
"CategoryTheory.Sieve",
"CompleteLattice.toCompleteSemilatticeInf",
"Iff",
"CategoryTheory.Sieve.instCompleteLattice",
"CategoryTheory.Category.toCategoryStruct",
"CompleteSemilatt... | true |
_private.Mathlib.GroupTheory.Coxeter.Length.0.CoxeterSystem.isLeftDescent_iff._proof_1_1 | Mathlib.GroupTheory.Coxeter.Length | [
"Lean.RArray.leaf",
"False",
"Lean.Grind.not_not",
"HMul.hMul",
"Monoid.toMulOneClass",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Classical.byContradiction",
"Nat.ToInt.add_congr",
"Group",
"Lean.Grind.Nat.lt_eq",
"Eq.mp",
"Lean.RArray.branch",
"Nat.ToInt.natCast_ofNat",
"Int.Li... | false |
BoundedContinuousFunction.instZero | Mathlib.Topology.ContinuousMap.Bounded.Basic | [
"TopologicalSpace",
"PseudoMetricSpace",
"BoundedContinuousFunction.const",
"Zero.mk",
"Zero.toOfNat0",
"OfNat.ofNat",
"BoundedContinuousFunction",
"Zero"
] | true |
Quotient.hrecOn' | Mathlib.Data.Quot | [
"Quotient.mk''",
"Setoid",
"Quotient",
"HasEquiv.Equiv",
"instHasEquivOfSetoid",
"HEq",
"Quot.hrecOn",
"Setoid.r"
] | true |
String.instDecidableIsValid | Init.Data.String.Basic | [
"decidable_of_iff",
"String",
"Decidable",
"instDecidableEqBool",
"String.Pos.Raw",
"Bool.true",
"String.Pos.Raw.isValid",
"String.Pos.Raw.isValid_eq_true_iff",
"Bool",
"String.Pos.Raw.IsValid",
"Eq"
] | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.centralizer_le_alternating_iff._proof_1_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | [
"Multiset.sum",
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"Equiv.Perm.cycleType",
"Equiv.instEquivLike",
"HMul.hMul",
"Int.Linear.norm_le",
"eq_false",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Int.Linear.eq_norm",
"Classical.byContradiction",
"Function.f... | false |
Set.Iic_union_Ico_eq_Iio | Mathlib.Order.Interval.Set.LinearOrder | [
"Set.Subset.antisymm",
"lt_of_le_of_lt",
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Set.instUnion",
"DistribLattice.toLattice",
"LE.le",
"Set.Ico",
"And.right",
"LT.lt",
"Set.Iic",
"Set.Iio_subset_Iic_... | true |
AlgebraicGeometry.SpecModulesToSheafFullyFaithful._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | [
"AlgebraicGeometry.Spec",
"CategoryTheory.Functor",
"Opposite",
"AlgebraicGeometry.Scheme.Modules.instCategory",
"CommRingCat.carrier",
"Quiver.opposite",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"TopologicalSpace.Opens.ins... | false |
Lean.Elab.Tactic.Do.SplitInfo._sizeOf_1 | Lean.Elab.Tactic.Do.VCGen.Split | [
"Lean.Meta.MatcherApp",
"Lean.Elab.Tactic.Do.SplitInfo.rec",
"Lean.Elab.Tactic.Do.SplitInfo",
"Lean.Expr",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Lean.Meta.MatcherApp._sizeOf_inst",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"OfNat.ofNat",
"Lean.Expr._sizeOf_inst"
] | false |
Lean.isLevelMVarAssignable | Lean.MetavarContext | [
"Pure.pure",
"Lean.MetavarContext.lDepth",
"Lean.LevelMVarId.name",
"instInhabitedOfMonad",
"instInhabitedBool",
"Monad.toApplicative",
"String",
"Lean.MetavarContext",
"panicWithPosWithDecl",
"Lean.MetavarContext.levelAssignDepth",
"GE.ge",
"instOfNatNat",
"instLENat",
"Applicative.toPure... | true |
_private.Lean.Compiler.InitAttr.0.Lean.isIOUnit.match_1 | Lean.Compiler.InitAttr | [
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"_private.Lean.Compiler.InitAttr.0.Lean.isIOUnit._sparseCasesOn_1",
"Option"
] | false |
Std.IterM.drain_eq_map_toListRev | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | [
"congrArg",
"Monad.toApplicative",
"Std.IteratorLoop",
"Std.Iterators.Finite",
"LawfulApplicative.toLawfulFunctor",
"Std.IterM.toListRev",
"LawfulMonad",
"Std.IterM.toListRev_eq",
"Std.Iterator",
"List",
"PUnit",
"congr",
"True",
"Std.LawfulIteratorLoop",
"eq_self",
"List.reverse",
"... | true |
_private.Batteries.Data.List.Perm.0.List.Perm.subperm_left.match_1_3 | Batteries.Data.List.Perm | [
"List.Perm",
"And.casesOn",
"List",
"And",
"Exists.casesOn",
"List.Subperm",
"And.intro",
"Exists.intro",
"List.Sublist"
] | false |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsPrimitiveRoot.subOneIntegralPowerBasisOfPrimePow._simp_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | [
"NumberField.RingOfIntegers.val",
"propext",
"NumberField.RingOfIntegers.ext_iff",
"NumberField.RingOfIntegers",
"Eq",
"Field"
] | false |
Std.TreeSet.Raw.instSliceableRioSlice | Std.Data.TreeSet.Raw.Slice | [
"Std.DTreeMap.Internal.Unit.RioSliceData.mk",
"Ord.mk",
"Ordering",
"Std.TreeMap.Raw.inner",
"autoParam",
"Std.Rio.Sliceable.mk",
"Std.TreeSet.Raw",
"Unit",
"Std.Rio",
"Std.DTreeMap.Raw.inner",
"Std.Slice.mk",
"Std.TreeSet.Raw.instSliceableRioSlice._auto_1",
"Std.Rio.Sliceable",
"Std.TreeS... | true |
Nat.uIcc_eq_range' | Mathlib.Order.Interval.Finset.Nat | [
"instDistribLatticeNat",
"Finset",
"List.range'",
"HSub.hSub",
"Nat.instLocallyFiniteOrder",
"DistribLattice.toLattice",
"instSubNat",
"instOfNatNat",
"instHAdd",
"Multiset.ofList",
"instHSub",
"HAdd.hAdd",
"Max.max",
"Nat",
"instAddNat",
"List.nodup_range'",
"Nat.instMax",
"Finset... | true |
instZeroLocallyFinsuppWithin._proof_3 | Mathlib.Topology.LocallyFinsupp | [
"Filter.instMembership",
"Eq.mpr",
"and_true",
"congrArg",
"Set.univ",
"Set.Finite",
"Membership.mem",
"Exists",
"nhds",
"id",
"Set.instInter",
"Inter.inter",
"Function.support_fun_zero",
"TopologicalSpace",
"funext",
"And",
"_private.Mathlib.Topology.LocallyFinsupp.0.instZeroLocally... | false |
Std.IterM.TerminationMeasures.Productive._sizeOf_inst | Init.Data.Iterators.Basic | [
"Std.IterM.TerminationMeasures.Productive._sizeOf_1",
"Std.Iterator",
"Std.IterM.TerminationMeasures.Productive",
"SizeOf.mk",
"SizeOf"
] | false |
CategoryTheory.Limits.pushoutRightPushoutInlIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | [
"CategoryTheory.Limits.WalkingSpan",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Limits.hasPushoutVertPaste",
"Quiver.Hom",
"CategoryTheory.Limits.pushoutRightPushoutInlIso._proof_1",
"CategoryTheory.Iso",
"CategoryTheory.Limits.PushoutCocone.inl",
"CategoryTheory.Limits.PushoutCocone.pa... | true |
AddSubmonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | [
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddSubmonoid.LocalizationMap",
"AddZeroClass.toAddZero",
"Subtype",
"AddSubmonoid",
"AddSubmonoid.LocalizationMap.toAddMonoidHom",
"AddCommMonoid",
"AddSubmonoid.LocalizationMap.map._proof_1",
"AddSubmonoid.LocalizationMap.lift",
"AddCommMonoid.toAd... | true |
Int.log_zero_left | Mathlib.Data.Int.Log | [
"Int.instAddCommGroup",
"NonAssocSemiring.toAddCommMonoidWithOne",
"DivisionCommMonoid.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"Nat.log_zero_left",
"ite_self",
"LinearOrder",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"P... | true |
RingAut.instGroup._proof_5 | Mathlib.Algebra.Ring.Aut | [
"Mul.mk",
"RingEquiv.refl",
"One.mk",
"HMul.hMul",
"Mul",
"RingAut",
"Int",
"npowRec",
"Nat.cast",
"Inv.mk",
"Nat",
"zpowRec",
"Eq.refl",
"RingEquiv.trans",
"instNatCastInt",
"Nat.succ",
"Eq",
"RingEquiv.symm",
"Add",
"instHMul"
] | false |
CategoryTheory.Functor.ShiftSequence.induced_shiftMap | Mathlib.CategoryTheory.Shift.InducedShiftSequence | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"AddMonoid.toAddSemigroup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Functor.ShiftSeque... | true |
FirstOrder.Language.ElementaryEmbedding.map_rel._simp_1 | Mathlib.ModelTheory.ElementaryMaps | [
"FirstOrder.Language.ElementaryEmbedding.map_rel",
"Function.comp",
"FirstOrder.Language.Structure.RelMap",
"FirstOrder.Language.Structure",
"FirstOrder.Language.ElementaryEmbedding.instFunLike",
"Nat",
"FirstOrder.Language.Relations",
"propext",
"FirstOrder.Language",
"Fin",
"FirstOrder.Languag... | false |
MeasureTheory.memLp_top_const | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | [
"MeasureTheory.Measure",
"SeminormedAddGroup.toNNNorm",
"PseudoMetricSpace.toUniformSpace",
"SeminormedAddGroup.toContinuousENorm",
"MeasureTheory.MemLp",
"MeasureTheory.memLp_top_const_enorm",
"MeasurableSpace",
"SeminormedAddCommGroup.toSeminormedAddGroup",
"SeminormedAddCommGroup.toPseudoMetricSp... | true |
CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"Equiv.instEquivLike",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.I₁",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.eqToIso",
"CategoryTheory.PreOneHypercover.congrIndexOneOfEqIso._proof_2",
"Equiv",
"CategoryTheory.Iso",
"CategoryTheory.PreOneHyper... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.getHSMulIntFn? | Lean.Meta.Tactic.Grind.Arith.Linear.StructId | [
"Pure.pure",
"Lean.Meta.Grind.GrindM",
"Lean.Meta.Sym.synthInstance?",
"_private.Lean.Meta.Tactic.Grind.Arith.Linear.StructId.0.Lean.Meta.Grind.Arith.Linear.mkRingInst?.match_1",
"Lean.Meta.Grind.Goal",
"StateRefT'.instAlternativeOfMonad",
"Lean.Meta.Grind.State",
"ReaderT",
"Monad.toApplicative",
... | true |
JacobsonSpace.recOn | Mathlib.Topology.JacobsonSpace | [
"JacobsonSpace",
"JacobsonSpace.mk",
"closedPoints",
"Set.instInter",
"Inter.inter",
"IsClosed",
"TopologicalSpace",
"closure",
"Eq",
"JacobsonSpace.rec",
"Set"
] | false |
OrderRingIso.toRingEquiv_eq_coe | Mathlib.Algebra.Order.Hom.Ring | [
"RingEquiv.instEquivLike",
"Mul",
"OrderRingIso",
"LE",
"RingEquiv.ext",
"OrderRingIso.toRingEquiv",
"RingEquiv",
"Eq",
"DFunLike.coe",
"Add",
"rfl",
"EquivLike.toFunLike"
] | true |
RingQuot.smul_quot | Mathlib.Algebra.RingQuot | [
"instHSMul",
"Algebra",
"Algebra.toSMul",
"RingQuot.Rel",
"RingQuot",
"CommSemiring",
"RingQuot.instSMulOfAlgebra",
"RingQuot.mk",
"Semiring",
"HSMul.hSMul",
"Eq",
"rfl",
"Quot.mk"
] | true |
CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt.hom_ext' | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Functor.LeftExtension",
"CategoryTheory.Limits.IsColimit.hom_ext",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Comma.left",
"CategoryThe... | true |
Homeomorph.sumCongr._proof_2 | Mathlib.Topology.Constructions.SumProd | [
"Continuous",
"Continuous.sumMap",
"Homeomorph.continuous",
"Homeomorph.toEquiv",
"Sum",
"id",
"instTopologicalSpaceSum",
"TopologicalSpace",
"Homeomorph.instEquivLike",
"Equiv.sumCongr",
"Homeomorph.symm",
"Homeomorph",
"DFunLike.coe",
"Equiv.invFun",
"EquivLike.toFunLike"
] | false |
Std.DTreeMap.Internal.Unit.RiiSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | [
"HEq.refl",
"Unit",
"Std.DTreeMap.Internal.Unit.RiiSliceData.noConfusionType",
"Std.DTreeMap.Internal.Unit.RiiSliceData.casesOn",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"Std.Rii",
"Eq",
"Std.DTreeMap.Internal.Unit.RiiSliceData",
"Std.DTreeMap.Internal.Impl"
] | false |
List.findIdxNth_cons_zero_of_pos | Batteries.Data.List.Lemmas | [
"_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_cons_zero_of_pos._proof_1_1",
"instOfNatNat",
"List.findIdxNth",
"List.cons",
"Bool.true",
"List",
"Nat",
"Bool",
"OfNat.ofNat",
"Eq"
] | true |
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_3 | Mathlib.Order.Filter.Bases.Finite | [
"and_left_comm",
"And",
"propext",
"Eq"
] | false |
Lean.Server.FileWorker.handleRpcRelease | Lean.Server.FileWorker | [
"Pure.pure",
"StateT.run",
"Lean.Lsp.RpcWireFormat.refFieldName",
"Unit.unit",
"Lean.Json.compress",
"Lean.Json",
"Lean.Server.FileWorker.WorkerContext.hLog",
"instMonadReaderOfReaderTOfMonad",
"instForInOfForIn'",
"IO.instMonadLiftSTRealWorldBaseIO",
"Lean.Server.rpcReleaseRef",
"ReaderT",
... | true |
Lean.JsonNumber | Lean.Data.Json.Basic | [
"Lean.JsonNumber.mk"
] | true |
IsLocalization.map_integerMultiple | Mathlib.RingTheory.Localization.Integer | [
"IsLocalization.IsInteger",
"Exists.choose_spec",
"instHSMul",
"IsLocalization",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Finset",
"IsLocalization.commonDenom",
"Algebra",
"RingHom",
"Algebra.toSMul",
"Membership.mem",
"Subtype",
"IsLocalization.integerMultiple",
"Submonoid.smul... | true |
Turing.ToPartrec.Code.rec.eq._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.4 | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.ToPartrec.Code.rec._@.Mathlib.Computability.TuringMachine.ToPartrec.3125930148._hygCtx._hyg.3",
"Turing.ToPartrec.Code.rec",
"Turing.ToPartrec.Code.succ",
"Turing.ToPartrec.Code.tail",
"Turing.ToPartrec.Code.comp",
"Turing.ToPartrec.Code.case",
"Turing.ToPartrec.Code.rec.eq._@.Mathlib.Computabil... | false |
CategoryTheory.ShortComplex.comp_liftCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex.comp_liftCycles",
"CategoryTheory.ShortComplex.comp_liftCycles._proof_1",
"CategoryTheory.ShortComplex",
"Eq.mp",
"id",
"Mat... | true |
AlgebraicGeometry.SpecMap_ΓSpecIso_inv_toSpecΓ | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | [
"Eq.mpr",
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"Lattice.toSemilatticeSup",
"Opposite",
"AlgebraicGeometry.PresheafedSpace.carrier",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompleteLattice.toLatti... | true |
Lean.Lsp.CompletionItemCapabilities.noConfusionType | Lean.Data.Lsp.Capabilities | [
"Lean.Lsp.CompletionItemCapabilities.casesOn",
"Bool",
"Eq",
"Lean.Lsp.CompletionItemCapabilities",
"Option"
] | false |
dvd_iff_exists_eq_mul_right | Mathlib.Algebra.Divisibility.Basic | [
"Semigroup",
"Semigroup.toMul",
"Dvd.dvd",
"HMul.hMul",
"dvd_def",
"semigroupDvd",
"Exists",
"Iff",
"Eq",
"instHMul"
] | true |
RelIso.preimage_apply | Mathlib.Order.RelIso.Basic | [
"Equiv.instEquivLike",
"Equiv",
"RelIso",
"RelIso.instFunLike",
"Eq",
"DFunLike.coe",
"Order.Preimage",
"rfl",
"EquivLike.toFunLike",
"RelIso.preimage"
] | true |
Lean.Parser.Command.macro._regBuiltin.Lean.Parser.Command.macro.formatter_19 | Lean.Parser.Syntax | [
"Lean.PrettyPrinter.Formatter",
"Lean.Name.mkStr5",
"IO",
"Unit",
"Lean.Parser.Command.macro.formatter",
"Lean.PrettyPrinter.formatterAttribute",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin"
] | false |
MeasureTheory.AddContent.onIocAux.eq_1 | Mathlib.MeasureTheory.Measure.AddContent | [
"Set.Ioc",
"MeasureTheory.AddContent.onIocAux",
"LinearOrder",
"PartialOrder.toPreorder",
"HSub.hSub",
"Classical.propDecidable",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"Exists",
"SemilatticeInf.toPartialOrder",
"AddCommGroup",
"DistribLattice.toLattice",
"SubtractionMonoid.toSubNegZero... | true |
CartanMatrix.F₄ | Mathlib.Data.Matrix.Cartan | [
"Equiv.instEquivLike",
"Matrix",
"Matrix.of",
"Equiv",
"Int.instNegInt",
"instOfNatNat",
"Int",
"instOfNat",
"Nat",
"Matrix.vecEmpty",
"OfNat.ofNat",
"Fin",
"DFunLike.coe",
"Matrix.vecCons",
"Neg.neg",
"EquivLike.toFunLike"
] | true |
ProbabilityTheory.measure_stieltjesOfMeasurableRat_univ | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | [
"Real.partialOrder",
"ConditionallyCompleteLinearOrder.toCompactIccSpace",
"Real",
"MeasureTheory.Measure",
"MulZeroClass.toMul",
"Set.univ",
"Rat",
"Measurable",
"PseudoMetricSpace.toUniformSpace",
"ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_univ",
"Real.semiring",
"Probab... | true |
_private.Std.Data.Iterators.Combinators.Monadic.Drop.0.Std.Iterators.Types.Drop.productiveRel_of_remaining | Std.Data.Iterators.Combinators.Monadic.Drop | [
"Std.Iterators.Types.Drop.remaining",
"Std.IterM.finitelyManySkips",
"Std.Iterators.Types.Drop.inner",
"Nat.lt_wfRel",
"WellFoundedRelation.rel",
"_private.Std.Data.Iterators.Combinators.Monadic.Drop.0.Std.Iterators.Types.Drop.ProductiveRel",
"Std.IterM.internalState",
"Std.Iterator",
"Std.Iterators... | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_10 | Init.Data.String.Pattern.String | [
"String.Slice",
"String.Slice.utf8ByteSize",
"LE.le",
"instLENat",
"Array",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"instDecidableEqNat",
"instLTNat",
"_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_5",
"Eq",
"Array.size",
"Not"
... | false |
CategoryTheory.ShortComplex.HomologyData._sizeOf_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ShortComplex.LeftHomologyData",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ShortComplex.RightHomologyData",
"CategoryTheory.ShortComplex",
"instSizeOfDefault",
"CategoryTheory.Iso._sizeOf_inst",
"CategoryTheory.Sh... | false |
Std.DTreeMap.Internal.Impl.Const.getD_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.Lemmas | [
"Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit!",
"Unit.unit",
"Ord",
"instForInOfForIn'",
"Std.DTreeMap.Internal.Impl.Const.getD",
"inferInstance",
"Id",
"Membership",
"List",
"Unit",
"List.instMembership",
"Id.instMonad",
"Subtype.val",
"Eq",
"Std.DTreeMap.Internal.Impl",
"rfl... | true |
_private.Lean.Elab.Command.0.Lean.Elab.Command.mkTermContext | Lean.Elab.Command | [
"Pure.pure",
"Lean.NameMap",
"Subarray",
"Lean.Elab.Term.Context.mk",
"instForInOfForIn'",
"Lean.Elab.Command.Scope.isMeta",
"Lean.Elab.Command.Context.macroStack",
"Lean.Elab.AutoBoundImplicitContext",
"Lean.Elab.Command.State.scopes",
"Std.Stream.next?",
"List.head!",
"Array.instMembership",... | true |
_private.Mathlib.Data.Finset.PImage.0.Finset.pimage_inter._simp_1_2 | Mathlib.Data.Finset.PImage | [
"PFun",
"PFun.image",
"HasSubset.Subset",
"PFun.image_inter",
"Set.instInter",
"Inter.inter",
"True",
"eq_true",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
WithBot.bot_ne_natCast | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | [
"WithBot",
"AddMonoidWithOne.toNatCast",
"Ne",
"Bot.bot",
"Nat.cast",
"WithBot.natCast",
"Nat",
"WithBot.bot_ne_coe",
"WithBot.bot",
"AddMonoidWithOne"
] | true |
StarSubalgebra.inclusion._proof_5 | Mathlib.Algebra.Star.Subalgebra | [
"Subtype.map",
"Algebra.algebraMap",
"StarSubalgebra.instPartialOrder",
"CommSemiring.toSemiring",
"StarSubalgebra.subsemiringClass",
"PartialOrder.toPreorder",
"Algebra",
"Preorder.toLE",
"RingHom",
"Algebra.toSMul",
"Membership.mem",
"id",
"Subtype",
"StarSubalgebra",
"StarSubalgebra.s... | false |
CategoryTheory.Limits.pullbackLeftPullbackSndIso_inv_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | [
"CategoryTheory.Limits.hasPullbackVertPaste",
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.pullback",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Limits.pullback.snd",
"CategoryTheory.Limits.pullbackLeftPullbackSndIso",
"CategoryTheory.Limits.pullba... | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.coe_subset_singleton._proof_1_1 | Mathlib.Data.Finset.Insert | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"Finset.mem_singleton",
"False",
"Lean.Grind.not_not",
"eq_false",
"Lean.Grind.iff_eq",
"Set.subset_def",
"congrArg",
"Finset",
"Classical.byContradiction",
"Lean.Grind.eq_false_of_imp_eq_true",
"Membership.mem",
"Exists",
... | false |
Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'._proof_14 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | [
"UniformSpace.comp",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PiNat.dist_triangle",
"Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'._aux_11",
"LE.le",
"SetRel.comp",
"Stream'",
"Filter.lift'",
"UniformSpace.ofDist",
"Nat",
"Dist.dist",
"Prod",
"PiNat.dist_self",
"PiNat.dist",
... | false |
Lean.Elab.Tactic.Do.ProofMode.MGoal.mk._flat_ctor | Lean.Elab.Tactic.Do.ProofMode.MGoal | [
"Lean.Elab.Tactic.Do.ProofMode.MGoal.mk",
"Lean.Expr",
"Lean.Level",
"Lean.Elab.Tactic.Do.ProofMode.MGoal"
] | false |
List.mapTR.loop.eq_2 | Init.Data.List.Basic | [
"List.mapTR.loop",
"List.cons",
"List",
"Eq.refl",
"Eq"
] | true |
LinearEquiv.toFGModuleCatIso._proof_1 | Mathlib.Algebra.Category.FGModuleCat.Basic | [
"LinearEquiv.symm",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"LinearMap.ext",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"ModuleCat.isFG",
"LinearEquiv.left_inv",
"CategoryTheory.CategoryStruct.id",
"AddCommGroup",
"CategoryTheory.ObjectProperty.FullSu... | false |
Std.DTreeMap.Internal.Impl.forInStep_eq_foldlM | Std.Data.DTreeMap.Internal.WF.Lemmas | [
"Pure.pure",
"Eq.mpr",
"Std.DTreeMap.Internal.Impl.forInStep_eq_foldlM.match_1",
"congrArg",
"Monad.toApplicative",
"Std.DTreeMap.Internal.Impl.rec",
"ForInStep.done",
"Eq.rec",
"Std.DTreeMap.Internal.Impl.inner",
"id",
"LawfulMonad",
"Std.DTreeMap.Internal.Impl.forInStep.match_1",
"Applicat... | true |
CategoryTheory.AddMon.instCartesianMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | [
"CategoryTheory.AddMon.Hom.ext'",
"CategoryTheory.Limits.BinaryFan.fst",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.AddMon.instCategory",
"CategoryTheory.AddMon.monMonoidal",
"CategoryTheory.AddMon.Hom.mk",
"CategoryTheory.SemiCartesianMonoidalCategory.snd",
... | false |
CommGroup.primaryComponent._proof_1 | Mathlib.GroupTheory.Torsion | [
"MulOne.toOne",
"CommGroup.primaryComponent._proof_3",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"Nat.instMonoid",
"Submonoid.toSubsemigroup",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"MulOne.toMul",
"CommGroup",
"Monoid.toPow",
"MulOneCl... | false |
Finsupp.embDomain_apply | Mathlib.Data.Finsupp.Defs | [
"Finsupp.instFunLike",
"Eq.mpr",
"dite_congr",
"congrArg",
"Finset",
"Finset.choose",
"Finsupp.mem_support_iff._simp_1",
"Classical.propDecidable",
"Finsupp.embDomain._proof_4",
"Finsupp.support",
"Finset.map",
"Membership.mem",
"Exists",
"dif_pos",
"Finsupp.mk",
"Finsupp.embDomain._pr... | true |
Mathlib.Meta.NormNum.isFibAux_two_mul_add_one_done | Mathlib.Tactic.NormNum.NatFib | [
"HMul.hMul",
"Mathlib.Meta.NormNum.isFibAux_two_mul_add_one",
"instMulNat",
"instOfNatNat",
"instHAdd",
"And.left",
"HAdd.hAdd",
"Nat.fib",
"Nat",
"Mathlib.Meta.NormNum.IsFibAux",
"instAddNat",
"OfNat.ofNat",
"Eq",
"rfl",
"instHMul"
] | true |
_private.Mathlib.Probability.UniformOn.0.ProbabilityTheory.uniformOn_pi._simp_1_1 | Mathlib.Probability.UniformOn | [
"Finite",
"Set.Finite",
"Set.Elem",
"Set.toFinite",
"True",
"eq_true",
"Eq",
"Set"
] | false |
Denumerable.sum._proof_3 | Mathlib.Logic.Denumerable | [
"Nat.bit",
"Eq.mpr",
"False",
"HMul.hMul",
"Sum.ctorIdx",
"Sum.exists._simp_1",
"Encodable.decodeSum.match_1",
"congrArg",
"Sum.inr.injEq",
"Option.instMembership",
"Encodable.decodeSum",
"exists_const._simp_1",
"False.elim",
"false_and",
"noConfusion_of_Nat",
"Nat.bit_bodd_div2",
"O... | false |
_private.Init.Data.Array.Sort.Basic.0.Array.MergeSort.Internal.merge.go._unsafe_rec | Init.Data.Array.Sort.Basic | [
"Eq.mpr",
"Subarray",
"Array.push",
"congrArg",
"_private.Init.Data.Array.Sort.Basic.0.Array.MergeSort.Internal.merge.go._unsafe_rec",
"HSub.hSub",
"_private.Init.Data.Array.Sort.Basic.0.Array.MergeSort.Internal.merge._proof_1",
"id",
"instDecidableEqBool",
"instSubNat",
"instOfNatNat",
"Subar... | false |
Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder | Aesop.Script.Step | [
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"Aesop.Script.TacticBuilder",
"Lean.MessageData",
"Subarray",
"Lean.Meta.SavedState",
"Aesop.Script.LazyStep.tacticBuilders",
"Lean.instMonadAlwaysExceptStateRefT'",
"Lean.instExceptToTraceResult",
"Lean.Core.instMonadLiftIOCoreM",
"ReaderT",
"Stri... | true |
Finset.sum_powerset | Mathlib.Algebra.BigOperators.Group.Finset.Powerset | [
"Eq.mpr",
"congrArg",
"Finset",
"Disjoint",
"id",
"Finset.disjiUnion",
"instOfNatNat",
"Finset.partialOrder",
"AddCommMonoid",
"Finset.range",
"instHAdd",
"SetLike.coe",
"Finset.instSetLike",
"HAdd.hAdd",
"Finset.powersetCard",
"Nat",
"Finset.card",
"instAddNat",
"Finset.powerset... | true |
tendstoUniformlyOn_tsum_nat | Mathlib.Analysis.Normed.Group.FunctionSeries | [
"Filter.instMembership",
"Norm.norm",
"Real.instLE",
"Real",
"CompleteSpace",
"AddCommGroup.toAddCommMonoid",
"Finset",
"uniformity",
"PartialOrder.toPreorder",
"PseudoMetricSpace.toUniformSpace",
"Membership.mem",
"tendstoUniformlyOn_tsum",
"Prod.mk",
"Finset.partialOrder",
"LE.le",
"... | true |
Filter.Germ.compTendsto'._proof_1 | Mathlib.Order.Filter.Germ.Basic | [
"Iff.mpr",
"Filter.Germ.ofFun",
"Filter.Germ.Tendsto",
"Function.comp",
"Filter.EventuallyEq",
"Filter.Germ.coe_eq",
"Filter.Germ.inductionOn",
"Filter.Germ",
"Filter.Tendsto.eventually",
"Filter.Germ.map",
"Eq",
"Filter"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.