name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.OrientedCmp.of_gt_iff_lt | Init.Data.Order.PackageFactories | ∀ {α : Type u} {cmp : α → α → Ordering},
(∀ (a b : α), cmp a b = Ordering.gt ↔ cmp b a = Ordering.lt) → Std.OrientedCmp cmp | null | true |
convex_halfSpace_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedAddMonoid β]
[inst_7 : Module 𝕜 β] [PosSMulMono 𝕜 β] {f : E → β}, IsLinearMap 𝕜 f → ∀ (r : β), Convex 𝕜... | null | true |
Sym2.sortEquiv_apply_coe | Mathlib.Data.Sym.Sym2.Order | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Sym2 α), ↑(Sym2.sortEquiv s) = (s.inf, s.sup) | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasFiniteProducts C] (f : α → C) (S : (Finset (CategoryTheory.Discrete α))ᵒᵖ),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => (CategoryTheory.Discrete.functor f).obj ↑x) | null | false |
Subsemiring._sizeOf_inst | Mathlib.Algebra.Ring.Subsemiring.Defs | (R : Type u) → {inst : NonAssocSemiring R} → [SizeOf R] → SizeOf (Subsemiring R) | null | false |
Lean.Meta.Grind.CheckResult.none | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult | No progress | true |
MeasureTheory.«_aux_Mathlib_MeasureTheory_OuterMeasure_AE___delab_app_MeasureTheory_term_=ᵐ[_]__1» | Mathlib.MeasureTheory.OuterMeasure.AE | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
ContDiffMapSupportedInClass.map_zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} [self : ContDiffMapSupportedInClass B E F n K] (f : B),
Set.EqOn (... | null | true |
Antisymmetrization.induction_on | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsPreorder α r] {p : Antisymmetrization α r → Prop}
(a : Antisymmetrization α r), (∀ (a : α), p (toAntisymmetrization r a)) → p a | null | true |
Std.Tactic.BVDecide.BVUnOp.ctorElimType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} → ℕ → Sort (max 1 u) | null | false |
Unitization.instModule._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {S : Type u_3} {R : Type u_1} {A : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid R] [inst_2 : AddCommMonoid A]
[inst_3 : Module S R] [inst_4 : Module S A] (r s : S) (x : Unitization R A), (r + s) • x = r • x + s • x | null | false |
HomologicalComplex.truncLE'XIso | Mathlib.Algebra.Homology.Embedding.TruncLE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embeddi... | The isomorphism `(K.truncLE' e).X i ≅ K.X i'` when `e.f i = i'`
and `e.BoundaryLE i` does not hold. | true |
AffineSubspace.SSameSide.trans | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder 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 z : P}, s.SSameSide x y → s.SSameSide y z → s.SSameSide x z | null | true |
CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.rec | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.ReflectsEffectiveEpiFamilies → Sort u_3} →
((reflects :
∀ {α : Type u} {B : C} (X... | null | false |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm.match_4 | Lean.Meta.Sym.Simp.App | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(kind : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → motive Lean.Meta.CongrArgKind.subsingletonInst) →
(Unit → motive Lean.Meta.CongrArgKind.eq) → ((x : Lean.Met... | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.Comparison.0.CategoryTheory.extensive_regular_generate_coherent.match_1_4 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C] (Y : C)
(T : CategoryTheory.Presieve Y) (motive : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y → Prop)
(x : T ∈ (CategoryTheory.extensiveCoverage C).coverings Y),
(∀ (α : Type) (x : Finite α) (X... | null | false |
Set.image_inv_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iio a = Set.Ioi a⁻¹ | null | true |
sin_pi_mul_ne_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {x : ℂ}, x ∈ Complex.integerComplement → Complex.sin (↑Real.pi * x) ≠ 0 | `sin π z` is non vanishing on the complement of the integers in `ℂ`. | true |
_private.Mathlib.Testing.Plausible.Functions.0.Plausible.TotalFunction.zeroDefault.match_1.splitter | Mathlib.Testing.Plausible.Functions | {α : Type u_1} →
{β : Type u_2} →
(motive : Plausible.TotalFunction α β → Sort u_3) →
(x : Plausible.TotalFunction α β) →
((A : List ((_ : α) × β)) → (a : β) → motive (Plausible.TotalFunction.withDefault A a)) → motive x | null | true |
Std.DTreeMap.Const.mergeWith._proof_1 | Std.Data.DTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} (mergeFn : α → β → β → β)
(t₁ t₂ : Std.DTreeMap α (fun x => β) cmp),
(Std.DTreeMap.Internal.Impl.Const.mergeWith mergeFn t₁.inner t₂.inner ⋯).impl.WF | null | false |
NormedSpace.exp_op | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝔸 : Type u_2} [inst : Ring 𝔸] [inst_1 : TopologicalSpace 𝔸] [inst_2 : IsTopologicalRing 𝔸] [T2Space 𝔸] (x : 𝔸),
NormedSpace.exp (MulOpposite.op x) = MulOpposite.op (NormedSpace.exp x) | null | true |
Module.Basis.linearMap | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
{ι₁ : Type u_6} →
{ι₂ : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
... | The standard basis of the space linear maps between two modules
induced by a basis of the domain and codomain.
If `M₁` and `M₂` are modules with basis `b₁` and `b₂` respectively indexed
by finite types `ι₁` and `ι₂`,
then `Basis.linearMap b₁ b₂` is the basis of `M₁ →ₗ[R] M₂` indexed by `ι₂ × ι₁`
where `(i, j)` indexes... | true |
CommMonCat.forget₂_full | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget₂ CommMonCat MonCat).Full | Ensure that `forget₂ CommMonCat MonCat` automatically reflects isomorphisms. | true |
Preord.ofHom_hom | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (f : X ⟶ Y), Preord.ofHom (Preord.Hom.hom f) = f | null | true |
Topology.IsLower.tendsto_nhds_iff_not_le | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLower α] {β : Type u_3} {f : β → α}
{l : Filter β} {x : α}, Filter.Tendsto f l (nhds x) ↔ ∀ (y : α), ¬y ≤ x → ∀ᶠ (z : β) in l, ¬y ≤ f z | null | true |
FinBoolAlg.Iso.mk._proof_4 | Mathlib.Order.Category.FinBoolAlg | ∀ {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a b : ↑α.1), e (a ⊓ b) = e a ⊓ e b | null | false |
_private.Batteries.Data.Array.Pairwise.0.Array.pairwise_push._simp_1_2 | Batteries.Data.Array.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | null | false |
MeasureTheory.VectorMeasure.restrict_add | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
[inst_2 : ContinuousAdd M] (v w : MeasureTheory.VectorMeasure α M) (i : Set α),
(v + w).restrict i = v.restrict i + w.restrict i | null | true |
_private.Mathlib.Algebra.Order.Round.0.round_eq_div._simp_1_3 | Mathlib.Algebra.Order.Round | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | null | false |
ContinuousAlternatingMap.instContinuousEval | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NormedField 𝕜] [Finite ι]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : TopologicalSpace F] [inst_5 : AddCommGroup F]
[inst_6 : IsTopologicalAddGroup F] [inst_7 : Module 𝕜 F], ContinuousEval (E [⋀^ι]→L[𝕜] F) (ι → E... | Applying a continuous alternating map to a vector is continuous
in the pair (map, vector).
Continuity in the vector holds by definition
and continuity in the map holds if both the domain and the codomain are topological vector spaces.
However, continuity in the pair (map, vector) needs the domain to be a locally bound... | true |
_private.Mathlib.GroupTheory.Nilpotent.0.Group.nilpotencyClass_pi._simp_1_2 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G] {n : ℕ},
(Group.nilpotencyClass G ≤ n) = (⊤.lowerCentralSeries n = ⊥) | null | false |
Equiv.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} (f : α ≃ β), Finite α ↔ Finite β | null | true |
MeasureTheory.setIntegral_abs_condExp_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → ∀ (f : α → ℝ), ∫ (x : α) in s, |μ[f | m] x| ∂μ ≤ ∫ (x : α) in s, |f x| ∂μ | null | true |
Lean.Elab.Do.map1TermElabM | Lean.Elab.Do.Basic | {β : Sort u_1} →
({α : Type} → (β → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α) →
{α : Type} → (β → Lean.Elab.Do.DoElabM α) → Lean.Elab.Do.DoElabM α | null | true |
ConditionallyCompleteLinearOrderBot.toDecidableEq._inherited_default | Mathlib.Order.ConditionallyCompleteLattice.Defs | {α : Type u_5} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) → DecidableLE α → DecidableEq α | null | false |
CompactT2.Projective | Mathlib.Topology.ExtremallyDisconnected | (X : Type u) → [TopologicalSpace X] → Prop | The assertion `CompactT2.Projective` states that given continuous maps
`f : X → Z` and `g : Y → Z` with `g` surjective between `t_2`, compact topological spaces,
there exists a continuous lift `h : X → Y`, such that `f = g ∘ h`. | true |
ModularForm.qExpansion_smul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ},
0 < h →
h ∈ Γ.strictPeriods →
∀ (a : ℂ) (f : F) [ModularFormClass F Γ k],
UpperHalfPlane.qExpansion h (a • ⇑f) = a • UpperHalfPlane.qExpansion h ⇑f | null | true |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.morphismRestrict_app._simp_1_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
Pi.zero_mono | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_5} {β : Type u_6} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Zero β], Monotone 0 | null | true |
TopCat.PrelocalPredicate.sheafify_inductionOn | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} {T : ↑X → Type u_2} (P : TopCat.PrelocalPredicate T) (op : {x : ↑X} → T x → T x),
(∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x},
P.pred a → ∀ (p : ↥U), ∃ W i, ↑p ∈ W ∧ P.pred fun x => op (a (i x))) →
∀ {U : TopologicalSpace.Opens ↑X} {a : (x : ↥U) → T ↑x}, P.sheafify.pred a → P.she... | For a unary operation (e.g. `x ↦ -x`) defined at each stalk, if a prelocal predicate is closed
under the operation on each open set (possibly by refinement), then the sheafified predicate is
also closed under the operation. See `sheafify_inductionOn'` for the version without refinement. | true |
Lean.IR.LitVal.str.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.LitVal → Sort u} →
(t : Lean.IR.LitVal) → t.ctorIdx = 1 → ((v : String) → motive (Lean.IR.LitVal.str v)) → motive t | null | false |
Submonoid.instInfSet._proof_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set (Submonoid M)) {a : M}, a ∈ ⋂ t ∈ s, ↑t → ∀ i ∈ s, a ∈ i | null | false |
instLawfulIdentityInt32HAddOfNat | Init.Data.SInt.Lemmas | Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0 | null | true |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_4 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (n : ℕ) (x : ArchimedeanClass R),
Int.negSucc n • x = -(↑n.succ • x) | null | false |
LinearMap.tensorEqLocus_coe | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | true |
CategoryTheory.Factorisation.casesOn | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Factorisation f → Sort u_1} →
(t : CategoryTheory.Factorisation f) →
((mid : C) →
(ι : X ⟶ mid) →
(π : mid ⟶ Y) →
... | null | false |
Subgroup.inv_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G}, x ∈ H → x⁻¹ ∈ H | A subgroup is closed under inverse. | true |
RingQuot.mkRingHom_def | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop),
RingQuot.mkRingHom r =
{ toFun := fun x => { toQuot := Quot.mk (RingQuot.Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ } | null | true |
Polynomial.Chebyshev.S | Mathlib.RingTheory.Polynomial.Chebyshev | (R : Type u_1) → [inst : CommRing R] → ℤ → Polynomial R | `S n` is the `n`th rescaled Chebyshev polynomial of the second kind (also known as a
Vieta–Fibonacci polynomial), given by $S_n(2x) = U_n(x)$. See
`Polynomial.Chebyshev.S_comp_two_mul_X`. | true |
Std.Do.Spec.forIn'_roo | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps]
[inst_2 : LT α] [inst_3 : DecidableLT α] [inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.PRange.LawfulUpwardEnumera... | null | true |
Std.IterM.step_intermediateDropWhile._proof_4 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] {P : β → Bool} (out : β),
P out = false → ((pure ∘ ULift.up ∘ P) out).Property { down := false } | null | false |
Multiplicative.ofAdd.eq_1 | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {α : Type u}, Multiplicative.ofAdd = { toFun := fun x => x, invFun := fun x => x, left_inv := ⋯, right_inv := ⋯ } | null | true |
Subsemigroup.mem_closure | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] {s : Set M} {x : M}, x ∈ Subsemigroup.closure s ↔ ∀ (S : Subsemigroup M), s ⊆ ↑S → x ∈ S | null | true |
Lean.Grind.Nat.lo_lo | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w + k₂ ≤ v → u + (k₁ + k₂) ≤ v | null | true |
Int.instLocallyFiniteOrder._proof_6 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ),
x ∈ Finset.map (Nat.castEmbedding.trans (addLeftEmbedding a)) (Finset.range (b + 1 - a).toNat) ↔ a ≤ x ∧ x ≤ b | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_eq_getD_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.Limits.PreservesPullback.iso_hom | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | null | true |
_private.Std.Http.Protocol.H1.Reader.0.Std.Http.Protocol.H1.Reader.instReprState.repr.match_1 | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} →
(motive : Std.Http.Protocol.H1.Reader.State dir → Sort u_1) →
(x : Std.Http.Protocol.H1.Reader.State dir) →
(Unit → motive Std.Http.Protocol.H1.Reader.State.needStartLine) →
((a : ℕ) → motive (Std.Http.Protocol.H1.Reader.State.needHeader a)) →
((a :... | null | false |
_private.Init.Data.String.Decode.0.String.toBitVec_getElem_utf8EncodeChar_zero_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (h : c.utf8Size = 2), (String.utf8EncodeChar c)[0].toBitVec = 6#3 ++ BitVec.extractLsb' 6 5 c.val.toBitVec | null | true |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_3 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬(a :: l).length - 1 = 0 → (a :: l).length - 2 < l.length | null | false |
CategoryTheory.Equivalence.cancel_unit_left._simp_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {X Y : C} (f f' : e.inverse.obj (e.functor.obj Y) ⟶ X),
(CategoryTheory.CategoryStruct.comp (e.unit.app Y) f = CategoryTheory.CategoryStruct.comp (e.unit.app Y) f') =
(f = f') | null | false |
cauchySeq_range_of_norm_bounded | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_3} [inst : SeminormedAddCommGroup E] {f : ℕ → E} {g : ℕ → ℝ},
(CauchySeq fun n => ∑ i ∈ Finset.range n, g i) →
(∀ (i : ℕ), ‖f i‖ ≤ g i) → CauchySeq fun n => ∑ i ∈ Finset.range n, f i | A version of the **direct comparison test** for conditionally convergent series.
See `cauchySeq_finset_of_norm_bounded` for the same statement about absolutely convergent ones. | true |
lp.norm_eq_card_dsupport | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} [inst : (i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E 0)), ‖f‖ = ↑⋯.toFinset.card | null | true |
CategoryTheory.Functor.Elements.isColimitCoconeπOpCompShrinkYonedaObj._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(F : CategoryTheory.Functor C (Type u_1)) (X : C)
(x :
(((CategoryTheory.CategoryOfElements.π F).op.comp
(CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.obj X)).coconeTypesEquiv.sym... | null | false |
ContinuousAlgEquiv.trans._proof_1 | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_3} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Semiring C]
[inst_6 : TopologicalSpace C] [inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : Algebra R C] (e₁ :... | null | false |
Lean.Elab.Tactic.Try.TrySuggestionEntry._sizeOf_1 | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.TrySuggestionEntry → ℕ | null | false |
List.Shortlex.of_length_lt | Mathlib.Data.List.Shortlex | ∀ {α : Type u_1} {r : α → α → Prop} {s t : List α}, s.length < t.length → List.Shortlex r s t | If a list `s` is shorter than a list `t`, then `s` is smaller than `t` under any shortlex
order. | true |
LinearEquiv.cast | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
[inst : Semiring R] →
{ι : Type u_14} →
{M : ι → Type u_15} →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → {i j : ι} → i = j → M i ≃ₗ[R] M j | `Equiv.cast (congrArg _ h)` as a linear equiv.
Note that unlike `Equiv.cast`, this takes an equality of indices rather than an equality of types,
to avoid having to deal with an equality of the algebraic structure itself. | true |
Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1.else_eq | Init.Grind.Ordered.Linarith | ∀ {motive : Lean.Grind.Linarith.Poly → Sort u} (t : Lean.Grind.Linarith.Poly)
(nil : motive Lean.Grind.Linarith.Poly.nil) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), Lean.Grind.Linarith.instBEqPoly.beq._sparseCasesOn_1 t nil «else» = «else» h | null | false |
_private.Lean.Structure.0.Lean.findParentProjStruct?.go._unsafe_rec | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → StateM Lean.NameSet (Option Lean.Name) | null | false |
Filter.map_mapsTo_Iic_iff_tendsto | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {F : Filter α} {G : Filter β} {m : α → β},
Set.MapsTo (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ Filter.Tendsto m F G | null | true |
Lean.Lsp.ResolvableCompletionItemData.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DocumentUri →
Lean.Lsp.Position → Option ℕ → Option Lean.Lsp.CompletionIdentifier → Lean.Lsp.ResolvableCompletionItemData | null | false |
nilpotencyClass_eq_quotient_center_plus_one | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hH : Group.IsNilpotent G] [Nontrivial G],
Group.nilpotencyClass G = Group.nilpotencyClass (G ⧸ Subgroup.center G) + 1 | **Alias** of `Group.nilpotencyClass_eq_quotient_center_plus_one`.
---
The nilpotency class of a non-trivial group is one more than its quotient by the center | true |
CategoryTheory.Lax.LaxTrans.Hom.noConfusionType | Mathlib.CategoryTheory.Bicategory.Modification.Lax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.Hom η θ →
{B' : Type u₁} →
... | null | false |
StarRingEquiv.noConfusion | Mathlib.Algebra.Star.StarRingHom | {P : Sort u} →
{A : Type u_1} →
{B : Type u_2} →
{inst : Add A} →
{inst_1 : Add B} →
{inst_2 : Mul A} →
{inst_3 : Mul B} →
{inst_4 : Star A} →
{inst_5 : Star B} →
{t : A ≃⋆+* B} →
{A' : Type u_1} →
... | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion.0.AlgebraicGeometry.isDominant_of_of_appTop_injective._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Ring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] (f : F), (RingHom.ker f = ⊥) = Function.Injective ⇑f | null | false |
smoothSheafCommGroup.eq_1 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | null | true |
_private.Mathlib.RingTheory.Radical.NatInt.0.Nat.one_lt_radical_iff.match_1_1 | Mathlib.RingTheory.Radical.NatInt | ∀ {n : ℕ} (motive : (∃ x ∈ n.primeFactors, 1 < x) → Prop) (x : ∃ x ∈ n.primeFactors, 1 < x),
(∀ (p : ℕ) (h : p ∈ n.primeFactors ∧ 1 < p), motive ⋯) → motive x | null | false |
SmoothBumpCovering.IsSubordinate.toSmoothPartitionOfUnity | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] [inst_5 : FiniteDimensional ℝ E] {s : Set M} [inst_6 : T2Space M]
[inst_7 : IsMani... | null | true |
AddMonoidHom.ofLeftInverse_symm_apply | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G →+ N} {g : N →+ G}
(h : Function.LeftInverse ⇑g ⇑f) (x : ↥f.range), (AddMonoidHom.ofLeftInverse h).symm x = g ↑x | null | true |
Lean.Grind.ToInt.Zero.rec | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
((toInt_zero : ↑0 = 0) → motive ⋯) → (t : Lean.Grind.ToInt.Zero α I) → motive t | null | false |
Positive.addSemigroup | Mathlib.Algebra.Order.Positive.Ring | {M : Type u_1} → [inst : AddMonoid M] → [inst_1 : Preorder M] → [AddLeftStrictMono M] → AddSemigroup { x // 0 < x } | null | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.instRankFiniteMapEmbedding._proof_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_2} {β : Type u_1} {M : Matroid α} [M.RankFinite] {f : α ↪ β}, (M.mapEmbedding f).RankFinite | null | false |
EReal.bot_lt_zero | Mathlib.Data.EReal.Basic | ⊥ < 0 | null | true |
ContinuousLineDeriv.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace F] →
[inst_2 : LineDeriv V E F] →
{motive : ContinuousLineDeriv V E F → Sort u_1} →
((continuous_lineDerivOp : ∀ (v : V), Continuous (LineDeriv.lineDerivOp v)) → ... | null | false |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.casesOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpiFamilies → Sort u_3} →
(t : F.PreservesEffectiveEpiFamilies) →
(... | null | false |
UniqueDiffWithinAt.mono_nhds | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → nhdsWithin x s ≤ nhdsWithin x t → UniqueDiffWithinAt 𝕜 t x | null | true |
eq_of_mabs_div_le_one | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a / b|ₘ ≤ 1 → a = b | null | true |
Ordnode.dual._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → (x : Ordnode α) → Ordnode.below x → Ordnode α | null | false |
Fin.insertNthEquiv_symm_apply | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)) (f : (i : Fin (n + 1)) → α i),
(Fin.insertNthEquiv α p).symm f = (f p, p.removeNth f) | null | true |
CategoryTheory.ihom.ev_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A : C)
[inst_2 : CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((CategoryTheory.ihom A).map f))
... | null | true |
EuclideanGeometry.oangle_eq_zero_iff_oangle_rev_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ = 0 ↔ EuclideanGeometry.oangle p₃ p₂ p... | An oriented angle is zero if and only if the angle with the order of the points reversed is
zero. | true |
meromorphicTrailingCoeffAt.eq_1 | Mathlib.Analysis.Meromorphic.TrailingCoefficient | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜),
meromorphicTrailingCoeffAt f x =
if h₁ : MeromorphicAt f x then if h₂ : meromorphicOrderAt f x = ⊤ then 0 else ⋯.choose x else 0 | null | true |
CategoryTheory.Sieve.overEquiv_functorPullback_map | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (U : CategoryTheory.Over X)
(S : CategoryTheory.Sieve ((CategoryTheory.Over.map f).obj U)),
(CategoryTheory.Sieve.overEquiv U) (CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.map f) S) =
(CategoryTheory.Sieve.overEquiv ((C... | null | true |
CommRingCat.instCategory | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.Category.{u_1, u_1 + 1} CommRingCat | null | true |
CategoryTheory.Pi.instLaxBraidedForallPi | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] →
[inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)] →
{D : I → Type u₂} →
[inst_3 : (i : I) → CategoryTheory.Catego... | null | true |
Cardinal.powerlt_le | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b c : Cardinal.{u}}, a ^< b ≤ c ↔ ∀ x < b, a ^ x ≤ c | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.exp_two_pi_mul_I_mul_div_eq_one_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Fin.encodeFun.eq_1 | Batteries.Data.Fin.Coding | ∀ {n : ℕ} (x_2 : Fin 0 → Fin n), Fin.encodeFun x_2 = ⟨0, ⋯⟩ | null | true |
MonoidWithZero.toMulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] (b : M₀), 1 • b = b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.