name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.EffectiveEpi.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : CategoryTheory.EffectiveEpi f → Sort u} →
(t : CategoryTheory.EffectiveEpi f) →
((effectiveEpi : Nonempty (CategoryTheory.EffectiveEpiStruct f)) → motive ⋯) → motive t | null | false |
_private.Mathlib.Topology.Baire.Lemmas.0.Set.Finite.dense_sInter._simp_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {α : Type u_1} {P : α → Prop} {a : α} {s : Set α}, (∀ x ∈ insert a s, P x) = (P a ∧ ∀ x ∈ s, P x) | null | false |
Polynomial.degree.eq_1 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), p.degree = p.support.max | null | true |
Tactic.ComputeAsymptotics.BasisExtension.insert.sizeOf_spec | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis : Tactic.ComputeAsymptotics.Basis} (f : ℝ → ℝ) (ex : Tactic.ComputeAsymptotics.BasisExtension basis),
sizeOf (Tactic.ComputeAsymptotics.BasisExtension.insert f ex) = 1 + sizeOf basis + sizeOf ex | null | true |
Lean.Lsp.MarkupKind.ctorElim | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.MarkupKind → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Lsp.MarkupKind) → ctorIdx = t.ctorIdx → Lean.Lsp.MarkupKind.ctorElimType ctorIdx → motive t | null | false |
CategoryTheory.Limits.Types.wedgeIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Types.End | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J]
(F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max u_3 u_1))))
(s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.multicospanIndexEnd F).multicospan)
(j : CategoryTheory.Limits.WalkingMulticospan (CategoryTheory.Limits.multicospa... | null | false |
LieAlgebra.Orthogonal.indefiniteDiagonal_transform | Mathlib.Algebra.Lie.Classical | ∀ (p : Type u_2) (q : Type u_3) (R : Type u₂) [inst : DecidableEq p] [inst_1 : DecidableEq q] [inst_2 : CommRing R]
[inst_3 : Fintype p] [inst_4 : Fintype q] {i : R},
i * i = -1 →
(LieAlgebra.Orthogonal.Pso p q R i).transpose * LieAlgebra.Orthogonal.indefiniteDiagonal p q R *
LieAlgebra.Orthogonal.Pso p... | null | true |
_private.Lean.LibrarySuggestions.SineQuaNon.0.Lean.LibrarySuggestions.SineQuaNon.prepareTriggers.match_3 | Lean.LibrarySuggestions.SineQuaNon | (motive : ℕ × Lean.Name × Float → Sort u_1) →
(x : ℕ × Lean.Name × Float) → ((j : ℕ) → (fst : Lean.Name) → (y : Float) → motive (j, fst, y)) → motive x | null | false |
Lean.Meta.DiscrTree.Key.proj.inj | Lean.Meta.DiscrTree.Types | ∀ {a : Lean.Name} {a_1 a_2 : ℕ} {a_3 : Lean.Name} {a_4 a_5 : ℕ},
Lean.Meta.DiscrTree.Key.proj a a_1 a_2 = Lean.Meta.DiscrTree.Key.proj a_3 a_4 a_5 → a = a_3 ∧ a_1 = a_4 ∧ a_2 = a_5 | null | true |
gcdMonoidOfLCM._proof_6 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (lcm : α → α → α), (∀ (a b : α), a ∣ lcm a b) → ∀ (x : α), lcm 0 x = 0 | null | false |
LinearEquiv.injective | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂),
... | null | true |
CategoryTheory.Bicategory.LeftLift.alongId | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a c : B} → (g : c ⟶ a) → CategoryTheory.Bicategory.LeftLift (CategoryTheory.CategoryStruct.id a) g | The left lift along the identity. | true |
isSemilinearSet_iff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsSemilinearSet s ↔ ∃ S, (∀ t ∈ S, IsLinearSet t) ∧ s = ⋃₀ ↑S | An equivalent expression of `IsSemilinearSet` in terms of `Finset` instead of `Set.Finite`. | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGT._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.gt) → α × β | null | false |
Polynomial.instStrongNormalizedGCDMonoid._proof_5 | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StrongNormalizedGCDMonoid R] (a b : Polynomial R),
normalize (lcm a b) = lcm a b | null | false |
Set.exists_mem_notMem_of_ncard_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
s.ncard < t.ncard → autoParam s.Finite Set.exists_mem_notMem_of_ncard_lt_ncard._auto_1 → ∃ e ∈ t, e ∉ s | null | true |
Finset.nonempty_Ioc._simp_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α], (Finset.Ioc a b).Nonempty = (a < b) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrability.Basic.0.intervalIntegral.intervalIntegrable_inv_one_add_sq._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | null | false |
CategoryTheory.Functor.mapCochainComplexShiftIso._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive] (n : ℤ) (K : HomologicalComplex C (ComplexShape.up ℤ))
... | null | false |
Action.forget_δ | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] (X Y : Action V G),
CategoryTheory.Functor.OplaxMonoidal.δ (Action.forget V G) X Y =
CategoryTheory.CategoryStruct.id ((Action.forget V G).obj (CategoryTheory.MonoidalCa... | null | true |
ContinuousMonoidHom.instCoeOutOfMonoidHomClassOfContinuousMapClass | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
{F : Type u_7} →
[inst_4 : FunLike F A B] → [MonoidHomClass F A B] → [ContinuousMapClass F A B] → CoeOut F (A →ₜ* B) | Any type satisfying `MonoidHomClass` and `ContinuousMapClass` can be cast into
`ContinuousMonoidHom` via `ContinuousMonoidHom.toContinuousMonoidHom`. | true |
CategoryTheory.MorphismProperty.Over.isoMk._proof_3 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T} {X : T}
{A B : P.Over Q X} (f : A.left ≅ B.left),
CategoryTheory.CategoryStruct.comp f.hom B.hom = A.hom →
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id T).map f.hom) B.hom =
CategoryT... | null | false |
_private.Init.Data.Int.LemmasAux.0.Int.ble'_eq_true._proof_1_4 | Init.Data.Int.LemmasAux | ∀ (a a_1 : ℕ), ¬(a_1 ≤ a ↔ Int.negSucc a ≤ Int.negSucc a_1) → False | null | false |
Std.TreeMap.getKeyD_minKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {km fallback : α},
t.minKey? = some km → t.getKeyD km fallback = km | null | true |
ZMod.valMinAbs_natAbs_eq_min | Mathlib.Data.ZMod.ValMinAbs | ∀ {n : ℕ} [hpos : NeZero n] (a : ZMod n), a.valMinAbs.natAbs = min a.val (n - a.val) | null | true |
Std.HashMap.isEmpty_inter_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m₂.isEmpty = true → (m₁ ∩ m₂).isEmpty = true | null | true |
Lean.getAttrParamOptPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ | null | true |
CategoryTheory.Preadditive.mono_iff_injective | Mathlib.Algebra.Homology.ShortComplex.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[inst_3 : CategoryTheory.HasForget₂ C Ab] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : (CategoryTheory.forge... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern.match_3.eq_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) (it : Std.IterM Id (String.Slice.Pattern.SearchStep s))
(motive : Option (s.sliceTo it.internalState.currPos).Pos → Sort u_1) (pos : (s.sliceTo it.internalState.currPos).Pos)
(h_1 : (pos_1 : (s.sliceTo it.internalState.currPos).Pos) → some pos = some pos_1 → motive (some po... | null | true |
ArchimedeanClass.FiniteElement._proof_2 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsStrictOrderedRing K | null | false |
CategoryTheory.HasDetector.casesOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t | null | false |
PowerSeries.substInvOfIsUnit | Mathlib.RingTheory.PowerSeries.Substitution | {R : Type u_2} → [inst : CommRing R] → (P : PowerSeries R) → IsUnit ((PowerSeries.coeff 1) P) → PowerSeries R | Given a power series `P = u • X + O(X²)` with `u` is an unit in ring `R`,
this is the power series `Q` such that `P(Q(X)) = X`.
See `PowerSeries.subst_substInvOfIsUnit_right`.
See also `PowerSeries.substInv` for a variant using `Invertible`. | true |
isIrreducible_iff_sInter | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsIrreducible s ↔ ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty | A set `s` is irreducible if and only if
for every finite collection of open sets all of whose members intersect `s`,
`s` also intersects the intersection of the entire collection
(i.e., there is an element of `s` contained in every member of the collection). | true |
deriv_const_add_id | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} (c : 𝕜), deriv (fun x => c + x) x = 1 | null | true |
derivWithin_const_smul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜} {R : Type u_2} [inst_3 : Monoid R]
[inst_4 : DistribMulAction R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F] (c : R),
DifferentiableWithinAt 𝕜 f s... | null | true |
TendstoLocallyUniformlyOn.comp | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β]
{F : ι → α → β} {f : α → β} {s : Set α} {p : Filter ι} [inst_2 : TopologicalSpace γ] {t : Set γ},
TendstoLocallyUniformlyOn F f p s →
∀ (g : γ → α), Set.MapsTo g t s → ContinuousOn g t → TendstoLo... | null | true |
Hyperreal.instField._proof_7 | Mathlib.Analysis.Real.Hyperreal | ∀ (a : ℝ*), a + 0 = a | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_roc_add_succ_right_eq_push._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m ≤ m + n → False | null | false |
Lean.KeyedDeclsAttribute.AttributeEntry.ctorIdx | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.AttributeEntry γ → ℕ | null | false |
CategoryTheory.Pretriangulated.Opposite.rotateTriangleOpEquivalenceInverseObjRotateUnopIso._proof_4 | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(T : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ),
CategoryTheory.CategoryStruct.comp
(Opposite.unop ((Categor... | null | false |
_private.Mathlib.RingTheory.KrullDimension.Regular.0.ringKrullDim_quotient_span_singleton_succ_eq_ringKrullDim_of_mem_jacobson._simp_1_1 | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u} {M : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (r : R)
(N : Submodule R M), r • N = Ideal.span {r} • N | null | false |
CategoryTheory.Span.SpanBicat.whiskerRight_hom_πₗ_assoc | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | true |
Metric.Snowflaking.instT2Space | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : TopologicalSpace X] [T2Space X],
T2Space (Metric.Snowflaking X α hα₀ hα₁) | null | true |
LinearMap.BilinMap.tmul | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | {R : Type uR} →
{A : Type uA} →
{M₁ : Type uM₁} →
{M₂ : Type uM₂} →
{N₁ : Type uN₁} →
{N₂ : Type uN₂} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : AddCommMonoid M₂] →
... | The tensor product of two bilinear forms, a shorthand for dot notation. | true |
ENNReal.toNNReal_natCast_eq_toNNReal | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ), (↑n).toNNReal = (↑n).toNNReal | null | true |
Cardinal.lift_eq_zero | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{v}}, Cardinal.lift.{u, v} a = 0 ↔ a = 0 | null | true |
ContinuousMap.Homotopy.mk.inj | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {inst : TopologicalSpace X} {inst_1 : TopologicalSpace Y} {f₀ f₁ : C(X, Y)}
{toContinuousMap : C(↑unitInterval × X, Y)} {map_zero_left : ∀ (x : X), toContinuousMap.toFun (0, x) = f₀ x}
{map_one_left : ∀ (x : X), toContinuousMap.toFun (1, x) = f₁ x} {toContinuousMap_1 : C(↑unitInterval × ... | null | true |
Lean.Omega.Coeffs.isZero | Init.Omega.Coeffs | Lean.Omega.Coeffs → Prop | Are the coefficients all zero? | true |
_private.Batteries.Data.List.Interleave.0.List.interleave_append_left.match_1_1 | Batteries.Data.List.Interleave | ∀ {α : Type u_1} (motive : (x x_1 : List α) → x_1.length ≤ x.length → List α → Prop) (x x_1 : List α)
(x_2 : x_1.length ≤ x.length) (x_3 : List α),
(∀ (x : List α) (x_4 : [].length ≤ x.length) (l₃ : List α), motive x [] x_4 l₃) →
(∀ (head : α) (tail : List α) (head_1 : α) (tail_1 : List α) (x : (head_1 :: tail_... | null | false |
Aesop.IndexMatchLocation.none.elim | Aesop.Index.Basic | {motive : Aesop.IndexMatchLocation → Sort u} →
(t : Aesop.IndexMatchLocation) → t.ctorIdx = 0 → motive Aesop.IndexMatchLocation.none → motive t | null | false |
CategoryTheory.ComposableArrows.threeδ₃Toδ₂.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ f₃_1 : k ⟶ l)
(e_f₃ : f₃ = f₃_1) (f₂₃ : j ⟶ l) (h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃),
CategoryTheory.ComposableArrows.threeδ₃Toδ₂ f₁ f₂ f₃ f₂₃ h₂₃ =
CategoryTheory.ComposableArrows.threeδ₃Toδ₂ f... | null | true |
Unitization.inrRangeEquiv._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] (x : A), (↑x).toProd.2 = x | null | false |
Right.inv_le_self | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : Preorder α] [MulRightMono α] {a : α}, 1 ≤ a → a⁻¹ ≤ a | null | true |
Float._sizeOf_inst._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.324 | Mathlib.Util.CompileInductive | SizeOf Float | null | false |
Prod.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Prod | {R : Type u_5} →
{M : Type u_6} →
{N : Type u_7} →
[inst : Zero M] → [inst_1 : Zero N] → [SMulZeroClass R M] → [SMulZeroClass R N] → SMulZeroClass R (M × N) | null | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.signVariations_eraseLead_mul_X_sub_C._proof_1_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] {P : Polynomial R} {η : R} (d : ℕ),
P.natDegree = d + 1 →
((Polynomial.X - Polynomial.C η) * P).natDegree = P.natDegree + 1 →
((Polynomial.X - Polynomial.C η) * P).nextCoeff = P.coeff d - η * P.coeff (d + 1) | null | false |
IsPurelyInseparable.tower_bot | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [IsPurelyInseparable F K], IsPurelyInseparable F E | If `K / E / F` is a field extension tower such that `K / F` is purely inseparable,
then `E / F` is also purely inseparable. | true |
CategoryTheory.Limits.image.lift_mk_factorThruImage_assoc | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasImage f] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image f, m := CategoryTheory.Limits.image.ι f, m_mono := ⋯,
... | null | true |
Std.Http.Status.notFound.sizeOf_spec | Std.Http.Data.Status | sizeOf Std.Http.Status.notFound = 1 | null | true |
Lean.DataValue.recOn | Lean.Data.KVMap | {motive : Lean.DataValue → Sort u} →
(t : Lean.DataValue) →
((v : String) → motive (Lean.DataValue.ofString v)) →
((v : Bool) → motive (Lean.DataValue.ofBool v)) →
((v : Lean.Name) → motive (Lean.DataValue.ofName v)) →
((v : ℕ) → motive (Lean.DataValue.ofNat v)) →
((v : ℤ) → mo... | null | false |
Perfection.lift | Mathlib.RingTheory.Perfection | (p : ℕ) →
[hp : Fact (Nat.Prime p)] →
(R : Type u₁) →
[inst : CommSemiring R] →
[CharP R p] →
[PerfectRing R p] →
(S : Type u₂) → [inst_3 : CommSemiring S] → [inst_4 : CharP S p] → (R →+* S) ≃ (R →+* Perfection S p) | Given rings `R` and `S` of characteristic `p`, with `R` being perfect,
any homomorphism `R →+* S` can be lifted to a homomorphism `R →+* Perfection S p`. | true |
Polynomial.instFree | Mathlib.LinearAlgebra.Finsupp.VectorSpace | ∀ {R : Type u_1} [inst : Semiring R], Module.Free R (Polynomial R) | null | true |
Polynomial.separable_C_mul_X_pow_add_C_mul_X_add_C | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} (a b c : R),
↑n = 0 → IsUnit b → (Polynomial.C a * Polynomial.X ^ n + Polynomial.C b * Polynomial.X + Polynomial.C c).Separable | If `n = 0` in `R` and `b` is a unit, then `a * X ^ n + b * X + c` is separable. | true |
CategoryTheory.ShortComplex.π₂_map | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex C} (f : X ⟶ Y), CategoryTheory.ShortComplex.π₂.map f = f.τ₂ | null | true |
Matrix.IsPivotedBy.lt_of_lt_of_ne_top | Mathlib.LinearAlgebra.Matrix.Echelon.Pivot | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_3} [inst : Zero R] {A : Matrix m n R} {l : m → WithTop n}
[inst_1 : LinearOrder n] [inst_2 : LT m] {i₁ i₂ : m}, A.IsPivotedBy l → i₁ < i₂ → l i₁ ≠ ⊤ → l i₁ < l i₂ | null | true |
zpow_mod_orderOf | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] (x : G) (z : ℤ), x ^ (z % ↑(orderOf x)) = x ^ z | null | true |
Matrix.instNonAssocRing._proof_5 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : DecidableEq n] [inst_1 : NonAssocRing α] (a : Matrix n n α), -a + a = 0 | null | false |
Nat.prod_mem_smoothNumbers | Mathlib.NumberTheory.SmoothNumbers | ∀ (n N : ℕ), (List.filter (fun x => decide (x < N)) n.primeFactorsList).prod ∈ N.smoothNumbers | The product of the prime factors of `n` that are less than `N` is an `N`-smooth number. | true |
CategoryTheory.Functor.FullyFaithful.addMonObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.OplaxMonoidal] (hF : F.FullyFaithful) (X : C)
[inst_5... | null | false |
CategoryTheory.Functor.IsIso | Mathlib.CategoryTheory.IsoCat | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` is an isomorphism of categories if it is full, faithful and
bijective on objects. Such a functor has a strict inverse `Functor.strictInv` and assembles
into an `IsoCat` via `Functor.asIsomorphism`. | true |
String.Pos.isUTF8FirstByte_getUTF8Byte_offset | Init.Data.String.Lemmas.Order | ∀ {s : String} {p : s.Pos} {h : p.offset < s.rawEndPos}, (s.getUTF8Byte p.offset h).IsUTF8FirstByte | null | true |
_private.Mathlib.Data.Finset.Sym.0.Finset.not_isDiag_mk_of_mem_offDiag._proof_1_1 | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α} {a b : α}, a ∈ s ∧ b ∈ s ∧ ¬a = b → ¬a = b | null | false |
_private.Std.Time.Date.Unit.Year.0.Std.Time.Year.instReprEra.repr.match_1 | Std.Time.Date.Unit.Year | (motive : Std.Time.Year.Era → Sort u_1) →
(x : Std.Time.Year.Era) → (Unit → motive Std.Time.Year.Era.bce) → (Unit → motive Std.Time.Year.Era.ce) → motive x | null | false |
Filter.map_neg | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Neg α] {f : Filter α}, Filter.map Neg.neg f = -f | null | true |
DirectLimit.instMulActionOfMulActionHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Monoid R]
... | null | false |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.match_1.eq_3 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_1} (motive : Option (Stream'.Seq1 (Option (Computation α))) → Sort u_2) (c : Computation α)
(S' : Stream'.Seq (Option (Computation α))) (h_1 : Unit → motive none)
(h_2 : (S' : Stream'.Seq (Option (Computation α))) → motive (some (none, S')))
(h_3 : (c : Computation α) → (S' : Stream'.Seq (Option (Co... | null | true |
CategoryTheory.Retract.trans._proof_2 | Mathlib.CategoryTheory.Retract | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (h : CategoryTheory.Retract X Y) {Z : C}
(h' : CategoryTheory.Retract Y Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h.i h'.i)
(CategoryTheory.CategoryStruct.comp h'.r h.r) =
CategoryTheory.CategoryStruc... | null | false |
Subsemiring.centralizer_eq_top_iff_subset | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] {s : Set R}, Subsemiring.centralizer s = ⊤ ↔ s ⊆ ↑(Subsemiring.center R) | null | true |
VAdd.mk._flat_ctor | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → (G → P → P) → VAdd G P | null | false |
Std.Rxc.LawfulHasSize.size_eq_succ_of_succ?_eq_some | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} {inst : LE α} {inst_1 : Std.PRange.UpwardEnumerable α} {inst_2 : Std.Rxc.HasSize α}
[self : Std.Rxc.LawfulHasSize α] (lo hi lo' : α),
lo ≤ hi → Std.PRange.succ? lo = some lo' → Std.Rxc.HasSize.size lo hi = Std.Rxc.HasSize.size lo' hi + 1 | If the smallest value in the range satisfies the upper bound and has a successor, the size is
one larger than the size of the range starting at the successor. | true |
right_eq_ite_iff | Init.PropLemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, (y = if p then x else y) ↔ p → y = x | null | true |
isDedekindDomain_iff | Mathlib.RingTheory.DedekindDomain.Basic | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_4) [inst_1 : CommRing K] [inst_2 : Algebra A K] [IsFractionRing A K],
IsDedekindDomain A ↔
IsDomain A ∧ IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x | An integral domain is a Dedekind domain iff and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. | true |
AddSubgroup.index_pi | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_3} [inst_1 : Fintype ι] (H : ι → AddSubgroup G),
(AddSubgroup.pi Set.univ H).index = ∏ i, (H i).index | null | true |
_private.Mathlib.CategoryTheory.Shift.ShiftSequence.0.CategoryTheory.Functor.ShiftSequence.tautological._simp_4 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalAdd.match_5 | Mathlib.Tactic.Positivity.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(f : Q(«$α» → «$α» → «$α»)) →
(_a : Q(AddZeroClass «$α»)) →
(motive : PLift («$f» =Q HAdd.hAdd) → Sort u_1) →
(x : PLift («$f» =Q HAdd.hAdd)) → ((_f_eq : «$f» =Q HAdd.hAdd) → motive { down := _f_eq }) → motive x | null | false |
Real.summable_Lp_add_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → ℝ} {p : ℝ},
1 ≤ p →
(∀ (i : ι), 0 ≤ f i) →
(∀ (i : ι), 0 ≤ g i) →
(Summable fun i => f i ^ p) → (Summable fun i => g i ^ p) → Summable fun i => (f i + g i) ^ p | null | true |
Finset.prod_eq_prod_sdiff_singleton_mul | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : DecidableEq ι] {s : Finset ι} {i : ι},
i ∈ s → ∀ (f : ι → M), ∏ x ∈ s, f x = (∏ x ∈ s \ {i}, f x) * f i | null | true |
Lean.Elab.Tactic.ResolveSimpIdResult._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.ResolveSimpIdResult → ℕ | null | false |
Seminorm.closedBall_zero' | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E] {r : ℝ} (x : E),
0 < r → Seminorm.closedBall 0 x r = Set.univ | null | true |
_private.Mathlib.Algebra.NoZeroSMulDivisors.Defs.0.instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors._simp_1 | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
Encodable.decidableRangeEncode.match_1 | Mathlib.Logic.Encodable.Basic | ∀ (α : Type u_1) [inst : Encodable α] (x : ℕ) (motive : x ∈ Set.range Encodable.encode → Prop)
(x_1 : x ∈ Set.range Encodable.encode), (∀ (n : α) (hn : Encodable.encode n = x), motive ⋯) → motive x_1 | null | false |
Polynomial.coeff_hermite_succ_zero | Mathlib.RingTheory.Polynomial.Hermite.Basic | ∀ (n : ℕ), (Polynomial.hermite (n + 1)).coeff 0 = -(Polynomial.hermite n).coeff 1 | null | true |
Cross.lieRing._proof_1 | Mathlib.LinearAlgebra.CrossProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R (Fin 3 → R) | null | false |
SimpleGraph.Copy.mapNeighborSet | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} →
{G : SimpleGraph V} → {H : SimpleGraph W} → (f : H.Copy G) → (a : W) → ↑(H.neighborSet a) ↪ ↑(G.neighborSet (f a)) | A copy induces an embedding of neighbor sets. | true |
WithVal.instOne | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : LinearOrderedCommGroupWithZero Γ₀] → [inst_1 : Ring R] → (v : Valuation R Γ₀) → One (WithVal v) | null | true |
AffineSubspace.sSameSide_vadd_left_iff | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P} {v : V}, v ∈ s.direction → (s.SSameSide (v +ᵥ x) y ↔ s.SSameSide x y) | null | true |
if_true | Init.ByCases | ∀ {α : Sort u_1} {x : Decidable True} (t e : α), (if True then t else e) = t | null | true |
Subsemiring.mk'.congr_simp | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R] (s s_1 : Set R) (e_s : s = s_1) (sm sm_1 : Submonoid R) (e_sm : sm = sm_1)
(hm : ↑sm = s) (sa sa_1 : AddSubmonoid R) (e_sa : sa = sa_1) (ha : ↑sa = s),
Subsemiring.mk' s sm hm sa ha = Subsemiring.mk' s_1 sm_1 ⋯ sa_1 ⋯ | null | true |
ZFSet.coe_union._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x y : ZFSet.{u}), ↑x ∪ ↑y = ↑(x ∪ y) | null | false |
Computation.LiftRel.swap | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β),
Computation.LiftRel (Function.swap R) cb ca ↔ Computation.LiftRel R ca cb | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.