name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Arrow.isoOfNatIso._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (e : F ≅ G)
(f : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp (e.app f.left).hom (G.mapArrow.obj f).hom =
CategoryTheory.CategoryStruc... | null | false |
ValuationSubring.mem_ofSubring._simp_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R : Subring K) (hR : ∀ (x : K), x ∈ R ∨ x⁻¹ ∈ R) (x : K),
(x ∈ ValuationSubring.ofSubring R hR) = (x ∈ R) | null | false |
TensorProduct.AlgebraTensorModule.lTensor_comp | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {Q : Type uQ} {Q' : Type uQ'} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 ... | null | true |
DMatrix.instUnique | Mathlib.Data.Matrix.DMatrix | {m : Type u_1} → {n : Type u_2} → {α : m → n → Type v} → [(i : m) → (j : n) → Unique (α i j)] → Unique (DMatrix m n α) | null | true |
Parser.Attr.qify_simps | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | The simpset `qify_simps` is used by the tactic `qify` to move expressions from `ℕ` or `ℤ` to `ℚ`
which gives a well-behaved division. | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.foldM._proof_1 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (le : α → α → Bool) (s : Batteries.BinomialHeap.Imp.Heap α) (hd : α)
(tl : Batteries.BinomialHeap.Imp.Heap α),
Batteries.BinomialHeap.Imp.Heap.deleteMin le s = some (hd, tl) → tl.realSize < s.realSize | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.forM_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
StrictMonoOn.union | Mathlib.Order.Monotone.Union | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α} {c : α},
StrictMonoOn f s → StrictMonoOn f t → IsGreatest s c → IsLeast t c → StrictMonoOn f (s ∪ t) | If `f` is strictly monotone both on `s` and `t`, with `s` to the left of `t` and the center
point belonging to both `s` and `t`, then `f` is strictly monotone on `s ∪ t` | true |
Lean.Order.pushExcept.eq_2 | Std.WP.Monad.Conjunctive | ∀ {α : Type u} {ε : Type v} {Pred : Type w} (post : α → Pred) (epost : ε → Pred) (e : ε),
Lean.Order.pushExcept post epost (Except.error e) = epost e | null | true |
Polynomial.isMonicOfDegree_X_add_one | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] [Nontrivial R] (r : R), (Polynomial.X + Polynomial.C r).IsMonicOfDegree 1 | null | true |
SkewPolynomial.support_C_mul_X_pow_subset | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : MulSemiringAction (Multiplicative ℕ) R] (n : ℕ) (c : R),
(SkewPolynomial.C c * SkewPolynomial.X ^ n).support ⊆ {n} | null | true |
Lean.Meta.TransparencyMode.noConfusion | Init.MetaTypes | {P : Sort v✝} → {x y : Lean.Meta.TransparencyMode} → x = y → Lean.Meta.TransparencyMode.noConfusionType P x y | null | false |
Std.Internal.instLawfulMemForInIdRci | Std.Internal.ForIn.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxi.IsAlwaysFinite α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α],
Std.Internal.LawfulMemForInId (Std.Rci α) α | null | true |
FinBoolAlg.noConfusion | Mathlib.Order.Category.FinBoolAlg | {P : Sort u} → {t t' : FinBoolAlg} → t = t' → FinBoolAlg.noConfusionType P t t' | null | false |
CategoryTheory.ShortComplex.π_moduleCatCyclesIso_hom_assoc_apply | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R}
(h : S.moduleCatLeftHomologyData.H ⟶ Z) (x : ↑S.cycles),
(CategoryTheory.ConcreteCategory.hom h)
((CategoryTheory.ConcreteCategory.hom S.moduleCatHomologyIso.hom)
((CategoryTheory.ConcreteCategory.hom S.ho... | null | true |
Plausible.InjectiveFunction.shrink._proof_5 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs' ys' : List α),
xs'.Perm ys' →
xs'.length ≤ ys'.length →
ys'.length ≤ xs'.length →
(List.map Sigma.fst (List.map Prod.toSigma (xs'.zip ys'))).Perm
(List.map Sigma.snd (List.map Prod.toSigma (xs'.zip ys'))) | null | false |
CategoryTheory.Comonad.forget_creates_limits_of_comonad_preserves | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} [CategoryTheory.Limits.PreservesLimitsOfShape J T.toFunctor]
(D : CategoryTheory.Functor J T.Coalgebra) [CategoryTheory.Limits.HasLimit (D.comp T.forget)],
CategoryTh... | For `D : J ⥤ Coalgebra T`, `D ⋙ forget T` has a limit, then `D` has a limit provided limits
of shape `J` are preserved by `T`.
| true |
List.SortedLT.map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, (List.map (⇑OrderDual.toDual) l).SortedLT → l.SortedGT | **Alias** of the forward direction of `List.sortedLT_map_toDual`. | true |
Nat.findGreatest_eq_zero_iff | Mathlib.Data.Nat.Find | ∀ {k : ℕ} {P : ℕ → Prop} [inst : DecidablePred P], Nat.findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n | null | true |
CentroidHom.centerToCentroidCenter | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalNonAssocSemiring α] → ↥(NonUnitalSubsemiring.center α) →ₙ+* ↥(Subsemiring.center (CentroidHom α)) | The canonical homomorphism from the center into the center of the centroid | true |
LieEquiv.ofSubalgebras_apply | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (L₁' : LieSubalgebra R L₁) (L₂' : LieSubalgebra R L₂)
(e : L₁ ≃ₗ⁅R⁆ L₂) (h : LieSubalgebra.map e.toLieHom L₁' = L₂') (x : ↥L₁'),
↑((LieEquiv.ofSubalgebra... | null | true |
_private.Std.Data.DHashMap.Internal.Raw.0.Std.DHashMap.Raw.diff.eq_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Raw α β),
m₁.diff m₂ =
if h₁ : 0 < m₁.buckets.size then
if h₂ : 0 < m₂.buckets.size then ↑(Std.DHashMap.Internal.Raw₀.diff ⟨m₁, h₁⟩ ⟨m₂, h₂⟩) else m₁
else m₂ | null | true |
CategoryTheory.isFinitelyPresentable_iff_preservesFilteredColimits | Mathlib.CategoryTheory.Presentable.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.IsFinitelyPresentable X ↔
CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.coyoneda.obj (Opposite.op X)) | null | true |
isPreirreducible_iff_isClosed_union_isClosed | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsPreirreducible s ↔ ∀ (z₁ z₂ : Set X), IsClosed z₁ → IsClosed z₂ → s ⊆ z₁ ∪ z₂ → s ⊆ z₁ ∨ s ⊆ z₂ | A set is preirreducible if and only if
for every cover by two closed sets, it is contained in one of the two covering sets. | true |
IntermediateField.LinearDisjoint.symm | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.LinearDisjoint ↥B → B.LinearDisjoint ↥A | Linear disjointness is symmetric. | true |
instModuleTensorProductMop._proof_1 | Mathlib.Algebra.Azumaya.Defs | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower R Aᵐᵒᵖ A | null | false |
Std.Async.System.Environment.get? | Std.Async.System | Std.Async.System.Environment → String → Option String | null | true |
CategoryTheory.Limits.ChosenPullback₃.w₁_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | null | true |
CategoryTheory.Functor.mapAddGrpFunctor._proof_8 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(X : C ⥤ₗ D),
{ app := fun A => CategoryTheory.AddGrp.homMk'' ((CategoryTheory.C... | null | false |
List.find?_append | Init.Data.List.Impl | ∀ {α : Type u_1} {p : α → Bool} {xs ys : List α}, List.find? p (xs ++ ys) = (List.find? p xs).or (List.find? p ys) | null | true |
StandardSubspace.mk._flat_ctor | Mathlib.Analysis.InnerProductSpace.StandardSubspace | {H : Type u_1} →
[inst : NormedAddCommGroup H] →
[inst_1 : InnerProductSpace ℂ H] →
(toClosedSubmodule : ClosedSubmodule ℝ H) →
toClosedSubmodule ⊓ toClosedSubmodule.mulI = ⊥ →
toClosedSubmodule ⊔ toClosedSubmodule.mulI = ⊤ → StandardSubspace H | null | false |
CategoryTheory.Bicategory.Equivalence.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {a b : B} {hom : a ⟶ b} {inv : b ⟶ a}
{unit : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp hom inv}
{counit : CategoryTheory.CategoryStruct.comp inv hom ≅ CategoryTheory.CategoryStruct.id b}
{left_triangle :
autoParam
(Categ... | null | true |
Ideal.IsTwoSided.mul_one | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I : Ideal R} [I.IsTwoSided], I * 1 = I | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_spanning_iff_of_subsingleton._simp_1_2 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {α : Type u_2} (M : Matroid α) (S : Set α), M.Spanning S = (M.closure S = M.E ∧ S ⊆ M.E) | null | false |
MeasureTheory.Lp.constₗ | Mathlib.MeasureTheory.Function.LpSpace.Indicator | {α : Type u_1} →
{E : Type u_2} →
{m : MeasurableSpace α} →
(p : ENNReal) →
(μ : MeasureTheory.Measure α) →
[inst : NormedAddCommGroup E] →
[MeasureTheory.IsFiniteMeasure μ] →
(𝕜 : Type u_3) →
[inst_2 : NormedRing 𝕜] →
[inst_3 :... | `MeasureTheory.Lp.const` as a `LinearMap`. | true |
SheafOfModules.hasLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat),
CategoryTheory.Limits.HasLimitsOfSize.{v₂, v, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (SheafOfModules R) | null | true |
_private.Mathlib.Basic.Real.ConjExponents.0.ENNReal.coe_conjExponent._simp_1_8 | Mathlib.Basic.Real.ConjExponents | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
LinearPMap | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
(R →+* S) →
(E : Type u_3) →
[inst_2 : AddCommGroup E] →
[Module R E] → (F : Type u_4) → [inst : AddCommGroup F] → [Module S F] → Type (max u_3 u_4) | A `LinearPMap σ E F` or `E →ₛₗ.[σ] F` is a (semi)linear map from a submodule of `E` to `F`. | true |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.CollectState.collectedThms._default | Lean.Meta.Tactic.Grind.EMatchAction | Std.HashSet (Lean.Meta.Grind.Origin × Lean.Meta.Grind.EMatchTheoremKind) | null | false |
ProbabilityTheory.«_aux_Mathlib_Probability_ConditionalProbability___macroRules_ProbabilityTheory_term__[|_]_1» | Mathlib.Probability.ConditionalProbability | Lean.Macro | null | false |
Associated.of_pow_associated_of_prime' | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p₁ p₂ : M} {k₁ k₂ : ℕ},
Prime p₁ → Prime p₂ → 0 < k₂ → Associated (p₁ ^ k₁) (p₂ ^ k₂) → Associated p₁ p₂ | null | true |
MeasureTheory.Filtration.natural | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} →
{m : MeasurableSpace Ω} →
{β : ι → Type u_3} →
[inst : (i : ι) → TopologicalSpace (β i)] →
[∀ (i : ι), TopologicalSpace.MetrizableSpace (β i)] →
[mβ : (i : ι) → MeasurableSpace (β i)] →
[∀ (i : ι), BorelSpace (β i)] →
... | Given a sequence of functions, the natural filtration is the smallest sequence
of σ-algebras such that the sequence of functions is measurable with respect to
the filtration. | true |
LightCondensed.instMonoidalLightCondSetLightCondModFree._aux_10 | Mathlib.Condensed.Light.Monoidal | (R : Type u_1) →
[inst : CommRing R] →
(LightCondensed.free R).obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit LightCondSet) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorUnit (LightCondMod R) | null | false |
Path.extend | Mathlib.Topology.Path | {X : Type u_1} → [inst : TopologicalSpace X] → {x y : X} → Path x y → C(ℝ, X) | A continuous map extending a path to `ℝ`, constant before `0` and after `1`. | true |
Lean.Lsp.PrepareRenameParams._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.PrepareRenameParams → ℕ | null | false |
CategoryTheory.Limits.kernelFactorThruImage.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] [inst_3 : CategoryTheory.Limits.HasImage f]
[inst_4 : CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.factorThruImage f)],
Category... | null | true |
Std.Tactic.BVDecide.BVExpr.Cache.insert._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} {w : ℕ} (expr : Std.Tactic.BVDecide.BVExpr w) (refs : aig.RefVec w)
(map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w),
(∀ {i : ℕ} (k : Std.Tactic.BVDecide.BVExpr.Cache.Key) (h1 : k ∈ map) (h2 : i < k.w),
(map.get k h... | null | false |
CategoryTheory.Limits.Fan.IsLimit.lift_proj_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : β → C} {c : CategoryTheory.Limits.Cofan X}
(d : CategoryTheory.Limits.Cofan X) (hc : CategoryTheory.Limits.IsColimit c) (i : β) {Z : C} (h : Z ⟶ X i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (c.inj i)) (hc.de... | null | false |
_private.Mathlib.Topology.Connected.Basic.0.IsPreconnected.iUnion_of_reflTransGen._simp_1_1 | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Equiv.optionCongr_apply | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) (a : Option α), e.optionCongr a = Option.map (⇑e) a | null | true |
Turing.ToPartrec.stepRet.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Cont) (x_1 : List ℕ),
Turing.ToPartrec.stepRet x x_1 =
match x, x_1 with
| Turing.ToPartrec.Cont.halt, v => Turing.ToPartrec.Cfg.halt v
| Turing.ToPartrec.Cont.cons₁ fs as k, v => Turing.ToPartrec.stepNormal fs (Turing.ToPartrec.Cont.cons₂ v k) as
| Turing.ToPartrec.Cont.cons₂ ... | null | true |
Polynomial.le_gaussNorm | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : FunLike F R ℝ] (v : F) {c : ℝ} (p : Polynomial R)
[ZeroHomClass F R ℝ] [NonnegHomClass F R ℝ], 0 ≤ c → ∀ (i : ℕ), v (p.coeff i) * c ^ i ≤ Polynomial.gaussNorm v c p | null | true |
Function.Injective.mulOneClass._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : MulOneClass M₂] (f : M₁ → M₂),
f 1 = 1 → (∀ (x y : M₁), f (x * y) = f x * f y) → ∀ (x : M₁), f (x * 1) = f x | null | false |
String.Pos.get?_eq_some_get | Init.Data.String.Lemmas.Slice | ∀ {s : String} {p : s.Pos} (h : p ≠ s.endPos), p.get? = some (p.get h) | null | true |
WeierstrassCurve.toCharTwoNF_spec | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {F : Type u_2} [inst : Field F] [CharP F 2] (W : WeierstrassCurve F) [inst_2 : DecidableEq F],
(W.toCharTwoNF • W).IsCharTwoNF | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.toBitVec_eq_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false → b.toBitVec = 2#2 ++ BitVec.setWidth 6 b.toBitVec | null | true |
inf_sup_self | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ (a ⊔ b) = a | null | true |
CategoryTheory.Preadditive.epi_of_cokernel_zero | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} {f : X ⟶ Y}
[inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f 0)],
CategoryTheory.Limits.cokernel.π f = 0 → CategoryTheory.Epi f | null | true |
MonCat.ofHom_hom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : MonCat} (f : M ⟶ N), MonCat.ofHom (MonCat.Hom.hom f) = f | null | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.whnfCore.go._unsafe_rec | Lean.Meta.WHNF | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
ZMod.ringEquivOfPrime | Mathlib.Data.ZMod.Basic | (R : Type u_1) → [inst : Ring R] → [inst_1 : Fintype R] → {p : ℕ} → Nat.Prime p → Fintype.card R = p → ZMod p ≃+* R | The unique ring isomorphism between `ZMod p` and a ring `R` of cardinality a prime `p`.
If you need any property of this isomorphism, first of all use `ringEquivOfPrime_eq_ringEquiv`
below (after `have : CharP R p := ...`) and deduce it by the results about `ZMod.ringEquiv`. | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.insertMany_list_eq_empty_iff._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) | null | false |
CategoryTheory.FreeBicategory.mk_associator_hom | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h) =
(CategoryTheory.Bicategory.associator f g h).hom | null | true |
Aesop.SearchM.State.mk._flat_ctor | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.Iteration → Q → Bool → Aesop.SearchM.State Q | null | false |
WeierstrassCurve.Projective.dblZ_ne_zero_of_Y_ne' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 ≠ W'.negY Q * P 2 → W'.dblZ P ≠ 0 | null | true |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.eval_single_add'._simp_1_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | null | false |
Lean.Meta.Grind.AC.MonadGetStruct.ctorIdx | Lean.Meta.Tactic.Grind.AC.Util | {m : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m → ℕ | null | false |
_private.Mathlib.Tactic.Inclusion.Extension.Interval.0.Inclusion.Interval.mul_mem._proof_1_29 | Mathlib.Tactic.Inclusion.Extension.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : LinearOrder α] [inst_2 : Ring β] [inst_3 : LinearOrder β]
(f : α ↪o β) {x y : β} {I J : Inclusion.Interval α},
¬I.ub ≤ 0 → ¬0 ≤ J.lb → I.ub = none ∧ J.lb = some 0 ∨ I.ub = some 0 ∧ J.lb = none → f 0 ≤ x * y | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.index_union_eq._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Dyadic.blt.eq_3 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), (Dyadic.ofOdd n k hn).blt Dyadic.zero = decide (n < 0) | null | true |
max_zero_add_max_neg_zero_eq_abs_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] (a : G),
max a 0 + max (-a) 0 = |a| | null | true |
Polynomial.ofFn._proof_1 | Mathlib.Algebra.Polynomial.OfFn | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : DecidableEq R] (n : ℕ) (x y : Fin n → R),
{ toFinsupp := AddMonoidAlgebra.ofCoeff (List.ofFn (x + y)).toFinsupp } =
{ toFinsupp := AddMonoidAlgebra.ofCoeff (List.ofFn x).toFinsupp } +
{ toFinsupp := AddMonoidAlgebra.ofCoeff (List.ofFn y).toFinsupp } | null | false |
Equiv.nonUnitalNonAssocRing._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocRing β] (x y : α),
e (e.symm (e.toFun x * e.toFun y)) = e.toFun x * e.toFun y | null | false |
GetElem.casesOn | Init.GetElem | {coll : Type u} →
{idx : Type v} →
{elem : Type w} →
{valid : coll → idx → Prop} →
{motive : GetElem coll idx elem valid → Sort u_1} →
(t : GetElem coll idx elem valid) →
((getElem : (xs : coll) → (i : idx) → valid xs i → elem) → motive { getElem := getElem }) → motive t | null | false |
Equiv.Perm.extendDomain_one | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p),
Equiv.Perm.extendDomain 1 f = 1 | null | true |
TopCat.prodIsoProd_hom_snd | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat),
CategoryTheory.CategoryStruct.comp (X.prodIsoProd Y).hom TopCat.prodSnd = CategoryTheory.Limits.prod.snd | null | true |
Lean.Elab.Do.DoElemContKind.noConfusion | Lean.Elab.Do.Basic | {P : Sort v✝} → {x y : Lean.Elab.Do.DoElemContKind} → x = y → Lean.Elab.Do.DoElemContKind.noConfusionType P x y | null | false |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.SpecialLinearGroup.diag_decompose._proof_1_3 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (i₀ : ι) (D : ι → F),
D i₀ * ∏ x with x ≠ i₀, D x = 1 → ¬∏ x with ¬x = i₀, D x = 0 | null | false |
Lean.ScopedEnvExtension.StateStack.recOn | Lean.ScopedEnvExtension | {α β σ : Type} →
{motive : Lean.ScopedEnvExtension.StateStack α β σ → Sort u} →
(t : Lean.ScopedEnvExtension.StateStack α β σ) →
((stateStack : List (Lean.ScopedEnvExtension.State σ)) →
(scopedEntries : Lean.ScopedEnvExtension.ScopedEntries β) →
(newEntries : List (Lean.ScopedEnvExtens... | null | false |
_private.Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction.0.Pentagonal.tsum_pow_mul_prod_bound._proof_1_1 | Mathlib.Combinatorics.Enumerative.Pentagonal.EulerFunction | ∀ {R : Type u_1} [inst : NormedCommRing R] (k : ℕ) {x : R}, ‖x‖ < 1 → ∀ (n : ℕ), ‖x‖ ^ ((k + 1) * n) ≤ ‖x‖ ^ n | null | false |
_private.Mathlib.RingTheory.Multiplicity.0.Nat.finiteMultiplicity_iff.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {b : ℕ} (motive : (a : ℕ) → (∀ (n : ℕ), a ^ n ∣ b) → a ≠ 0 → a ≠ 1 → a ≤ 1 → Prop) (a : ℕ) (h : ∀ (n : ℕ), a ^ n ∣ b)
(ha : a ≠ 0) (ha1 : a ≠ 1) (x : a ≤ 1),
(∀ (h : ∀ (n : ℕ), 0 ^ n ∣ b) (ha : 0 ≠ 0) (ha1 : 0 ≠ 1) (x : 0 ≤ 1), motive 0 h ha ha1 x) →
(∀ (h : ∀ (n : ℕ), 1 ^ n ∣ b) (ha : 1 ≠ 0) (ha1 : 1 ≠ 1) (x... | null | false |
Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.SplitIfs | Lean.Elab.Tactic.Tactic | null | false |
norm_le_norm_div_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedGroup E] (a b : E), ‖a‖ ≤ ‖a / b‖ + ‖b‖ | null | true |
NonemptyInterval.length_nonneg | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (s : NonemptyInterval α),
0 ≤ s.length | null | true |
MeasureTheory.AnalyticSet.preimage | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {X : Type u_3} {Y : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [PolishSpace X] [T2Space Y]
{s : Set Y}, MeasureTheory.AnalyticSet s → ∀ {f : X → Y}, Continuous f → MeasureTheory.AnalyticSet (f ⁻¹' s) | Preimage of an analytic set is an analytic set. | true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_16 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → 0 < (x :: y :: tail).length | null | false |
instMulActionSemiHomClassMulActionHom | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} (φ : M → N) (X : Type u_5) [inst : SMul M X] (Y : Type u_6) [inst_1 : SMul N Y],
MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y | null | true |
ProbabilityTheory.Kernel.coe_mk | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (f : α → MeasureTheory.Measure β)
(hf : Measurable f), ⇑{ toFun := f, measurable' := hf } = f | null | true |
List.attach_reverse | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α},
xs.reverse.attach =
List.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach.reverse | null | true |
AlgebraicGeometry.Scheme.Hom.normalizationDiagramMap._proof_1 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U V : (TopologicalSpace.Opens ↥Y)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map i)
(CommRingCat.ofHom
(algebraMap ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↥(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.uno... | null | false |
AlgebraicGeometry.Scheme.Cover.gluedCover._proof_4 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f j))
(CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f k)) | null | false |
ProofWidgets.RefreshComponent.RpcEncodablePacket.state._@.ProofWidgets.Component.RefreshComponent.1995342541._hygCtx._hyg.1 | ProofWidgets.Component.RefreshComponent | ProofWidgets.RefreshComponent.RpcEncodablePacket✝ → Lean.Json | null | false |
Lean.Parser.Tactic.appendConfig | Init.Meta.Defs | Lean.Syntax → Lean.Syntax → Lean.TSyntax `Lean.Parser.Tactic.optConfig | Appends two tactic configurations.
The configurations can be `Lean.Parser.Tactic.optConfig`, `Lean.Parser.Tactic.config`,
or these wrapped in null nodes (for example because the syntax is `(config)?`).
| true |
RightCancelSemigroup.toSemigroup | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} → [self : RightCancelSemigroup G] → Semigroup G | null | true |
Subfield.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L), Subfield.extendScalars ⋯ = ⊥ | null | true |
MeasureTheory.diracProbaEquiv.congr_simp | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
[inst_3 : T0Space X], MeasureTheory.diracProbaEquiv = MeasureTheory.diracProbaEquiv | null | true |
HomologicalComplex.HomologySequence.snakeInput._proof_33 | Mathlib.Algebra.Homology.HomologySequence | 2 < 3 + 1 | null | false |
Mathlib.Deriving.Fintype.«_aux_Mathlib_Tactic_DeriveFintype___macroRules_Mathlib_Deriving_Fintype_termDerive_fintype%__1» | Mathlib.Tactic.DeriveFintype | Lean.Macro | The term elaborator `derive_fintype% α` tries to synthesize a `Fintype α` instance
using all the assumptions in the local context; this can be useful, for example, if one
needs an extra `DecidableEq` instance. It works only if `α` is an inductive
type that `proxy_equiv% α` can handle. The elaborator makes use of the
ex... | false |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk.injEq | Lean.Elab.DocString | ∀ (footnotes : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls : Std.HashMap String (Lean.Doc.Ref✝ String)) (deferred : Array Lean.Doc.DeferredCheck)
(footnotes_1 : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls_1 : Std.HashMap String (Lean.Doc.Ref✝ String)... | null | true |
CategoryTheory.Limits.ReflectsLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` reflects limits if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.