name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Do.PredTrans.instLE | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → LE (Std.Do.PredTrans ps α) | null | true |
_private.Std.Async.Basic.0.Std.Async.MaybeTask.toTask.match_1 | Std.Async.Basic | {α : Type} →
(motive : Std.Async.MaybeTask α → Sort u_1) →
(x : Std.Async.MaybeTask α) →
((a : α) → motive (Std.Async.MaybeTask.pure a)) →
((t : Task α) → motive (Std.Async.MaybeTask.ofTask t)) → motive x | null | false |
MeasureTheory.SimpleFunc.ctorIdx | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u} → {inst : MeasurableSpace α} → {β : Type v} → MeasureTheory.SimpleFunc α β → ℕ | null | false |
LinearMap.mk₂' | Mathlib.LinearAlgebra.BilinearMap | (R : Type u_1) →
(S : Type u_3) →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{M : Type u_5} →
{N : Type u_7} →
{Pₗ : Type u_11} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : AddCommMonoid Pₗ] →
... | Create a bilinear map from a function that is linear in each component.
See `mk₂` for the special case where both arguments come from modules over the same ring. | true |
WeierstrassCurve.Jacobian.Y_eq_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 → P 1 * Q 2 ^ 3 ≠ Q 1 * P 2 ^ 3 → P 1 * Q 2 ^ 3 = W'.negY Q * P 2 ^ 3 | null | true |
Bundle.Pretrivialization.domExtend._proof_5 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
{s : Set B} (e : Bundle.Pretrivialization F fun z => proj ↑z), e.target = e.baseSet ×ˢ Set.univ | null | false |
CategoryTheory.ObjectProperty.instIsClosedUnderSubobjectsInverseImageOfPreservesMonomorphisms | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderSubobjects] (F : CategoryTheory.Functor D C)
[F.PreservesMonomorphisms], (P.inverseImage F).IsClosedUnderSubobjects | null | true |
Mathlib.Tactic.Ring.Common.ExProdNat.mul.inj | Mathlib.Tactic.Ring.Common | ∀ {x e b : Q(ℕ)} {a : Mathlib.Tactic.Ring.Common.ExBaseNat x} {a_1 : Mathlib.Tactic.Ring.Common.ExProdNat e}
{a_2 : Mathlib.Tactic.Ring.Common.ExProdNat b} {a_3 : Mathlib.Tactic.Ring.Common.ExBaseNat x}
{a_4 : Mathlib.Tactic.Ring.Common.ExProdNat e} {a_5 : Mathlib.Tactic.Ring.Common.ExProdNat b},
Mathlib.Tactic.R... | null | true |
CategoryTheory.MorphismProperty.Q' | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(W : CategoryTheory.MorphismProperty C) → [inst_1 : W.HasLocalization] → CategoryTheory.Functor C W.Localization' | The localization functor `C ⥤ W.Localization'`
that is fixed by the `[HasLocalization W]` instance. | true |
CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) [inst_2 : S.HasLeftHomology],
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv S.iCycles = h.i | null | true |
Computation.get.congr_simp | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s s_1 : Computation α) (e_s : s = s_1) [h : s.Terminates], s.get = s_1.get | null | true |
Real.tsum_eq_tsum_fourier_of_rpow_decay_of_summable | Mathlib.Analysis.Fourier.PoissonSummation | ∀ {f : ℝ → ℂ},
Continuous f →
∀ {b : ℝ},
1 < b →
(f =O[Filter.cocompact ℝ] fun x => |x| ^ (-b)) →
(Summable fun n => FourierTransform.fourier f ↑n) →
∀ (x : ℝ), ∑' (n : ℤ), f (x + ↑n) = ∑' (n : ℤ), FourierTransform.fourier f ↑n * (fourier n) ↑x | **Poisson's summation formula**, assuming that `f` decays as
`|x| ^ (-b)` for some `1 < b` and its Fourier transform is summable. | true |
Int8.toUInt8_neg | Init.Data.SInt.Lemmas | ∀ (a : Int8), (-a).toUInt8 = -a.toUInt8 | null | true |
MaxTropical.instSemilatticeSup._proof_1 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : SemilatticeSup R] (x x_1 : MaxTropical R),
MaxTropical.untrop x ≤ MaxTropical.untrop x ⊔ MaxTropical.untrop x_1 | null | false |
CategoryTheory.Functor.initial_iff_comp_initial_full_faithful | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) [G.Initial] [G.Full] [G.Faithful], F.Initial ↔ (F.comp G).Initial | null | true |
Asymptotics.IsLittleO.eventually_mul_div_cancel | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} {𝕜 : Type u_5} [inst : NormedDivisionRing 𝕜] {l : Filter α} {u v : α → 𝕜},
u =o[l] v → u / v * v =ᶠ[l] u | If `u = o(v)` along `l`, then `(u / v) * v = u` eventually at `l`. | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Basic.0.gosperCatalan.eq_1 | Mathlib.Combinatorics.Enumerative.Catalan.Basic | ∀ (n j : ℕ), gosperCatalan✝ n j = ↑j.centralBinom * ↑(n - j).centralBinom * (2 * ↑j - ↑n) / (2 * ↑n * (↑n + 1)) | null | true |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x : Z ⟶ t.pt), ↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x... | null | false |
Nat.pow_lt_ascFactorial | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ) {k : ℕ}, 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k | null | true |
WeierstrassCurve.Jacobian.isUnit_Y_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
W.Nonsingular P → P 2 = 0 → IsUnit (P 1) | null | true |
Mathlib.Tactic.Order.Graph.findSCCsImp | Mathlib.Tactic.Order.Graph.Tarjan | Mathlib.Tactic.Order.Graph → StateM Mathlib.Tactic.Order.Graph.TarjanState Unit | Implementation of `findSCCs` in the `StateM TarjanState` monad. | true |
Std.DHashMap.Raw.Const.get?_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a b : α}, (a == b) = true → Std.DHashMap.Raw.Const.get? m a = Std.DHashMap.Raw.Const.get? m b | null | true |
CategoryTheory.Limits.Sigma.map_comp_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g]
[inst_3 : CategoryTheory.Limits.HasCoproduct h] (q : (a : α) → g a ⟶ f a) (q' : (a : α) → h a ⟶ g a),
CategoryTheory.CategoryStruct... | null | true |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.SpecialLinearGroup.diag_decompose._proof_1_4 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {F : Type u_2} [inst : Field F] {ι : Type u_1} [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (i₀ : ι) (D : ι → F),
∀ x_1 ∈ {x | ¬x = i₀}, (if i₀ = x_1 then D x_1 else (D x_1)⁻¹) = (D x_1)⁻¹ | null | false |
Set.fintypeLENat._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
TopCat.«term∂𝔻_» | Mathlib.Topology.Category.TopCat.Sphere | Lean.ParserDescr | `∂𝔻 n` denotes the boundary of the `n`-disk. | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_1 | Mathlib.Analysis.MellinInversion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
CategoryTheory.Limits.WidePullbackShape.struct._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1}, none = none | null | false |
BiheytingHomClass.map_sdiff | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : BiheytingAlgebra α} {inst_1 : BiheytingAlgebra β}
{inst_2 : FunLike F α β} [self : BiheytingHomClass F α β] (f : F) (a b : α), f (a \ b) = f a \ f b | The proposition that a bi-Heyting homomorphism preserves the difference operation. | true |
Subtype.map_eq | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} {f g : α → β} (h₁ : ∀ (a : α), p a → q (f a))
(h₂ : ∀ (a : α), p a → q (g a)) {x y : Subtype p}, Subtype.map f h₁ x = Subtype.map g h₂ y ↔ f ↑x = g ↑y | null | true |
measurableSMul₂_of_add | Mathlib.MeasureTheory.Group.Arithmetic | ∀ (M : Type u_2) [inst : Add M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M], MeasurableVAdd₂ M M | null | true |
Vector.forall_getElem | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {p : α → Prop}, (∀ (i : ℕ) (h : i < n), p xs[i]) ↔ ∀ a ∈ xs, p a | null | true |
FractionalIdeal.isPrincipal_of_isPrincipal_num | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] (I : FractionalIdeal (nonZeroDivisors R) (FractionRing R)),
Submodule.IsPrincipal I.num → (↑I).IsPrincipal | If the numerator ideal of a fractional ideal is principal, then so is the fractional ideal. | true |
CategoryTheory.StructuredArrow.commaMapEquivalenceInverse_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor C T}
{R : CategoryTheory.Functor D T} {C' : Type u₄} [inst_3 : CategoryTheory.Category.{v₄, u₄} C'] {D' : Ty... | null | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f), CategoryTheory.CategoryStruct.comp (ht.lift s.flip) t.fst = s.snd | null | false |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.elabDoElemFns.match_1 | Lean.Elab.Do.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive ex | null | false |
ENNReal.instAddCommMonoidWithOne | Mathlib.Basic.ENNReal.Basic | AddCommMonoidWithOne ENNReal | null | true |
CategoryTheory.Bicategory.iterated_mateEquiv_conjugateEquiv_symm | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f₁ : a ⟶ c} {u₁ : c ⟶ a} {f₂ : b ⟶ d} {u₂ : d ⟶ b}
{l₁ : a ⟶ b} {r₁ : b ⟶ a} {l₂ : c ⟶ d} {r₂ : d ⟶ c} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (adj₃ : CategoryTheory.Bicategory.Adjuncti... | null | true |
CategoryTheory.TwistShiftData.z_zero_left | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (b : A), t.z 0 b = 1 | null | true |
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered | Mathlib.GroupTheory.ArchimedeanDensely | ∀ (G : Type u_2) [inst : LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G],
Nonempty (G ≃*o WithZero (Multiplicative ℤ)) ↔ ¬DenselyOrdered G | Any nontrivial (has other than 0 and 1) linearly ordered mul-archimedean group with zero is
either isomorphic (and order-isomorphic) to `ℤᵐ⁰`, or is densely ordered, exclusively | true |
Real.exp_approx_end' | Mathlib.Analysis.Complex.Exponential | ∀ {n : ℕ} {x a b : ℝ} (m : ℕ),
n + 1 = m →
∀ (rm : ℝ),
↑m = rm →
|x| ≤ 1 →
|1 - a| ≤ b - |x| / rm * ((rm + 1) / rm) → |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b | null | true |
ite_nonpos | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LE α],
a ≤ 0 → b ≤ 0 → (if p then a else b) ≤ 0 | null | true |
Part.get_eq_of_mem | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α}, a ∈ o → ∀ (h' : o.Dom), o.get h' = a | null | true |
DirectLimit.lift_injective | 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)] [inst_3 : IsDirectedOrder ι] {C : Sort u_9}
(ih : (i : ι) → F i → ... | null | true |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_96 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} (i j : ℕ),
j < l.length →
i < j →
2 ≤ (List.drop i (List.take (j + 1) l)).length →
0 < (List.drop i (List.take j l) ++ List.take 1 (List.drop j l)).length | null | false |
CategoryTheory.Functor.commShiftMapCochainComplex._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive] (a b : ℤ),
F.mapCochainComplexShiftIso (a + b) =
... | null | false |
Std.Sat.AIG.relabel.eq_1 | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
(r : α → β) (aig : Std.Sat.AIG α),
Std.Sat.AIG.relabel r aig =
{ decls := Array.map (Std.Sat.AIG.Decl.relabel r) aig.decls, cache := Std.Sat.AIG.Cache.empty, hdag := ⋯,
hzero := ⋯, hconst :=... | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.hexDigit_isHexDigit._proof_1_1 | Std.Http.Data.URI.Encoding | ∀ {x : UInt8}, x.toNat < 16 → x.toNat < 10 → ¬48 ≤ x.toNat + 48 → False | null | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.unfold?.unfoldDeclToUnfold?.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((cinfo : Lean.ConstantInfo) → motive (some cinfo)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂),
R₁.Exact →
R₂.Exact →
CategoryTheory.Epi
(CategoryTheory.ComposableArrows.app' φ 0 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._... | null | true |
UInt16.ne_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ≠ ~~~a | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord.0.NumberField.mixedEmbedding.volume_eq_two_pi_pow_mul_integral._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | null | false |
Module.AEval.restrict_equiv_mapSubmodule._proof_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (p : Submodule R M) (hp : p ∈ ((Algebra.lsmul R R M) a).invtSubmodule) (x : ↥p),
(Module... | null | false |
HomotopicalAlgebra.RightHomotopyClass.precomp_bijective_of_weakEquivalence | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C} (Z : C)
[HomotopicalAlgebra.IsFibrant Z] (f : X ⟶ Y) [HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y]
[HomotopicalAlgebra.WeakEquivalence f], Function.Bijective fun g => g.precomp f | null | true |
SetRel.isCover_univ._simp_1 | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.IsCover Set.univ s N = (s.Nonempty → N.Nonempty) | null | false |
UInt64.toFin_not | Init.Data.UInt.Bitwise | ∀ (a : UInt64), (~~~a).toFin = a.toFin.rev | null | true |
LocallyFiniteSupport.locallyFinite_support | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : Zero Y] (f : X → Y),
LocallyFiniteSupport f → LocallyFinite fun s => {↑s} | null | true |
wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Defs.639413672._hygCtx._hyg.8 | Mathlib.Analysis.Calculus.FDeriv.Defs | Subtype (Eq definition✝) | null | false |
UniformOnFun.hasBasis_nhds_zero_of_basis | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {G : Type u_2} {ι : Type u_3} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G]
(𝔖 : Set (Set α)),
𝔖.Nonempty →
DirectedOn (fun x1 x2 => x1 ⊆ x2) 𝔖 →
∀ {p : ι → Prop} {b : ι → Set G},
(nhds 0).HasBasis p b →
(nhds 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p... | null | true |
USize.toNat.eq_1 | Init.Data.UInt.Lemmas | ∀ (n : USize), n.toNat = n.toBitVec.toNat | null | true |
Nat.cast_list_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {R : Type u_4} [inst : AddMonoidWithOne R] (s : List ℕ), ↑s.sum = (List.map Nat.cast s).sum | null | true |
MonoidHom.instCommMonoid._proof_6 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : CommMonoid N] (a b : M →* N), a * b = b * a | null | false |
Std.TreeSet.Raw.getD_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.Raw.ofList l cmp).getD k' fallback = k | null | true |
AddMonoidAlgebra.isGroupLikeElem_single_one._simp_1 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {A : Type u_3} {G : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
(g : G), IsGroupLikeElem R (AddMonoidAlgebra.single g 1) = True | null | false |
AlgebraicGeometry.IsNoetherian.mk | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} [toIsLocallyNoetherian : AlgebraicGeometry.IsLocallyNoetherian X]
[toCompactSpace : CompactSpace ↥X], AlgebraicGeometry.IsNoetherian X | null | true |
FirstOrder.Field.FieldAxiom.existsPairNE.sizeOf_spec | Mathlib.ModelTheory.Algebra.Field.Basic | sizeOf FirstOrder.Field.FieldAxiom.existsPairNE = 1 | null | true |
CategoryTheory.Limits.PreservesPullback.iso.eq_1 | 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 |
Lean.Meta.LazyDiscrTree.patternPath | Lean.Meta.LazyDiscrTree | Lean.Expr → Lean.MetaM (Array Lean.Meta.LazyDiscrTree.Key) | Create a key path from an expression using the function used for patterns.
This differs from Lean.Meta.DiscrTree.mkPath and targetPath in that the expression
should uses free variables rather than meta-variables for holes.
| true |
CategoryTheory.MonoidalLinear.casesOn | Mathlib.CategoryTheory.Monoidal.Linear | {R : Type u_1} →
[inst : Semiring R] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} C] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Linear R C] →
[inst_4 : CategoryTheory.MonoidalCategory C] →
[inst_5 : CategoryTheory.Monoi... | null | false |
MeasureTheory.OuterMeasure.isCaratheodory_disjointed | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {ι : Type u_1} [inst : Preorder ι] [inst_1 : LocallyFiniteOrderBot ι]
{s : ι → Set α}, (∀ (i : ι), m.IsCaratheodory (s i)) → ∀ (i : ι), m.IsCaratheodory (disjointed s i) | null | true |
Std.ExtDTreeMap.Const.size_alter_eq_add_one | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
k ∉ t → (f (Std.ExtDTreeMap.Const.get? t k)).isSome = true → (Std.ExtDTreeMap.Const.alter t k f).size = t.size + 1 | null | true |
inseparable_iff_forall_isOpen | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y ↔ ∀ (s : Set X), IsOpen s → (x ∈ s ↔ y ∈ s) | null | true |
PowerSeries.invUnitsSub_mul_X | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {R : Type u_1} [inst : Ring R] (u : Rˣ),
PowerSeries.invUnitsSub u * PowerSeries.X = PowerSeries.invUnitsSub u * PowerSeries.C ↑u - 1 | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.instBEqKey.beq._sparseCasesOn_2 | Lean.Compiler.LCNF.InferBorrow | {motive : Lean.Compiler.LCNF.ParamMap.Key✝ → Sort u} →
(t : Lean.Compiler.LCNF.ParamMap.Key✝) →
((name : Lean.Name) → (jpId : Lean.FVarId) → motive (Lean.Compiler.LCNF.ParamMap.Key.jp✝ name jpId)) →
(Nat.hasNotBit 2 (Lean.Compiler.LCNF.ParamMap.Key.ctorIdx✝ t) → motive t) → motive t | null | false |
Std.Sat.CNF.Clause.polarity.eq_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} (c : Std.Sat.CNF.Clause α) (i : ℕ),
c.polarity i = if h : i < c.polarities.size then c.polarities[i] == 1 else false | null | true |
Polynomial.X_pow_sub_one_splits | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {n : ℕ}, IsPrimitiveRoot ζ n → (Polynomial.X ^ n - Polynomial.C 1).Splits | If there is a primitive `n`-th root of unity in `K`, then `X ^ n - 1` splits. | true |
derivWithin_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (Function.const 𝕜 c) s = 0 | null | true |
CochainComplex.mappingCone.inr_fst_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain F K d) (he : 1 + d = e) (hf : 0 + e = f),
(Coch... | null | true |
Lean.Elab.Tactic.Grind.SimpCacheKey._sizeOf_inst | Lean.Elab.Tactic.Grind.Basic | SizeOf Lean.Elab.Tactic.Grind.SimpCacheKey | null | false |
finsum_mem_def | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M),
∑ᶠ (a : α) (_ : a ∈ s), f a = ∑ᶠ (a : α), s.indicator f a | null | true |
Finset.prod_mulIndicator_eq_prod_inter | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq ι] (s t : Finset ι) (f : ι → β),
∏ i ∈ s, (↑t).mulIndicator f i = ∏ i ∈ s ∩ t, f i | null | true |
TensorPower.toTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {n : ℕ} → TensorPower R n M →ₗ[R] TensorAlgebra R M | The canonical embedding from a tensor power to the tensor algebra | true |
instOrOpInt64 | Init.Data.SInt.Basic | OrOp Int64 | null | true |
CommAlgCat.FiniteEtale.fiber_map | Mathlib.RingTheory.Etale.Finite | ∀ (R : Type u) [inst : CommRing R] (Ω : Type w) [inst_1 : Field Ω] [inst_2 : Algebra R Ω]
{S T : (CommAlgCat.FiniteEtale R)ᵒᵖ} (f : S ⟶ T),
(CommAlgCat.FiniteEtale.fiber R Ω).map f = FintypeCat.homMk fun x => AlgHom.comp x (CommAlgCat.Hom.hom f.unop.hom) | null | true |
CategoryTheory.IsFiltered.of_right_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D}
(h : L ⊣ R), CategoryTheory.IsFiltered D | If `C` is filtered, and we have a functor `R : C ⥤ D` with a left adjoint, then `D` is filtered.
| true |
VectorBundle.continuousLinearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
(F : Type u_3) →
(E : B → Type u_4) →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R ... | A continuous linear equivalence between the fiber at `b` and the model fiber,
induced by the preferred trivialisation at each `b`. | true |
_private.Mathlib.Data.Finset.Powerset.0.Finset.pairwiseDisjoint_pair_insert._simp_1_3 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
MvPowerSeries.instAlgebraRestricted | Mathlib.RingTheory.MvPowerSeries.Restricted | {σ : Type u_2} →
{S : Type u_3} →
[inst : NormedCommRing S] → [inst_1 : IsUltrametricDist S] → (c : σ → ℝ) → Algebra S (MvPowerSeries.Restricted S c) | Algebra structure on `Restricted S c` when `S` is commutative. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, 0 ≤ newWidth | null | false |
ContDiffWithinAt.ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℂ n f s x → ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x | null | true |
MultilinearMap.uncurry_curryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryLeft.uncurryLeft = f | null | true |
Std.TreeSet.minD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
(t.insert k).minD fallback = t.min?.elim k fun k' => if cmp k k' = Ordering.lt then k else k' | null | true |
Std.Http.Header.instBEqValue | Std.Http.Data.Headers.Value | BEq Std.Http.Header.Value | null | true |
Std.Format.FlattenBehavior.fill.sizeOf_spec | Init.Data.Format.Basic | sizeOf Std.Format.FlattenBehavior.fill = 1 | null | true |
_private.Mathlib.Basic.Unique.0.unique_iff_existsUnique.match_1_3 | Mathlib.Basic.Unique | ∀ (α : Sort u_1) (motive : (∃! x, True) → Prop) (x : ∃! x, True),
(∀ (a : α) (left : True) (h : ∀ (y : α), (fun x => True) y → y = a), motive ⋯) → motive x | null | false |
Polynomial.eval_sumIDeriv_of_pos | Mathlib.Algebra.Polynomial.SumIteratedDerivative | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R] [NoZeroDivisors R] (p : Polynomial R) {q : ℕ},
0 < q →
∃ gp,
gp.natDegree ≤ p.natDegree - q ∧
∀ (r : R) {p' : Polynomial R},
p = (Polynomial.X - Polynomial.C r) ^ (q - 1) * p' →
Polynomial.eval r (Polynomial.sumIDeriv p) =
... | null | true |
List.isChain_range | Mathlib.Data.List.Range | ∀ (r : ℕ → ℕ → Prop) (n : ℕ), List.IsChain r (List.range n) ↔ ∀ m < n - 1, r m m.succ | null | true |
isScalarTower_closedBall_closedBall_closedBall | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜' E] {r : ℝ}
[inst_5 : NormedAlgebra 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' E],
IsScalarTower ↑(Metric.closedBall 0 1) ↑(Metric.closed... | null | true |
HasFibers.inducedMap_comp_assoc | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {R S : 𝒮} {a : 𝒳} {b b' : HasFibers.Fib p R} (f : R ⟶ S)
(ψ : (HasFibers.ι R).obj b' ⟶ a) [inst_3 : p.IsCartesian f ψ] (φ : (HasFibe... | null | true |
CategoryTheory.CommGrp.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommGrp C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.