name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ZSpan.ceil.congr_simp | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (m m_1 : E), m = m_1 → ZSpan.ceil b m = ZSpan.ceil b m_1 | null | true |
MulSemiringActionHom.mk.inj | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} {inst : Monoid M} {N : Type u_2} {inst_1 : Monoid N} {φ : M →* N} {R : Type u_10} {inst_2 : Semiring R}
{inst_3 : MulSemiringAction M R} {S : Type u_12} {inst_4 : Semiring S} {inst_5 : MulSemiringAction N S}
{toDistribMulActionHom : R →ₑ+[φ] S} {map_one' : toDistribMulActionHom.toFun 1 = 1}
{map_... | null | true |
AlgebraicTopology.NormalizedMooreComplex.objX.match_1 | Mathlib.AlgebraicTopology.MooreComplex | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
SSet.Truncated.ev01₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2} (φ : V.obj (Opposite.op { obj := { len := 2 }, property := SSet.Truncated.ι0₂._proof_3 })),
(CategoryTheory.ConcreteCategory.hom
(V.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
((CategoryTheory.ConcreteCategory.hom (V.map SS... | null | false |
Std.DTreeMap.Internal.Cell._sizeOf_1 | Std.Data.DTreeMap.Internal.Cell | {α : Type u} →
{inst : Ord α} →
{β : α → Type v} → {k : α → Ordering} → [SizeOf α] → [(a : α) → SizeOf (β a)] → Std.DTreeMap.Internal.Cell α β k → ℕ | null | false |
FunLike.commRing._proof_8 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : SMul ℤ F] [inst_2 : CommRing β]
[IsSMulApply ℤ F α β] (n : ℤ) (f : F), ⇑(n • f) = n • ⇑f | null | false |
CoalgCat.ofComon._proof_2 | Mathlib.Algebra.Category.CoalgCat.ComonEquivalence | ∀ (R : Type u_1) [inst : CommRing R] {X Y Z : CategoryTheory.Comon (ModuleCat R)} (f : X ⟶ Y) (g : Y ⟶ Z),
{
toCoalgHom' :=
let __src := ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g).hom;
{ toLinearMap := __src, counit_comp := ⋯, map_comp_comul := ⋯ } } =
CategoryTheory.Category... | null | false |
CategoryTheory.Functor.op | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → CategoryTheory.Functor Cᵒᵖ Dᵒᵖ | The opposite of a functor, i.e. considering a functor `F : C ⥤ D` as a functor `Cᵒᵖ ⥤ Dᵒᵖ`.
In informal mathematics no distinction is made between these. | true |
lp.mapCLM._proof_7 | Mathlib.Analysis.Normed.Lp.lpHolder | ∀ {α : Type u_1} {𝕜 : Type u_4} {E : α → Type u_3} {F : α → Type u_2} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : α) → NormedAddCommGroup (E i)] [inst_2 : (i : α) → NormedSpace 𝕜 (E i)]
[inst_3 : (i : α) → NormedAddCommGroup (F i)] [inst_4 : (i : α) → NormedSpace 𝕜 (F i)] (p : ENNReal)
[inst_5 : Fact (1... | null | false |
NNRat.den_ne_zero | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ≥0), q.den ≠ 0 | null | true |
Equiv.Perm.apply_zpow_apply_eq_iff._simp_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} (f : Equiv.Perm α) (n : ℤ) {x : α}, (f ((f ^ n) x) = (f ^ n) x) = (f x = x) | null | false |
WittVector.ghostMap_apply | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x : WittVector p R) (n : ℕ),
WittVector.ghostMap x n = (WittVector.ghostComponent n) x | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.mk.noConfusion | Lean.Meta.Sym.Pattern | {P : Sort u} →
{eAssignment : Array (Option Lean.Expr)} →
{uAssignment : Array (Option Lean.Level)} →
{ePending : Array (Lean.Expr × Lean.Expr)} →
{uPending : Array (Lean.Level × Lean.Level)} →
{iPending : Array (Lean.Expr × Lean.Expr)} →
{tPending : Array ℕ} →
{u... | null | false |
coe_nndist | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), ↑(nndist x y) = dist x y | null | true |
contMDiffAt_of_subsingleton | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | null | true |
Dyadic.toRat_lt_toRat_iff | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, x.toRat < y.toRat ↔ x < y | null | true |
Equiv.sigmaULiftPLiftEquivSubtype | Mathlib.Logic.Equiv.Defs | {α : Type v} → (P : α → Prop) → (i : α) × ULift.{u_1, 0} (PLift (P i)) ≃ Subtype P | A `Sigma` with `fun i ↦ ULift (PLift (P i))` fibers is equivalent to `{ x // P x }`.
Variant of `sigmaPLiftEquivSubtype`.
| true |
Std.Iterators.Types.RepeatIterator.mk._flat_ctor | Std.Data.Iterators.Producers.Repeat | {α : Type u} → {f : α → α} → α → Std.Iterators.Types.RepeatIterator α f | null | false |
String.Pos.prev_ne_endPos._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p ≠ s.startPos}, (p.prev h = s.endPos) = False | null | false |
NonUnitalAlgebra.comap_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] [inst_7 : IsScalarTower R B B] [inst_8 : SMulCommClass R B B] (f : ... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalNNRealRpow._proof_2 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (α : Q(Type)) (val : Q(PartialOrder «$α»)) (__defeqres : PLift («$val» =Q NNReal.instPartialOrder)),
«$val» =Q NNReal.instPartialOrder | null | false |
OnePoint.coe_preimage_infty | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1}, OnePoint.some ⁻¹' {OnePoint.infty} = ∅ | null | true |
SSet.skeleton_obj_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ (X : SSet) {d n : ℕ}, d < n → (X.skeleton n).obj (Opposite.op { len := d }) = ⊤ | null | true |
CategoryTheory.Localization.Construction.whiskerLeft_natTransExtension | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} {D : Type uD}
[inst_1 : CategoryTheory.Category.{uD', uD} D] {F G : CategoryTheory.Functor W.Localization D}
(τ : W.Q.comp F ⟶ W.Q.comp G), W.Q.whiskerLeft (CategoryTheory.Localization.Construction.natTransExtension... | null | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_44 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
QuaternionAlgebra.Basis.j_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).j = F q.j | null | true |
LinearMap.compDer._proof_4 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {N : Type u_2}
[inst_6 : AddCommMonoid N] [inst_7 : Module A N] [inst_8 : Module R N] [inst_9 : IsScalarTower R A M]
[inst_... | null | false |
Set.pi_def | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {π : α → Type u_7} (i : Set α) (s : (a : α) → Set (π a)), i.pi s = ⋂ a ∈ i, Function.eval a ⁻¹' s a | null | true |
Lean.JsonNumber.exponent | Lean.Data.Json.Basic | Lean.JsonNumber → ℕ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList._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 |
List.Vector.insertIdx._proof_2 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (i : Fin (n + 1)) (v : List.Vector α n), ((↑v).insertIdx (↑i) a).length = n + 1 | null | false |
ringKrullDim_eq_zero_of_field | Mathlib.RingTheory.KrullDimension.Field | ∀ (F : Type u_1) [inst : Field F], ringKrullDim F = 0 | null | true |
CategoryTheory.Limits.HasImageMap.has_image_map | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {f g : CategoryTheory.Arrow C}
{inst_1 : CategoryTheory.Limits.HasImage f.hom} {inst_2 : CategoryTheory.Limits.HasImage g.hom} {sq : f ⟶ g}
[self : CategoryTheory.Limits.HasImageMap sq], Nonempty (CategoryTheory.Limits.ImageMap sq) | `HasImageMap sq` means that there is an `ImageMap` for the square `sq`. | true |
UInt16.neg_sub | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, -(a - b) = b - a | null | true |
Lean.DeclarationRange.charUtf16 | Lean.Data.DeclarationRange | Lean.DeclarationRange → ℕ | A precomputed UTF-16 `character` field as in `Lean.Lsp.Position`. We need to store this
because LSP clients want us to report the range in terms of UTF-16, but converting a Unicode
codepoint stored in `Lean.Position` to UTF-16 requires loading and mapping the target source
file, which is IO-heavy. | true |
SimpleGraph.bot_adj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (v w : V), ⊥.Adj v w = False | null | false |
_private.Init.Data.Vector.Lemmas.0.Vector.append_eq_append_iff._proof_7 | Init.Data.Vector.Lemmas | ∀ {n m k l : ℕ}, k + l = n + m → ¬n ≤ k → ¬n - k + m = l → False | null | false |
CategoryTheory.Pretriangulated.Triangle.mk' | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
(obj₁ obj₂ obj₃ : C) →
(obj₁ ⟶ obj₂) →
(obj₂ ⟶ obj₃) →
(obj₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj obj₁) → CategoryTheory.Pretriangulated.Triangle C | null | true |
instBoundedSpaceOrderDual | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} [inst : Bornology α] [BoundedSpace α], BoundedSpace αᵒᵈ | null | true |
DirectedOn.notMem_of_lt_csInf | Mathlib.Order.ConditionallyCompletePartialOrder.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderInf α] {x : α} {s : Set α},
DirectedOn (fun x1 x2 => x2 ≤ x1) s → x < sInf s → BddBelow s → x ∉ s | null | true |
Module.Basis.mem_span_iff_repr_mem | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {ι : Type u_1} (R : Type u_2) {M : Type u_3} {S : Type u_4} [inst : CommRing R] [IsDomain R] [inst_2 : Ring S]
[Nontrivial S] [inst_4 : AddCommGroup M] [inst_5 : Algebra R S] [inst_6 : Module S M] [inst_7 : Module R M]
[IsScalarTower R S M] [Module.IsTorsionFree R S] (b : Module.Basis ι S M) (m : M),
m ∈ Submod... | Let `b` be an `S`-basis of `M`. Then `m : M` lies in the `R`-module spanned by `b` iff all the
coordinates of `m` on the basis `b` are in `R` (see `Basis.mem_span` for the case `R = S`). | true |
Equiv.nonAssocRing._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonAssocRing β], e (e.symm 0) = 0 | null | false |
Mathlib.Linter.TextBased.instBEqErrorFormat.beq | Mathlib.Tactic.Linter.TextBased | Mathlib.Linter.TextBased.ErrorFormat → Mathlib.Linter.TextBased.ErrorFormat → Bool | null | true |
AlgebraicGeometry.Scheme.Cover.Over.recOn | Mathlib.AlgebraicGeometry.Cover.Over | {S : AlgebraicGeometry.Scheme} →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X : AlgebraicGeometry.Scheme} →
[inst_2 : X.Over S] →
{𝒰 : AlgebraicGeo... | null | false |
Lean.Lsp.ReferenceContext.includeDeclaration | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → Bool | null | true |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity.0.MeasureTheory.eLpNorm_le_nnreal_smul_eLpNorm_of_ae_le_mul._simp_1_2 | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {E : Type u_4} [inst : NormedAddGroup E] {a : E}, (‖a‖₊ = 0) = (a = 0) | null | false |
WeierstrassCurve.VariableChange.mapHom | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | {R : Type u} →
[inst : CommRing R] →
{A : Type v} →
[inst_1 : CommRing A] → (R →+* A) → WeierstrassCurve.VariableChange R →* WeierstrassCurve.VariableChange A | The map over a ring homomorphism of a change of variables is a group homomorphism. | true |
ContinuousLinearEquiv.continuousMultilinearMapCongrLeft_apply | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {E₁ : ι → Type u_4} {F : Type u_5} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : (i : ι) → TopologicalSpace (E₁ i)]
[inst_5 : (i : ι) → AddCommGroup (E₁ ... | null | true |
Std.Tactic.BVDecide.Normalize.BitVec.ite_else_not_ite | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (cond : Bool) {a b c : BitVec w}, (bif cond then a else ~~~bif cond then b else c) = bif cond then a else ~~~c | null | true |
Lean.Order.instCCPOEIOOfNonempty._proof_3 | Init.Internal.Order.Basic | ∀ {ε α : Type} [inst : Nonempty ε] {x : EIO ε α}, Lean.Order.instCCPOEIOOfNonempty._aux_1 x x | null | false |
Filter.map_mul_left_nhdsGT | Mathlib.Topology.Algebra.Group.Order | ∀ {H : Type u_1} [inst : TopologicalSpace H] [inst_1 : CommGroup H] [inst_2 : PartialOrder H] [IsOrderedMonoid H]
[ContinuousMul H] {c a : H},
Filter.map (fun x => c * x) (nhdsWithin a (Set.Ioi a)) = nhdsWithin (c * a) (Set.Ioi (c * a)) | null | true |
ContinuousAddMonoidHom.toContinuousAddMonoidHom._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {B : Type u_2} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] {F : Type u_3} [inst_4 : FunLike F A B] [inst_5 : AddMonoidHomClass F A B]
[ContinuousMapClass F A B] (f : F), Continuous (↑↑f).toFun | null | false |
_private.Mathlib.Order.SetDissipate.0.Set.iInter_subset_dissipate._simp_1_2 | Mathlib.Order.SetDissipate | ∀ {α : Type u_1} {ι : Sort u_4} {s : Set α} {t : ι → Set α}, (s ⊆ ⋂ i, t i) = ∀ (i : ι), s ⊆ t i | null | false |
Std.DTreeMap.le_maxKeyD_of_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | null | true |
Localization.mulEquivOfQuotient_mk' | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(Localization.mulEquivOfQuotient f) ((Localization.monoidOf S).mk' x y) = f.mk' x y | null | true |
Cardinal.natCast_mul_le_natCast_mul._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (↑n * a ≤ ↑n * b) = (a ≤ b) | null | false |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isCursorOnWhitespace | Lean.Server.Completion.SyntheticCompletion | Lean.FileMap → String.Pos.Raw → Bool | null | true |
Lean.Core.State.mk | Lean.CoreM | Lean.Environment →
Lean.MacroScope →
Lean.NameGenerator →
Lean.DeclNameGenerator →
Lean.TraceState →
Lean.Core.Cache →
Lean.MessageLog →
Lean.Elab.InfoState → Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree) → Lean.Core.State | null | true |
Set.Finite.isCountablyCompact_sUnion | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_2} [inst : TopologicalSpace E] {S : Set (Set E)},
S.Finite → (∀ s ∈ S, IsCountablyCompact s) → IsCountablyCompact (⋃₀ S) | A finite union of countably compact sets is countably compact. | true |
minpoly.natDegree_pos | Mathlib.FieldTheory.Minpoly.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} [Nontrivial B],
IsIntegral A x → 0 < (minpoly A x).natDegree | The degree of a minimal polynomial, as a natural number, is positive. | true |
LatticeHom.toSupHom | Mathlib.Order.Hom.Lattice | {α : Type u_6} → {β : Type u_7} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → SupHom α β | null | true |
_private.Mathlib.CategoryTheory.Triangulated.SpectralObject.0.CategoryTheory.Triangulated.SpectralObject._proof_7 | Mathlib.CategoryTheory.Triangulated.SpectralObject | 0 ≤ 2 | null | false |
MvPolynomial.isAlgebraic_of_mem_vars_of_forall_totalDegree_le | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_1} {K : Type u_2} {ι : Type u_3} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ι → K}
{F : MvPolynomial ι k},
(∀ (F' : MvPolynomial ι k), F' ≠ 0 → (MvPolynomial.aeval a) F' = 0 → F.totalDegree ≤ F'.totalDegree) →
(MvPolynomial.aeval a) F = 0 → ∀ i ∈ F.vars, IsAlgebraic (↥(Algebra... | null | true |
DirectSum.addEquivProdDirectSum | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{α : Option ι → Type w} →
[inst : (i : Option ι) → AddCommMonoid (α i)] →
(DirectSum (Option ι) fun i => α i) ≃+ α none × DirectSum ι fun i => α (some i) | Isomorphism obtained by separating the term of index `none` of a direct sum over `Option ι`. | true |
AddAction.stabilizer_vadd_eq_left | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : AddAction G β]
[inst_3 : VAdd α β] [VAddAssocClass G α β] (a : α) (b : β),
(Function.Injective fun x => x +ᵥ b) → AddAction.stabilizer G (a +ᵥ b) = AddAction.stabilizer G a | null | true |
mem_countableSupClosure_iff_iSup | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} {a : α} [inst : CompleteLattice α],
a ∈ countableSupClosure s ↔ ∃ t, (∀ (n : ℕ), t n ∈ s) ∧ ⨆ n, t n = a | null | true |
Lean.Grind.IntModule.OfNatModule.r_rfl | Init.Grind.Module.Envelope | ∀ {α : Type u} [inst : Lean.Grind.NatModule α] (a : α × α), Lean.Grind.IntModule.OfNatModule.r α a a | null | true |
List.pmap_eq_pmapImpl | Init.Data.List.Attach | @List.pmap = @List.pmapImpl | null | true |
Lean.Lsp.LeanModule.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanModule → Sort u} →
((name : String) →
(uri : Lean.Lsp.DocumentUri) → (data? : Option Lean.Json) → motive { name := name, uri := uri, data? := data? }) →
(t : Lean.Lsp.LeanModule) → motive t | null | false |
Std.ExtDTreeMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α} {k : α},
k ∉ t → l.contains k = false → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKey? k = none | null | true |
Graph.noConfusionType | Mathlib.Combinatorics.Graph.Basic | Sort u → {α : Type u_3} → {β : Type u_4} → Graph α β → {α' : Type u_3} → {β' : Type u_4} → Graph α' β' → Sort u | null | false |
CategoryTheory.Equivalence.counit_naturality_assoc._to_dual_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 : D} (f : Y ⟶ X) {Z : D} (h : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (e.counitInv.app Y))
(e.functor.map (e.inverse.map f)) =
C... | null | false |
Lean.MonadError.toAddErrorMessageContext | Lean.Exception | {m : Type → Type} → [self : Lean.MonadError m] → Lean.AddErrorMessageContext m | null | true |
CategoryTheory.DifferentialObject.shiftFunctor | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddCommGroupWithOne S] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
S → CategoryTheory.Functor (CategoryTheory.DifferentialObject S C) (Cate... | The shift functor on `DifferentialObject S C`. | true |
_private.Lean.Level.0.Lean.Level.data.match_1 | Lean.Level | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((name : Lean.Name) → motive (Lean.Level.param name)) →
((u : Lean.Level) → motive u.succ) →
((u v : Lean.Level) → motive (u.max... | null | false |
CategoryTheory.AddMon.monMonoidal | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.MonoidalCategory (CategoryTheory.AddMon C) | null | true |
Lean.Grind.CommRing.Poly.pow._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly | null | false |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_finitary._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : Set β → Prop}, (∀ t ⊆ f '' s, p t) = ∀ t ⊆ s, p (f '' t) | null | false |
Float32.isInf | Init.Data.Float.Float32 | Float32 → Bool | Checks whether a floating-point number is a positive or negative infinite number, but not a finite
number or `NaN`.
This function has a logical model in terms of `Float32.Model`. It is compiled to the C operator `isinf`.
| true |
ByteArray.Iterator.remainingBytes | Init.Data.ByteArray.Basic | ByteArray.Iterator → ℕ | The number of bytes remaining in the iterator.
| true |
Lean.Parser.withOpen.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | null | true |
_private.Init.Data.String.Substring.0.Substring.Raw.nextn.match_1.eq_1 | Init.Data.String.Substring | ∀ (motive : Substring.Raw → ℕ → String.Pos.Raw → Sort u_1) (x : Substring.Raw) (p : String.Pos.Raw)
(h_1 : (x : Substring.Raw) → (p : String.Pos.Raw) → motive x 0 p)
(h_2 : (ss : Substring.Raw) → (i : ℕ) → (p : String.Pos.Raw) → motive ss i.succ p),
(match x, 0, p with
| x, 0, p => h_1 x p
| ss, i.succ, p... | null | true |
CategoryTheory.Functor.instIsIsoPlusAppPlusRightDerivedFunctorPlusUnitObjInjectiveObjectMapCochainComplexPlusι | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
(F : CategoryTheory.Functor C D) [inst_6 : F.Additiv... | null | true |
Unitary.path._proof_2 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)),
selfAdjoint.expUnitary (↑0 • Unitary.argSelfAdjoint (v * star u)) * u = u | null | false |
Set.image2_image2_image2_comm | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {δ : Type u_7} {ε : Type u_9} {ε' : Type u_10} {ζ : Type u_11}
{ζ' : Type u_12} {ν : Type u_13} {s : Set α} {t : Set β} {u : Set γ} {v : Set δ} {f : ε → ζ → ν} {g : α → β → ε}
{h : γ → δ → ζ} {f' : ε' → ζ' → ν} {g' : α → γ → ε'} {h' : β → δ → ζ'},
(∀ (a : α) (b : β) ... | null | true |
WeierstrassCurve.Projective.neg_equiv | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P Q : Fin 3 → R}, P ≈ Q → W'.neg P ≈ W'.neg Q | null | true |
_private.Mathlib.RingTheory.Ideal.IsPrincipal.0.Ideal.associatesEquivIsPrincipal._simp_6 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ {M : Type u_1} [inst : Monoid M] (a : M), Associates.mk a = ⟦a⟧ | null | false |
Subring.map_center_le_center | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {F : Type u_1} [inst_2 : FunLike F R S]
[inst_3 : RingHomClass F R S] {f : F}, Function.Surjective ⇑f → Subring.map (↑f) (Subring.center R) ≤ Subring.center S | null | true |
Mathlib.Meta.FunProp.Context._sizeOf_1 | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Context → ℕ | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Multiset.Basic.0.Multiset.prod_dvd_prod_of_le._simp_1_1 | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {α : Type u_1} [inst : Semigroup α] (a b : α), (a ∣ a * b) = True | null | false |
_private.Mathlib.NumberTheory.NumberField.Discriminant.Basic.0.NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr._simp_1_5 | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
Int.lcm_mul_left_left_eq_mul_of_lcm_eq_mul | Init.Data.Int.Gcd | ∀ {n m k : ℤ}, n.lcm m = n.natAbs * m.natAbs → (k * n).lcm m = n.natAbs * k.lcm m | null | true |
IsIdempotentElem.add_sub_mul_of_commute | Mathlib.Algebra.Ring.Idempotent | ∀ {R : Type u_1} [inst : NonUnitalRing R] {a b : R},
Commute a b → IsIdempotentElem a → IsIdempotentElem b → IsIdempotentElem (a + b - a * b) | null | true |
CategoryTheory.Adjunction.LeftAdjointCommShift.iso_hom_app_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {A : Type u_3} [inst_2 : AddGroup A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShif... | null | true |
PUnit.instSMulZeroClass._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Zero R] (x : PUnit.{u_1 + 1}), x • 0 = x • 0 | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_3.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : (CategoryTheory.WithInitial C)ᵒᵖ) → (Opposite.unop y ⟶ Opposite.unop x) → (x ⟶ y) → Sort u_3) (a : C)
(x :
Opposite.unop (Opposite.op CategoryTheory.WithInitial.star) ⟶
Opposite.unop (Opposite.op (CategoryTheory.WithInitial.of... | null | true |
Std.Http.Config.maxRequests | Std.Http.Server.Config | Std.Http.Config → ℕ | Maximum number of requests per connection.
| true |
Filter.EventuallySubset.antisymm | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s t : Set α} {l : Filter α}, s ≤ᶠ[l] t → t ≤ᶠ[l] s → s =ᶠ[l] t | null | true |
LieSubmodule.mem_baseChange_iff | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : CommRing A] [inst_8 : Algebra R A] {N : LieSubmodule R L M}
{m : Tensor... | null | true |
_private.Mathlib.Data.EReal.Inv.0.EReal.sign_mul_inv_abs._simp_1_1 | Mathlib.Data.EReal.Inv | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] [AddLeftMono α] [AddRightMono α] (a : α), (0 ≤ |a|) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.