name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra | Mathlib.Order.CompleteBooleanAlgebra | [
"CompleteAtomicBooleanAlgebra",
"CompleteBooleanAlgebra"
] | true |
instFunLikeAddActionHom | Mathlib.GroupTheory.GroupAction.Hom | [
"DFunLike.mk",
"instFunLikeAddActionHom._proof_1",
"VAdd",
"AddActionHom",
"AddActionHom.toFun",
"Eq",
"FunLike"
] | true |
IsChain.pairwiseDisjoint_sUnion | Mathlib.Data.Set.Pairwise.Chain | [
"Function.onFun",
"Set.PairwiseDisjoint",
"PartialOrder.toPreorder",
"Set.sUnion",
"Preorder.toLE",
"Disjoint",
"OrderBot",
"Membership.mem",
"PartialOrder",
"HasSubset.Subset",
"IsChain.pairwise_sUnion",
"Iff",
"IsChain",
"Set.instMembership",
"Set.instHasSubset",
"Set"
] | true |
CategoryTheory.PreZeroHypercover.empty_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | [
"CategoryTheory.PreZeroHypercover.X",
"PEmpty",
"PEmpty.elim",
"Eq.refl",
"Eq",
"CategoryTheory.PreZeroHypercover.empty",
"CategoryTheory.Category"
] | true |
instBoundedMulOfLipschitzMul | Mathlib.Topology.Bornology.BoundedOperation | [
"Set.instSProd",
"Set.ext",
"Monoid",
"Eq.mpr",
"Prod.pseudoEMetricSpaceMax",
"LipschitzWith",
"HMul.hMul",
"PseudoMetricSpace.toBornology",
"_private.Mathlib.Topology.Bornology.BoundedOperation.0.instBoundedMulOfLipschitzMul.match_4",
"BoundedMul.mk",
"BoundedMul",
"Monoid.toMulOneClass",
"... | true |
_private.Mathlib.RingTheory.PowerSeries.Substitution.0.PowerSeries.coeff_subst_sum_C_substInvFun_mul_X_pow_sub_X._simp_1_11 | Mathlib.RingTheory.PowerSeries.Substitution | [
"MvPowerSeries",
"RingHom",
"MvPowerSeries.constantCoeff",
"PowerSeries.constantCoeff.eq_def",
"PowerSeries.constantCoeff",
"MvPowerSeries.instSemiring",
"Unit",
"Semiring",
"PowerSeries",
"Eq.symm",
"Semiring.toNonAssocSemiring",
"Eq"
] | false |
Int8.ofNat_le_iff_le | Init.Data.SInt.Lemmas | [
"Iff.mpr",
"instPowNat",
"Eq.mpr",
"congrArg",
"Iff.rfl",
"Int8.instNeg",
"Int8.minValue",
"Int8",
"Int.le_of_lt_add_one",
"Int8.toInt_neg",
"Int8.toInt",
"id",
"Int.instNegInt",
"instOfNatNat",
"Int",
"BitVec.toNat",
"LE.le",
"instLENat",
"Int.neg_ofNat_le_natCast._simp_1",
"N... | true |
WeierstrassCurve.instIsEllipticOfJ1728OfFactIsUnitOfNat | Mathlib.AlgebraicGeometry.EllipticCurve.ModelsWithJ | [
"Monoid",
"Eq.mpr",
"WeierstrassCurve.Δ",
"NegZeroClass.toNeg",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Mathlib.Meta.NormNum.isNat_eq_true",
"WeierstrassCurve.ofJ1728",
"WeierstrassCurve.IsElliptic",
"Monoid.toMulOneClass",
"congrArg",
"C... | true |
AddRightCancelMonoid.toAddMonoid_injective | Mathlib.Algebra.Group.Ext | [
"IsRightCancelAdd",
"AddMonoid.toAddSemigroup",
"AddMonoid.mk",
"Eq.rec",
"instOfNatNat",
"AddMonoid.mk.noConfusion",
"AddSemigroup",
"AddRightCancelMonoid",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"Nat",
"AddRightCancelMonoid.toAddMonoid",
"AddMonoid",
"eq_of_heq",
"Eq.ndrec",
... | true |
Subsemigroup.mem_sInf | Mathlib.Algebra.Group.Subsemigroup.Basic | [
"Set.mem_iInter₂",
"Mul",
"Membership.mem",
"Iff",
"SetLike.coe",
"Subsemigroup",
"Subsemigroup.instInfSet",
"Subsemigroup.instSetLike",
"Set.instMembership",
"SetLike.instMembership",
"InfSet.sInf",
"Set"
] | true |
Homeomorph.inv₀._proof_2 | Mathlib.Topology.Algebra.GroupWithZero | [
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"GroupWithZero.toDivInvMonoid",
"GroupWithZero",
"Subtype",
"Ne",
"Inv.inv",
"MonoidWithZero.toMulZeroOneClass",
"Zero.toOfNat0",
"inv_ne_zero",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"Subtype.val",
"MulZeroClass.toZero",
... | false |
MvPolynomial.instAddCommGroupR._proof_19 | Mathlib.FieldTheory.Finite.Polynomial | [
"Submodule",
"Submodule.addSubgroupClass",
"Nat.instMulZeroClass",
"CommRing",
"Semiring.toModule",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"MvPolynomial.instAddCommGroupR._proof_10",
"MvPolynomial.instAddCommGroupR._proof_11",
"Add.mk",
"AddMonoid.toZero",
"MvPolynomial.ins... | false |
ReflBEq.casesOn | Init.Core | [
"ReflBEq.mk",
"ReflBEq.rec",
"Bool.true",
"BEq.beq",
"ReflBEq",
"Bool",
"BEq",
"Eq"
] | false |
Units.coe_neg_one | Mathlib.Algebra.Ring.Units | [
"Monoid",
"Units.val",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Units.instNeg",
"Units",
"MulOne.toMul",
"Units.instOne",
"MulOneClass.toMulOne",
"HasDistribNeg",
"One.toOfNat1",
"HasDistribNeg.toInvolutiveNeg",
"InvolutiveNeg.toNeg",
"OfNat.ofNat",
"Eq",
"Neg.neg",
"rfl"
] | true |
AddCommGrpCat.Hom.rec | Mathlib.Algebra.Category.Grp.Basic | [
"AddMonoid.toAddZeroClass",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"AddCommGrpCat.Hom",
"AddCommGrpCat.carrier",
"AddGroup.toSubNegMonoid",
"AddCommGrpCat",
"_private.Mathlib.Algebra.Category.Grp.Basic.0.AddCommGrpCat.Hom.mk",
"SubNegMonoid.toAddMonoid",
"AddCommGrpCat.str",
"AddMo... | false |
Tactic.ComputeAsymptotics.Seq.FriendlyOperation.ite | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | [
"Eq.mpr",
"instDecidableNot",
"Stream'.Seq",
"Real.instLE",
"Real",
"Option.instDecidableEq",
"congrArg",
"Tactic.ComputeAsymptotics.Seq.instMetricSpaceSeq",
"Classical.propDecidable",
"Tactic.ComputeAsymptotics.Seq.dist_eq_one_of_head",
"Eq.mp",
"id",
"Ne",
"Stream'.Seq.head",
"Classica... | true |
AddCommGroup.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | [
"instNeZeroNatHAdd_1",
"Zero.ofOfNat0",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"NeZero",
"OfNat.ofNat"
] | false |
LocallyConstant.toContinuousMapLinearMap_apply | Mathlib.Topology.ContinuousMap.LocallyConstant | [
"DistribMulAction.toDistribSMul",
"LocallyConstant.instAddCommMonoid",
"ContinuousMap",
"AddMonoid.toAddZeroClass",
"LinearMap.instFunLike",
"AddZeroClass.toAddZero",
"ContinuousMap.module",
"DistribSMul.toSMulZeroClass",
"LocallyConstant",
"ContinuousConstSMul",
"ContinuousMap.instAddCommMonoid... | true |
NumberField.integralBasis_apply | Mathlib.NumberTheory.NumberField.Basic | [
"AddCommGroup.intIsScalarTower",
"NumberField.integralBasis",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Algebra.algebraMap",
"NumberField.instCommRingRingOfIntegers",
"CommSemiring.toSemiring",
"Rat",
"Module.Basis.localizationLocalization_apply",
"NumberFie... | true |
Std.Tactic.BVDecide.LRAT.Internal.Formula.sat_iff_forall | Std.Tactic.BVDecide.LRAT.Internal.CNF | [
"_private.Std.Tactic.BVDecide.LRAT.Internal.CNF.0.Std.Tactic.BVDecide.LRAT.Internal.Formula.sat_iff_forall._proof_1_1",
"Eq.mpr",
"List.all",
"Std.Tactic.BVDecide.LRAT.Internal.Clause.instEntails",
"Std.Tactic.BVDecide.LRAT.Internal.Clause.instDecidableEval",
"congrArg",
"Std.Tactic.BVDecide.LRAT.Intern... | true |
Height.mulHeight₁_pos | Mathlib.NumberTheory.Height.Basic | [
"Real.partialOrder",
"Real",
"Real.instZero",
"Real.instZeroLEOneClass",
"PartialOrder.toPreorder",
"Real.instLT",
"Height.AdmissibleAbsValues",
"Height.one_le_mulHeight₁",
"Real.instFloorRing",
"Real.instRing",
"Real.instOne",
"zero_lt_one",
"LT.lt.trans_le",
"LT.lt",
"Height.mulHeight₁... | true |
Real.continuous_arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | [
"Real",
"Continuous",
"Homeomorph.continuous",
"Real.sinhHomeomorph",
"PseudoMetricSpace.toUniformSpace",
"Real.arsinh",
"Homeomorph.symm",
"Real.pseudoMetricSpace",
"UniformSpace.toTopologicalSpace"
] | true |
TensorialAt.mkHom._proof_5 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | [
"VectorBundle.continuousLinearEquivAt",
"NormedCommRing.toSeminormedCommRing",
"NormedSpace.toIsBoundedSMul",
"NormedSpace",
"ContinuousSMul",
"FiberBundle",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.t... | false |
_private.Init.Data.String.Basic.0.String.Slice.Pos.copy._proof_1 | Init.Data.String.Basic | [
"Iff.mpr",
"String.Slice.Pos.offset",
"String.Slice.Pos.isValidForSlice",
"String.Slice",
"String.Pos.Raw.IsValidForSlice",
"String.Slice.copy",
"String.Slice.Pos",
"String.Pos.Raw.isValid_copy_iff",
"String.Pos.Raw.IsValid"
] | false |
HurwitzZeta.differentiableAt_completedCosZeta | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | [
"WeakFEPair.differentiableAt_Λ",
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"False",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"Semiring.toModule",
"NormedRing.toRing",
"Gro... | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mulLeftMono.match_3 | Mathlib.SetTheory.Ordinal.Arithmetic | [
"Ordinal.partialOrder",
"Ordinal.isEquivalent",
"PartialOrder.toPreorder",
"Preorder.toLE",
"IsWellOrder",
"LE.le",
"Quotient.mk",
"WellOrder.mk",
"WellOrder",
"Ordinal",
"WellOrder.casesOn"
] | false |
CalcParams.indent | Mathlib.Tactic.Widget.Calc | [
"CalcParams",
"Nat"
] | true |
Congr!.Config.closePost | Mathlib.Tactic.CongrExclamation | [
"Bool",
"Congr!.Config"
] | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._proof_15 | Mathlib.Algebra.Lie.Extension | [
"LieHom",
"LieAlgebra.toModule",
"LieSubmodule.instSetLike",
"Eq.mpr",
"Subtype.mk.congr_simp",
"Function.LeftInverse",
"CommRing",
"instHSMul",
"LieAlgebra.Extension",
"map_sub",
"LieAlgebra.Extension.proj",
"SemilinearMapClass.distribMulActionSemiHomClass",
"AddMonoid.toAddSemigroup",
"L... | false |
MonotoneOn.intervalIntegrable_slope | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | [
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NormedCommRing.toSeminormedCommRing",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"Real.partialOrder",
"Real.instLE",
"Real",
"Preorder.toLT",
"Semiring.toModu... | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.mk.inj | Lean.Elab.Tactic.Induction | [
"Lean.Elab.Tactic.ElimTargetView",
"Lean.Meta.GeneralizeArg",
"_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.mk.noConfusion",
"Lean.Expr",
"And",
"_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo",
"And.intro",
"_private.Lean.Elab.Tactic.Induction.0.Lean.El... | true |
MeasureTheory.laverage_const | Mathlib.MeasureTheory.Integral.Average | [
"MeasureTheory.lintegral_const",
"instHSMul",
"MeasureTheory.Measure",
"instSMulOfMul",
"HMul.hMul",
"MeasureTheory.laverage",
"congrArg",
"CommSemiring.toSemiring",
"MeasureTheory.isProbabilityMeasureSMul",
"Set.univ",
"MeasureTheory.IsProbabilityMeasure.measure_univ",
"MeasureTheory.Measure.... | true |
_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.maybeProveInjective.match_1 | Mathlib.Tactic.ApplyFun | [
"Option.ctorIdx",
"_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.maybeProveInjective._sparseCasesOn_1",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"Option"
] | false |
eq_of_forall_symmetric | Mathlib.Topology.UniformSpace.Separation | [
"Filter.instMembership",
"UniformSpace",
"Eq.mpr",
"SetRel",
"uniformity",
"Membership.mem",
"id",
"Prod.mk",
"And",
"SetRel.IsSymm",
"T0Space",
"Prod",
"UniformSpace.toTopologicalSpace",
"Eq",
"Set.instMembership",
"UniformSpace.hasBasis_symmetric",
"Filter",
"and_imp._simp_1",
... | true |
Set.countable_setOf_nonempty_of_disjoint | Mathlib.Data.Set.Countable | [
"Iff.mpr",
"Eq.mpr",
"Function.Injective.countable",
"Function.onFun",
"CompleteBooleanAlgebra.toCompleteDistribLattice",
"congrArg",
"Classical.byContradiction",
"PartialOrder.toPreorder",
"setOf",
"Subtype.casesOn",
"Preorder.toLE",
"Disjoint",
"Membership.mem",
"Exists",
"SemilatticeI... | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofAbelian._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Abelian | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex",
"CategoryTheory.ShortComplex.X₁",
"CategoryTheory.Limits.cokernel",
"CategoryTheory.Abelian",
"CategoryTheory.Limits.cokernel.condition",
"CategoryTheory.Limit... | false |
Matrix.kroneckerStarAlgEquiv._proof_1 | Mathlib.RingTheory.MatrixAlgebra | [
"Matrix.instStar",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semiring.toModule",
"SemilinearMapClass.distribMulActionSemiHomClass",
"Matrix.module",
"instDecidableEqProd",
"congrArg",
"CommSemiring.toSemiring",
"Matrix",
"TensorProduct.addMonoid",
"TensorProduct.addCommMonoid",
"AddMonoid.to... | false |
IO.Error.unsatisfiedConstraints.inj | Init.System.IOError | [
"IO.Error.unsatisfiedConstraints.noConfusion",
"String",
"And",
"And.intro",
"UInt32",
"IO.Error",
"Eq",
"IO.Error.unsatisfiedConstraints"
] | true |
Lean.Elab.Term.instInhabitedArg | Lean.Elab.Arg | [
"Lean.Elab.Term.instInhabitedArg.default",
"Inhabited",
"Lean.Elab.Term.Arg",
"Inhabited.mk"
] | true |
Nat.finMulAntidiag_one | Mathlib.Algebra.Order.Antidiag.Nat | [
"Eq.mpr",
"MulOne.toOne",
"False",
"Nat.instMulZeroClass",
"_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.finMulAntidiag_one._simp_1_2",
"Finset.univ",
"Nat.instOne",
"and_true",
"Monoid.toMulOneClass",
"congrArg",
"Nat.unique_units",
"Finset",
"instInhabitedTrue",
"Finset.ext",
"Mem... | true |
CategoryTheory.MorphismProperty.LeftFractionRel.op | Mathlib.CategoryTheory.Localization.CalculusOfFractions | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.MorphismProperty.LeftFraction.op",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Quiver.Hom.op",
"Exists",
"CategoryTheory.MorphismProperty.op",
"CategoryTheory.MorphismProperty.RightFraction.f",
"CategoryTheory.MorphismProp... | true |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"Std.Tactic.BVDecide.BVExpr.PackedBitVec.casesOn",
"BitVec",
"Std.Tactic.BVDecide.BVExpr.PackedBitVec",
"Nat",
"HEq",
"Eq"
] | false |
Std.HashMap.contains_insert_self | Std.Data.HashMap.Lemmas | [
"BEq.rfl",
"Std.HashMap.contains",
"congrArg",
"Std.HashMap",
"LawfulHashable",
"Std.HashMap.contains_insert",
"Bool.true",
"EquivBEq.toReflBEq",
"BEq.beq",
"EquivBEq",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Bool.or",
"Bool.true_or",
"congrFun'",
"Hashable",
"BEq",
"Eq",
"... | true |
Std.OrientedCmp.not_isLE_of_lt | Init.Data.Order.Ord | [
"Ordering.gt",
"Eq.mpr",
"congrArg",
"Ordering",
"Std.OrientedCmp",
"id",
"imp_self._simp_1",
"Ordering.swap",
"Bool.true",
"Ordering.swap_eq_lt._simp_1",
"implies_congr",
"Ordering.lt",
"Bool.not_eq_true",
"True",
"Bool",
"of_eq_true",
"Ordering.isLE_eq_false._simp_1",
"Std.Orient... | true |
DFinsupp.sumAddHom | Mathlib.Data.DFinsupp.BigOperators | [
"DFinsupp.sumAddHom._proof_2",
"DFinsupp.sumZeroHom",
"AddMonoid.toAddZeroClass",
"AddMonoidHom.toZeroHom",
"AddZeroClass.toAddZero",
"AddMonoidHom.mk",
"DFinsupp.addZeroClass",
"ZeroHom",
"AddCommMonoid",
"AddZero.toZero",
"AddZeroClass",
"DFinsupp.instZero",
"DFinsupp",
"AddCommMonoid.to... | true |
Lean.ForEachExprWhere.ForEachM | Lean.Util.ForEachExprWhere | [
"StateRefT'",
"Lean.ForEachExprWhere.State",
"STWorld"
] | true |
RightCancelMonoid.pow_eq_pow_iff_modEq | Mathlib.GroupTheory.OrderOfElement | [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"Trans.trans",
"Dvd.dvd",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"Nat.instAddMonoid",
"pow_add",
"Nat.exists_eq_add_of_le",
"Exists",
"Eq.mp",
"id",
"MulOne.toMul",
"le_of_not_ge",
"instOfNatNat... | true |
_private.Mathlib.Algebra.CharP.Defs.0.CharP.char_is_prime_or_zero.match_1_1 | Mathlib.Algebra.CharP.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"instHAdd",
"NonAssocSemiring",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.zero",
"CharP",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
Rep.quotientToCoinvariantsFunctor._proof_5 | Mathlib.RepresentationTheory.Coinvariants | [
"Rep.coinvariantsFunctor",
"Rep.V",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"Representation.ofQuotient",
"LinearMap.comp.congr_simp",
"Rep.quotientToCoinvariantsFunctor._proof_3",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"Monoid.toMulOneClass",
"Lin... | false |
MeasureTheory.eventually_sub_right_iff | Mathlib.MeasureTheory.Group.Measure | [
"Filter.instMembership",
"MeasureTheory.ae",
"Eq.mpr",
"MeasureTheory.Measure",
"congrArg",
"Filter.map",
"Filter.Eventually",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"setOf",
"HSub.hSub",
"MeasureTheory.map_sub_right_ae",
"Membership.mem",
"Eq.rec",
"AddZeroClass.toAddZero",
"id",
"M... | true |
AlternatingMap.map_basis_eq_zero_iff | Mathlib.LinearAlgebra.Determinant | [
"AlternatingMap",
"CommRing",
"Algebra.to_smulCommClass",
"instHSMul",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Finite",
"AlternatingMap.zero_apply",
"Module.t... | true |
CategoryTheory.ShortComplex.Exact.moduleCat_of_range_eq_ker._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | [
"Eq.mpr",
"Submodule",
"RingHomSurjective.ids",
"le_refl",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"PartialOrder.toPreorder",
"LinearMap.ker",
"Preorder.toLE",
"LinearMap.range",
"id",
"Submodule.instPartialOrder",
... | false |
Std.Time.instHAddOffsetOffset_8 | Std.Time.Date.Basic | [
"Rat.instOfNat",
"instHDiv",
"Rat",
"HDiv.hDiv",
"Std.Time.Minute.Offset",
"HAdd",
"Std.Time.Millisecond.Offset",
"Std.Time.Internal.UnitVal.add",
"Std.Time.Minute.Offset.toMilliseconds",
"OfNat.ofNat",
"HAdd.mk",
"Rat.instDiv"
] | true |
Filter.map_neg' | Mathlib.Order.Filter.Pointwise | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"Filter.map",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"Function.Semiconj.filter_map",
"AddMonoidHomClass",
"SubtractionMonoid.toSubNegZeroMonoid",
"map_neg",
"SubtractionMonoid.toSubNegMonoid",
"SubNegZeroMonoid.toNegZeroClass",... | true |
Asymptotics.isBigOWith_map | Mathlib.Analysis.Asymptotics.Defs | [
"Norm.norm",
"Eq.mpr",
"Real.instLE",
"Real",
"HMul.hMul",
"Asymptotics.IsBigOWith",
"Asymptotics.IsBigOWith_def",
"congrArg",
"Filter.map",
"Filter.Eventually",
"Function.comp",
"Norm",
"id",
"LE.le",
"Filter.eventually_map",
"Iff",
"Real.instMul",
"congr",
"Eq",
"Filter",
"... | true |
Matroid.IsColoop.insert_indep_of_indep | Mathlib.Combinatorics.Matroid.Loop | [
"Eq.mpr",
"congrArg",
"Matroid.IsColoop.mem_ground",
"Membership.mem",
"em",
"Set.insert_eq_of_mem",
"Matroid.Indep",
"id",
"Insert.insert",
"Matroid.IsColoop",
"Matroid.IsColoop.notMem_closure_of_notMem",
"Set.instInsert",
"Matroid.Indep.notMem_closure_iff_of_notMem",
"propext",
"Matroi... | true |
integrableOn_Ico_iff_integrableOn_Ioo'._auto_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Filter.Germ.instMulZeroClass._proof_2 | Mathlib.Order.Filter.Germ.Basic | [
"Filter.Germ.ofFun",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Pi.mulZeroClass",
"Filter.germSetoid",
"MulZeroClass",
"Filter.Germ.instMul",
"MulZeroClass.mul_zero",
"Quotient",
"Filter.Germ",
"Filter.Germ.instZero",
"Quotient.ind'",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Filte... | false |
AddSubmonoidClass.finsuppSum_mem | Mathlib.Algebra.BigOperators.Finsupp.Basic | [
"SetLike",
"Finsupp.mem_support_iff",
"Finsupp.instFunLike",
"Finset",
"AddMonoid.toAddZeroClass",
"Finsupp.sum",
"Finsupp.support",
"Membership.mem",
"AddSubmonoidClass",
"Ne",
"AddCommMonoid",
"Finset.instSetLike",
"Iff.mp",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"OfNat.ofNat"... | true |
CategoryTheory.Functor.CommShift.isoZero | Mathlib.CategoryTheory.Shift.CommShift | [
"CategoryTheory.Functor",
"AddMonoid.toAddZeroClass",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.rightUnitor",
"CategoryTheory.Functor.comp",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Functor.id",
"CategoryTheory.shiftFunctorZero",
"AddZeroClass.toAddZero",
"CategoryTheory.Iso... | true |
SkewMonoidAlgebra.of._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | [
"Monoid",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"SkewMonoidAlgebra.instMul",
"AddZeroClass.toAddZero",
"SkewMonoidAlgebra.single_mul_single",
"MulO... | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.Fintype.not_linearIndependent_iffₒₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | [
"Exists",
"propext",
"Classical.not_forall",
"Eq",
"Not"
] | false |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_ae_parallelepiped._simp_1_4 | Mathlib.Algebra.Module.ZLattice.Basic | [
"Preorder.toLT",
"Set.mem_Ico",
"Preorder.toLE",
"Membership.mem",
"LE.le",
"Set.Ico",
"And",
"LT.lt",
"propext",
"Eq",
"Set.instMembership",
"Preorder",
"Set"
] | false |
StrictAnti.not_bddBelow_range_of_isPredArchimedean | Mathlib.Order.SuccPred.Archimedean | [
"OrderDual.toDual",
"Preorder.toLT",
"Equiv.instEquivLike",
"NoMaxOrder",
"StrictMono.not_bddAbove_range_of_isSuccArchimedean",
"Preorder.toLE",
"Function.comp",
"Equiv",
"IsPredArchimedean",
"StrictAnti",
"StrictAnti.dual_right",
"BddBelow",
"instSuccOrderOrderDualOfPredOrder",
"Nonempty"... | true |
Units.eq_inv_of_mul_eq_one_right | Mathlib.Algebra.Group.Units.Basic | [
"Monoid",
"Units.val",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"Units",
"Units.inv_eq_of_mul_eq_one_left",
"MulOne.toMul",
"MulOneClass.toMulOne",
"Inv.inv",
"One.toOfNat1",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Units.instInv",
"instHMul"
] | true |
Std.ExtTreeMap.maxKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | [
"instDecidableEqOrdering",
"Std.ExtTreeMap.maxKey?",
"Ordering",
"Std.ExtDTreeMap.maxKeyD_insertIfNew",
"Std.TransCmp",
"Std.ExtTreeMap",
"Std.ExtTreeMap.inner",
"Ordering.lt",
"Std.ExtTreeMap.insertIfNew",
"Option.elim",
"Eq",
"Std.ExtTreeMap.maxKeyD",
"ite"
] | true |
SchwartzMap.instAddCommGroup | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | [
"SchwartzMap.instAddCommGroup._proof_4",
"SchwartzMap.instZero",
"Real",
"NormedSpace",
"SchwartzMap.instSub",
"SchwartzMap.instAddCommGroup._proof_1",
"AddCommGroup",
"SchwartzMap",
"SchwartzMap.instNeg",
"SchwartzMap.instFunLike",
"SchwartzMap.instAddCommGroup._proof_2",
"SchwartzMap.instAdd... | true |
PFun.prodLift_fst_comp_snd_comp | Mathlib.Data.PFun | [
"Iff.mpr",
"Part",
"Part.mk",
"PFun",
"PFun.prodLift",
"Iff.of_eq",
"congrArg",
"Part.bind",
"Part.some",
"Part.bind_some",
"Membership.mem",
"Exists",
"Part.instMembership",
"Prod.mk",
"Part.mem_mk_iff._simp_1",
"Part.get",
"Prod.fst",
"iff_self",
"funext",
"And",
"Iff",
"... | true |
Complex.cos_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | [
"Real.pi",
"HMul.hMul",
"Complex.cos",
"Nat.instAtLeastTwoHAddOfNat",
"Function.Periodic.nat_mul",
"Complex.instMul",
"instOfNatNat",
"Complex.instNatCast",
"Complex.ofReal",
"Nat.cast",
"Complex.cos_periodic",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"Complex.instAdd",
... | true |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_2 | Mathlib.Algebra.Order.Ring.Idempotent | [
"add_mul",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semigroup.toMul",
"HMul.hMul",
"mul_mul_mul_comm",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"CommSemiring.toSemiring",
"MulZeroClass.zero_mul",
"AddMonoid.toAddZeroClass",
"NonUnitalCommSemiring.toCommSemigroup",
"Di... | false |
Aesop.instEmptyCollectionLocalRuleSet | Aesop.RuleSet | [
"EmptyCollection.mk",
"Aesop.LocalRuleSet",
"Aesop.LocalRuleSet.empty",
"EmptyCollection"
] | true |
Lean.Lsp.InlayHintLabel.ctorElimType | Lean.Data.Lsp.LanguageFeatures | [
"cond",
"Nat.ble",
"Lean.Lsp.InlayHintLabelPart",
"String",
"Lean.Lsp.InlayHintLabel",
"PULift",
"Lean.Lsp.InlayHintLabel.name",
"Array",
"Nat",
"Lean.Lsp.InlayHintLabel.parts"
] | false |
PositiveLinearMap.toLinearMap_nsmul | Mathlib.Algebra.Order.Module.PositiveLinearMap | [
"instHSMul",
"PartialOrder.toPreorder",
"AddMonoid.toNSMul",
"PartialOrder",
"LinearMap",
"AddCommMonoid",
"LinearMap.addMonoid",
"Nat",
"PositiveLinearMap",
"Semiring",
"PositiveLinearMap.instSMulNat",
"HSMul.hSMul",
"Module",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Eq",
"IsOr... | true |
MeasureTheory.lpTrimToLpMeasSubgroup_ae_eq | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"MeasurableSpace.instLE",
"MeasureTheory.Lp.memLp",
"MeasureTheory.AEEqFun.cast",
"MeasureTheory.lpTrimToLpMeasSubgroup",
"MeasureTheory.Measure.trim",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"AddSubgroup.toAddGroup",
"Membershi... | true |
Lean.Omega.Constraint.instToString._private_1 | Init.Omega.Constraint | [
"_private.Init.Omega.Constraint.0.Lean.Omega.instAppendString",
"String",
"Int.instDecidableEq",
"Int",
"ToString.toString",
"Int.instLTInt",
"instHAppendOfAppend",
"Unit",
"_private.Init.Omega.Constraint.0.Lean.Omega.Constraint.instToString.match_1",
"LT.lt",
"Int.decLt",
"Lean.Omega.Constrai... | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_7 | Mathlib.Analysis.MeanInequalities | [
"AddGroup.toSubtractionMonoid",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"AddRightMono",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNegZeroMonoid.toNegZeroClass",
"LE",
"SubNegMonoid.toSub",
"AddGroup",
"instHSub",
"AddGroup.toSubNegMonoid",
"propext",
... | false |
Lean.Elab.Tactic.DiscrTreeKey.evalDiscrTreeSimpKeyCmd | Lean.Elab.Tactic.DiscrTreeKey | [
"Lean.TSyntax",
"Lean.MessageData",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Command.CommandElab",
"Lean.Elab.Command.liftTermElabM",
"Lean.Meta.DiscrTree.keysAsPattern",
"_private.Lean.Elab.Tactic.DiscrTreeKey.0.Lean.Elab.Tactic.DiscrTreeKey.mkKey",
"Lean.Elab.Term.instMonadTermElabM",
"R... | true |
Std.TreeMap.maxKey! | Std.Data.TreeMap.Basic | [
"Std.TreeMap.inner",
"Ordering",
"Inhabited",
"Std.DTreeMap.maxKey!",
"Std.TreeMap"
] | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Lean.Elab.Tactic.Conv.PatternMatchState.all.inj | Lean.Elab.Tactic.Conv.Pattern | [
"Lean.MVarId",
"Array",
"Lean.Elab.Tactic.Conv.PatternMatchState.all.noConfusion",
"Lean.Elab.Tactic.Conv.PatternMatchState",
"Lean.Elab.Tactic.Conv.PatternMatchState.all",
"Eq"
] | true |
CategoryTheory.MorphismProperty.instCopyDiscardCategoryWideSubcategoryOfIsStableUnderComonoid._proof_8 | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | [
"CategoryTheory.MorphismProperty.IsStableUnderComonoid",
"CategoryTheory.MorphismProperty",
"CategoryTheory.WideSubcategory.obj",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.MorphismProperty.instComonObjWideSubcategoryOfIsStableUnderComonoidObj",
"CategoryTheory... | false |
List.mapAsyncChunked | Mathlib.Data.List.Defs | [
"Task",
"List.map",
"Task.spawn",
"List.toChunks",
"instOfNatNat",
"Task.Priority.default",
"List",
"Unit",
"Task.get",
"Nat",
"optParam",
"OfNat.ofNat",
"List.flatMap"
] | true |
CategoryTheory.Functor.comp_mapGrp_mul | Mathlib.CategoryTheory.Monoidal.Grp | [
"CategoryTheory.Functor",
"CategoryTheory.Functor.mapGrp",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.comp",
"CategoryTheory.Grp.instCategory",
"CategoryTheory.GrpObj.toMonObj",
"CategoryTheory.Grp.grp",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCat... | true |
Perfection.coeff | Mathlib.RingTheory.Perfection | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Perfection.coeff._proof_2",
"Nat.Prime",
"RingHom.mk",
"Perfection",
"Perfection.coeffMonoidHom",
"Perfection.instCommMonoid",
"MonoidHom",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"RingHom",
"Fact",
"Perfection.coeff._proof_1",
"AddCom... | true |
Subgroup.div_mem | Mathlib.Algebra.Group.Subgroup.Defs | [
"Subgroup.instSubgroupClass",
"instHDiv",
"div_mem",
"Group",
"Membership.mem",
"HDiv.hDiv",
"Subgroup",
"Group.toDivInvMonoid",
"DivInvMonoid.toDiv",
"SetLike.instMembership",
"Subgroup.instSetLike"
] | true |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?.match_8 | Lean.Meta.Tactic.Grind.PropagateInj | [
"_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_1",
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Lean.Meta.Grind.InjectiveInfo",
"Option"
] | false |
existsUnique_eq' | Mathlib.Logic.ExistsUnique | [
"_private.Mathlib.Logic.ExistsUnique.0.existsUnique_eq'._simp_1_3",
"congrArg",
"and_self",
"Exists",
"funext",
"And",
"ExistsUnique",
"True",
"of_eq_true",
"Eq",
"_private.Mathlib.Logic.ExistsUnique.0.existsUnique_eq'._simp_1_2",
"Eq.trans"
] | true |
FirstOrder.Language.Relations.transitive._proof_1 | Mathlib.ModelTheory.Syntax | [
"instNeZeroNatHAdd_1",
"Zero.ofOfNat0",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"NeZero",
"OfNat.ofNat"
] | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | [
"SizeOf.mk",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof",
"SizeOf",
"Lean.Meta.Grind.Arith.Cutsat.EqCnstr._sizeOf_2"
] | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Cycle.formPerm_subsingleton._simp_1_5 | Mathlib.GroupTheory.Perm.Cycle.Concrete | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"IsBotZeroClass",
"propext",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"nonpos_iff_eq_zero",
"Zero"
] | false |
Nat.toInt8 | Init.Data.SInt.Basic | [
"Int8",
"Nat",
"Int8.ofNat"
] | true |
_private.Mathlib.FieldTheory.Isaacs.0.Field.nonempty_algEquiv_of_aeval_eq_zero_eq.match_1_1 | Mathlib.FieldTheory.Isaacs | [
"AlgHom",
"Algebra",
"Nonempty.intro",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"Nonempty.casesOn",
"DivisionSemiring.toSemiring",
"Nonempty",
"Semifield.toCommSemiring",
"Field"
] | false |
CategoryTheory.Comma.mapLeft.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.mk",
"CategoryTheory.Functor.category",
"CategoryTheory.Comma.left",
"CategoryTheory.Comma.hom",
"CategoryTheory.CommaMorphism.mk",
"CategoryTheory.Comma",
"Cat... | true |
AddSubmonoid.mem_multiples_iff | Mathlib.Algebra.Group.Submonoid.Membership | [
"instHSMul",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"AddMonoid.toNSMul",
"Membership.mem",
"Exists",
"AddSubmonoid",
"Iff",
"Nat",
"AddSubmonoid.multiples",
"AddMonoid",
"HSMul.hSMul",
"AddSubmonoid.instSetLike",
"Eq",
"SetLike.instMembership"
] | true |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.IsFractional.mapEquiv._simp_1_4 | Mathlib.RingTheory.FractionalIdeal.Operations | [
"Exists",
"forall_exists_index",
"propext",
"Exists.intro",
"Eq"
] | false |
Lean.IR.NormalizeIds.normJP | Lean.Compiler.IR.NormIds | [
"Lean.IR.IndexRenaming",
"Lean.IR.JoinPointId.idx",
"Lean.IR.NormalizeIds.normIndex",
"Id",
"Lean.IR.JoinPointId.mk",
"Lean.IR.NormalizeIds.M",
"Lean.IR.JoinPointId",
"Id.instMonad",
"ReaderT.instFunctorOfMonad",
"Functor.map",
"Lean.IR.Index"
] | true |
Lean.Compiler.LCNF.ExtractClosed.shouldExtractFVar | Lean.Compiler.LCNF.ExtractClosed | [
"Inhabited.default",
"instInhabitedOfMonad",
"instInhabitedBool",
"Lean.Compiler.LCNF.ExtractClosed.M",
"IO.RealWorld",
"Lean.FVarId",
"Lean.Compiler.LCNF.ExtractClosed.State",
"StateRefT'",
"Lean.Compiler.LCNF.instMonadCompilerM",
"StateRefT'.instMonad",
"Lean.Compiler.LCNF.CompilerM",
"Bool"... | true |
Nat.length_toList_rio | Init.Data.Range.Polymorphic.NatLemmas | [
"congrArg",
"Std.PRange.instHasSizeNat_1",
"Std.Rio.mk",
"Std.PRange.instLawfulUpwardEnumerableLTNat",
"Std.PRange.instIsAlwaysFiniteNat_1",
"Nat.size_rio",
"Std.PRange.instLawfulHasSizeNat_1",
"Std.PRange.instUpwardEnumerableNat",
"Std.Rio.toList",
"Nat",
"Std.Rio.length_toList",
"True",
"e... | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.instIteratorId.match_1.eq_5 | Init.Data.String.Slice | [
"Std.IterStep",
"String.Slice.Pattern.SearchStep",
"String.Slice.SplitInclusiveIterator",
"String.Slice",
"Std.IterStep.skip",
"Std.IterM.mk",
"String.Slice.Pattern.ToForwardSearcher",
"Id",
"String.Slice.SplitInclusiveIterator.instIteratorId.match_1",
"Unit",
"Std.Iter",
"Std.IterStep.yield",... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.length_bypass_le._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Paths | [
"Lean.RArray.leaf",
"False",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"SimpleGraph.Walk.length",
"Classical.byContradiction",
"Nat.not_le_eq",
"Nat.ToInt.add_congr",
"SimpleGraph.Walk",
"Lean.RArray.branch",
"Nat.ToInt.natCast_ofNat",
"Int.Linear.Expr.add",
"SimpleGraph.Walk.bypass"... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.