name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Subsemigroup.comap_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul P] (S : Subsemigroup P)
(g : N →ₙ* P) (f : M →ₙ* N), Subsemigroup.comap f (Subsemigroup.comap g S) = Subsemigroup.comap (g.comp f) S |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral.0.norm_sub_le_integral_of_norm_deriv_le_of_le._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.DistLEIntegral | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (a b : E), ‖a - b‖ = dist a b |
Std.TreeSet.ofList_singleton | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {k : α}, Std.TreeSet.ofList [k] cmp = ∅.insert k |
CategoryTheory.ActionCategory.stabilizerIsoEnd_symm_apply | Mathlib.CategoryTheory.Action | ∀ (M : Type u_1) [inst : Monoid M] {X : Type u} [inst_1 : MulAction M X] (x : X) (f : CategoryTheory.End ⟨(), x⟩),
(CategoryTheory.ActionCategory.stabilizerIsoEnd M x).symm f = f |
CategoryTheory.StructuredArrow.instFaithfulObjCompPost | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : C) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D), (CategoryTheory.StructuredArrow.post S F G).Faithful |
Lean.Meta.Simp.Diagnostics.mk.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} →
{usedThmCounter triedThmCounter : Lean.PHashMap Lean.Meta.Origin ℕ} →
{congrThmCounter : Lean.PHashMap Lean.Name ℕ} →
{thmsWithBadKeys : Lean.PArray Lean.Meta.SimpTheorem} →
{usedThmCounter' triedThmCounter' : Lean.PHashMap Lean.Meta.Origin ℕ} →
{congrThmCounter' : Lean.PHashMap Lean.Name ℕ} →
{thmsWithBadKeys' : Lean.PArray Lean.Meta.SimpTheorem} →
{ usedThmCounter := usedThmCounter, triedThmCounter := triedThmCounter,
congrThmCounter := congrThmCounter, thmsWithBadKeys := thmsWithBadKeys } =
{ usedThmCounter := usedThmCounter', triedThmCounter := triedThmCounter',
congrThmCounter := congrThmCounter', thmsWithBadKeys := thmsWithBadKeys' } →
(usedThmCounter = usedThmCounter' →
triedThmCounter = triedThmCounter' →
congrThmCounter = congrThmCounter' → thmsWithBadKeys = thmsWithBadKeys' → P) →
P |
PresheafOfModules.wellPowered | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C₀ : Type u} [inst : CategoryTheory.SmallCategory C₀] (R₀ : CategoryTheory.Functor C₀ᵒᵖ RingCat),
CategoryTheory.WellPowered.{u, u, u + 1} (PresheafOfModules R₀) |
QuaternionAlgebra.mk | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → R → R → R → R → QuaternionAlgebra R a b c |
Lean.Lsp.CodeActionParams.mk.sizeOf_spec | Lean.Data.Lsp.CodeActions | ∀ (toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams) (toPartialResultParams : Lean.Lsp.PartialResultParams)
(textDocument : Lean.Lsp.TextDocumentIdentifier) (range : Lean.Lsp.Range) (context : Lean.Lsp.CodeActionContext),
sizeOf
{ toWorkDoneProgressParams := toWorkDoneProgressParams, toPartialResultParams := toPartialResultParams,
textDocument := textDocument, range := range, context := context } =
1 + sizeOf toWorkDoneProgressParams + sizeOf toPartialResultParams + sizeOf textDocument + sizeOf range +
sizeOf context |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances.0.cfc_complex_eq_real._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, ((starRingEnd K) z = z) = (↑(RCLike.re z) = z) |
HurwitzZeta.hurwitzEvenFEPair._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | (1 + 1).AtLeastTwo |
CategoryTheory.Functor.descOfIsLeftKanExtension.congr_simp | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α α_1 : F ⟶ L.comp F') (e_α : α = α_1) [inst_3 : F'.IsLeftKanExtension α] (G : CategoryTheory.Functor D H)
(β β_1 : F ⟶ L.comp G), β = β_1 → F'.descOfIsLeftKanExtension α G β = F'.descOfIsLeftKanExtension α_1 G β_1 |
_private.Mathlib.RingTheory.RingHom.QuasiFinite.0.RingHom.QuasiFinite.ofLocalizationSpanTarget._simp_1_1 | Mathlib.RingTheory.RingHom.QuasiFinite | ∀ {M : Type u_1} [inst : Monoid M] {n : M} {P : Submonoid M}, (Submonoid.powers n ≤ P) = (n ∈ P) |
Primrec.nat_bodd | Mathlib.Computability.Primrec.Basic | Primrec Nat.bodd |
Std.Internal.IO.Async.EAsync.instMonadLiftBaseIO | Std.Internal.Async.Basic | {ε : Type} → MonadLift BaseIO (Std.Internal.IO.Async.EAsync ε) |
_private.Mathlib.Analysis.Analytic.Basic.0.AnalyticWithinAt.congr_set._simp_1_1 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, (s ∈ nhdsWithin a s) = True |
NonUnitalSubsemiring.mem_iInf | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {ι : Sort u_1} {S : ι → NonUnitalSubsemiring R} {x : R},
x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i |
DoubleCentralizer.instModule._proof_1 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] {S : Type u_3}
[inst_5 : Semiring S] [inst_6 : Module S A] [inst_7 : SMulCommClass 𝕜 S A] [inst_8 : ContinuousConstSMul S A]
[inst_9 : IsScalarTower S A A] [inst_10 : SMulCommClass S A A] (_x : S) (_y : DoubleCentralizer 𝕜 A),
DoubleCentralizer.toProdHom (_x • _y) = DoubleCentralizer.toProdHom (_x • _y) |
CategoryTheory.Classifier.pullback_χ_obj_mk_truth | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
(𝒞 : CategoryTheory.Classifier C) {Z X : C} (i : Z ⟶ X) [inst_2 : CategoryTheory.Mono i],
(CategoryTheory.Subobject.pullback (𝒞.χ i)).obj 𝒞.truth_as_subobject = CategoryTheory.Subobject.mk i |
PowerBasis.ofAdjoinEqTop_gen | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S}
(hx : IsIntegral K x) (hx' : Algebra.adjoin K {x} = ⊤), (PowerBasis.ofAdjoinEqTop hx hx').gen = x |
MulHom.mk.inj | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {N : Type u_11} {inst : Mul M} {inst_1 : Mul N} {toFun : M → N}
{map_mul' : ∀ (x y : M), toFun (x * y) = toFun x * toFun y} {toFun_1 : M → N}
{map_mul'_1 : ∀ (x y : M), toFun_1 (x * y) = toFun_1 x * toFun_1 y},
{ toFun := toFun, map_mul' := map_mul' } = { toFun := toFun_1, map_mul' := map_mul'_1 } → toFun = toFun_1 |
UpperHalfPlane.instIsFiniteMeasureOnCompactsComapComplexCoeVolume | Mathlib.Analysis.Complex.UpperHalfPlane.Measure | MeasureTheory.IsFiniteMeasureOnCompacts (MeasureTheory.Measure.comap UpperHalfPlane.coe MeasureTheory.volume) |
CategoryTheory.ObjectProperty.extensionProduct_isoClosure_left | 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 Q : CategoryTheory.ObjectProperty C), P.isoClosure.extensionProduct Q = P.extensionProduct Q |
MeasureTheory.AEStronglyMeasurable.pow | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Monoid β] [ContinuousMul β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f ^ n) μ |
_private.Mathlib.Algebra.Group.Int.Even.0.Int.even_iff._simp_1_3 | Mathlib.Algebra.Group.Int.Even | ∀ (n : ℤ), n + n = 2 * n |
ProbabilityTheory.setIntegral_compProd_univ_left | Mathlib.Probability.Kernel.Composition.IntegralCompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {E : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : NormedAddCommGroup E] {a : α} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsSFiniteKernel κ] {η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η]
[inst_3 : NormedSpace ℝ E] (f : β × γ → E) {t : Set γ},
MeasurableSet t →
MeasureTheory.IntegrableOn f (Set.univ ×ˢ t) ((κ.compProd η) a) →
∫ (z : β × γ) in Set.univ ×ˢ t, f z ∂(κ.compProd η) a = ∫ (x : β), ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a |
Lean.Server.Test.Runner.Client.instToJsonStrictOrLazy | Lean.Server.Test.Runner | {α β : Type} → [Lean.ToJson α] → [Lean.ToJson β] → Lean.ToJson (Lean.Server.Test.Runner.Client.StrictOrLazy α β) |
DFinsupp.le_iff' | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : DecidableEq ι] [inst_4 : (i : ι) → (x : α i) → Decidable (x ≠ 0)]
{f g : Π₀ (i : ι), α i} {s : Finset ι}, f.support ⊆ s → (f ≤ g ↔ ∀ i ∈ s, f i ≤ g i) |
DirectSum.coeAlgHom._proof_2 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {S : Type u_2} {R : Type u_1} [inst : AddMonoid ι] [inst_1 : CommSemiring S] [inst_2 : Semiring R]
[inst_3 : Algebra S R] (A : ι → Submodule S R) [inst_4 : SetLike.GradedMonoid A] {i j : ι} (x : ↥(A i))
(x_1 : ↥(A j)), (A (i + j)).subtype (GradedMonoid.GMul.mul x x_1) = (A (i + j)).subtype (GradedMonoid.GMul.mul x x_1) |
_private.Mathlib.GroupTheory.CosetCover.0.Subgroup.leftCoset_cover_filter_FiniteIndex_aux.match_1_3 | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {s : Finset ι}
(t : (i : ι) → i ∈ s → (H i).FiniteIndex → Finset ↥(H i)) (j : ι) (hj : j ∈ s) (hjfi : (H j).FiniteIndex)
(motive : (t j hj hjfi).Nonempty → Prop) (x : (t j hj hjfi).Nonempty),
(∀ (x : ↥(H j)) (hx : x ∈ t j hj hjfi), motive ⋯) → motive x |
Matrix.BlockTriangular.det_fintype | Mathlib.LinearAlgebra.Matrix.Block | ∀ {α : Type u_1} {m : Type u_3} {R : Type v} {M : Matrix m m R} {b : m → α} [inst : CommRing R] [inst_1 : DecidableEq m]
[inst_2 : Fintype m] [inst_3 : DecidableEq α] [inst_4 : Fintype α] [inst_5 : LinearOrder α],
M.BlockTriangular b → M.det = ∏ k, (M.toSquareBlock b k).det |
SaturatedAddSubmonoid.sSup_def | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {f : Set (SaturatedAddSubmonoid M)},
sSup f = (sSup (SaturatedAddSubmonoid.toAddSubmonoid '' f)).saturation |
CategoryTheory.CategoryOfElements.map._proof_3 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F₁ F₂ : CategoryTheory.Functor C (Type u_1)}
(α : F₁ ⟶ F₂) {X Y Z : F₁.Elements} (f : X ⟶ Y) (g : Y ⟶ Z),
⟨↑(CategoryTheory.CategoryStruct.comp f g), ⋯⟩ = CategoryTheory.CategoryStruct.comp ⟨↑f, ⋯⟩ ⟨↑g, ⋯⟩ |
Subgroup.map | Mathlib.Algebra.Group.Subgroup.Map | {G : Type u_1} → [inst : Group G] → {N : Type u_5} → [inst_1 : Group N] → (G →* N) → Subgroup G → Subgroup N |
FractionalIdeal.mem_coeIdeal_of_mem | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{x : R} {I : Ideal R}, x ∈ I → (algebraMap R P) x ∈ ↑I |
Module.annihilator_finsupp | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
[Nonempty ι], Module.annihilator R (ι →₀ M) = Module.annihilator R M |
Int.mul_neg_of_pos_of_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, 0 < a → b < 0 → a * b < 0 |
CategoryTheory.Limits.Multifork.toPiFork_π_app_one | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
{I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I)
{c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right}
(hd : CategoryTheory.Limits.IsLimit d),
(CategoryTheory.Limits.Multifork.toPiFork hc hd K).π.app CategoryTheory.Limits.WalkingParallelPair.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (I.fstPiMapOfIsLimit c hd) |
CategoryTheory.yonedaMon_naturality | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X Y : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N]
(α : CategoryTheory.yonedaMonObj M ⟶ CategoryTheory.yonedaMonObj N) (f : X ⟶ Y) (g : Y ⟶ M),
(CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op X))) (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp f ((CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Y))) g) |
CircularPreorder.mk._flat_ctor | Mathlib.Order.Circular | {α : Type u_1} →
(btw sbtw : α → α → α → Prop) →
(∀ (a : α), btw a a a) →
(∀ {a b c : α}, btw a b c → btw b c a) →
autoParam (∀ {a b c : α}, sbtw a b c ↔ btw a b c ∧ ¬btw c b a)
CircularPreorder.sbtw_iff_btw_not_btw._autoParam →
(∀ {a b c d : α}, sbtw a b c → sbtw b d c → sbtw a d c) → CircularPreorder α |
CategoryTheory.Limits.preservesFiniteColimits_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesFiniteLimits F],
CategoryTheory.Limits.PreservesFiniteColimits F.leftOp |
fintypeToFinBoolAlgOp._proof_7 | Mathlib.Order.Category.FinBoolAlg | ∀ {X Y : FintypeCat} (f : X ⟶ Y), (CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)) ⊤ = ⊤ |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.generalizeMatchDiscrs.mkNewTarget | Lean.Meta.Tactic.Split | Lean.Name →
Array Lean.Expr →
Lean.Meta.MatcherInfo → ℕ → Array Lean.Expr → Array Lean.Expr → IO.Ref Bool → Lean.Expr → Lean.MetaM Lean.Expr |
Std.DTreeMap.Const.get?_ofList_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → Std.DTreeMap.Const.get? (Std.DTreeMap.Const.ofList l cmp) k' = some v |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.r.match_1.splitter | Init.Grind.Module.Envelope | (α : Type u_1) →
(motive : α × α → α × α → Sort u_2) → (x x_1 : α × α) → ((a b c d : α) → motive (a, b) (c, d)) → motive x x_1 |
WittVector.inverseCoeff.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 → ∀ (a_2 a_3 : ℕ), a_2 = a_3 → WittVector.inverseCoeff a A a_2 = WittVector.inverseCoeff a_1 A_1 a_3 |
Stream'.Seq.get?_cons_succ | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (a : α) (s : Stream'.Seq α) (n : ℕ), (Stream'.Seq.cons a s).get? (n + 1) = s.get? n |
multilinearCurryLeftEquiv_symm_apply | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ (R : Type uR) {n : ℕ} (M : Fin n.succ → Type v) (M₂ : Type v₂) [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂]
(f : M 0 →ₗ[R] MultilinearMap R (fun i => M i.succ) M₂), (multilinearCurryLeftEquiv R M M₂).symm f = f.uncurryLeft |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u} {β : Type v} [inst : PartialOrder β] {l : Filter α} {f g : α → β}, (f =ᶠ[l] g) = (f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f) |
CategoryTheory.WithInitial.ofCommaObject._proof_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D]
(c : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D)))
(x y : C) (f : x ⟶ y),
CategoryTheory.CategoryStruct.comp ((fun x => c.hom.app x) x) (c.right.map f) = (fun x => c.hom.app x) y |
CategoryTheory.Limits.asEmptyCone._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) ⦃X_1 Y : CategoryTheory.Discrete PEmpty.{1}⦄
(f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Discrete PEmpty.{1})).obj X).map f)
(id (CategoryTheory.Discrete.casesOn Y fun as => ⋯.elim)) =
CategoryTheory.CategoryStruct.comp (id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim))
((CategoryTheory.Functor.empty C).map f) |
lowerClosure_mul_distrib | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : Set α),
lowerClosure (s * t) = lowerClosure s * lowerClosure t |
CategoryTheory.Oplax.StrongTrans.Modification.equivOplax_apply | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G}
(Γ : (CategoryTheory.Oplax.StrongTrans.toOplax η).Modification (CategoryTheory.Oplax.StrongTrans.toOplax θ)),
CategoryTheory.Oplax.StrongTrans.Modification.equivOplax Γ = CategoryTheory.Oplax.StrongTrans.Modification.mkOfOplax Γ |
Std.Internal.List.getValueD_insertListConst_of_contains_eq_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)}
{k : α} {fallback : β},
(List.map Prod.fst toInsert).contains k = false →
Std.Internal.List.getValueD k (Std.Internal.List.insertListConst l toInsert) fallback =
Std.Internal.List.getValueD k l fallback |
«term∃_,_» | Init.NotationExtra | Lean.ParserDescr |
TopCat.Presheaf.pullbackObjObjOfImageOpen | Mathlib.Topology.Sheaves.Presheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasColimits C] →
{X Y : TopCat} →
(f : X ⟶ Y) →
(ℱ : TopCat.Presheaf C Y) →
(U : TopologicalSpace.Opens ↑X) →
(H : IsOpen (⇑(CategoryTheory.ConcreteCategory.hom f) '' ↑U)) →
((TopCat.Presheaf.pullback C f).obj ℱ).obj (Opposite.op U) ≅
ℱ.obj (Opposite.op { carrier := ⇑(CategoryTheory.ConcreteCategory.hom f) '' ↑U, is_open' := H }) |
Antitone.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α} [AddRightMono α],
Antitone f → ∀ (a : α), Antitone fun x => f x + a |
CategoryTheory.Mon.instIsCommMonObj | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {M : CategoryTheory.Mon C} [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.IsCommMonObj M |
Ideal.map_ofList | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (rs : List R),
Ideal.map f (Ideal.ofList rs) = Ideal.ofList (List.map (⇑f) rs) |
Lean.Server.FileWorker.EditableDocumentCore.initSnap | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.EditableDocumentCore → Lean.Language.Lean.InitialSnapshot |
CategoryTheory.IsCardinalFiltered.max._proof_1 | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {κ : Cardinal.{u_1}} {K : Type u_2},
HasCardinalLT K κ → HasCardinalLT (CategoryTheory.Arrow (CategoryTheory.Discrete K)) κ |
_private.Init.Data.String.Iterator.0.String.Pos.Raw.get?.match_1.eq_1 | Init.Data.String.Iterator | ∀ (motive : String → String.Pos.Raw → Sort u_1) (s : String) (p : String.Pos.Raw)
(h_1 : (s : String) → (p : String.Pos.Raw) → motive s p),
(match s, p with
| s, p => h_1 s p) =
h_1 s p |
Flag.instMulActionOrderIso | Mathlib.Algebra.Order.Group.Action.Flag | {α : Type u_1} → [inst : Preorder α] → MulAction (α ≃o α) (Flag α) |
ContDiff.differentiable_deriv_two | Mathlib.Analysis.Calculus.ContDiff.Deriv | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F}, ContDiff 𝕜 2 f → Differentiable 𝕜 (deriv f) |
TopologicalSpace.PositiveCompacts.instOrderTopOfCompactSpaceOfNonempty._proof_2 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : Nonempty α], ↑⊤ = ↑⊤ |
List.lookmap_id' | Mathlib.Data.List.Lookmap | ∀ {α : Type u_1} (f : α → Option α), (∀ (a b : α), b ∈ f a → a = b) → ∀ (l : List α), List.lookmap f l = l |
PosNum.testBit.eq_def | Mathlib.Data.Num.Lemmas | ∀ (x : PosNum) (x_1 : ℕ),
x.testBit x_1 =
match x, x_1 with
| PosNum.one, 0 => true
| PosNum.one, x => false
| a.bit0, 0 => false
| p.bit0, n.succ => p.testBit n
| a.bit1, 0 => true
| p.bit1, n.succ => p.testBit n |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (a ∣ b) = ∃ c, b = a * c |
CategoryTheory.Limits.BinaryBicone.inrCokernelCofork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (c : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.CokernelCofork c.inr |
Lean.Meta.Grind.EMatchTheoremConstraint.isValue.elim | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremConstraint → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremConstraint) →
t.ctorIdx = 6 →
((bvarIdx : ℕ) → (strict : Bool) → motive (Lean.Meta.Grind.EMatchTheoremConstraint.isValue bvarIdx strict)) →
motive t |
Matroid.fundCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → α → Set α → Set α |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.funProp._sparseCasesOn_1 | Mathlib.Tactic.FunProp.Core | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
(Nat.hasNotBit 1408 t.ctorIdx → motive t) → motive t |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor.0.AlgebraicGeometry.ProjectiveSpectrum.comap._simp_3 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Functor | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (Z : Set (ProjectiveSpectrum 𝒜)), IsClosed Z = ∃ s, Z = ProjectiveSpectrum.zeroLocus 𝒜 s |
MvPolynomial.renameEquiv | Mathlib.Algebra.MvPolynomial.Rename | {σ : Type u_1} →
{τ : Type u_2} → (R : Type u_4) → [inst : CommSemiring R] → σ ≃ τ → MvPolynomial σ R ≃ₐ[R] MvPolynomial τ R |
CategoryTheory.LocalizerMorphism.smallHomMap'._proof_3 | Mathlib.CategoryTheory.Localization.SmallHom | ∀ {C₁ : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C₁] {W₁ : CategoryTheory.MorphismProperty C₁}
{C₂ : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C₂] {W₂ : CategoryTheory.MorphismProperty C₂}
(Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {Y : C₁} {Y' : C₂}
[CategoryTheory.Localization.HasSmallLocalizedHom W₂ Y' Y'] (eY : Φ.functor.obj Y ≅ Y'),
CategoryTheory.Localization.HasSmallLocalizedHom W₂ (Φ.functor.obj Y) Y' |
CategoryTheory.ShortComplex.HomologyData.recOn | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
{motive : S.HomologyData → Sort u_1} →
(t : S.HomologyData) →
((left : S.LeftHomologyData) →
(right : S.RightHomologyData) →
(iso : left.H ≅ right.H) →
(comm :
CategoryTheory.CategoryStruct.comp left.π (CategoryTheory.CategoryStruct.comp iso.hom right.ι) =
CategoryTheory.CategoryStruct.comp left.i right.p) →
motive { left := left, right := right, iso := iso, comm := comm }) →
motive t |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPullback.isoPullback_inv_snd._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) |
Std.DTreeMap.Internal.Impl.getEntry?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β) (k : α),
t.getEntry? k =
match t with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k' v' l r =>
match compare k k' with
| Ordering.lt => l.getEntry? k
| Ordering.gt => r.getEntry? k
| Ordering.eq => some ⟨k', v'⟩ |
AlgebraicGeometry.Scheme.affineOpens.eq_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (X : AlgebraicGeometry.Scheme), X.affineOpens = {U | AlgebraicGeometry.IsAffineOpen U} |
AddChar.zmod_char_primitive_of_eq_one_only_at_zero | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {C : Type v} [inst : CommMonoid C] (n : ℕ) (ψ : AddChar (ZMod n) C), (∀ (a : ZMod n), ψ a = 1 → a = 0) → ψ.IsPrimitive |
quasispectrum.preimage_algebraMap | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (S : Type u_3) {R : Type u_4} {A : Type u_5} [inst : Semifield R] [inst_1 : Field S] [inst_2 : NonUnitalRing A]
[inst_3 : Algebra R S] [inst_4 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [inst_7 : Module R A]
[IsScalarTower R S A] {a : A}, ⇑(algebraMap R S) ⁻¹' quasispectrum S a = quasispectrum R a |
Std.DTreeMap.Equiv.getEntryLT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.lt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.lt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.lt), motive ⋯) → motive x_1 |
Lean.JsonRpc.RequestID._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.RequestID → ℕ |
Mathlib.Tactic.Push.push | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Config →
Option Lean.Meta.Simp.Discharge →
Mathlib.Tactic.Push.Head → Lean.Elab.Tactic.Location → optParam Bool true → Lean.Elab.Tactic.TacticM Unit |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ediv_zero.match_1_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (a : ℕ), motive (Int.ofNat a)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive x |
ISize.ofIntLE.congr_simp | Init.Data.SInt.Lemmas | ∀ (i i_1 : ℤ) (e_i : i = i_1) (_hl : ISize.minValue.toInt ≤ i) (_hr : i ≤ ISize.maxValue.toInt),
ISize.ofIntLE i _hl _hr = ISize.ofIntLE i_1 ⋯ ⋯ |
Lean.Compiler.LCNF.NormFVarResult.erased.sizeOf_spec | Lean.Compiler.LCNF.CompilerM | sizeOf Lean.Compiler.LCNF.NormFVarResult.erased = 1 |
SimpleGraph.lapMatrix_mulVec_eq_zero_iff_forall_reachable | Mathlib.Combinatorics.SimpleGraph.LapMatrix | ∀ {V : Type u_1} [inst : Fintype V] (G : SimpleGraph V) [inst_1 : DecidableRel G.Adj] [inst_2 : DecidableEq V]
{x : V → ℝ}, (SimpleGraph.lapMatrix ℝ G).mulVec x = 0 ↔ ∀ (i j : V), G.Reachable i j → x i = x j |
CategoryTheory.Monad.ForgetCreatesColimits.liftedCocone | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{D : CategoryTheory.Functor J T.Algebra} →
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) →
CategoryTheory.Limits.IsColimit c →
[CategoryTheory.Limits.PreservesColimit (D.comp T.forget) T.toFunctor] →
[CategoryTheory.Limits.PreservesColimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] →
CategoryTheory.Limits.Cocone D |
sdiff_inf_distrib | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b c : α), a \ (b ⊓ c) = a \ b ⊔ a \ c |
GenContFract.first_den_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.dens 1 = gp.b |
orderBornology | Mathlib.Topology.Order.Bornology | {α : Type u_1} → [Lattice α] → [Nonempty α] → Bornology α |
Metric.vadd_eball | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
[IsIsometricVAdd G X] (c : G) (x : X) (r : ENNReal), c +ᵥ Metric.eball x r = Metric.eball (c +ᵥ x) r |
SimpleGraph.Walk.IsHamiltonianCycle.mk._flat_ctor | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.edges.Nodup → p ≠ SimpleGraph.Walk.nil → p.support.tail.Nodup → p.tail.IsHamiltonian → p.IsHamiltonianCycle |
_private.Init.Data.Array.Erase.0.Array.exists_erase_eq.match_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} [inst : BEq α] {a : α} {xs : Array α}
(motive :
(∃ a_1 ys zs,
(∀ b ∈ ys, ¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs ∧ xs.eraseP (BEq.beq a) = ys ++ zs) →
Prop)
(x :
∃ a_1 ys zs,
(∀ b ∈ ys, ¬(a == b) = true) ∧ (a == a_1) = true ∧ xs = ys.push a_1 ++ zs ∧ xs.eraseP (BEq.beq a) = ys ++ zs),
(∀ (w : α) (ys zs : Array α) (h₁ : ∀ b ∈ ys, ¬(a == b) = true) (e : (a == w) = true) (h₂ : xs = ys.push w ++ zs)
(h₃ : xs.eraseP (BEq.beq a) = ys ++ zs), motive ⋯) →
motive x |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.isIso_toSucc_iff._simp_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W f) (g : X ⟶ Z) {Z_1 : C} (h : ∐ CategoryTheory.OrthogonalReflection.D₁.obj₂ ⟶ Z_1),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιRight f hf g) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.ιLeft f hf g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.OrthogonalReflection.D₁.t W Z) h) |
_private.Mathlib.NumberTheory.LSeries.RiemannZeta.0.two_mul_riemannZeta_eq_tsum_int_inv_pow_of_even._proof_1_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ {k : ℕ}, 2 ≤ k → ¬k = 0 |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_1 | Lean.Meta.Tactic.Grind.EMatch | Lean.Meta.Grind.EMatch.SearchState → ℕ |
IterateMulAct.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Instances | {α : Type u_1} → {f : α → α} → MeasurableSpace (IterateMulAct f) |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_eq_one_iff.match_1_1 | Mathlib.Data.Nat.Totient | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) →
(∀ (a : Unit), motive 1) → (∀ (a : Unit), motive 2) → (∀ (n : ℕ), motive n.succ.succ.succ) → motive x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.