name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_6 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | [
"Eq.mpr",
"CategoryTheory.Bicategory.InducedBicategory.categoryStruct",
"CategoryTheory.Bicategory.InducedBicategory.mkHom₂",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Bicategory.InducedBicategory.Hom₂.hom",
"_private.Mathlib.CategoryTheory.Bicategory.InducedB... | false |
ContDiffPointwiseHolderAt.mk._flat_ctor | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | [
"ContDiffAt",
"Norm.norm",
"Real.instPow",
"Real",
"ContDiffPointwiseHolderAt",
"NormedSpace",
"ContinuousMultilinearMap.instSub",
"ENat.instNatCast",
"Real.denselyNormedField",
"NormedSpace.toModule",
"ContinuousMultilinearMap.hasOpNorm'",
"Asymptotics.IsBigO",
"HSub.hSub",
"PseudoMetricS... | false |
Stream'.Seq.BisimO.eq_1 | Mathlib.Data.Seq.Defs | [
"Stream'.Seq",
"Option.none",
"True",
"Stream'.Seq1",
"Eq.refl",
"Stream'.Seq.BisimO",
"Eq"
] | true |
FirstOrder.Language.Ultraproduct.term_realize_cast | Mathlib.ModelTheory.Ultraproducts | [
"Eq.mpr",
"congrArg",
"HEq.refl",
"FirstOrder.Language.Term",
"Eq.casesOn",
"id",
"Setoid",
"FirstOrder.Language.Term.func",
"Quotient.mk",
"FirstOrder.Language.Term.rec",
"funext",
"FirstOrder.Language.Structure",
"FirstOrder.Language.Term.realize_quotient_mk'",
"Quotient",
"FirstOrder.... | true |
Num.lt_to_nat | Mathlib.Data.Num.Lemmas | [
"Ordering.gt",
"False",
"Nat.instMulZeroClass",
"Preorder.toLT",
"eq_false",
"Nat.instOne",
"Num.cmp",
"congrArg",
"False.elim",
"noConfusion_of_Nat",
"lt_self_iff_false._simp_1",
"Ordering",
"Ordering.eq",
"iff_self",
"castNum",
"Num",
"Iff",
"Nat.instPreorder",
"Ordering.lt",
... | true |
Turing.PartrecToTM2.trNat_default | Mathlib.Computability.TuringMachine.ToPartrec | [
"Inhabited.default",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.trNat_zero",
"instInhabitedNat",
"List",
"Nat",
"Eq",
"Turing.PartrecToTM2.trNat",
"List.nil"
] | true |
Lean.Meta.Simp.NormCastConfig.decide._inherited_default | Init.MetaTypes | [
"id",
"Bool",
"Bool.false"
] | false |
LinearMap.toContinuousBilinearMap_apply | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | [
"LinearMap.toContinuousBilinearMap",
"NormedCommRing.toSeminormedCommRing",
"CompleteSpace",
"ContinuousSMul",
"ContinuousLinearMap.topologicalSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike... | true |
List.countP.go._unsafe_rec | Init.Data.List.Basic | [
"cond",
"List.findIdx.go.match_1",
"instOfNatNat",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List.countP.go._unsafe_rec",
"Bool",
"instAddNat",
"OfNat.ofNat"
] | false |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.match_1.splitter | Init.Data.String.Slice | [
"String.Slice.Pattern.SearchStep",
"String.Slice",
"String.Slice.SplitIterator.operating",
"String.Slice.Pattern.ToForwardSearcher",
"_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.match_1",
"String.Slice.SplitIterator",
"Unit",
"Std.Iter",
"String.Slice.Pos",
"String.Slice.... | true |
CategoryTheory.ShortComplex.SnakeInput.naturality_φ₁ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Category.assoc",
"CategoryTheory.ShortComplex.SnakeInput.L₂",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ShortComplex.Hom.comm₁₂",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex.Hom.τ₁",
"CategoryTheory.ShortComplex.Snake... | true |
CategoryTheory.Limits.Types.Small.limitConeIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Types.Limits | [
"CategoryTheory.Limits.Types.Small.limitCone_pt_ext",
"Eq.mpr",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cone",
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCone",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Equiv... | false |
CategoryTheory.CartesianMonoidalCategory.associator_inv_fst_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Limits.IsTerminal.from",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalCategoryStruct.rightUnitor",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoid... | true |
Prod.continuousConstSMul | Mathlib.Topology.Algebra.ConstMulAction | [
"instHSMul",
"SMul",
"Prod.instSMul",
"instTopologicalSpaceProd",
"continuous_snd",
"continuous_fst",
"ContinuousConstSMul",
"ContinuousConstSMul.mk",
"Prod.fst",
"TopologicalSpace",
"HSMul.hSMul",
"Prod",
"Continuous.const_smul",
"Prod.snd",
"Continuous.prodMk"
] | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Take.0.Std.Iter.step_take.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Take | [
"Std.IterStep",
"Std.IterStep.skip",
"Id",
"Std.Iterator",
"Subtype.mk",
"Std.Iter.step_take.match_1",
"Std.Iter",
"Std.IterStep.yield",
"Std.Iter.IsPlausibleStep",
"Std.IterStep.done",
"Eq.refl",
"Eq",
"Std.Iter.Step"
] | true |
instMinISize | Init.Data.SInt.Basic | [
"instLEISize",
"minOfLe",
"Min",
"ISize.decLe",
"ISize"
] | true |
Std.ExtTreeMap.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.ExtTreeMap.Lemmas | [
"Std.ExtDTreeMap.Const.getKeyD_insertManyIfNewUnit_list_of_mem",
"instForInOfForIn'",
"Membership.mem",
"Ordering",
"inferInstance",
"Std.TransCmp",
"Id",
"Membership",
"List",
"Unit",
"Std.ExtTreeMap",
"List.instMembership",
"Std.ExtTreeMap.getKeyD",
"Std.ExtTreeMap.inner",
"Id.instMona... | true |
ampleSet_empty._simp_1 | Mathlib.Analysis.Convex.AmpleSet | [
"Real",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup",
"Real.semiring",
"TopologicalSpace",
"True",
"eq_true",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Module",
"Eq",
"ampleSet_empty",
"AmpleSet",
"Set"
] | false |
SchauderBasis.RankOneDecomposition.mk.noConfusion | Mathlib.Analysis.Normed.Module.Bases | [
"Submodule",
"RingHomSurjective.ids",
"SchauderBasis.succSub",
"NormedSpace",
"HEq.refl",
"ContinuousLinearMap.funLike",
"Submodule.addCommMonoid",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"Membership.mem",
"NormedField.toField",
"nhds",
"LinearMap.range",
"SchauderBasis... | false |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.HasSum.exists_hasSum_smul_of_apply_eq_zero._simp_1_7 | Mathlib.Analysis.Analytic.IsolatedZeros | [
"False",
"eq_false",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"CharZero",
"Nat.cast_add_one_ne_zero",
"AddMonoidWithOne.toOne",
"AddZero.toZero",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"On... | false |
Lean.Meta.ApplyNewGoals.toCtorIdx | Init.Meta.Defs | [
"Lean.Meta.ApplyNewGoals.ctorIdx",
"Lean.Meta.ApplyNewGoals",
"Nat"
] | false |
contDiffAt_infty | Mathlib.Analysis.Calculus.ContDiff.Defs | [
"ContDiffAt",
"NormedSpace",
"ENat.instNatCast",
"instTopENat",
"congrArg",
"Set.univ",
"Nat.cast",
"WithTop.some",
"iff_self",
"Iff",
"_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffAt_infty._simp_1_1",
"Nat",
"ENat",
"congr",
"True",
"WithTop.natCast",
"of_eq_true",
"... | true |
Int.abs_eq_normalize | Mathlib.Algebra.GCDMonoid.Nat | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"abs",
"Int.normalize_of_nonneg",
"congrArg",
"Int.instLinearOrder",
"PartialOrder.toPreorder",
"MonoidWithZeroHom.funLike",
"Preorder.toLE",
"CommSemiring.toCommMonoidWithZero",
"Int.instNegInt",
"SubtractionMonoid.toSubNegZeroMonoid",
"... | true |
Set.mk_preimage_sym2 | Mathlib.Data.Sym.Sym2 | [
"Set.instSProd",
"Sym2.mk",
"SProd.sprod",
"Set.sym2",
"Set.preimage",
"Function.uncurry",
"Prod",
"Eq",
"Sym2",
"rfl",
"Set"
] | true |
Set.mapsTo_image_iff._simp_1 | Mathlib.Data.Set.Function | [
"Function.comp",
"Set.MapsTo",
"Set.mapsTo_image_iff",
"propext",
"Set.image",
"Eq",
"Set"
] | false |
exists_eq'._simp_1 | Init.PropLemmas | [
"Exists",
"exists_eq'",
"True",
"eq_true",
"Eq"
] | false |
String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec | Init.Data.String.Lemmas.Pattern.Basic | [
"String.Slice.Pattern.Model.NoPrefixForwardPatternModel",
"String.Slice.Pattern.Model.ForwardPatternModel",
"String",
"instAppendString",
"instHAppendOfAppend",
"String.Slice.Pattern.Model.ForwardPatternModel.Matches",
"String.Slice.Pattern.Model.NoPrefixForwardPatternModel.mk",
"Eq",
"HAppend.hAppe... | false |
WeierstrassCurve.ctorIdx | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | [
"WeierstrassCurve",
"Nat"
] | false |
Subtype.restrict_injective | Mathlib.Data.Subtype | [
"Subtype",
"Subtype.coe_injective",
"Subtype.restrict",
"Function.Injective.comp",
"Function.Injective",
"Subtype.val"
] | true |
Subsemigroup.unop_le_unop_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | [
"Function.Surjective.forall",
"MulOpposite",
"PartialOrder.toPreorder",
"Subsemigroup.instPartialOrder",
"Preorder.toLE",
"Mul",
"Membership.mem",
"LE.le",
"Iff",
"Subsemigroup.unop",
"Subsemigroup",
"MulOpposite.unop",
"MulOpposite.unop_surjective",
"Subsemigroup.instSetLike",
"SetLike.... | true |
Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?_fst | Std.Data.DHashMap.Internal.RawLemmas | [
"Eq.mpr",
"Std.DHashMap.Internal.Raw₀.get?",
"congrArg",
"Std.DHashMap.Internal.Raw₀.get?ₘ",
"LawfulBEq",
"id",
"Prod.fst",
"Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?",
"Eq.refl",
"Hashable",
"Std.DHashMap.Internal.Raw₀.get?_eq_get?ₘ",
"Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?_eq_ge... | true |
Lean.Elab.CommandContextInfo.mk._flat_ctor | Lean.Elab.InfoTree.Types | [
"Lean.Elab.CommandContextInfo",
"Lean.MetavarContext",
"Lean.FileMap",
"List",
"Lean.Name",
"Lean.Elab.CommandContextInfo.mk",
"Lean.Options",
"Lean.Environment",
"Lean.NameGenerator",
"Lean.OpenDecl",
"Option"
] | false |
Std.DHashMap.Equiv.isEmpty_eq | Std.Data.DHashMap.Lemmas | [
"Std.DHashMap.Equiv",
"Std.DHashMap.Raw",
"Std.DHashMap.wf",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"LawfulHashable",
"Subtype.mk",
"EquivBEq",
"Std.DHashMap.inner",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Bool",
"Std.DHashMap.Equiv.inner",
"Std.DHashMap.Internal.As... | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₁Toδ₀'._proof_1_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | [
"Int.Linear.eq_of_core",
"Lean.RArray.leaf",
"False",
"HMul.hMul",
"congrArg",
"Int.Linear.eq_norm",
"Classical.byContradiction",
"Eq.mp",
"Lean.RArray.branch",
"Int.Linear.Expr.add",
"id",
"Lean.RArray",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Int.Linear.Poly.num",
"ComplexShape",... | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.IsSwap.of_subtype_isSwap.match_1_1 | Mathlib.GroupTheory.Perm.Support | [
"Equiv.swap",
"Equiv.Perm.IsSwap",
"Subtype.casesOn",
"Exists",
"Subtype",
"Ne",
"Subtype.mk",
"And",
"Exists.casesOn",
"Equiv.Perm",
"Exists.intro",
"Eq",
"Subtype.instDecidableEq",
"DecidableEq"
] | false |
Batteries.RBNode.ins._sunfold | Batteries.Data.RBMap.Basic | [
"Batteries.RBNode.ins.match_3",
"Batteries.RBNode",
"Batteries.RBNode.ins",
"Batteries.RBNode.balance2",
"Ordering",
"Batteries.RBNode.nil",
"Unit",
"Batteries.RBColor.red",
"Batteries.RBColor.black",
"Batteries.RBNode.ins.match_1",
"Batteries.RBNode.node",
"Batteries.RBNode.balance1"
] | false |
ContinuousMap.Homotopy.pi._proof_1 | Mathlib.Topology.Homotopy.Basic | [
"Real",
"ContinuousMap",
"PseudoMetricSpace.toUniformSpace",
"instTopologicalSpaceProd",
"Membership.mem",
"ContinuousMap.HomotopyLike.toContinuousMapClass",
"ContinuousMapClass",
"Set.Elem",
"ContinuousMap.Homotopy.instHomotopyLike",
"TopologicalSpace",
"ContinuousMap.Homotopy.instFunLike",
"... | false |
_private.Mathlib.NumberTheory.FrobeniusNumber.0.Nat.exists_mem_span_nat_finset_of_ge.match_1_3 | Mathlib.NumberTheory.FrobeniusNumber | [
"Membership.mem",
"Exists",
"Ne",
"instOfNatNat",
"And.casesOn",
"And",
"Exists.casesOn",
"Nat",
"And.intro",
"Exists.intro",
"OfNat.ofNat",
"Set.instMembership",
"Set"
] | false |
Nat.cast_finprod_mem | Mathlib.Algebra.BigOperators.Finprod | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"CommSemiring.toSemiring",
"Set.Finite",
"Membership.mem",
"MonoidHom.map_finprod_mem",
"AddMonoidWithOne.toNatCast",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Nat.cast",
"Nat.instNonAssocSemiring",
"CommSemiring",
"finprod",
"Nat",
"CommSemiring.... | true |
upperClosure_eq_bot | Mathlib.Order.UpperLower.Closure | [
"le_bot_iff",
"And.imp",
"OrderDual.toDual",
"Exists.choose_spec",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"Equiv.instEquivLike",
"UpperSet",
"UpperSet.instSetLike",
"LinearOrder",
"OrderBot.toBot",
"upperClosure",
"PartialOrder.toPreorder",
"UpperSet.completelyDistribLattice",
"le_... | true |
Lean.Doc.instFromDocArgNat | Lean.Elab.DocString | [
"Lean.Doc.instFromDocArgNat._private_1",
"Lean.Doc.DocArg",
"Nat",
"Lean.Doc.FromDocArg.mk",
"Lean.Doc.FromDocArg"
] | true |
String.Pos.mk.sizeOf_spec | Init.Data.String.Defs | [
"String",
"String.Pos.Raw._sizeOf_inst",
"instSizeOfDefault",
"String.Pos.mk",
"instOfNatNat",
"String.Pos.Raw",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"String.Pos",
"instAddNat",
"Eq.refl",
"OfNat.ofNat",
"String.Pos.Raw.IsValid",
"Eq",
"String.Pos._sizeOf_inst"
] | true |
Int64.ne_iff_toBitVec_ne | Init.Data.SInt.Lemmas | [
"Iff.mpr",
"BitVec",
"Decidable.not_iff_not",
"Int64",
"Ne",
"instOfNatNat",
"instDecidableEqBitVec",
"Iff",
"Nat",
"instDecidableEqInt64",
"Int64.toBitVec",
"Int64.eq_iff_toBitVec_eq",
"OfNat.ofNat",
"Eq",
"Not"
] | true |
NumberField.discr_mem_differentIdeal | Mathlib.NumberTheory.NumberField.Discriminant.Different | [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"NegZeroClass.toNeg",
"Nat.instMulZeroOneClass",
"Int.cast_natCast",
"IsIntegralClosure",
"IsDedekindDomain.toIsDomain",
"neg_mem_iff",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNo... | true |
CategoryTheory.MonoidalOpposite.noConfusionType | Mathlib.CategoryTheory.Monoidal.Opposite | [
"CategoryTheory.MonoidalOpposite",
"HEq",
"CategoryTheory.MonoidalOpposite.casesOn"
] | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go | Init.Data.Nat.Power2.Basic | [
"_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._unary",
"instOfNatNat",
"GT.gt",
"Nat",
"PSigma.mk",
"instLTNat",
"OfNat.ofNat"
] | true |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_8 | Mathlib.MeasureTheory.Measure.AddContent | [
"Set.Ioc",
"False",
"Preorder.toLT",
"eq_false",
"Lean.Grind.iff_eq",
"LinearOrder",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"Lean.Grind.Order.eq_of_le_of_le",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Eq.mp",
"DistribLattice.toLattice",
"id",
... | false |
LieModule.genWeightSpace_neg_zsmul_add_ne_bot | Mathlib.Algebra.Lie.Weights.Chain | [
"IsDomain",
"CommRing",
"instHSMul",
"LieModule.Weight.instFunLike",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"LieSubmodule.instBot",
"_private.Mathlib.Algebra.Lie.Weights.Chain.0.LieModule.genWeightSpace_neg_zsmul_add_ne_bot._proof_1_2",
"AddGroupWithOne.toAd... | true |
Int.ediv_mul_add_emod | Init.Data.Int.DivMod.Bootstrap | [
"Eq.mpr",
"Int.instDiv",
"instHDiv",
"HMul.hMul",
"congrArg",
"Int.mul_ediv_add_emod",
"id",
"HDiv.hDiv",
"instHMod",
"Int",
"Int.instMul",
"instHAdd",
"HMod.hMod",
"HAdd.hAdd",
"Int.instAdd",
"Int.instMod",
"Int.mul_comm",
"Eq",
"instHMul"
] | true |
String.Pos.offset_add_slice | Init.Data.String.Basic | [
"Eq.mpr",
"congrArg",
"String",
"_private.Init.Data.String.Basic.0.String.Pos.offset_add_slice._proof_1_2",
"HSub.hSub",
"String.Slice",
"Eq.mp",
"_private.Init.Data.String.Basic.0.String.Slice.Pos.ofStr._simp_1",
"id",
"instSubNat",
"String.Slice.utf8ByteSize",
"LE.le",
"instLENat",
"Stri... | true |
Nat.max_left_comm | Init.Data.Nat.Lemmas | [
"Eq.mpr",
"Nat.max_comm",
"congrArg",
"id",
"Nat.max_assoc",
"Max.max",
"Nat",
"Eq.refl",
"Nat.instMax",
"Eq.symm",
"Eq"
] | true |
Affine.Simplex.height.eq_1 | Mathlib.Geometry.Euclidean.Altitude | [
"InnerProductSpace.toNormedSpace",
"Affine.Simplex.points",
"Affine.Simplex.height",
"Nat.instMulZeroClass",
"Real",
"Real.instRCLike",
"NormedSpace.toModule",
"Affine.Simplex",
"Real.instRing",
"instOfNatNat",
"instHAdd",
"NormedAddTorsor.toAddTorsor",
"MetricSpace",
"HAdd.hAdd",
"Affin... | true |
Aesop.VariableMap.addHyp | Aesop.Forward.State | [
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"Aesop.BaseM",
"Lean.MessageData",
"instInhabitedProd",
"Aesop.InstMap",
"Aesop.instBEqPremiseIndex",
"_private.Aesop.Forward.State.0.Aesop.VariableMap.addHyp.match_1",
"Lean.instMonadAlwaysExceptStateRefT'",
"Lean.instExceptToTraceResult",
"StateRef... | true |
Lean.Elab.Tactic.BVDecide.Frontend.BVCheck.mkContext | Lean.Elab.Tactic.BVDecide.Frontend.BVCheck | [
"Lean.Elab.Tactic.BVDecide.Frontend.BVCheck.getSrcDir",
"instHDiv",
"Lean.Elab.Term.instMonadTermElabM",
"HDiv.hDiv",
"Lean.Elab.Tactic.BVDecide.Frontend.TacticContext",
"Lean.Elab.Term.TermElabM",
"Lean.Elab.Tactic.BVDecide.Frontend.TacticContext.new",
"Monad.toBind",
"Bind.bind",
"System.FilePat... | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.process.processAppDefault._unsafe_rec | Lean.Meta.Sym.Pattern | [
"Pure.pure",
"Lean.Expr.isApp",
"Lean.Meta.Sym.Context",
"ReaderT.instMonad",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Applicative.toPure",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM",
"Lean.Meta.Sym.SymM",
"Bool.true",
"_private.Lean.Meta.Sym.Patte... | false |
Diffeomorph.prodAssoc._proof_1 | Mathlib.Geometry.Manifold.Diffeomorph | [
"ContMDiff.comp",
"Prod.normedSpace",
"Prod.normedAddCommGroup",
"NormedSpace",
"ContMDiff",
"instTopologicalSpaceProd",
"Function.comp",
"contMDiff_snd",
"instTopologicalSpaceModelProd",
"Prod.mk",
"Prod.fst",
"TopologicalSpace",
"ModelWithCorners",
"ENat",
"NontriviallyNormedField",
... | false |
Lean.ImportArtifacts.casesOn | Lean.Setup | [
"Lean.ImportArtifacts.rec",
"Array",
"Lean.ImportArtifacts.ofArray",
"Lean.ImportArtifacts",
"System.FilePath"
] | false |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | [
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.mk.noConfusion",
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.mk",
"Std.Sat.AIG.Ref",
"And",
"Std.Sat.AIG",
"And.intro",
"eq_of_heq",
"Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput",
"HEq",
"Hashable",
"Eq",
"DecidableEq"
] | true |
LipschitzWith.edist_lt_top | Mathlib.Topology.EMetricSpace.Lipschitz | [
"ENNReal.ofNNReal",
"Preorder.toLT",
"LipschitzWith",
"HMul.hMul",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"NNReal",
"Ne",
"ENNReal.instCommSemiring",
"PseudoEMetricSpace",
"ENNReal.mul_ne_top",
"PseudoEMetricSpace.toEDist",
"Distrib.toMul",
"Ne.lt_top",
"NonAssocSemiring.t... | true |
CategoryTheory.ProjectiveResolution.noConfusion | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | [
"CategoryTheory.Limits.HasZeroMorphisms",
"ChainComplex",
"HomologicalComplex.instCategory",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ProjectiveResolution.quasiIso._autoParam",
"HEq.refl",
"CategoryTheory.ProjectiveResolution.noConfusionType",
"Homolog... | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.zeroThm? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | [
"Lean.Meta.Grind.Arith.Cutsat.ToIntInfo",
"Lean.Expr",
"Option"
] | true |
_private.Mathlib.Data.PFun.0.PFun.fix.match_1.eq_2 | Mathlib.Data.PFun | [
"Sum",
"Sum.inl",
"PFun.fix.match_1",
"Sum.inr",
"Eq.refl",
"Eq"
] | true |
CategoryTheory.MonoidalClosed.uncurry_pre_app_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | [
"CategoryTheory.Category.assoc",
"CategoryTheory.MonoidalClosed.uncurry",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MonoidalClosed.uncurry_pre_app",
"CategoryTheory.MonoidalCategory",
"Eq.mp",
"CategoryTheory.MonoidalClosed.pre",
"id",
"Mathlib.Tactic.Re... | true |
WeierstrassCurve.Affine.Point.toProjective | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | [
"Nontrivial",
"WeierstrassCurve.Projective.Point",
"CommRing",
"WeierstrassCurve.toProjective",
"WeierstrassCurve.Affine",
"WeierstrassCurve.Affine.Point",
"WeierstrassCurve.Projective.Point.fromAffine"
] | true |
List.erase_eq_eraseTR | Init.Data.List.Impl | [
"cond",
"Eq.mpr",
"List.eraseTR",
"Array.toList_push",
"Array.toListAppend_eq",
"List.append_assoc",
"Array.push",
"congrArg",
"List.filter.match_1",
"_private.Init.Data.List.Impl.0.List.eraseTR.go",
"id",
"List.rec",
"List.append_nil",
"Array.toList",
"List.toArray",
"List.cons",
"A... | true |
Algebra.intTraceAux._proof_4 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | [
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"Algebra",
"Algebra.toSMul",
"AddZeroClass.toAddZer... | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.instReprStructFieldDefault.repr.match_1 | Lean.Elab.Structure | [
"Lean.Elab.Command.Structure.StructFieldDefault.autoParam",
"Lean.Elab.Command.Structure.StructFieldDefault.casesOn",
"Lean.Expr",
"Lean.Elab.Command.Structure.StructFieldDefault.optParam",
"Lean.Elab.Command.Structure.StructFieldDefault"
] | false |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_11 | Mathlib.RingTheory.WittVector.Isocrystal | [
"OreLocalization.instAddMonoid._proof_2",
"CommRing",
"WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8",
"Nat.Prime",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"WittVector.instCommRing",
"CommSemiring.toSemiring",
"OreLocalizat... | false |
Lean.Grind.instCommRingInt64._proof_3 | Init.GrindInstances.Ring.SInt | [
"Int.cast",
"instHSMul",
"HMul.hMul",
"congrArg",
"Int64.neg_mul",
"id",
"Int.instNegInt",
"Int64",
"Int64.instNeg",
"SMul.mk",
"Int",
"Lean.Grind.Int64.intCast_neg",
"True",
"eq_self",
"Lean.Grind.Int64.intCast",
"of_eq_true",
"HSMul.hSMul",
"congrFun'",
"Eq",
"instMulInt64",
... | false |
ComplexShape.rel_π₁ | Mathlib.Algebra.Homology.ComplexShapeSigns | [
"TotalComplexShape.rel₁",
"Prod.mk",
"ComplexShape",
"ComplexShape.π",
"TotalComplexShape",
"ComplexShape.Rel"
] | true |
Submonoid.coe_pos | Mathlib.Algebra.Order.GroupWithZero.Submonoid | [
"MulOne.toOne",
"Set.Ioi",
"MulZeroClass.toMul",
"PartialOrder.toPreorder",
"Submonoid.pos",
"Preorder.toLE",
"PartialOrder",
"ZeroLEOneClass",
"MulZeroOneClass",
"MulZeroOneClass.toMulOneClass",
"MulOneClass.toMulOne",
"SetLike.coe",
"PosMulStrictMono",
"One.toOfNat1",
"Zero.toOfNat0",
... | true |
Aesop.UnorderedArraySet.empty | Aesop.Util.UnorderedArraySet | [
"_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk",
"List.toArray",
"Aesop.UnorderedArraySet",
"BEq",
"List.nil"
] | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.visitNamespace._sunfold | Lean.Elab.DeclNameGen | [
"Pure.pure",
"Lean.instMonadEnvOfMonadLift",
"Unit.unit",
"StateRefT'.instAlternativeOfMonad",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"modify",
"Lean.Expr.instBEq",
"String",
"Lean.Meta.State",
"Lean.Expr.const",
"instMonadLiftT",
"IO",
"StateRefT'.instMonad... | false |
Nat.Primrec | Mathlib.Computability.Primrec.Basic | [
"Nat.Primrec.left",
"Nat.Primrec.prec",
"Nat.Primrec.succ",
"Nat.Primrec.comp",
"Nat.Primrec.zero",
"Nat.Primrec.right",
"Nat",
"Nat.Primrec.pair"
] | true |
ConvexOn.secant_mono_aux1 | Mathlib.Analysis.Convex.Slope | [
"Mathlib.Tactic.FieldSimp.zpow'_one",
"Mathlib.Tactic.FieldSimp.NF.div_eq_eval₁",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.FieldSimp.subst_sub",
"Mathlib.Tactic.FieldSimp.eq_div_of_eq_one_of_subst",
"le_refl",
"Mat... | true |
MvPolynomial.evalᵢ.eq_1 | Mathlib.FieldTheory.Finite.Polynomial | [
"Pi.Function.module",
"Nat.instMulZeroClass",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"CommRing.toNonUnitalCommRing",
"AddMonoidAlgebra.addAddCommMonoid",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"HSub.hSub",
"MvPo... | true |
Matrix.diagonal_tsum | Mathlib.Topology.Instances.Matrix | [
"Matrix.diagonalAddMonoidHom",
"Matrix.diag",
"Function.LeftInverse.map_tsum",
"AddMonoidHom.instAddMonoidHomClass",
"Pi.addCommMonoid",
"Pi.topologicalSpace",
"Matrix",
"AddMonoid.toAddZeroClass",
"SummationFilter",
"Matrix.diag_diagonal",
"AddZeroClass.toAddZero",
"id",
"Matrix.addCommMono... | true |
Array.getElem_insertIdx_of_lt | Init.Data.Array.InsertIdx | [
"dite_cond_eq_true",
"Array.insertIdx",
"congrArg",
"HSub.hSub",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Array.getElem_insertIdx",
"dite",
"Array",
"GetElem.getElem",
"instHSub",
"Array.instGetElemNatLtSize",
"Nat",
"LT.lt",
"True",
"eq_self",
"eq_true",
"of_eq_tru... | true |
Lean.Parser.ParserExtension.instInhabitedEntry.default | Lean.Parser.Extension | [
"Inhabited.default",
"Lean.Parser.ParserExtension.Entry",
"Lean.Parser.Token",
"String.instInhabited",
"Lean.Parser.ParserExtension.Entry.token"
] | true |
OrderIso.isLUB_preimage._simp_1 | Mathlib.Order.Bounds.OrderIso | [
"Preorder.toLE",
"OrderIso",
"OrderIso.isLUB_preimage",
"instFunLikeOrderIso",
"Set.preimage",
"IsLUB",
"propext",
"Eq",
"DFunLike.coe",
"Preorder",
"Set"
] | false |
le_bot_iff._simp_1 | Mathlib.Order.BoundedOrder.Basic | [
"le_bot_iff",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderBot",
"PartialOrder",
"Bot.bot",
"LE.le",
"propext",
"Eq"
] | false |
Lean.Meta.Grind.Arith.Cutsat.Search.State.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM | [
"Lean.Meta.Grind.Arith.Cutsat.Search.State",
"Lean.PArray",
"Lean.Meta.Grind.Arith.Cutsat.Search.State.mk",
"Lean.Meta.Grind.Arith.Cutsat.Search.State.rec",
"Bool",
"Lean.Meta.Grind.Arith.Cutsat.Case",
"Lean.FVarIdSet"
] | false |
_private.Init.Data.String.Defs.0.String.append_left_inj._simp_1_1 | Init.Data.String.Defs | [
"String.toByteArray_inj",
"String",
"String.toByteArray",
"propext",
"ByteArray",
"Eq.symm",
"Eq"
] | false |
Lean.Elab.Term.Do.homogenize | Lean.Elab.Do.Legacy | [
"Pure.pure",
"_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.union",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.Meta.MetaM",
"IO.RealWorld",
"Prod.mk",
"Lean.Elab.Term.Do.VarSet",
"Lean.Elab.Term.Do.extendUpdatedVars",
"Lean.Elab.Term.Do.CodeBlock",
"Applicative.toPure",
"Lean.Elab.Term.Do.Cod... | true |
Std.DHashMap.Raw.mem_of_mem_filterMap | Std.Data.DHashMap.RawLemmas | [
"Std.DHashMap.Raw.WF",
"Std.DHashMap.Raw.instMembershipOfBEqOfHashable",
"Eq.mpr",
"Std.DHashMap.Raw.filterMap",
"Std.DHashMap.Raw",
"Membership.mem",
"Std.DHashMap.Raw.contains",
"id",
"Std.DHashMap.Raw.contains_of_contains_filterMap",
"LawfulHashable",
"Bool.true",
"EquivBEq",
"implies_con... | true |
CategoryTheory.curriedYonedaLemma._proof_3 | Mathlib.CategoryTheory.Yoneda | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.coyoneda",
"CategoryTheory.curriedYonedaLemma._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"congrArg",
"CategoryTheory.types_ext",
"CategoryTheory.Functor.cate... | false |
lp.instModulePreLp._proof_5 | Mathlib.Analysis.Normed.Lp.lpSpace | [
"instHSMul",
"NormedRing.toRing",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"instAddCommGroupPreLp",
"AddZeroClass.toAddZero",
"SMul.mk",
"SemigroupAction.mk",
"lp.instModulePreLp._proof_4",
"AddZero.toZero",
"SeminormedAddCommGroup.toPseud... | false |
Lean.Grind.CommRing.Poly.pow.match_1 | Init.Grind.Ring.CommSolver | [
"Unit.unit",
"instOfNatNat",
"dite",
"Unit",
"Nat",
"Eq.ndrec_symm",
"instDecidableEqNat",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"Not",
"Nat.casesOn"
] | false |
Lean.Elab.Tactic.evalIntro | Lean.Elab.Tactic.BuiltinTactic | [
"Pure.pure",
"Lean.mkNullNode",
"Lean.TSyntax",
"Std.Rci.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Std.Rci",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalIntro.introStep",
"Std.Rxi.Iterator.instIteratorAccess",
"instForInOfFor... | true |
SSet.StrictSegal._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | [
"SSet.Path",
"Opposite",
"SSet.StrictSegal.rec",
"SSet.StrictSegal",
"Function.comp",
"id",
"instOfNatNat",
"SSet",
"SimplexCategory.mk",
"Opposite.op",
"Nat",
"CategoryTheory.types",
"SimplexCategory",
"CategoryTheory.Category.opposite",
"SimplexCategory.smallCategory",
"OfNat.ofNat",... | false |
Finset.max'_lt_iff._simp_1 | Mathlib.Data.Finset.Max | [
"Preorder.toLT",
"Finset",
"LinearOrder",
"PartialOrder.toPreorder",
"Finset.max'",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Finset.instSetLike",
"LT.lt",
"propext",
"Finset.Nonempty",
"Eq",
"Finset.max'_lt_iff",
"SetLike.instMembership",
"instDis... | false |
Module.DirectLimit.addCommMonoid._proof_3 | Mathlib.Algebra.Colimit.Module | [
"AddMonoid.toAddSemigroup",
"instAddCommMonoidDirectSum",
"DirectSum.instModule",
"DistribMulAction.toDistribSMul",
"Add.mk",
"AddMonoid.toAddZeroClass",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LE.le",
"Module.DirectLimit.addCommMonoid._aux_1",
"LinearMap",
... | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.einfsep._simp_1_5 | Mathlib.Topology.MetricSpace.Infsep | [
"Set.offDiag",
"Membership.mem",
"Set.mem_offDiag",
"Ne",
"Prod.fst",
"And",
"propext",
"Prod",
"Eq",
"Set.instMembership",
"Prod.snd",
"Set"
] | false |
CategoryTheory.Abelian.Ext.mk₀_smul | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.ShiftedHom.mk₀.congr_simp",
"instCategoryDerivedCategory",
"CategoryTheory.Abelian.Ext.instModule",
"instHSMul",
"DerivedCategory",
"CategoryTheory.Abelian.Ext.smul_hom",
"CategoryTheory.Abelian.Ext.ext",
"CategoryTheory.CategoryStruct.toQuiver... | true |
Lean.Widget.DiffTag.willInsert.sizeOf_spec | Lean.Widget.InteractiveCode | [
"instOfNatNat",
"Lean.Widget.DiffTag._sizeOf_inst",
"Lean.Widget.DiffTag.willInsert",
"Lean.Widget.DiffTag",
"Nat",
"SizeOf.sizeOf",
"Eq.refl",
"OfNat.ofNat",
"Eq"
] | true |
List.reduceOption_length_le | Mathlib.Data.List.ReduceOption | [
"Option.isNone",
"Eq.mpr",
"congrArg",
"Nat.le_add_right",
"id",
"LE.le",
"instLENat",
"List",
"instHAdd",
"HAdd.hAdd",
"Nat",
"List.filter",
"instAddNat",
"List.reduceOption",
"Eq",
"List.length",
"Option",
"List.length_eq_reduceOption_length_add_filter_none"
] | true |
spectralNorm.spectralNorm_pow_natDegree_eq_prod_roots | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | [
"MulAlgebraNorm",
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Multiset.prod_replicate",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"False",
"Real.partialOrder",
"Real",
"Polynomial.roots",
"CompleteSpace",
"NormedRing.toRing",
"Multiset.count_replicate",
"Multiset.map",
"congrArg",
... | true |
HomotopicalAlgebra.PathObject.weakEquivalence_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | [
"HomotopicalAlgebra.PathObject",
"HomotopicalAlgebra.PathObject.toPrepathObject",
"HomotopicalAlgebra.PrepathObject.P",
"HomotopicalAlgebra.CategoryWithWeakEquivalences",
"HomotopicalAlgebra.WeakEquivalence",
"CategoryTheory.Category",
"HomotopicalAlgebra.PrepathObject.ι"
] | true |
Ordnode.erase._sunfold | Mathlib.Data.Ordmap.Ordnode | [
"Ordnode",
"Ordering",
"Ordnode.glue",
"Ordnode.mem.match_1",
"Ordnode.erase",
"cmpLE",
"Ordnode.node",
"LE",
"DecidableLE",
"Unit",
"Ordnode.balanceL",
"Nat",
"Ordnode.nil",
"Ordnode.balanceR",
"Eq",
"Ordnode.adjustWith.match_1"
] | false |
QuadraticMap.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Basic | [
"instHSMul",
"HMul.hMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"QuadraticMap.mk",
"LinearMap.BilinMap",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"instSizeOfDefault",
"Exists",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"instOfNatNat",
"Line... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.