name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Pi.Part.hasFix | Mathlib.Control.Fix | {α : Type u_1} → {β : Type u_3} → Fix (α → Part β) | null | true |
Lean.Doc.Inline.noConfusion | Lean.DocString.Types | {P : Sort u_1} →
{i : Type u} →
{t : Lean.Doc.Inline i} →
{i' : Type u} → {t' : Lean.Doc.Inline i'} → i = i' → t ≍ t' → Lean.Doc.Inline.noConfusionType P t t' | null | false |
MvPowerSeries.coeff_mul_right_one_sub_of_lt_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} (w : σ → ℕ) {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} {d : σ →₀ ℕ},
↑((Finsupp.weight w) d) < MvPowerSeries.weightedOrder w g →
(MvPowerSeries.coeff d) ((1 - g) * f) = (MvPowerSeries.coeff d) f | null | true |
CommGrpCat.Hom._mkInternal.injEq | Mathlib.Algebra.Category.Grp.Basic | ∀ {A B : CommGrpCat} (hom' hom'_1 : ↑A →* ↑B), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | false |
Ideal.isPrincipalNonZeroDivisorsSubmonoid._proof_2 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ (R : Type u_1) [inst : CommRing R], ↑1 = R ∙ 1 | null | false |
CategoryTheory.Sheaf.isSheaf_of_isLimit | Mathlib.CategoryTheory.Sites.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {K : Type z} [inst_2 : CategoryTheory.Category.{z', z} K]
[CategoryTheory.Limits.HasLimitsOfShape K D] (F : CategoryTheory.Functor K (CategoryTheory.Sheaf J ... | If `E` is a cone which is a limit on the level of presheaves,
then the limit presheaf is again a sheaf.
This is used to show that the forgetful functor from sheaves to presheaves creates limits.
| true |
MaximalSpectrum.toPiLocalization_apply_apply | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ (R : Type u_1) [inst : CommSemiring R] {r : R} {I : MaximalSpectrum R},
(MaximalSpectrum.toPiLocalization R) r I = (algebraMap R (Localization.AtPrime I.asIdeal)) r | null | true |
LinearEquiv.ofIsUnitDet._proof_2 | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_2} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {M' : Type u_4}
[inst_3 : AddCommGroup M'] [inst_4 : Module R M'] {ι : Type u_3} [inst_5 : DecidableEq ι] [inst_6 : Fintype ι]
{f : M →ₗ[R] M'} {v : Module.Basis ι R M} {v' : Module.Basis ι R M'},
IsUnit ((LinearMa... | null | false |
SimpleGraph.IsFiveWheelLike.card_inter | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {r k : ℕ} {v w₁ w₂ : α} {s t : Finset α},
G.IsFiveWheelLike r k v w₁ w₂ s t → (s ∩ t).card = k | null | true |
Std.Async.IO.AsyncWrite.mk.noConfusion | Std.Async.IO | {α β : Type} →
{P : Sort u} →
{write : α → β → Std.Async.Async Unit} →
{writeAll : α → Array β → Std.Async.Async Unit} →
{flush : α → Std.Async.Async Unit} →
{write' : α → β → Std.Async.Async Unit} →
{writeAll' : α → Array β → Std.Async.Async Unit} →
{flush' : α →... | null | false |
_private.Mathlib.Data.Part.0.Part.mem_toOption._simp_1_4 | Mathlib.Data.Part | ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) | null | false |
LinearMap.inverse._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] {σ : R →+* S}
(f : M →ₛₗ[σ] M₂) (g : M₂ → M),
(∀ (x : M), g (f x) = x) → (∀ (x : M₂), f (g x) = x) → ∀ (x y :... | null | false |
CategoryTheory.Pseudofunctor.CoGrothendieck.noConfusionType | Mathlib.CategoryTheory.Bicategory.Grothendieck | Sort u →
{𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} →
F.CoGrothendieck →
{𝒮' : Type u₁} →
[inst' : CategoryTheory.Category.{v₁, u₁} 𝒮'] →
{F' : Categ... | null | false |
CategoryTheory.Sheaf.IsConstant.recOn | Mathlib.CategoryTheory.Sites.ConstantSheaf | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.HasWeakSheafify J D] →
{F : CategoryTheory.Sheaf J D} →
{moti... | null | false |
CategoryTheory.ObjectProperty.isoModSerre_of_mono | Mathlib.CategoryTheory.Abelian.SerreClass.MorphismProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsSerreClass] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f],
P.epiModSerre f → P.isoModSerre f | null | true |
OrderHom.le_def | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {f g : α →o β}, f ≤ g ↔ ∀ (x : α), f x ≤ g x | null | true |
Multiset.lt_cons_self | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (s : Multiset α) (a : α), s < a ::ₘ s | null | true |
Algebra.traceMatrix_of_matrix_vecMul | Mathlib.RingTheory.Trace.Basic | ∀ {κ : Type w} {A : Type u} {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[inst_3 : Fintype κ] (b : κ → B) (P : Matrix κ κ A),
Algebra.traceMatrix A (Matrix.vecMul b (P.map ⇑(algebraMap A B))) = P.transpose * Algebra.traceMatrix A b * P | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.ContinuousLinearMap.IsIdempotentElem.isSelfAdjoint_iff_isStarNormal._simp_1_5 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Lean.ReducibilityAttrs.0.Lean.initFn._@.Lean.ReducibilityAttrs.2994861043._hygCtx._hyg.2 | Lean.ReducibilityAttrs | IO Unit | null | false |
Std.Time.PlainDate.withMonthRollOver | Std.Time.Date.PlainDate | Std.Time.PlainDate → Std.Time.Month.Ordinal → Std.Time.PlainDate | Creates a new `PlainDate` by adjusting the month to the given `month` value.
The day is rolled over to the next valid month if necessary.
| true |
CategoryTheory.Abelian.SpectralObject.IsThirdQuadrant.mk | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{Y : CategoryTheory.Abelian.SpectralObject C EInt},
(∀ (i j : EInt) (hij : i ≤ j),
WithBotTop.coe 0 < i →
∀ (n : ℤ),
CategoryTheory.Limits.IsZero
((Y.H n).obj (CategoryTheory.Compos... | null | true |
AlgebraicGeometry.isIntegral_of_isOpenImmersion | Mathlib.AlgebraicGeometry.Properties | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] [AlgebraicGeometry.IsIntegral Y]
[Nonempty ↥X], AlgebraicGeometry.IsIntegral X | null | true |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_30 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 : Turing.ToPartrec.Code), ¬a.comp a_1 = Turing.ToPartrec.Code.succ | null | false |
Order.IsPredLimit.le_iff_forall_le | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a b : α} [inst : LinearOrder α], Order.IsPredLimit a → (b ≤ a ↔ ∀ (c : α), a < c → b ≤ c) | null | true |
Std.DTreeMap.Raw.Const.get?_insertManyIfNewUnit_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α (fun x => Unit) cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp],
t.WF →
∀ {l : List α} {k : α},
Std.DTreeMap.Raw.Const.get? (Std.DTreeMap.Raw.Const.insertManyIfNewUnit t l) k =
if k ∈ t ∨ l.contains k = true then some ()... | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.addPolynomial_slope._proof_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} {x₁ x₂ y₁ y₂ : F},
y₁ ^ 2 + W.a₁ * x₁ * y₁ + W.a₃ * y₁ = x₁ ^ 3 + W.a₂ * x₁ ^ 2 + W.a₄ * x₁ + W.a₆ →
y₂ ^ 2 + W.a₁ * x₂ * y₂ + W.a₃ * y₂ = x₂ ^ 3 + W.a₂ * x₂ ^ 2 + W.a₄ * x₂ + W.a₆ →
¬x₁ = x₂ →
{ a := 1, b := -((y₁ - y₂) / (x₁ - x₂)) ... | null | false |
instNonUnitalAlgHomClassOfNonUnitalAlgEquivClass | Mathlib.Algebra.Star.StarAlgHom | ∀ {F : Type u_1} {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B]
[inst_5 : EquivLike F A B] [NonUnitalAlgEquivClass F R A B], NonUnitalAlgHomClass F R A B | null | true |
Lean.Elab.Tactic.Conv.evalConvConvSeq | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | null | true |
InfHom.instFunLike.eq_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β],
InfHom.instFunLike = { coe := InfHom.toFun, coe_injective := ⋯ } | null | true |
«term_/_» | Init.Notation | Lean.TrailingParserDescr | `a / b` computes the result of dividing `a` by `b`.
The meaning of this notation is type-dependent.
* For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`.
* For `Nat`, `a / b` rounds downwards.
* For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative.
It is impl... | true |
_private.Mathlib.FieldTheory.PrimitiveElement.0.Field.isAlgebraic_of_finite_intermediateField.match_1_1 | Mathlib.FieldTheory.PrimitiveElement | ∀ (F : Type u_2) (E : Type u_1) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (α : E)
(motive : (∃ x y, x ≠ y ∧ F⟮α ^ x⟯ = F⟮α ^ y⟯) → Prop) (x : ∃ x y, x ≠ y ∧ F⟮α ^ x⟯ = F⟮α ^ y⟯),
(∀ (_m _n : ℕ) (hneq : _m ≠ _n) (heq : F⟮α ^ _m⟯ = F⟮α ^ _n⟯), motive ⋯) → motive x | null | false |
CategoryTheory.ObjectProperty.strictLimitsOfShape.limit | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} {J : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} J] (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasLimit F],
(∀ (j : J), P (F.obj j)) → P.strictLimitsOfShape J (CategoryTheory.Limits.l... | null | true |
CategoryTheory.Functor.Fiber.fiberCategory._proof_3 | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u_2} {𝒳 : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} 𝒮]
[inst_1 : CategoryTheory.Category.{u_3, u_4} 𝒳] {p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {X Y : p.Fiber S}
(f : { φ // p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ }),
⟨CategoryTheory.CategoryStruct.comp ↑⟨CategoryTheory.Ca... | null | false |
Finset.image_subset_infs_right | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeInf α] {s t : Finset α} {a : α},
a ∈ s → Finset.image (fun x => a ⊓ x) t ⊆ s ⊼ t | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.isNonarchimedean_smoothingFun._simp_1_2 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b : α}, (a - b ≤ a) = True | null | false |
Besicovitch.SatelliteConfig.ctorIdx | Mathlib.MeasureTheory.Covering.Besicovitch | {α : Type u_1} → {inst : MetricSpace α} → {N : ℕ} → {τ : ℝ} → Besicovitch.SatelliteConfig α N τ → ℕ | null | false |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.Arg.toImpure.match_1 | Lean.Compiler.LCNF.ToImpure | (motive : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Unit → motive Lean.Compiler.LCNF.Arg.erased) →
((expr : Lean.Expr) →
(h ... | null | false |
Algebra.Generators.Hom.id_val | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Generators R S ι) (n : ι), (Algebra.Generators.Hom.id P).val n = MvPolynomial.X n | null | true |
CategoryTheory.Functor.mapHomologicalComplexUpToQuasiIso._proof_1 | Mathlib.Algebra.Homology.Localization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {ι : Type u_1} (c : ComplexShape ι)
[inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.CategoryWithHomology C]
[inst_3 : (HomologicalComplex.quasiIso C c).HasLocalization],
(HomologicalComplex.quasiIso C c).Q'.IsLocalization (Homological... | null | false |
CommRingCat.prodFan.eq_1 | Mathlib.Algebra.Category.Ring.Constructions | ∀ (A B : CommRingCat),
A.prodFan B =
CategoryTheory.Limits.BinaryFan.mk (CommRingCat.ofHom (RingHom.fst ↑A ↑B)) (CommRingCat.ofHom (RingHom.snd ↑A ↑B)) | null | true |
DirectLimit.map₀ | Mathlib.Order.DirectedInverseSystem | {ι : Type u_1} →
[inst : Preorder ι] →
{F : ι → Type u_4} →
{T : ⦃i j : ι⦄ → i ≤ j → Sort u_8} →
(f : (i j : ι) → (h : i ≤ j) → T h) →
[inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)] →
[inst_2 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] →
[ins... | "Nullary map" to construct an element in the direct limit. | true |
MeasureTheory.Measure.absolutelyContinuous_rfl | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.AbsolutelyContinuous μ | **Alias** of `MeasureTheory.Measure.AbsolutelyContinuous.rfl`. | true |
Algebra.Extension.instAddCommGroupH1Cotangent._aux_8 | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → {P : Algebra.Extension R S} → ℕ → P.H1Cotangent → P.H1Cotangent | null | false |
Filter.exists_forall_mem_of_hasBasis_mem_blimsup' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} {l : Filter β} {b : ι → Set β},
l.HasBasis (fun x => True) b →
∀ {u : β → Set α} {p : β → Prop} {x : α},
x ∈ Filter.blimsup u l p → ∃ f, ∀ (i : ι), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i | null | true |
FirstOrder.Field.genericMonicPoly | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | (n : ℕ) → FreeCommRing (Fin (n + 1)) | A generic monic polynomial of degree `n` as an element of the
free commutative ring in `n + 1` variables, with a variable for each
of the `n` non-leading coefficients of the polynomial and one variable (`Fin.last n`)
for `X`. | true |
instErgodicSMulMulOppositeOfIsMulRightInvariant | Mathlib.Dynamics.Ergodic.Action.Regular | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [MeasurableMul₂ G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [MeasureTheory.SFinite μ] [μ.IsMulRightInvariant], ErgodicSMul Gᵐᵒᵖ G μ | null | true |
CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : ... | null | true |
Submodule.galgebra._proof_6 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {S : Type u_3} {R : Type u_2} [inst : AddMonoid ι] [inst_1 : CommSemiring S] [inst_2 : Semiring R]
[inst_3 : Algebra S R] (A : ι → Submodule S R) [inst_4 : SetLike.GradedMonoid A] (_r : S)
(x : GradedMonoid fun i => ↥(A i)),
_r • x = GradedMonoid.mk 0 ((LinearMap.codRestrict (A 0) (Algebra.linear... | null | false |
Equiv.Perm.SameCycle.pow_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℕ}, f.SameCycle x y → f.SameCycle x ((f ^ n) y) | **Alias** of the reverse direction of `Equiv.Perm.sameCycle_pow_right`. | true |
Lean.Meta.SynthInstance.State._sizeOf_inst | Lean.Meta.SynthInstance | SizeOf Lean.Meta.SynthInstance.State | null | false |
Mathlib.Tactic.Choose.mkFreshNameFrom | Mathlib.Tactic.Choose | Lean.Name → Lean.Name → Lean.CoreM Lean.Name | `mkFreshNameFrom orig base` returns `mkFreshUserName base` if ``orig = `_``
and `orig` otherwise. | true |
Lean.Meta.SimpAll.Entry.mk.sizeOf_spec | Lean.Meta.Tactic.Simp.SimpAll | ∀ (fvarId : Lean.FVarId) (userName : Lean.Name) (id : Lean.Meta.Origin) (origType type proof : Lean.Expr),
sizeOf { fvarId := fvarId, userName := userName, id := id, origType := origType, type := type, proof := proof } =
1 + sizeOf fvarId + sizeOf userName + sizeOf id + sizeOf origType + sizeOf type + sizeOf proo... | null | true |
CommGrpCat.μ_forget_apply | Mathlib.Algebra.Category.Grp.CartesianMonoidal | ∀ {G H : CommGrpCat} (p : ↑G) (q : ↑H),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.forget CommGrpCat) G H))
(p, q) =
(p, q) | null | true |
ImportGraph.Shake.ComptimeDependency.indirect.injEq | ImportGraph.Shake.DeclNeeds | ∀ (use : Lean.IndirectModUse) (imposingModules : Array Lean.Name) (use_1 : Lean.IndirectModUse)
(imposingModules_1 : Array Lean.Name),
(ImportGraph.Shake.ComptimeDependency.indirect use imposingModules =
ImportGraph.Shake.ComptimeDependency.indirect use_1 imposingModules_1) =
(use = use_1 ∧ imposingModule... | null | true |
CategoryTheory.Limits.isColimitCoconeLeftOpOfCone._proof_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor J Cᵒᵖ) {c : CategoryTheory.Limits.Cone F}
(hc : CategoryTheory.Limits.IsLimit c) (s : CategoryTheory.Limits.Cocone F.leftOp) (j : Jᵒᵖ),
(CategoryTheory.Category... | null | false |
Asymptotics.IsBigO.abs_right | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {E : Type u_2} [inst : Norm E] {f : α → E} {l : Filter α} {u : α → ℝ},
f =O[l] u → f =O[l] fun x => |u x| | **Alias** of the reverse direction of `Asymptotics.isBigO_abs_right`. | true |
PLift.map | Mathlib.Control.ULift | {α : Sort u} → {β : Sort v} → (α → β) → PLift α → PLift β | Functorial action. | true |
Nat.brecOn.go._@.Mathlib.Util.CompileInductive.1571041013._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | {motive : ℕ → Sort u} → (t : ℕ) → ((t : ℕ) → Nat.below t → motive t) → motive t ×' Nat.below t | null | false |
WithZero.instAddCommMonoid._proof_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u_1} [inst : AddCommSemigroup α] (x x_1 : WithZero α), x + x_1 = x_1 + x | null | false |
Int.getElem?_toList_rcc_eq_none_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m...=n).toList[i]? = none) = ((n + 1 - m).toNat ≤ i) | null | false |
Option.le.eq_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (val : β), Option.le r none (some val) = True | null | true |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_5 | Mathlib.Topology.Category.Stonean.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
_private.Batteries.Data.List.Lemmas.0.List.isChain_iff_pairwise._simp_1_8 | Batteries.Data.List.Lemmas | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) | null | false |
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars._proof_3 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {X : ModuleCat R}
{Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y) (r : R) (s : S),
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt f (r • s) g =
(RingHom.id R) r • ModuleCat.ExtendRestrictScalarsAdj.HomEqu... | null | false |
ContinuousLinearMap.isVonNBounded_iff | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_4}
{F : Type u_5} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] {R : Type u_7} [inst_7 : NormedDivisionRing R] [in... | A set `S` of continuous linear maps is von Neumann bounded
iff for any von Neumann bounded set `s`,
the set `{f x | (f ∈ S) (x ∈ s)}` is von Neumann bounded.
For the forward implication with weaker typeclass assumptions, see `isVonNBounded_image2_apply`. | true |
_private.Batteries.Util.ProofWanted.0.WantedRefKind._sizeOf_1 | Batteries.Util.ProofWanted | WantedRefKind✝ → ℕ | null | false |
Num.castNum_or._simp_1 | Mathlib.Data.Num.Lemmas | ∀ (m n : Num), ↑m ||| ↑n = ↑(m ||| n) | null | false |
Complex.rec | Mathlib.Basic.Complex.Basic | {motive : ℂ → Sort u} → ((re im : ℝ) → motive { re := re, im := im }) → (t : ℂ) → motive t | null | false |
Std.DTreeMap.Raw.minKey?_insertIfNew_of_isEmpty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, t.isEmpty = true → (t.insertIfNew k v).minKey? = some k | null | true |
LinOrd.hasForgetToLat._proof_2 | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
Lat.ofHom (OrderHomClass.toLatticeHom (↑X) (↑Z) (LinOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (Lat.ofHom (OrderHomClass.toLatticeHom (↑X) (↑Y) (LinOrd.Hom.hom f)))
(Lat.ofHom (OrderHomClass.toLatticeHom (↑Y) (↑Z) (... | null | false |
CategoryTheory.EffectiveEpi.mk | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : Y ⟶ X},
Nonempty (CategoryTheory.EffectiveEpiStruct f) → CategoryTheory.EffectiveEpi f | null | true |
Std.DTreeMap.Raw.Const.getThenInsertIfNew?_snd | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (Std.DTreeMap.Raw.Const.getThenInsertIfNew? t k v).2 = t.insertIfNew k v | null | true |
Lean.Elab.Command.InductiveElabStep2.recOn | Lean.Elab.MutualInductive | {motive : Lean.Elab.Command.InductiveElabStep2 → Sort u} →
(t : Lean.Elab.Command.InductiveElabStep2) →
((ctors : List Lean.Constructor) →
(collectUsedFVars : StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit) →
(collectExtraHeaderLMVars : StateRefT' IO.RealWorld Lean.CollectLevelM... | null | false |
OrderHom.piIso._proof_2 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} [inst : Preorder α] {ι : Type u_2} {π : ι → Type u_3} [inst_1 : (i : ι) → Preorder (π i)],
Function.RightInverse OrderHom.pi fun f i => (Pi.evalOrderHom i).comp f | null | false |
_private.Mathlib.Order.LiminfLimsup.0.Filter.limsSup_principal_eq_sSup._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u} {a : Set α} {p : α → Prop}, (∀ᶠ (x : α) in Filter.principal a, p x) = ∀ x ∈ a, p x | null | false |
Directed.ciInf_le | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | ∀ {ι : Sort u_1} {α : Type u_2} [inst : ConditionallyCompletePartialOrderInf α] {f : ι → α},
Directed (fun x1 x2 => x2 ≤ x1) f → BddBelow (Set.range f) → ∀ (i : ι), ⨅ j, f j ≤ f i | null | true |
_private.Mathlib.RingTheory.Polynomial.Chebyshev.0.Polynomial.Chebyshev.T.match_1.eq_3 | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (motive : ℤ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1)
(h_3 : (n : ℕ) → motive (Int.ofNat n.succ.succ)) (h_4 : (n : ℕ) → motive (Int.negSucc n)),
(match Int.ofNat n.succ.succ with
| 0 => h_1 ()
| 1 => h_2 ()
| Int.ofNat n.succ.succ => h_3 n
| Int.negSucc n => h_4 n) =
... | null | true |
_private.Mathlib.Tactic.ToExpr.0.Mathlib.toExprMData | Mathlib.Tactic.ToExpr | Lean.MData → Lean.Expr | Core of a hand-written `ToExpr` handler for `MData`.
Uses the `KVMap.set*` functions rather than going into the internals
of the `KVMap` data structure. | true |
_private.Lean.Meta.Sym.Eta.0.Lean.Meta.Sym.hasLooseBVarsInRange | Lean.Meta.Sym.Eta | Lean.Expr → ℕ → Bool | Returns `true` if `e` contains a loose bound variable with index in `[0, n)`
This function assumes `n` is small. If this becomes a bottleneck, we should
implement a version of `lean_expr_has_loose_bvar` that checks the range in one traversal.
| true |
instLawfulBEqLex | Mathlib.Order.Lex | ∀ (α : Type u_2) [inst : BEq α] [LawfulBEq α], LawfulBEq (Lex α) | null | true |
AffineBasis.basisOf_reindex | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {ι' : Type u_2} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V]
[inst_1 : AddTorsor V P] [inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P) (e : ι ≃ ι') (i : ι'),
(b.reindex e).basisOf i = (b.basisOf (e.symm i)).reindex (e.subtypeEquiv ⋯) | null | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_38 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam (∀ (a b : Polynomial.UniversalFactorizationRing m k hn p), a - b = a + -b)
SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Interval.pure_one | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : One α], Interval.pure 1 = 1 | null | true |
CategoryTheory.Localization.Construction.ψ₂.eq_1 | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(w : X ⟶ Y) (hw : W w),
CategoryTheory.Localization.Construction.ψ₂ W w hw =
(CategoryTheory.Paths.of (CategoryTheory.Localization.Construction.LocQuiver W)).map (Sum.inr ⟨w, hw⟩) | null | true |
Qq.Impl.PatVarDecl.noConfusion | Qq.MatchImpl | {P : Sort u} → {t t' : Qq.Impl.PatVarDecl} → t = t' → Qq.Impl.PatVarDecl.noConfusionType P t t' | null | false |
Set.powersetCard.mulActionHom_compl_bijective | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] {n : ℕ} [inst_2 : DecidableEq α]
[inst_3 : Fintype α] {m : ℕ} (hm : m + n = Fintype.card α),
Function.Bijective ⇑(Set.powersetCard.mulActionHom_compl G α hm) | null | true |
Lean.Widget.WidgetSource.mk.sizeOf_spec | Lean.Widget.UserWidget | ∀ (sourcetext : String), sizeOf { sourcetext := sourcetext } = 1 + sizeOf sourcetext | null | true |
CategoryTheory.PreGaloisCategory.hasQuotientsByFiniteGroups._autoParam | Mathlib.CategoryTheory.Galois.Basic | Lean.Syntax | null | false |
LinearMap.BilinForm.IsSymm.recOn | Mathlib.LinearAlgebra.BilinearForm.Properties | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{B : LinearMap.BilinForm R M} →
{motive : B.IsSymm → Sort u} →
(t : B.IsSymm) → ((eq : ∀ (x y : M), (B x) y = (B y) x) → motive ⋯) → motive t | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_iff._simp_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
Std.Sat.AIG.ExtendingEntrypoint | Std.Sat.AIG.LawfulOperator | {α : Type} → [inst : Hashable α] → [inst_1 : DecidableEq α] → Std.Sat.AIG α → Type | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toInt64_ne_minValue._proof_1_2 | Init.Data.SInt.Lemmas | ∀ (a : Int32), -2 ^ 31 ≤ a.toInt → a.toInt = -9223372036854775808 → False | null | false |
ContMDiffMul.mk | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G]
[to... | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.monic_freeMonic._simp_1_1 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.leadingCoeff = p.coeff p.natDegree | null | false |
Lean.Meta.Grind.instNonemptyMethodsRef | Lean.Meta.Tactic.Grind.Types | Nonempty Lean.Meta.Grind.MethodsRef | null | true |
SkewPolynomial.monomial_add | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} (n : ℕ) [inst : Semiring R] (r s : R),
(SkewPolynomial.monomial n) (r + s) = (SkewPolynomial.monomial n) r + (SkewPolynomial.monomial n) s | null | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.takeWhile.match_1.splitter | Batteries.Data.String.Lemmas | (motive : Substring.Raw → (Char → Bool) → Sort u_1) →
(x : Substring.Raw) →
(x_1 : Char → Bool) →
((s : String) → (b e : String.Pos.Raw) → (p : Char → Bool) → motive { str := s, startPos := b, stopPos := e } p) →
motive x x_1 | null | true |
Set.update_preimage_pi | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} [inst : DecidableEq ι]
{f : (i : ι) → α i}, i ∈ s → (∀ j ∈ s, j ≠ i → f j ∈ t j) → Function.update f i ⁻¹' s.pi t = t i | null | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.induct_rcc_right._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ (a b : ℤ), (b - a).toNat = 0 → ¬b ≤ a → False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.