name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
map_eq_zero_iff_eq_zero | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : FunLike F α β] [inst_1 : AddGroup α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [AddGroupNormClass F α β] (f : F) {x : α}, f x = 0 ↔ x = 0 |
_private.Mathlib.MeasureTheory.Measure.Haar.Quotient.0._aux_Mathlib_MeasureTheory_Measure_Haar_Quotient___macroRules__private_Mathlib_MeasureTheory_Measure_Haar_Quotient_0_termπ_1 | Mathlib.MeasureTheory.Measure.Haar.Quotient | Lean.Macro |
AddHom.fst._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_1) (N : Type u_2) [inst : Add M] [inst_1 : Add N] (x x_1 : M × N), (x + x_1).1 = (x + x_1).1 |
CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃}
{R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B)
{X₂ X₂' : C₂} {X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) (g' : R.obj X₂' ⟶ B.obj X₃) (γ γ_1 : X₂' ⟶ X₂) (e_γ : γ = γ_1)
(hγ : CategoryTheory.CategoryStruct.comp (R.map γ) g = g'),
w.costructuredArrowDownwardsPrecomp g g' γ hγ = w.costructuredArrowDownwardsPrecomp g g' γ_1 ⋯ |
AddMonoidAlgebra.semiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddMonoid M],
AddMonoidAlgebra.semiring =
{ toNonUnitalSemiring := AddMonoidAlgebra.nonUnitalSemiring, toOne := AddMonoidAlgebra.nonAssocSemiring.toOne,
one_mul := ⋯, mul_one := ⋯, toNatCast := AddMonoidAlgebra.nonAssocSemiring.toNatCast, natCast_zero := ⋯,
natCast_succ := ⋯, npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯ } |
NormedRing.toNonUnitalNormedRing._proof_9 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedRing α] (a : α), 0 * a = 0 |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SharedCoefficients.mk.inj | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | ∀ {common x y common_1 x_1 y_1 : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap},
{ common := common, x := x, y := y } = { common := common_1, x := x_1, y := y_1 } →
common = common_1 ∧ x = x_1 ∧ y = y_1 |
lcm_dvd_lcm_mul_left | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] (m n k : α), lcm m n ∣ lcm (k * m) n |
RCLike.mk.noConfusion | Mathlib.Analysis.RCLike.Basic | {K : semiOutParam (Type u_1)} →
{P : Sort u} →
{toDenselyNormedField : DenselyNormedField K} →
{toStarRing : StarRing K} →
{toNormedAlgebra : NormedAlgebra ℝ K} →
{toCompleteSpace : CompleteSpace K} →
{re im : K →+ ℝ} →
{I : K} →
{I_re_ax : re I = 0} →
{I_mul_I_ax : I = 0 ∨ I * I = -1} →
{re_add_im_ax : ∀ (z : K), (algebraMap ℝ K) (re z) + (algebraMap ℝ K) (im z) * I = z} →
{ofReal_re_ax : ∀ (r : ℝ), re ((algebraMap ℝ K) r) = r} →
{ofReal_im_ax : ∀ (r : ℝ), im ((algebraMap ℝ K) r) = 0} →
{mul_re_ax : ∀ (z w : K), re (z * w) = re z * re w - im z * im w} →
{mul_im_ax : ∀ (z w : K), im (z * w) = re z * im w + im z * re w} →
{conj_re_ax : ∀ (z : K), re ((starRingEnd K) z) = re z} →
{conj_im_ax : ∀ (z : K), im ((starRingEnd K) z) = -im z} →
{conj_I_ax : (starRingEnd K) I = -I} →
{norm_sq_eq_def_ax : ∀ (z : K), ‖z‖ ^ 2 = re z * re z + im z * im z} →
{mul_im_I_ax : ∀ (z : K), im z * im I = im z} →
{toPartialOrder : PartialOrder K} →
{le_iff_re_im : ∀ {z w : K}, z ≤ w ↔ re z ≤ re w ∧ im z = im w} →
{toDecidableEq : DecidableEq K} →
{toDenselyNormedField' : DenselyNormedField K} →
{toStarRing' : StarRing K} →
{toNormedAlgebra' : NormedAlgebra ℝ K} →
{toCompleteSpace' : CompleteSpace K} →
{re' im' : K →+ ℝ} →
{I' : K} →
{I_re_ax' : re' I' = 0} →
{I_mul_I_ax' : I' = 0 ∨ I' * I' = -1} →
{re_add_im_ax' :
∀ (z : K),
(algebraMap ℝ K) (re' z) +
(algebraMap ℝ K) (im' z) * I' =
z} →
{ofReal_re_ax' :
∀ (r : ℝ), re' ((algebraMap ℝ K) r) = r} →
{ofReal_im_ax' :
∀ (r : ℝ), im' ((algebraMap ℝ K) r) = 0} →
{mul_re_ax' :
∀ (z w : K),
re' (z * w) = re' z * re' w - im' z * im' w} →
{mul_im_ax' :
∀ (z w : K),
im' (z * w) =
re' z * im' w + im' z * re' w} →
{conj_re_ax' :
∀ (z : K),
re' ((starRingEnd K) z) = re' z} →
{conj_im_ax' :
∀ (z : K),
im' ((starRingEnd K) z) = -im' z} →
{conj_I_ax' : (starRingEnd K) I' = -I'} →
{norm_sq_eq_def_ax' :
∀ (z : K),
‖z‖ ^ 2 =
re' z * re' z + im' z * im' z} →
{mul_im_I_ax' :
∀ (z : K), im' z * im' I' = im' z} →
{toPartialOrder' : PartialOrder K} →
{le_iff_re_im' :
∀ {z w : K},
z ≤ w ↔
re' z ≤ re' w ∧
im' z = im' w} →
{toDecidableEq' : DecidableEq K} →
{
toDenselyNormedField :=
toDenselyNormedField,
toStarRing := toStarRing,
toNormedAlgebra :=
toNormedAlgebra,
toCompleteSpace :=
toCompleteSpace,
re := re, im := im,
I := I,
I_re_ax := I_re_ax,
I_mul_I_ax := I_mul_I_ax,
re_add_im_ax :=
re_add_im_ax,
ofReal_re_ax :=
ofReal_re_ax,
ofReal_im_ax :=
ofReal_im_ax,
mul_re_ax := mul_re_ax,
mul_im_ax := mul_im_ax,
conj_re_ax := conj_re_ax,
conj_im_ax := conj_im_ax,
conj_I_ax := conj_I_ax,
norm_sq_eq_def_ax :=
norm_sq_eq_def_ax,
mul_im_I_ax :=
mul_im_I_ax,
toPartialOrder :=
toPartialOrder,
le_iff_re_im :=
le_iff_re_im,
toDecidableEq :=
toDecidableEq } =
{
toDenselyNormedField :=
toDenselyNormedField',
toStarRing := toStarRing',
toNormedAlgebra :=
toNormedAlgebra',
toCompleteSpace :=
toCompleteSpace',
re := re', im := im',
I := I',
I_re_ax := I_re_ax',
I_mul_I_ax := I_mul_I_ax',
re_add_im_ax :=
re_add_im_ax',
ofReal_re_ax :=
ofReal_re_ax',
ofReal_im_ax :=
ofReal_im_ax',
mul_re_ax := mul_re_ax',
mul_im_ax := mul_im_ax',
conj_re_ax := conj_re_ax',
conj_im_ax := conj_im_ax',
conj_I_ax := conj_I_ax',
norm_sq_eq_def_ax :=
norm_sq_eq_def_ax',
mul_im_I_ax :=
mul_im_I_ax',
toPartialOrder :=
toPartialOrder',
le_iff_re_im :=
le_iff_re_im',
toDecidableEq :=
toDecidableEq' } →
(toDenselyNormedField ≍
toDenselyNormedField' →
toStarRing ≍ toStarRing' →
toNormedAlgebra ≍
toNormedAlgebra' →
re ≍ re' →
⋯ →
I ≍ I' →
toPartialOrder ≍
toPartialOrder' →
toDecidableEq ≍
toDecidableEq' →
P) →
P |
Std.IterM.Total.rec | Init.Data.Iterators.Consumers.Monadic.Total | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.IterM.Total m β → Sort u} →
((it : Std.IterM m β) → motive { it := it }) → (t : Std.IterM.Total m β) → motive t |
CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} (J' : Type u_2) (h : J ≃ J'),
(CategoryTheory.Functor.id (CategoryTheory.Limits.WidePullbackShape J)).obj none =
((CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h j)).comp
(CategoryTheory.Limits.WidePullbackShape.wideCospan none (fun j => some (h.invFun j)) fun j =>
CategoryTheory.Limits.WidePullbackShape.Hom.term (h.invFun j))).obj
none |
CategoryTheory.CartesianMonoidalCategory.fullSubcategory_tensorObj_obj | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{P : CategoryTheory.ObjectProperty C} [inst_2 : P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete PEmpty.{1})]
[inst_3 : P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)]
(X Y : P.FullSubcategory),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).obj =
CategoryTheory.MonoidalCategoryStruct.tensorObj X.obj Y.obj |
Quiver.Path.instDecidableEq._proof_3 | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (v w : V) (p q : Quiver.Path v w), ⟨p, ⋯⟩ = ⟨q, ⋯⟩ ↔ ↑⟨p, ⋯⟩ = ↑⟨q, ⋯⟩ |
HurwitzZeta.completedHurwitzZetaOdd | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | UnitAddCircle → ℂ → ℂ |
Field.finSepDegree_eq | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsAlgebraic F E],
Field.finSepDegree F E = Cardinal.toNat (Field.sepDegree F E) |
Std.DTreeMap.mem_union_of_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₂ → k ∈ t₁ ∪ t₂ |
GradeMinOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMin_grade : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMin_grade' : ∀ ⦃a : α⦄, IsMin a → IsMin (GradeOrder.grade a)} →
{ toGradeOrder := toGradeOrder, isMin_grade := isMin_grade } =
{ toGradeOrder := toGradeOrder', isMin_grade := isMin_grade' } →
(toGradeOrder ≍ toGradeOrder' → P) → P |
Mathlib.Tactic.Erw?.logDiffs | Mathlib.Tactic.ErwQuestion | Lean.Syntax → Lean.Expr → Lean.Expr → StateT (Array (Unit → Lean.MessageData)) Lean.MetaM Bool |
PrincipalSeg.pemptyToPUnit | Mathlib.Order.InitialSeg | PrincipalSeg emptyRelation emptyRelation |
CategoryTheory.Abelian.LeftResolution.karoubi_F | Mathlib.Algebra.Homology.LeftResolution.Reduced | ∀ {A : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive A] [inst_4 : ι.Additive],
Λ.karoubi.F = CategoryTheory.Abelian.LeftResolution.karoubi.F Λ |
CategoryTheory.Abelian.LeftResolution.chainComplexMap._proof_2 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) {X Y : A} [inst_2 : ι.Full] [inst_3 : ι.Faithful]
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_5 : CategoryTheory.Abelian A] (n : ℕ)
(p :
(f : (Λ.chainComplex X).X n ⟶ (Λ.chainComplex Y).X n) ×'
(f' : (Λ.chainComplex X).X (n + 1) ⟶ (Λ.chainComplex Y).X (n + 1)) ×'
CategoryTheory.CategoryStruct.comp f' ((Λ.chainComplex Y).d (n + 1) n) =
CategoryTheory.CategoryStruct.comp ((Λ.chainComplex X).d (n + 1) n) f),
CategoryTheory.CategoryStruct.comp (ι.map ((Λ.chainComplex X).d (n + 1) n)) (ι.map p.fst) =
CategoryTheory.CategoryStruct.comp (ι.map p.snd.fst) (ι.map ((Λ.chainComplex Y).d (n + 1) n)) |
SSet.Truncated.Path.map._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {n : ℕ} {X Y : SSet.Truncated (n + 1)} {m : ℕ} (f : X.Path m) (σ : X ⟶ Y) (i : Fin m),
((SSet.Truncated.trunc (n + 1) 1 ⋯).obj Y).map
(SimplexCategory.Truncated.Hom.tr (SimplexCategory.δ 1) SSet.Truncated.Path₁._proof_1
SSet.Truncated.Path₁._proof_5).op
(σ.app (Opposite.op { obj := SimplexCategory.mk 1, property := ⋯ }) (f.arrow i)) =
σ.app (Opposite.op { obj := SimplexCategory.mk 0, property := ⋯ }) (f.vertex i.castSucc) |
ProbabilityTheory.IsMeasurableRatCDF.measure_stieltjesFunction_Iic | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (a : α)
(x : ℝ), (hf.stieltjesFunction a).measure (Set.Iic x) = ENNReal.ofReal (↑(hf.stieltjesFunction a) x) |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo._sizeOf_1 | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.ArrowInfo✝ → ℕ |
UInt16.toBitVec_nsmul | Mathlib.Data.UInt | ∀ (n : ℕ) (a : UInt16), (n • a).toBitVec = n • a.toBitVec |
MeasureTheory.Filtration.rightCont_eq_self | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : LinearOrder ι] [SuccOrder ι]
(𝓕 : MeasureTheory.Filtration ι m), 𝓕.rightCont = 𝓕 |
GradedTensorProduct.liftEquiv._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_4} {ι : Type u_5} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ]
[inst_9 : Module ι (Additive ℤˣ)] {C : Type u_3} [inst_10 : Ring C] [inst_11 : Algebra R C]
(fg : { fg // ∀ ⦃i j : ι⦄ (a : ↥(𝒜 i)) (b : ↥(ℬ j)), fg.1 ↑a * fg.2 ↑b = (-1) ^ (j * i) • (fg.2 ↑b * fg.1 ↑a) }),
(fun F => ⟨(F.comp (GradedTensorProduct.includeLeft 𝒜 ℬ), F.comp (GradedTensorProduct.includeRight 𝒜 ℬ)), ⋯⟩)
((fun fg => GradedTensorProduct.lift 𝒜 ℬ (↑fg).1 (↑fg).2 ⋯) fg) =
fg |
instLinearOrderedAddCommMonoidWithTopOrderDualAdditive._proof_2 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] ⦃x : (Additive α)ᵒᵈ⦄, x ≠ ⊤ → IsAddLeftRegular x |
AlgebraicGeometry.PresheafedSpace.GlueData.vPullbackConeIsLimit | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(D : AlgebraicGeometry.PresheafedSpace.GlueData C) →
[inst_1 : CategoryTheory.Limits.HasLimits C] → (i j : D.J) → CategoryTheory.Limits.IsLimit (D.vPullbackCone i j) |
CategoryTheory.StructuredArrow.commaMapEquivalenceFunctor._proof_3 | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u_10} [inst : CategoryTheory.Category.{u_9, u_10} C] {D : Type u_12}
[inst_1 : CategoryTheory.Category.{u_11, u_12} D] {T : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} T]
{L : CategoryTheory.Functor C T} {R : CategoryTheory.Functor D T} {C' : Type u_6}
[inst_3 : CategoryTheory.Category.{u_5, u_6} C'] {D' : Type u_8} [inst_4 : CategoryTheory.Category.{u_7, u_8} D']
{T' : Type u_4} [inst_5 : CategoryTheory.Category.{u_3, u_4} T'] {L' : CategoryTheory.Functor C' T'}
{R' : CategoryTheory.Functor D' T'} {F₁ : CategoryTheory.Functor C C'} {F₂ : CategoryTheory.Functor D D'}
{F : CategoryTheory.Functor T T'} (α : F₁.comp L' ⟶ L.comp F) (β : R.comp F ⟶ F₂.comp R')
[inst_6 : CategoryTheory.IsIso β] (X : CategoryTheory.Comma L' R')
{Y Z : CategoryTheory.StructuredArrow X (CategoryTheory.Comma.map α β)} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.StructuredArrow.map₂ (CategoryTheory.CategoryStruct.id (L'.obj X.left)) α).map
(CategoryTheory.StructuredArrow.homMk f.right.left ⋯))
{ left := CategoryTheory.StructuredArrow.mk Z.hom.left, right := CategoryTheory.StructuredArrow.mk Z.hom.right,
hom := CategoryTheory.StructuredArrow.homMk Z.right.hom ⋯ }.hom =
CategoryTheory.CategoryStruct.comp
{ left := CategoryTheory.StructuredArrow.mk Y.hom.left, right := CategoryTheory.StructuredArrow.mk Y.hom.right,
hom := CategoryTheory.StructuredArrow.homMk Y.right.hom ⋯ }.hom
((CategoryTheory.StructuredArrow.map₂ X.hom (CategoryTheory.inv β)).map
(CategoryTheory.StructuredArrow.homMk f.right.right ⋯)) |
IsWellOrder.toHasWellFounded._proof_1 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [inst : LT α] [hwo : IsWellOrder α fun x1 x2 => x1 < x2], WellFounded fun x1 x2 => x1 < x2 |
CategoryTheory.ShortComplex.Splitting.ofExactOfSection | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.Balanced C] →
(S : CategoryTheory.ShortComplex C) →
S.Exact →
(s : S.X₃ ⟶ S.X₂) →
CategoryTheory.CategoryStruct.comp s S.g = CategoryTheory.CategoryStruct.id S.X₃ →
CategoryTheory.Mono S.f → S.Splitting |
Set.unbounded_of_isEmpty | Mathlib.Order.RelClasses | ∀ {α : Type u} [IsEmpty α] {r : α → α → Prop} (s : Set α), Set.Unbounded r s |
Lean.Meta.Canonicalizer.ExprVisited.rec | Lean.Meta.Canonicalizer | {motive : Lean.Meta.Canonicalizer.ExprVisited → Sort u} →
((e : Lean.Expr) → motive { e := e }) → (t : Lean.Meta.Canonicalizer.ExprVisited) → motive t |
NonemptyInterval.instDecidableEq | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : LE α] → [DecidableEq α] → DecidableEq (NonemptyInterval α) |
Std.TreeSet.isEmpty_diff_left | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp],
t₁.isEmpty = true → (t₁ \ t₂).isEmpty = true |
Mathlib.Tactic.LibraryRewrite.RewriteLemma.noConfusion | Mathlib.Tactic.Widget.LibraryRewrite | {P : Sort u} →
{t t' : Mathlib.Tactic.LibraryRewrite.RewriteLemma} →
t = t' → Mathlib.Tactic.LibraryRewrite.RewriteLemma.noConfusionType P t t' |
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.0.CategoryTheory.MonoidalCategory.DayConvolution.pentagon._simp_1_5 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
List.pmap_eq_nil_iff._simp_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {l : List α} {H : ∀ a ∈ l, p a},
(List.pmap f l H = []) = (l = []) |
Std.DTreeMap.Internal.Impl.getKey?_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l → (↑(t.insertMany! l)).getKey? k' = some k |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.isReduced_of_noZeroDivisors.match_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (a : M₀) (motive : IsNilpotent a → Prop) (x : IsNilpotent a),
(∀ (n : ℕ) (ha : a ^ n = 0), motive ⋯) → motive x |
Ultrafilter.ofComplNotMemIff._proof_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} (f : Filter α), (∀ (s : Set α), sᶜ ∉ f ↔ s ∈ f) → f = ⊥ → False |
Module.support_quotSMulTop | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M]
(x : R), Module.support R (QuotSMulTop x M) = Module.support R M ∩ PrimeSpectrum.zeroLocus {x} |
Cardinal.beth_mono | Mathlib.SetTheory.Cardinal.Aleph | Monotone Cardinal.beth |
NNReal.coe_natCast | Mathlib.Data.NNReal.Defs | ∀ (n : ℕ), ↑↑n = ↑n |
CategoryTheory.OverPresheafAux.map_mkPrecomp_eqToHom._proof_2 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : CategoryTheory.Functor Cᵒᵖ (Type u_2)} {X Y : C}
{f : X ⟶ Y} {g g' : CategoryTheory.yoneda.obj Y ⟶ A},
g = g' →
Opposite.op
(CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) g')) =
Opposite.op
(CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) g)) |
CategoryTheory.sheafHom._proof_1 | Mathlib.CategoryTheory.Sites.SheafHom | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{A : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} A] (F G : CategoryTheory.Sheaf J A),
CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.sheafHom' F G) |
Filter.sdiff_limsup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteBooleanAlgebra α] (f : Filter β) (u : β → α) [f.NeBot] (a : α),
a \ Filter.limsup u f = Filter.liminf (fun b => a \ u b) f |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.find_mem_find?_decide._proof_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {p : Fin n → Prop} [inst : DecidablePred p] (h : ∃ i, p i),
Fin.find p h ∈ Fin.findSome? (Option.guard fun b => decide (p b)) |
Valued.completable | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀],
CompletableTopField K |
Nat.dvd_add | Init.Data.Nat.Dvd | ∀ {a b c : ℕ}, a ∣ b → a ∣ c → a ∣ b + c |
Std.DHashMap.getD_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{fallback : β k} {f : β k → β k}, (m.modify k f).getD k fallback = (Option.map f (m.get? k)).getD fallback |
Polynomial.smeval_monomial | Mathlib.Algebra.Polynomial.Smeval | ∀ {R : Type u_1} [inst : Semiring R] (r : R) {S : Type u_2} [inst_1 : AddCommMonoid S] [inst_2 : Pow S ℕ]
[inst_3 : MulActionWithZero R S] (x : S) (n : ℕ), ((Polynomial.monomial n) r).smeval x = r • x ^ n |
imageToKernel_comp_hom_inv_comp | Mathlib.Algebra.Homology.ImageToKernel | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {A B C : V}
(f : A ⟶ B) (g : B ⟶ C) [inst_2 : CategoryTheory.Limits.HasEqualizers V] [inst_3 : CategoryTheory.Limits.HasImages V]
{Z : V} {i : B ≅ Z}
(w :
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f i.hom)
(CategoryTheory.CategoryStruct.comp i.inv g) =
0),
imageToKernel (CategoryTheory.CategoryStruct.comp f i.hom) (CategoryTheory.CategoryStruct.comp i.inv g) w =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.imageSubobjectCompIso f i.hom).hom
(CategoryTheory.CategoryStruct.comp (imageToKernel f g ⋯)
(CategoryTheory.Limits.kernelSubobjectIsoComp i.inv g).inv) |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk._flat_ctor | Lean.Language.Basic | Lean.MessageLog → Option (IO.Ref (Option Dynamic)) → Lean.Language.Snapshot.Diagnostics |
Lean.Server.Test.Cancel.tacticWait_for_unblock | Lean.Server.Test.Cancel | Lean.ParserDescr |
Lean.Meta.Grind.Arith.Linear.UnsatProof.lt.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Linear.IneqCnstr},
Lean.Meta.Grind.Arith.Linear.UnsatProof.lt c = Lean.Meta.Grind.Arith.Linear.UnsatProof.lt c_1 → c = c_1 |
ManyOneDegree | Mathlib.Computability.Reduce | Type |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} (m : Std.DHashMap α fun x => Unit), 0 < m.inner.buckets.size |
Ioc_mem_nhdsGE_of_mem | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a b c : α},
b ∈ Set.Ioo a c → Set.Ioc a c ∈ nhdsWithin b (Set.Ici b) |
_private.Mathlib.CategoryTheory.Functor.OfSequence.0.CategoryTheory.Functor.OfSequence.map_id._proof_1 | Mathlib.CategoryTheory.Functor.OfSequence | ∀ (i : ℕ), i ≤ i |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.simpleFuncAux.match_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
Aesop.Frontend.BuilderOption.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.BuilderOption → ℕ |
Lean.Elab.Term.PatternElabException.mk.injEq | Lean.Elab.Match | ∀ (ex : Lean.Exception) (patternIdx : ℕ) (pathToIndex : List ℕ) (ex_1 : Lean.Exception) (patternIdx_1 : ℕ)
(pathToIndex_1 : List ℕ),
({ ex := ex, patternIdx := patternIdx, pathToIndex := pathToIndex } =
{ ex := ex_1, patternIdx := patternIdx_1, pathToIndex := pathToIndex_1 }) =
(ex = ex_1 ∧ patternIdx = patternIdx_1 ∧ pathToIndex = pathToIndex_1) |
AugmentedSimplexCategory.instFaithfulSimplexCategoryInclusion | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | AugmentedSimplexCategory.inclusion.Faithful |
Lean.Meta.Try.Collector.Result.recOn | Lean.Meta.Tactic.Try.Collect | {motive : Lean.Meta.Try.Collector.Result → Sort u} →
(t : Lean.Meta.Try.Collector.Result) →
((allConsts unfoldCandidates eqnCandidates : Lean.Meta.Try.Collector.OrdSet Lean.Name) →
(funIndCandidates : Lean.Meta.FunInd.SeenCalls) →
(indCandidates : Array Lean.Meta.Try.Collector.InductionCandidate) →
(libSearchResults : Lean.Meta.Try.Collector.OrdSet (Lean.Name × Lean.Meta.Grind.EMatchTheoremKind)) →
motive
{ allConsts := allConsts, unfoldCandidates := unfoldCandidates, eqnCandidates := eqnCandidates,
funIndCandidates := funIndCandidates, indCandidates := indCandidates,
libSearchResults := libSearchResults }) →
motive t |
BoxIntegral.Prepartition | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} → BoxIntegral.Box ι → Type u_1 |
Lean.Syntax.Range.mk.sizeOf_spec | Lean.Syntax | ∀ (start stop : String.Pos.Raw), sizeOf { start := start, stop := stop } = 1 + sizeOf start + sizeOf stop |
Lean.Widget.UserWidgetDefinition.casesOn | Lean.Widget.UserWidget | {motive : Lean.Widget.UserWidgetDefinition → Sort u} →
(t : Lean.Widget.UserWidgetDefinition) →
((name javascript : String) → motive { name := name, javascript := javascript }) → motive t |
Lean.Server.FileWorker.FileSetupResult._sizeOf_inst | Lean.Server.FileWorker.SetupFile | SizeOf Lean.Server.FileWorker.FileSetupResult |
Std.DTreeMap.Internal.Impl.getKey_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] [Inhabited α] (h : t.WF) {k k' : α} {f : Option (β k) → Option (β k)}
{hc : k' ∈ (Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl},
(Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.getKey k' hc =
if heq : compare k k' = Ordering.eq then k else t.getKey k' ⋯ |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp_inv_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅} {Z : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] [inst_4 : CategoryTheory.Category.{v₅, u₅} Y]
[inst_5 : CategoryTheory.Category.{v₆, u₆} Z] (U : CategoryTheory.Functor X Y) (V : CategoryTheory.Functor Y Z)
(X_1 : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G Z) (x : X),
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp F G U V).inv.app X_1).fst.app x =
CategoryTheory.CategoryStruct.id (X_1.fst.obj (V.obj (U.obj x))) |
FGModuleRepr.S | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | {R : Type u} → [inst : CommRing R] → (self : FGModuleRepr R) → Submodule R (Fin self.n → R) |
PolynomialLaw.add_def_apply | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f g : M →ₚₗ[R] N) (S : Type u) [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] (m : TensorProduct R S M), (f + g).toFun' S m = f.toFun' S m + g.toFun' S m |
Set.powersetCard.mulActionHom_singleton.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] [inst_2 : DecidableEq α],
Set.powersetCard.mulActionHom_singleton G α = { toFun := ⇑Set.powersetCard.ofSingleton, map_smul' := ⋯ } |
Subalgebra.normedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NormedCommRing E] [inst_2 : Algebra 𝕜 E]
(s : Subalgebra 𝕜 E) (x y : ↥s), dist x y = ‖-x + y‖ |
FreeAlgebra.Rel.zero_mul | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a : FreeAlgebra.Pre R X}, FreeAlgebra.Rel R X (0 * a) 0 |
Finset.union_sdiff_self_eq_union | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s ∪ t \ s = s ∪ t |
Order.Iic_subset_Iio_succ_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, ¬IsMax a → Set.Iic a ⊆ Set.Iio (Order.succ a) |
AbstractCompletion.mapEquiv._proof_6 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_4} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_2, u_4} α) {β : Type u_3}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_1, u_3} β) (e : α ≃ᵤ β),
UniformContinuous (pkg'.map pkg ⇑e.symm) |
LieAlgebra.IsKilling.coroot_neg | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
[inst_5 : LieAlgebra.IsKilling K L] [inst_6 : LieModule.IsTriangularizable K (↥H) L] (α : LieModule.Weight K (↥H) L),
LieAlgebra.IsKilling.coroot (-α) = -LieAlgebra.IsKilling.coroot α |
Std.DTreeMap.Internal.Impl.get!_empty | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] [inst : Std.LawfulEqOrd α] {a : α}
[inst_1 : Inhabited (β a)], Std.DTreeMap.Internal.Impl.empty.get! a = default |
Ring.KrullDimLE | Mathlib.RingTheory.KrullDimension.Basic | ℕ → (R : Type u_1) → [CommSemiring R] → Prop |
IsRelPrime.mul_add_right_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → ∀ (z : R), IsRelPrime (z * y + x) y |
CategoryTheory.Factorisation.instCategory._proof_2 | Mathlib.CategoryTheory.Category.Factorisation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
(d : CategoryTheory.Factorisation f),
CategoryTheory.CategoryStruct.comp d.ι (CategoryTheory.CategoryStruct.id d.mid) = d.ι |
FirstOrder.Language.Substructure.mem_sInf | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : Set (L.Substructure M)} {x : M},
x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p |
SeminormedRing.induced._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (R : Type u_1) [inst : Ring R] (x : R), Semiring.npow 0 x = 1 |
Ideal.toCharacterSpace._proof_6 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {A : Type u_1} [inst : NormedCommRing A] [CompleteSpace A] (I : Ideal A), CompleteSpace (A ⧸ I) |
Std.ExtTreeMap.getElem!_inter_of_mem_right | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
[inst_1 : Inhabited β], k ∈ t₂ → (t₁ ∩ t₂)[k]! = t₁[k]! |
Ordinal.type_pEmpty | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 0 |
MeasureTheory.NullMeasurableSet.addFundamentalInterior | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α) [Countable G]
[inst_3 : MeasurableSpace α] [MeasurableConstVAdd G α] {μ : MeasureTheory.Measure α}
[MeasureTheory.VAddInvariantMeasure G α μ],
MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet (MeasureTheory.addFundamentalInterior G s) μ |
Lean.Doc.Inline.match_on_same_ctor._@.Lean.DocString.Types.3732691326._hygCtx._hyg.126 | Lean.DocString.Types | {i : Type u} →
{motive : (t t_1 : Lean.Doc.Inline i) → t.ctorIdx = t_1.ctorIdx → Sort u_1} →
(t t_1 : Lean.Doc.Inline i) →
(h : t.ctorIdx = t_1.ctorIdx) →
((string string' : String) → motive (Lean.Doc.Inline.text string) (Lean.Doc.Inline.text string') ⋯) →
((content content' : Array (Lean.Doc.Inline i)) →
motive (Lean.Doc.Inline.emph content) (Lean.Doc.Inline.emph content') ⋯) →
((content content' : Array (Lean.Doc.Inline i)) →
motive (Lean.Doc.Inline.bold content) (Lean.Doc.Inline.bold content') ⋯) →
((string string' : String) → motive (Lean.Doc.Inline.code string) (Lean.Doc.Inline.code string') ⋯) →
((mode : Lean.Doc.MathMode) →
(string : String) →
(mode' : Lean.Doc.MathMode) →
(string' : String) →
motive (Lean.Doc.Inline.math mode string) (Lean.Doc.Inline.math mode' string') ⋯) →
((string string' : String) →
motive (Lean.Doc.Inline.linebreak string) (Lean.Doc.Inline.linebreak string') ⋯) →
((content : Array (Lean.Doc.Inline i)) →
(url : String) →
(content' : Array (Lean.Doc.Inline i)) →
(url' : String) →
motive (Lean.Doc.Inline.link content url) (Lean.Doc.Inline.link content' url') ⋯) →
((name : String) →
(content : Array (Lean.Doc.Inline i)) →
(name' : String) →
(content' : Array (Lean.Doc.Inline i)) →
motive (Lean.Doc.Inline.footnote name content) (Lean.Doc.Inline.footnote name' content')
⋯) →
((alt url alt' url' : String) →
motive (Lean.Doc.Inline.image alt url) (Lean.Doc.Inline.image alt' url') ⋯) →
((content content' : Array (Lean.Doc.Inline i)) →
motive (Lean.Doc.Inline.concat content) (Lean.Doc.Inline.concat content') ⋯) →
((container : i) →
(content : Array (Lean.Doc.Inline i)) →
(container' : i) →
(content' : Array (Lean.Doc.Inline i)) →
motive (Lean.Doc.Inline.other container content)
(Lean.Doc.Inline.other container' content') ⋯) →
motive t t_1 h |
Plausible.Random.random | Plausible.Random | {m : Type u → Type u_1} →
{α : Type u} → [self : Plausible.Random m α] → {g : Type} → [RandomGen g] → Plausible.RandGT g m α |
_private.Init.Data.AC.0.Lean.Data.AC.evalList.match_1.splitter | Init.Data.AC | (motive : List ℕ → Sort u_1) →
(x : List ℕ) →
(Unit → motive []) →
((x : ℕ) → motive [x]) → ((x : ℕ) → (xs : List ℕ) → (xs = [] → False) → motive (x :: xs)) → motive x |
Submodule.isAssociatedPrime_iff | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {I : Ideal R} [IsNoetherianRing R], N.IsAssociatedPrime I ↔ I.IsPrime ∧ ∃ x, I = N.colon {x} |
List.sortedLT_range | Mathlib.Data.List.Sort | ∀ (n : ℕ), (List.range n).SortedLT |
iff_eq_eq | Mathlib.Logic.Basic | ∀ {a b : Prop}, (a ↔ b) = (a = b) |
CategoryTheory.ObjectProperty.instIsTriangulatedFullSubcategory | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryTheory.ObjectProperty C) [inst_6 : P.IsTriangulated] [CategoryTheory.IsTriangulated C],
CategoryTheory.IsTriangulated P.FullSubcategory |
Subsemiring.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [IsTopologicalSemiring R], SeparatelyContinuousAdd R |
Frame.copy._proof_1 | Mathlib.Order.Copy | ∀ {α : Type u_1} (c : Order.Frame α) (le : α → α → Prop) (eq_le : le = LE.le) (top : α) (eq_top : top = ⊤) (bot : α)
(eq_bot : bot = ⊥) (sup : α → α → α) (eq_sup : sup = max) (inf : α → α → α) (eq_inf : inf = min) (himp : α → α → α)
(eq_himp : himp = HImp.himp) (compl : α → α) (eq_compl : compl = Compl.compl) (a b : α), Lattice.inf a b ≤ a |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.