name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.PPFns | Lean.Util.PPExt | [
"Lean.PPFns.mk"
] | true |
Lean.KVMap.instValueBool.match_1 | Lean.Data.KVMap | [
"Lean.DataValue.ctorIdx",
"Nat.hasNotBit",
"Lean.KVMap.instValueBool._sparseCasesOn_1",
"Lean.DataValue.ofBool",
"Bool",
"Lean.DataValue"
] | false |
MvPowerSeries.weightedOrder_le | Mathlib.RingTheory.MvPowerSeries.Order | [
"Iff.mpr",
"Finsupp.instAddZeroClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"MvPowerSeries.instZero",
"Semiring.toModule",
"instCharZeroENat",
"le_rfl",
"instAddMonoidWithOneENat",
"MvPowerSeries.weightedOrder.eq_1",
"ENat.instNatCast",
"instTopENat",
... | true |
Continuous.edist | Mathlib.Topology.Instances.ENNReal.Lemmas | [
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Continuous",
"Continuous.comp",
"instTopologicalSpaceProd",
"continuous_edist",
"Prod.mk",
"PseudoEMetricSpace",
"Prod.fst",
"TopologicalSpace",
"WeakPseudoEMetricSpace.toEDist",
"PseudoEMetricSpace.toUniformSpace",
"ENNReal",
"ENNReal.instTopo... | true |
BoxIntegral.TaggedPrepartition.IsSubordinate | Mathlib.Analysis.BoxIntegral.Partition.Tagged | [
"Real",
"Set.Ioi",
"pseudoMetricSpacePi",
"Real.instZero",
"BoxIntegral.Box.Icc",
"Membership.mem",
"Set.Elem",
"BoxIntegral.TaggedPrepartition.tag",
"BoxIntegral.TaggedPrepartition.instMembershipBox",
"HasSubset.Subset",
"Fintype",
"Set.instLE",
"BoxIntegral.Box.instLE",
"Zero.toOfNat0",
... | true |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_9 | Batteries.Data.List.Perm | [
"Lean.Grind.nestedProof",
"Lean.Grind.Nat.lt_eq",
"List.getElem_filter_eq_getElem_getElem_findIdxs._proof_2",
"LawfulBEq",
"List.Subperm.idxInj._proof_2",
"List.Perm",
"instOfNatNat",
"LE.le",
"instLENat",
"Fin.val",
"GetElem.getElem",
"List.findIdxs",
"List",
"instHAdd",
"EquivBEq.toRef... | false |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.exists_primeCompl_mul_eq_or_mul_eq._proof_1_4 | Mathlib.RingTheory.DedekindDomain.AdicValuation | [
"RingHom.instRingHomClass",
"Lean.RArray.leaf",
"Lean.Grind.Field.toCommRing",
"False",
"CommRing",
"Lean.Grind.CommRing.Mon.mult",
"Lean.Grind.CommRing.diseq_to_eq",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Expr",
"HMul.hMul",
"Lean.Grind.CommRing.Expr.mul",
"DivisionCommMonoid.toDivi... | false |
_private.Init.Data.List.Range.0.List.getElem?_zipIdx.match_1_1 | Init.Data.List.Range | [
"instOfNatNat",
"List.cons",
"List",
"Nat",
"List.casesOn",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn",
"List.nil"
] | false |
VitaliFamily.filterAt_enlarge | Mathlib.MeasureTheory.Covering.VitaliFamily | [
"Filter.instMembership",
"Iff.mpr",
"Eq.mpr",
"False",
"Real",
"MeasureTheory.Measure",
"Filter.smallSets",
"Lattice.toSemilatticeSup",
"Metric.closedBall_mem_nhds",
"MeasurableSet",
"Real.instZero",
"congrArg",
"Filter.Eventually",
"PartialOrder.toPreorder",
"setOf",
"PseudoMetricSpac... | true |
DoubleCentralizer.coe._proof_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | [
"NormedSpace",
"NormedSpace.toModule",
"NormedField.toField",
"NonUnitalRing.toNonUnitalNonAssocRing",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring",
"NonUnitalNormedRing",
"Field.toSemifield",
"Field.toCommRing",
"smulCommClass_self",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Semifiel... | false |
_private.Mathlib.NumberTheory.Padics.HeightOneSpectrum.0.Rat.int_algebraMap_surjective._simp_1_1 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | [
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IsScalarTower",
"Algebra",
"RingHom",
"Algebra.toSMul",
"CommSemiring",
"RingHom.instFunLike",
"Semiring",
"Eq.symm",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe",
"IsScalarTower.algebraMap_apply"
] | false |
CategoryTheory.Pseudofunctor.mapComp'_comp_id_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Pseudofunctor.mapComp'_comp_id_hom_app",
"CategoryTheory.Pseudofunctor.mapId",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.Functor.comp",
"CategoryTheory.Cat.str",
"CategoryTheory.Cat... | true |
hasBasis_nhdsSet_Ici_Ici | Mathlib.Topology.Order.NhdsSet | [
"OrderDual.toDual",
"OrderTopology",
"Set.Ioi",
"Preorder.toLT",
"Equiv.instEquivLike",
"Set.Ici",
"Filter.NeBot",
"LinearOrder",
"nhdsWithin",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"hasBasis_nhdsSet_Iic_Iic",
"Equiv",
"TopologicalSpace",... | true |
CategoryTheory.Cat.HasLimits.limitConeIsLimit | Mathlib.CategoryTheory.Category.Cat.Limit | [
"CategoryTheory.Cat.category",
"CategoryTheory.Cat.HasLimits.limitConeIsLimit._proof_4",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.Cat.HasLimits.limitConeLift",
"CategoryTheory.Functor",
"CategoryTheory.Limits.IsLimit.mk",
"CategoryTheory.Limits.Cone",
"CategoryTheory.Cat.HasLimits.limitCone",
... | true |
_private.Mathlib.MeasureTheory.Measure.AEMeasurable.0.cond.match_1.eq_1 | Mathlib.MeasureTheory.Measure.AEMeasurable | [
"Unit.unit",
"cond.match_1",
"Bool.true",
"Unit",
"Bool",
"Eq.refl",
"Bool.false",
"Eq"
] | true |
Std.TreeMap.get!_union_of_not_mem_right | Std.Data.TreeMap.Lemmas | [
"Std.TreeMap.inner",
"Membership.mem",
"Ordering",
"Std.TransCmp",
"Std.TreeMap.get!",
"Std.TreeMap.instMembership",
"Inhabited",
"Union.union",
"Std.TreeMap.instUnion",
"Eq",
"Not",
"Std.DTreeMap.Const.get!_union_of_not_mem_right",
"Std.TreeMap"
] | true |
IsAbsoluteValue.mk | Mathlib.Algebra.Order.AbsoluteValue.Basic | [
"HMul.hMul",
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"Distrib.toAdd",
"LE.le",
"instDistribOfSemiring",
"instHAdd",
"Iff",
"Distrib.toMul",
"HAdd.hAdd",
"IsAbsoluteValue",
"Semiring",
"Zero.toOfNat0",
"IsAbsoluteValue.mk",
"OfNat.ofNat",
"Eq",
"MulZeroClass.toZe... | true |
Filter.frequently_imp_distrib_right | Mathlib.Order.Filter.Basic | [
"congrArg",
"Filter.NeBot",
"Filter.Eventually",
"Filter.Frequently",
"iff_self",
"Filter.frequently_const._simp_1",
"Iff",
"implies_congr",
"True",
"_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_imp_distrib_right._simp_1_1",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Filter",
"Eq.... | true |
matPolyEquiv_symm_apply_coeff | Mathlib.RingTheory.MatrixPolynomialAlgebra | [
"Eq.mpr",
"AlgEquiv.symm",
"congrArg",
"CommSemiring.toSemiring",
"Matrix",
"Polynomial.algebraOfAlgebra",
"Eq.rec",
"Matrix.instAlgebra",
"Algebra.id",
"id",
"AlgEquiv.apply_symm_apply",
"Polynomial",
"Polynomial.coeff",
"matPolyEquiv",
"CommSemiring",
"Fintype",
"AlgEquiv",
"Poly... | true |
Lean.Parser.Tactic.Conv.rewrite | Init.Conv | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Parser.Tactic.optConfig",
"Lean.Name.mkStr5",
"instOfNatNat",
"Lean.Parser.Tactic.rwRuleSeq",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1"
] | true |
Std.TreeMap.Raw.toList_rco | Std.Data.TreeMap.Raw.Slice | [
"Pure.pure",
"Std.Slice.toList",
"Std.Rco.Sliceable.mkSlice",
"Std.DTreeMap.Internal.Const.RcoSliceData",
"Std.TreeMap.Raw.instSliceableRcoSlice",
"Std.TreeMap.Raw.WF.out",
"Monad.toApplicative",
"Std.Iterators.Types.Map.instIterator",
"MonadLiftT.monadLift",
"instMonadLiftT",
"Std.TreeMap.Raw.t... | true |
Finset.inf'_congr | Mathlib.Data.Finset.Lattice.Fold | [
"Finset.le_inf'_iff",
"Finset.inf'",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Eq.rec",
"LE.le",
"iff_self",
"SemilatticeInf",
"Iff",
"Finset.instSetLike",
"congr",
"True",
"propext",
"Finset.Nonempty",
"... | true |
CategoryTheory.yoneda'_comp | Mathlib.CategoryTheory.Sites.Types | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.typesGrothendieckTopology",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.yoneda",
"CategoryTheory.yoneda'",
"CategoryTheory.types",
"CategoryTheory.Category.opposite",
"CategoryTheory.Presheaf.IsSheaf",
"C... | true |
ContinuousMap.HomotopyWith.ext_iff | Mathlib.Topology.Homotopy.Basic | [
"Real",
"HEq.refl",
"ContinuousMap",
"Set.Elem",
"Eq.casesOn",
"ContinuousMap.HomotopyWith.instFunLike",
"ContinuousMap.HomotopyWith",
"TopologicalSpace",
"Iff",
"Iff.intro",
"ContinuousMap.HomotopyWith.ext",
"Eq.ndrec",
"Eq.refl",
"HEq",
"Prod",
"Eq.symm",
"Eq",
"DFunLike.coe",
... | true |
Vector.mapFinIdxM | Init.Data.Vector.Basic | [
"Vector",
"HSub.hSub",
"Vector.mapFinIdxM._proof_8",
"Vector.mapFinIdxM.map",
"instSubNat",
"Vector.mapFinIdxM._proof_9",
"instOfNatNat",
"List.toArray",
"instHSub",
"Vector.mapFinIdxM._proof_7",
"Vector.mk",
"Nat",
"LT.lt",
"Vector.cast",
"instLTNat",
"OfNat.ofNat",
"Monad",
"List... | true |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage.match_1 | Mathlib.CategoryTheory.Limits.Types.Images | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
MonoidHom.coe_of_map_mul_inv | Mathlib.Algebra.Group.Hom.Basic | [
"MonoidHom.instFunLike",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"MonoidHom",
"Monoid.toMulOneClass",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MonoidHom.ofMapMulInv",
"MulOneClass.toMulOne",... | true |
CategoryTheory.AddMonObj.zero_eq_zero | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | [
"Eq.mpr",
"CategoryTheory.SemiCartesianMonoidalCategory.toUnit_unique",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Hom.addMonoid",
"AddMonoid.toAddZeroClass",
"CategoryTheory.CategoryStruct.id",
"AddZeroClass.toAddZero",
"id",
"CategoryTheory.SemiCartesia... | true |
CategoryTheory.Limits.createsColimitsOfShapeOfRightOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | [
"CategoryTheory.CreatesColimitsOfShape.mk",
"CategoryTheory.Functor",
"CategoryTheory.Limits.createsColimitOfRightOp",
"Opposite",
"CategoryTheory.CreatesLimitsOfShape.CreatesLimit",
"CategoryTheory.CreatesLimitsOfShape",
"CategoryTheory.CreatesColimitsOfShape",
"CategoryTheory.Category.opposite",
"... | true |
FirstOrder.Language.ElementarilyEquivalent.toModel | Mathlib.ModelTheory.Bundled | [
"FirstOrder.Language.Theory.ModelType",
"FirstOrder.Language.Theory.ModelType.struc",
"FirstOrder.Language.ElementarilyEquivalent",
"FirstOrder.Language.Theory",
"FirstOrder.Language.Theory.ModelType.mk",
"FirstOrder.Language.Structure",
"FirstOrder.Language.Theory.ModelType.Carrier",
"FirstOrder.Lang... | true |
SimpleGraph.finsubgraphOfAdj.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | [
"SimpleGraph.Subgraph",
"SimpleGraph.Adj",
"Set.Finite",
"Subtype.mk",
"SimpleGraph",
"Eq.refl",
"SimpleGraph.Finsubgraph",
"SimpleGraph.finsubgraphOfAdj._proof_1",
"Eq",
"SimpleGraph.Subgraph.verts",
"SimpleGraph.subgraphOfAdj",
"SimpleGraph.finsubgraphOfAdj"
] | true |
Filter.pi_mono | Mathlib.Order.Filter.Pi | [
"Filter.instCompleteLatticeFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Filter.comap_mono",
"iInf_mono",
"LE.le",
"Function.eval",
"Filter.pi",
"Filter",
"Filter.comap",
"Filter.instPartialOrder"
] | true |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.instLawfulUpwardEnumerable._simp_4 | Init.Data.Range.Polymorphic.BitVec | [
"instPowNat",
"BitVec.toNat_lt_twoPow_of_le",
"BitVec",
"instOfNatNat",
"BitVec.toNat",
"LE.le",
"instLENat",
"instNatPowNat",
"HPow.hPow",
"Nat",
"LT.lt",
"True",
"eq_true",
"instHPow",
"instLTNat",
"OfNat.ofNat",
"Eq"
] | false |
Aesop.FVarIdSubst.ofFVarSubstIgnoringNonFVarIds | Aesop.RuleTac.FVarIdSubst | [
"Lean.instBEqFVarId",
"Aesop.FVarIdSubst",
"Lean.AssocList.foldl",
"_private.Aesop.RuleTac.FVarIdSubst.0.Aesop.FVarIdSubst.apply.match_1",
"Lean.Expr",
"Lean.FVarId",
"Std.HashMap",
"Std.HashMap.instEmptyCollection",
"Lean.instHashableFVarId",
"Lean.Meta.FVarSubst",
"EmptyCollection.emptyCollect... | true |
CategoryTheory.isIso_iff_nonzero | Mathlib.CategoryTheory.Preadditive.Schur | [
"CategoryTheory.IsIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.isIso_of_hom_simple",
"Ne",
"CategoryTheory.Limits.HasZeroMorphisms.zero",
"CategoryTheory.Preadditive",
"Iff",
"CategoryTheory.inv.congr_simp",
"Cate... | true |
FinBddDistLat.ofHom | Mathlib.Order.Category.FinBddDistLat | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"FinBddDistLat.instBoundedOrderCarrier",
"BoundedLatticeHom.instFunLike",
"PartialOrder.toPreorder",
"Preorder.toLE",
"FinBddDistLat.of",
"SemilatticeInf.toPartialOrder",
"FinBddDistLat.instDistribLatticeCarrier",
"DistribLattice.toLattice",
... | true |
Order.Preimage.instIsStrictOrder | Mathlib.Order.RelClasses | [
"IsStrictOrder.toIsTrans",
"IsStrictOrder",
"IsStrictOrder.mk",
"Order.Preimage.instIrrefl",
"Order.Preimage",
"IsStrictOrder.toIrrefl",
"Order.Preimage.instIsTrans"
] | true |
AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq | Mathlib.GroupTheory.GroupAction.Defs | [
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddAction.stabilizerAddSubmonoid",
"AddSubmonoid",
"AddAction",
"DecidablePred",
"AddMonoid",
"AddSubmonoid.instSetLike",
"SetLike.instMembership",
"AddAction.instDecidablePredMemAddSubmonoidStabilizerAddSubmonoidOfDecidableEq._aux_1",
"DecidableEq"... | true |
Polynomial.instNormalizationMonoid._proof_10 | Mathlib.Algebra.Polynomial.FieldDivision | [
"Units.val",
"Polynomial.C",
"MulOne.toOne",
"CommRing",
"HMul.hMul",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"NormalizationMonoid",
"Polynomial.instNormalizationMonoid._proof_2",
"RingHom",
"CommSemiring.toCommMonoidWithZero",
"Units",
"MulOne.toMul",
"P... | false |
Profinite.NobelingProof.isClosed_C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | [
"Preorder.toLT",
"Continuous",
"isWellOrder_lt",
"Pi.topologicalSpace",
"Ordinal.partialOrder",
"Profinite.NobelingProof.C0",
"LinearOrder",
"WellFoundedLT",
"PartialOrder.toPreorder",
"instTopologicalSpaceBool",
"setOf",
"instDiscreteTopologyBool",
"SemilatticeInf.toPartialOrder",
"Ordina... | true |
Std.DHashMap.Internal.Raw₀.map | Std.Data.DHashMap.Internal.Defs | [
"_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.expandIfNecessary.match_1",
"_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.map._proof_1",
"Std.DHashMap.Raw",
"Array.map",
"instOfNatNat",
"Subtype.mk",
"Array",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt... | true |
Fin.succAbove_of_lt_succ | Mathlib.Data.Fin.SuccPred | [
"Iff.mpr",
"Fin.succAbove_of_le_castSucc",
"Fin.succAbove",
"Fin.succ",
"instOfNatNat",
"LE.le",
"instLEFin",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instLTFin",
"Fin.le_castSucc_iff",
"instAddNat",
"Fin.castSucc",
"OfNat.ofNat",
"Fin",
"Eq"
] | true |
QuadraticAlgebra.instCommSemiring._proof_4 | Mathlib.Algebra.QuadraticAlgebra.Defs | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"QuadraticAlgebra.re",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"QuadraticAlgebra.ext",
"Mathlib.Tactic.Ring.Common.mul_congr",
"HMul.hMul",
"QuadraticAlgebra",
"Nat.rawCast",
"congrArg",
"CommSemiring.toSemiring",
"Mathlib.Meta.NormNum.IsN... | false |
Part.mem_ofOption._simp_1 | Mathlib.Data.Part | [
"Part",
"Part.mem_ofOption",
"Option.instMembership",
"Membership.mem",
"Part.instMembership",
"propext",
"Eq",
"Option",
"Part.ofOption"
] | false |
Lean.Macro.Context.ctorIdx | Init.Prelude | [
"Lean.Macro.Context",
"Nat"
] | false |
SimpleGraph.finsetWalkLength._f | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | [
"Finset.univ",
"Finset",
"SimpleGraph.instDecidableEqWalk",
"SimpleGraph.LocallyFinite",
"SimpleGraph.Walk",
"Finset.map",
"Membership.mem",
"SimpleGraph.neighborSet",
"Function.Embedding.mk",
"Set.Elem",
"instOfNatNat",
"Finset.biUnion",
"Finset.instEmptyCollection",
"dite",
"SimpleGrap... | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_le_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | [
"Semiring.toModule",
"HMul.hMul",
"IsScalarTower.right",
"CommSemiring.toSemiring",
"Membership.mem",
"Exists",
"Algebra.id",
"Set.instSingletonSet",
"Ideal",
"Submodule.mul",
"instDistribOfSemiring",
"CommSemiring",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"And",
"Distrib.toMul",
... | false |
CategoryTheory.Limits.WidePushoutShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | [
"Option.some",
"Eq.symm",
"Eq",
"CategoryTheory.Limits.WidePushoutShape"
] | false |
Lean.InductiveVal.mk.inj | Lean.Declaration | [
"Lean.InductiveVal.mk",
"Lean.ConstantVal",
"Lean.InductiveVal.mk.noConfusion",
"List",
"And",
"Nat",
"And.intro",
"Bool",
"Lean.Name",
"Eq",
"Lean.InductiveVal"
] | true |
_private.Init.Data.String.Basic.0.String.copy_toSlice._simp_1_2 | Init.Data.String.Basic | [
"String",
"String.toByteArray",
"String.utf8ByteSize",
"Nat",
"Eq.symm",
"Eq",
"ByteArray.size",
"String.size_toByteArray"
] | false |
CategoryTheory.ObjectProperty.small_unop_iff | Mathlib.CategoryTheory.ObjectProperty.Small | [
"Eq.mpr",
"Opposite",
"CategoryTheory.ObjectProperty.Small",
"CategoryTheory.CategoryStruct.opposite",
"congrArg",
"Iff.rfl",
"CategoryTheory.ObjectProperty.unop",
"id",
"Iff",
"propext",
"CategoryTheory.Category.opposite",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.ObjectPr... | true |
AlgCat.limitSemiring._aux_1 | Mathlib.Algebra.Category.AlgCat.Limits | [
"Subalgebra.instSetLike",
"AlgCat.instAlgebraObjForgetAlgHomCarrier",
"CategoryTheory.Functor",
"CommRing",
"Equiv.instEquivLike",
"CategoryTheory.Limits.Types.Small.limitCone",
"AlgCat.instCategory",
"AlgHom",
"AlgCat.instConcreteCategoryAlgHomCarrier",
"AlgHom.funLike",
"AddMonoid.toAddZeroCla... | false |
ArchimedeanClass.instFieldFiniteResidueField._aux_8 | Mathlib.Algebra.Order.Ring.StandardPart | [
"IsOrderedRing",
"ArchimedeanClass.FiniteResidueField._proof_1",
"LinearOrder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"ArchimedeanClass.FiniteResidueField",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"Nat",
"DivisionSemiring.toSemiring",
"Field",
"ArchimedeanCl... | false |
Finset.ruzsa_triangle_inequality_addNeg_add_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"SubtractionMonoid.toInvolutiveNeg",
"HMul.hMul",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"Eq.mp",
"Finset.subtractionMonoid",
"neg_neg",
"instMulNat",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",... | true |
Mathlib.Tactic.Algebra.algebraWith | Mathlib.Tactic.Algebra.Basic | [
"Lean.ParserDescr.nonReservedSymbol",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
NonUnitalCommCStarAlgebra.toNonUnitalNormedCommRing | Mathlib.Analysis.CStarAlgebra.Classes | [
"NonUnitalCommCStarAlgebra",
"NonUnitalNormedCommRing"
] | true |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.foldlMAux.traverse | Lean.Data.PersistentHashMap | [
"Inhabited.default",
"instInhabitedOfMonad",
"Array",
"Nat",
"Inhabited",
"Monad",
"Eq",
"Array.size",
"Inhabited.mk"
] | true |
Nat.add_mod_eq_add_mod_left | Init.Data.Nat.Lemmas | [
"Eq.mpr",
"Nat.add_mod_eq_add_mod_right",
"congrArg",
"id",
"Nat.instMod",
"instHMod",
"instHAdd",
"HMod.hMod",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Eq.refl",
"Eq",
"Nat.add_comm"
] | true |
WithConv.casesOn | Mathlib.Algebra.WithConv | [
"WithConv.toConv",
"WithConv.rec",
"WithConv"
] | false |
PresheafOfModules.Sheafify.smul_zero | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | [
"CategoryTheory.Presheaf.imageSieve",
"Eq.mpr",
"AddMonoidHom.map_zero",
"CategoryTheory.GrothendieckTopology.Cover.shape",
"CategoryTheory.Functor",
"instHSMul",
"CategoryTheory.hasSheafCompose_of_preservesMulticospan",
"AddMonoidHom.instAddMonoidHomClass",
"Opposite",
"CategoryTheory.CategoryStr... | true |
eval_det | Mathlib.RingTheory.MatrixPolynomialAlgebra | [
"Eq.mpr",
"Polynomial.eval",
"Matrix.scalar",
"CommRing",
"congrArg",
"CommSemiring.toSemiring",
"Matrix",
"Polynomial.algebraOfAlgebra",
"RingHom",
"Matrix.instAlgebra",
"Algebra.id",
"id",
"Polynomial.eval₂",
"Matrix.nonAssocSemiring",
"Polynomial",
"matPolyEquiv",
"congr_arg",
"... | true |
CategoryTheory.epi_comp_iff_of_isIso | Mathlib.CategoryTheory.EpiMono | [
"CategoryTheory.Category.assoc",
"CategoryTheory.IsIso",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.epi_comp",
"CategoryTheory.IsIso.inv_isIso",
"CategoryTheory.CategoryStruct.id",
"inferInstance",
"Eq.mp",
"CategoryTheory.Category... | true |
IsOpen.tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | [
"IsOpen.nhdsWithin_eq",
"UniformSpace",
"Eq.mpr",
"TendstoLocallyUniformlyOn",
"SProd.sprod",
"congrArg",
"nhdsWithin",
"Iff.rfl",
"uniformity",
"Membership.mem",
"nhds",
"id",
"Prod.mk",
"Prod.fst",
"TopologicalSpace",
"Iff",
"forall₂_congr",
"Filter.Tendsto",
"Iff.trans",
"Is... | true |
RelIso.prodLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | [
"Equiv.instEquivLike",
"congrArg",
"Function.Injective.eq_iff",
"Equiv",
"Prod.Lex",
"Prod.map",
"RelIso.injective",
"Prod.fst",
"iff_self",
"RelIso",
"And",
"Iff",
"RelIso.map_rel_iff",
"RelIso.instFunLike",
"congr",
"True",
"propext",
"of_eq_true",
"_private.Mathlib.Order.RelIs... | false |
Lean.NamePart.num.sizeOf_spec | Lean.Data.NameTrie | [
"instOfNatNat",
"Lean.NamePart",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Lean.NamePart.num",
"instAddNat",
"Eq.refl",
"instSizeOfNat",
"OfNat.ofNat",
"Eq",
"Lean.NamePart._sizeOf_inst"
] | true |
_private.Mathlib.Analysis.CStarAlgebra.Fuglede.0.SemiconjBy.star_right_of_unital | Mathlib.Analysis.CStarAlgebra.Fuglede | [
"NormedAlgebra.restrictScalars",
"_private.Mathlib.Analysis.CStarAlgebra.Fuglede.0.expMulMulExp._proof_1",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"CStarAlgebra.toNonUnitalCStarAlgebra",
"instHSMul",
"_private.Mathlib.Analysis.CStarAlgeb... | true |
CategoryTheory.Limits.Types.isPullback_of_isPushout | Mathlib.CategoryTheory.Limits.Types.Pushouts | [
"Eq.mpr",
"CategoryTheory.Limits.WalkingSpan",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_iff_of_isColimit",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.IsPushout.cocone",
"CategoryTheory.IsPullback",
"TypeCa... | true |
isRelLowerSet_empty._simp_1 | Mathlib.Order.UpperLower.Relative | [
"IsRelLowerSet",
"isRelLowerSet_empty",
"LE",
"True",
"eq_true",
"Set.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Eq",
"Set"
] | false |
sectionOfRetractionKerToTensorAux.congr_simp | Mathlib.RingTheory.Smooth.Kaehler | [
"LinearMap.id",
"RingHom.instRingHomClass",
"sectionOfRetractionKerToTensorAux",
"CommRing",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"instAddCommGroupKaehlerDifferential",
"Algebra.algebraMap",
"CommSemirin... | true |
nnnorm_cfcₙHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | [
"norm_cfcₙHom",
"NormedCommRing.toSeminormedCommRing",
"Real.instLE",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"instSMulOfMul",
"NormedSpace",
"outParam",
"IsTopologicalRing.toIsTopologicalSemiring",
"Real.instZero",
"CommSemiring.toSemiring",
"DistribMul... | true |
Set.instFintypeIcc | Mathlib.Order.Interval.Finset.Defs | [
"Set.instFintypeIcc._proof_1",
"Set.Elem",
"Fintype.ofFinset",
"Finset.Icc",
"Set.Icc",
"Fintype",
"LocallyFiniteOrder",
"Preorder"
] | true |
OptionT.instMonadLift | Init.Control.Option | [
"OptionT",
"MonadLift",
"OptionT.lift",
"MonadLift.mk",
"Monad"
] | true |
String.toInt?_comp_toSlice | Std.Data.String.ToInt | [
"String.toSlice",
"congrArg",
"String.Slice.toInt?",
"String",
"Option.some",
"Function.comp",
"String.toInt?",
"String.Slice",
"Int",
"Option.ext",
"iff_self",
"funext",
"String.toInt?_toSlice",
"Iff",
"True",
"of_eq_true",
"congrFun'",
"Eq",
"Eq.trans",
"Option"
] | true |
Batteries.Tactic.PrintPrefixConfig.ctorIdx | Batteries.Tactic.PrintPrefix | [
"Batteries.Tactic.PrintPrefixConfig",
"Nat"
] | false |
CategoryTheory.Functor.preimageIso_mapIso | Mathlib.CategoryTheory.Functor.FullyFaithful | [
"CategoryTheory.Functor.preimage_map",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Iso",
"CategoryTheory.Functor.preimageIso",
"True",
"eq_self",
"of_eq_true",
"CategoryTheory.Category.toCategoryStruct",
"congrFun'",
"Category... | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_ExactFunctor_1 | Mathlib.CategoryTheory.Limits.ExactFunctor | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
Nat.ofNat_lt_cast | Mathlib.Data.Nat.Cast.Order.Basic | [
"Preorder.toLT",
"AddMonoid.toAddSemigroup",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddLeftMono",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"ZeroLEOneClass",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Nat.cast",
"CharZero",
"AddMonoidWithOne.toOne",
... | true |
IsDedekindDomain.selmerGroup.fromUnit | Mathlib.RingTheory.DedekindDomain.SelmerGroup | [
"MulOne.toOne",
"MonoidHom.range",
"CommRing",
"IsDedekindDomain.HeightOneSpectrum.valuationOfNeZeroMod._proof_1",
"MonoidHom.instFunLike",
"CommMonoid.toCommSemigroup",
"Algebra.algebraMap",
"MonoidHom",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"IsDedekindDomain.selmerGroup.fromUnit._... | true |
instCommRingFreeCommRing._aux_1 | Mathlib.RingTheory.FreeCommRing | [
"instAddCommGroupFreeAbelianGroup._aux_1",
"FreeCommRing",
"Multiset",
"Multiplicative"
] | false |
Lean.Compiler.LCNF.ToMonoM.State.rec | Lean.Compiler.LCNF.ToMono | [
"Lean.Compiler.LCNF.ToMonoM.State",
"Lean.Compiler.LCNF.ToMonoM.State.mk",
"Lean.FVarIdHashSet"
] | false |
_private.Init.Data.Nat.Fold.0.Nat.fold_congr._proof_1 | Init.Data.Nat.Fold | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"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.eval",
"Option.some",
"Lean.Omega.LinearC... | false |
Fintype.sum_subtype_add_sum_subtype | Mathlib.Algebra.BigOperators.Group.Finset.Basic | [
"Finset.mem_univ",
"Eq.mpr",
"instDecidableNot",
"Finset.univ",
"congrArg",
"Compl.compl",
"Finset",
"AddMonoid.toAddZeroClass",
"setOf",
"Classical.propDecidable",
"Finset.sum_subtype",
"Membership.mem",
"BooleanAlgebra.toCompl",
"Subtype.fintype",
"AddZeroClass.toAddZero",
"id",
"S... | true |
Finsupp.embDomain_comapDomain | Mathlib.Data.Finsupp.Basic | [
"Finsupp.instFunLike",
"Eq.mpr",
"Finsupp.ext",
"congrArg",
"Finsupp.notMem_support_iff",
"Function.Injective.injOn",
"Finset",
"Classical.propDecidable",
"Finsupp.support",
"Membership.mem",
"mt",
"id",
"HasSubset.Subset",
"Finsupp.comapDomain_apply",
"Finsupp.embDomain_apply_self",
"... | true |
Set.MapsTo.subset_preimage | Mathlib.Data.Set.Function | [
"HasSubset.Subset",
"Set.preimage",
"Set.MapsTo",
"Set.instHasSubset",
"Set"
] | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.Strictness.toPositive.match_1 | Mathlib.Tactic.Positivity.Core | [
"Mathlib.Meta.Positivity.Strictness",
"Lean.Expr.const",
"Nat.hasNotBit",
"Lean.Expr.sort",
"Lean.Level",
"List.cons",
"_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.Strictness.toPositive._sparseCasesOn_1",
"Lean.Literal.natVal",
"Qq.Quoted",
"Mathlib.Meta.Positivity.Strictness... | false |
Setoid.mkClasses_classes | Mathlib.Data.Setoid.Partition | [
"Setoid.mkClasses",
"Setoid.refl'",
"setOf",
"Membership.mem",
"Setoid.classes_eqv_classes",
"Eq.rec",
"Setoid.classes",
"Setoid.symm'",
"Setoid",
"Setoid.ext",
"Iff.intro",
"Setoid.eq_of_mem_classes",
"Eq",
"Set.instMembership",
"Setoid.r",
"Setoid.mem_classes",
"Set"
] | true |
Lean.Elab.Tactic.Omega.Problem.addInequality | Lean.Elab.Tactic.Omega.Core | [
"Lean.Meta.mkSorry",
"Lean.Elab.Tactic.Omega.Proof",
"Lean.Elab.Tactic.Omega.Fact",
"Lean.MetavarKind.natural",
"Lean.Elab.Tactic.Omega.Problem.proveFalse?",
"Lean.Elab.Tactic.Omega.Problem.addConstraint",
"Array.push",
"Lean.Omega.Constraint.mk",
"Lean.Elab.Tactic.Omega.State",
"ReaderT",
"Lean... | true |
Sym.mem_mk | Mathlib.Data.Sym.Basic | [
"Iff.rfl",
"Membership.mem",
"Multiset",
"Multiset.instMembership",
"Iff",
"Nat",
"Sym",
"Sym.mk",
"Multiset.card",
"Sym.instMembership",
"Eq"
] | true |
Std.Sat.AIG.RefVec.cast'.eq_1 | Std.Sat.AIG.RefVec | [
"Std.Sat.AIG.Decl",
"Std.Sat.AIG.Fanin.gate",
"Vector",
"Std.Sat.AIG.RefVec.mk",
"Vector.instGetElemNatLt",
"Std.Sat.AIG.RefVec.cast'._proof_1",
"GetElem.getElem",
"Std.Sat.AIG",
"Nat",
"LT.lt",
"Std.Sat.AIG.RefVec.refs",
"Eq.refl",
"Hashable",
"instLTNat",
"Std.Sat.AIG.RefVec.cast'",
... | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toISize_ne_minValue._simp_1_2 | Init.Data.SInt.Lemmas | [
"Int32.toInt_inj",
"Int",
"Int32.toInt",
"propext",
"Eq.symm",
"Eq",
"Int32"
] | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.mkBoxedVersion.match_1 | Lean.Compiler.LCNF.ExplicitBoxing | [
"Unit.unit",
"Subarray",
"Option.casesOn",
"Option.some",
"Prod.mk",
"Option.none",
"Unit",
"Lean.Compiler.LCNF.Purity.impure",
"Lean.Compiler.LCNF.Param",
"Prod",
"Prod.casesOn",
"Option"
] | false |
NumberField.IsCMField.mem_realUnits_iff | Mathlib.NumberTheory.NumberField.CMField | [
"Units.val",
"RingHom.instRingHomClass",
"MonoidHom.range",
"MonoidHom.instFunLike",
"Subfield.toAlgebra",
"Algebra.algebraMap",
"MonoidHom.mem_range._simp_2",
"MonoidHom",
"_private.Mathlib.NumberTheory.NumberField.CMField.0.NumberField.IsCMField.mem_realUnits_iff._simp_1_3",
"NumberField.maximal... | true |
MonoidHom.fiberEquivKerOfSurjective._proof_1 | Mathlib.GroupTheory.Coset.Basic | [
"Exists.choose_spec",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Group",
"DivInvMonoid.toMonoid",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Exists.choose",
"Eq",
"DFunLike.coe",
"Function.Surjective"
] | false |
Std.TreeMap.Raw.getElem!_union_of_not_mem_right | Std.Data.TreeMap.Raw.Lemmas | [
"Std.TreeMap.Raw.instUnion",
"Std.DTreeMap.Raw.Const.get!_union_of_not_mem_right",
"Std.TreeMap.Raw.WF.out",
"Membership.mem",
"Ordering",
"Std.TreeMap.Raw.instMembership",
"Std.TransCmp",
"Std.TreeMap.Raw.WF",
"Std.TreeMap.Raw.inner",
"Std.TreeMap.Raw",
"Inhabited",
"Std.TreeMap.Raw.instGetEl... | true |
List.takeListTR.go._f | Batteries.Data.List.Basic | [
"Array.push",
"Prod.mk",
"List.rotate.match_1",
"Array.toList",
"List.cons",
"Array",
"List",
"Nat",
"List.takeListTR.go.match_1",
"List.below",
"List.splitAt",
"Prod",
"List.nil"
] | false |
Subarray.get! | Init.Data.Array.Subarray | [
"Inhabited.default",
"Subarray.getD",
"Subarray",
"Nat",
"Inhabited"
] | true |
Mathlib.Tactic.ITauto.IProp.ctorElim | Mathlib.Tactic.ITauto | [
"Mathlib.Tactic.ITauto.AndKind",
"Mathlib.Tactic.ITauto.IProp",
"Mathlib.Tactic.ITauto.IProp.and'",
"Mathlib.Tactic.ITauto.IProp.var",
"Mathlib.Tactic.ITauto.IProp.false",
"Mathlib.Tactic.ITauto.IProp.imp",
"Mathlib.Tactic.ITauto.IProp.true",
"Mathlib.Tactic.ITauto.IProp.ctorElimType",
"Mathlib.Tact... | false |
Ordering | Init.Data.Ord.Basic | [
"Ordering.gt",
"Ordering.eq",
"Ordering.lt"
] | true |
List.Cursor | Std.Do.Triple.SpecLemmas | [
"List.Cursor.mk",
"List"
] | true |
Stream'.WSeq.drop.aux_none | Mathlib.Data.WSeq.Basic | [
"Nat.brecOn",
"Stream'.WSeq.drop.aux",
"Computation",
"Option.none",
"Computation.pure",
"Nat",
"Stream'.WSeq.drop.aux_none._f",
"Stream'.WSeq",
"Prod",
"Eq",
"Option"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.