name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WittVector.hasNatPow | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [hp : Fact (Nat.Prime p)] → [CommRing R] → Pow (WittVector p R) ℕ | null | true |
Std.DHashMap.Internal.Raw₀.isHashSelf_reinsertAux | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
(data : { d // 0 < d.size }) (a : α) (b : β a),
Std.DHashMap.Internal.IsHashSelf ↑data →
Std.DHashMap.Internal.IsHashSelf ↑(Std.DHashMap.Internal.Raw₀.reinsertAux hash data a b) | null | true |
toPullbackDiag | Mathlib.Data.Set.Prod | {X : Type u_1} → {Y : Sort u_2} → (f : X → Y) → X → Function.Pullback f f | The diagonal map $\Delta: X \to X \times_Y X$. | true |
USize.toUInt16_shiftLeft_mod | Init.Data.UInt.Bitwise | ∀ (a b : USize), (a <<< (b % 16)).toUInt16 = a.toUInt16 <<< b.toUInt16 | null | true |
Order.cof_ord_cof | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ (α : Type u_1) [inst : LinearOrder α] [WellFoundedLT α], (Order.cof α).ord.cof = Order.cof α | null | true |
Std.DTreeMap.Internal.Impl.get_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
[inst : Std.TransOrd α] [inst_1 : Std.LawfulEqOrd α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : t.WF)
{h' : k ∈ (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl},
(Std.DTreeMap.Internal.Impl.filterMap f t... | null | true |
Matroid.IsRkFinite.union | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X Y : Set α}, M.IsRkFinite X → M.IsRkFinite Y → M.IsRkFinite (X ∪ Y) | null | true |
Orientation.oangle_eq_angle_of_sign_eq_one | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, (o.oangle x y).sign = 1 → o.oangle x y = ↑(InnerProductGeometry.angle x y) | The oriented angle between two vectors equals the unoriented angle if the sign is positive. | true |
CategoryTheory.Limits.binaryBiconeOfIsSplitEpiOfKernel | Mathlib.CategoryTheory.Preadditive.Biproducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
{f : X ⟶ Y} →
[CategoryTheory.IsSplitEpi f] →
{c : CategoryTheory.Limits.KernelFork f} →
CategoryTheory.Limits.IsLimit c → CategoryTheory.Limits.Binary... | Every split epi `f` with a kernel induces a binary bicone with `f` as its `snd` and
the kernel map as its `inl`.
We will show in `isBilimitBinaryBiconeOfIsSplitEpiOfKernel` that this binary bicone is in fact
already a biproduct. | true |
IsSMulRegular.rTensor | Mathlib.RingTheory.Regular.IsSMulRegular | ∀ {R : Type u_1} (M : Type u_2) {M' : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M']
[inst_3 : Module R M] [inst_4 : Module R M'] [Module.Flat R M] {r : R},
IsSMulRegular M' r → IsSMulRegular (TensorProduct R M' M) r | null | true |
CategoryTheory.Limits.Cofan.isColimitTrans._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {X : α → C}
(c : CategoryTheory.Limits.Cofan X) (hc : CategoryTheory.Limits.IsColimit c) {β : α → Type u_1}
{Y : (a : α) → β a → C} (π : (a : α) → (b : β a) → Y a b ⟶ X a)
(hs : (a : α) → CategoryTheory.Limits.IsColimit (CategoryTheory.... | null | false |
Lean.Elab.Tactic.Omega.instToExprLinearCombo | Lean.Elab.Tactic.Omega.Core | Lean.ToExpr Lean.Omega.LinearCombo | null | true |
Std.Time.Duration.instHMulInt_1 | Std.Time.Duration | HMul Std.Time.Duration ℤ Std.Time.Duration | null | true |
Hyperreal.instField._aux_8 | Mathlib.Analysis.Real.Hyperreal | ℕ → ℝ* → ℝ* | null | false |
_private.Mathlib.LinearAlgebra.Determinant.0.LinearEquiv.det_mul_det_symm._simp_1_1 | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f g : M →ₗ[A] M),
LinearMap.det f * LinearMap.det g = LinearMap.det (f ∘ₗ g) | null | false |
AddGrpCat.Hom.ext | Mathlib.Algebra.Category.Grp.Basic | ∀ {A B : AddGrpCat} {x y : A.Hom B}, x.hom' = y.hom' → x = y | null | true |
RingCon.instFunLikeForallProp._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R], Function.Injective (DFunLike.coe ∘ fun c => c.toCon) | null | false |
Subsemigroup.map_strictMono_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → StrictMono (Subsemigroup.map f) | null | true |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_measurableSet._simp_1_2 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) | null | false |
Ordinal.enumOrd_univ | Mathlib.SetTheory.Ordinal.Enum | Ordinal.enumOrd Set.univ = id | null | true |
MonoidAlgebra.mapDomainRingEquiv._proof_4 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N], MonoidHomClass (N ≃* M) N M | null | false |
_private.Mathlib.Order.RelIso.Basic.0.RelHomClass.irrefl.match_1_1 | Mathlib.Order.RelIso.Basic | ∀ {β : Type u_1} {s : β → β → Prop} (motive : Std.Irrefl s → Prop) (x : Std.Irrefl s),
(∀ (H : ∀ (a : β), ¬s a a), motive ⋯) → motive x | null | false |
Hamming.instPseudoMetricSpace._proof_1 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : Fintype ι] [inst_1 : (i : ι) → DecidableEq (β i)] (x y : Hamming β),
0 ≤ dist x y | null | false |
Int.mul_lt_mul_right_of_neg | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, a < 0 → (b * a < c * a ↔ c < b) | null | true |
Std.TreeSet.get?_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get? k' = some k | null | true |
HVertexOperator.coeff._proof_1 | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_2} [inst : PartialOrder Γ] {R : Type u_3} {V : Type u_4} {W : Type u_1} [inst_1 : CommRing R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
(A : HVertexOperator Γ R V W) (n : Γ) (u v : V),
((HahnModule.of R).symm (A (u + v))).coeff n =
((HahnModu... | null | false |
OrderEmbedding.coe_ofMapLEIff | Mathlib.Order.Hom.Basic | ∀ {α : Type u_6} {β : Type u_7} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β}
(h : ∀ (a b : α), f a ≤ f b ↔ a ≤ b), ⇑(OrderEmbedding.ofMapLEIff f h) = f | null | true |
PProd.forall._simp_1 | Mathlib.Data.Prod.PProd | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∀ (x : α ×' β), p x) = ∀ (a : α) (b : β), p ⟨a, b⟩ | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.resRec.match_3.splitter | Init.Data.BitVec.Bitblast | {w : ℕ} →
(motive : (s : ℕ) → s < w → 0 < s → Sort u_1) →
(s : ℕ) →
(hs : s < w) →
(hslt : 0 < s) →
((hs : 0 < w) → (hslt : 0 < 0) → s = 0 → motive 0 hs hslt) →
((s' : ℕ) → (hs : s' + 1 < w) → (hslt : 0 < s' + 1) → s = s'.succ → motive s'.succ hs hslt) →
motive s ... | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceR!.match_1.eq_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (rs : ℕ) (rk : α) (rv : β rk)
(rls : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k_1 : α) (v_1 : β k_1)
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf... | null | true |
finsum_congr_Prop | Mathlib.Algebra.BigOperators.Finprod | ∀ {M : Type u_2} [inst : AddCommMonoid M] {p q : Prop} {f : p → M} {g : q → M} (hpq : p = q),
(∀ (h : q), f ⋯ = g h) → finsum f = finsum g | null | true |
Rat.instCharZero | Mathlib.Algebra.Ring.Rat | CharZero ℚ | The characteristic of `ℚ` is 0. | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_compl_positive_negative.match_1_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) (B : ℕ → Set α) (m : ℕ)
(motive :
B m ∈ {B | MeasurableSet B ∧ MeasureTheory.VectorMeasure.restrict s B ≤ MeasureTheory.VectorMeasure.restrict 0 B} →
Prop)
(x :
B m ∈ {B | MeasurableSet B ∧ MeasureTheory.VectorMeasure.rest... | null | false |
Metric.contractibleSpace_eball | Mathlib.Analysis.Normed.Module.Connected | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [NormedSpace ℝ E] {x : E} {r : ENNReal},
0 < r → ContractibleSpace ↑(Metric.eball x r) | null | true |
Std.HashSet.fold | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (β → α → β) → β → Std.HashSet α → β | Folds the given function over the elements of the hash set in some order. | true |
isLeftRegular_toLex._simp_2 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Monoid α] {a : α}, IsLeftRegular (toLex a) = IsLeftRegular a | null | false |
_private.Lean.Elab.ConfigEval.DeriveEvalTerm.0.Lean.Elab.ConfigEval.ensureEvalTerm.extraDeps | Lean.Elab.ConfigEval.DeriveEvalTerm | Lean.Syntax → Lean.Expr → Lean.Elab.TermElabM (Array Lean.Expr) | null | true |
TypeVec.prod.mk | Mathlib.Data.TypeVec | {n : ℕ} → {α β : TypeVec.{u} n} → (i : Fin2 n) → α i → β i → α.prod β i | constructor for `prod` | true |
AlgebraicGeometry.instIsMultiplicativeSchemeIsAffineHom | Mathlib.AlgebraicGeometry.Morphisms.Affine | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsAffineHom | null | true |
OrderEmbedding.isWellOrder | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [IsWellOrder β fun x1 x2 => x1 < x2]
(f : α ↪o β), IsWellOrder α fun x1 x2 => x1 < x2 | null | true |
OmegaCompletePartialOrder.ωScottContinuous.of_apply₂ | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {γ : Type u_4} {β : α → Type u_6} [inst : (x : α) → OmegaCompletePartialOrder (β x)]
[inst_1 : OmegaCompletePartialOrder γ] {f : γ → (x : α) → β x},
(∀ (a : α), OmegaCompletePartialOrder.ωScottContinuous fun x => f x a) → OmegaCompletePartialOrder.ωScottContinuous f | null | true |
Lean.Expr.NumObjs.State.mk._flat_ctor | Lean.Util.NumObjs | Lean.PtrSet Lean.Expr → ℕ → Lean.Expr.NumObjs.State | null | false |
_private.Mathlib.Analysis.Normed.Group.Continuity.0.controlled_prod_of_mem_closure._simp_1_6 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | null | false |
ContinuousAffineEquiv.constVAdd | Mathlib.Topology.Algebra.ContinuousAffineEquiv | (k : Type u_1) →
(P₁ : Type u_2) →
{V₁ : Type u_6} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : Module k V₁] →
[inst_3 : AddTorsor V₁ P₁] → [inst_4 : TopologicalSpace P₁] → [ContinuousConstVAdd V₁ P₁] → V₁ → P₁ ≃ᴬ[k] P₁ | The map `p ↦ v +ᵥ p` as a continuous affine automorphism of an affine space
on which addition is continuous. | true |
Perfection.liftMonoidHom | Mathlib.RingTheory.Perfection | (p : ℕ) →
(M : Type u_2) →
[inst : CommMonoid M] →
[PerfectRing M p] → (N : Type u_3) → [inst_2 : CommMonoid N] → (M →* N) ≃* (M →* Perfection N p) | Given monoids `M` and `N`, with `M` being perfect,
any homomorphism `M →+* N` can be lifted uniquely to a homomorphism `M →* Perfection N p`. | true |
Lean.BaseMessage.endPos._default | Lean.Message | {α : Type u} → Option Lean.Position | null | false |
Lean.Meta.Origin.stx.elim | Lean.Meta.Tactic.Simp.SimpTheorems | {motive : Lean.Meta.Origin → Sort u} →
(t : Lean.Meta.Origin) →
t.ctorIdx = 2 → ((id : Lean.Name) → (ref : Lean.Syntax) → motive (Lean.Meta.Origin.stx id ref)) → motive t | null | false |
CategoryTheory.SmallObject.llp_rlp_ιObj | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [inst_3 : I.IsCardinalForSmallObjectArgument κ] {X Y : C}
(f : X ⟶ Y), I.rlp.llp (CategoryTheory.SmallObject.ιObj I κ f) | null | true |
DirectLimit.instRingOfRingHomClass._proof_8 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
Congr!.Config.useCongrSimp | Mathlib.Tactic.CongrExclamation | Congr!.Config → Bool | Whether to use the congruence generator that is used by `simp` and `congr`. This generator
is more strict, and it does not respect all configuration settings. It does respect
`preferLHS`, `partialApp` and `maxArgs` and transparency settings. It acts as if `sameFun := true`
and it ignores `typeEqs`. | true |
Std.DTreeMap.Internal.Const.RcoSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : SizeOf β]
(treeMap : Std.DTreeMap.Internal.Impl α fun x => β) (range : Std.Rco α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | null | true |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.perm_card_two_iff._simp_1_7 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {a b : α} (m : Multiset α), ({a} = b ::ₘ m) = (a = b ∧ m = 0) | null | false |
CategoryTheory.Presieve.IsSheafFor | Mathlib.CategoryTheory.Sites.IsSheafFor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} → CategoryTheory.Functor Cᵒᵖ (Type w) → CategoryTheory.Presieve X → Prop | We define `P` to be a sheaf for the presieve `R` if every compatible family has a unique
amalgamation.
This is the definition of a sheaf for the given presieve given in C2.1.2 of [Elephant], and
https://ncatlab.org/nlab/show/sheaf#GeneralDefinitionInComponents.
Using `compatible_iff_sieveCompatible`,
this is equivalen... | true |
CategoryTheory.Limits.HasColimit.mk' | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C},
Nonempty (CategoryTheory.Limits.ColimitCocone F) → CategoryTheory.Limits.HasColimit F | null | true |
Nat.factorization_mul_apply_of_coprime | Mathlib.Data.Nat.Factorization.Defs | ∀ {p a b : ℕ}, a.Coprime b → (a * b).factorization p = a.factorization p + b.factorization p | For coprime `a` and `b`, the power of `p` in `a * b` is the sum of the powers in `a` and `b` | true |
TwoSidedIdeal.sub_mem | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) {x y : R}, x ∈ I → y ∈ I → x - y ∈ I | null | true |
mulTSupport | Mathlib.Topology.Algebra.Support | {X : Type u_1} → {α : Type u_2} → [One α] → [TopologicalSpace X] → (X → α) → Set X | The topological support of a function is the closure of its support, i.e. the closure of the
set of all elements where the function is not equal to 1. | true |
_private.Mathlib.Analysis.Convex.Cone.Extension.0.exists_extension_of_le_sublinear._proof_1_2 | Mathlib.Analysis.Convex.Cone.Extension | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] (N : E → ℝ),
(∀ (c : ℝ), 0 < c → ∀ (x : E), N (c • x) = c * N x) → N 0 = 0 | null | false |
TopPair.ofHom._proof_2 | Mathlib.Topology.Category.TopPair | ∀ {X Y : TopPair} (f : TopPair.fst ⟶ TopPair.fst), ⊤ f | null | false |
_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.isFractional_span_iff.match_1_1 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{s : Set P} (motive : IsFractional S (Submodule.span R s) → Prop) (x : IsFractional S (Submodule.span R s)),
(∀ (a : R) (a_mem : a ∈ S) (h : ∀ b ∈ Submodule.span R s, IsLocalization.IsInteger R (a • b)... | null | false |
Lean.Lsp.CreateFile.mk._flat_ctor | Lean.Data.Lsp.Basic | Lean.Lsp.DocumentUri → Option Lean.Lsp.CreateFile.Options → Option String → Lean.Lsp.CreateFile | null | false |
_private.Lean.Compiler.ExternAttr.0.Lean.instBEqExternEntry.beq.match_1 | Lean.Compiler.ExternAttr | (motive : Lean.ExternEntry → Lean.ExternEntry → Sort u_1) →
(x x_1 : Lean.ExternEntry) →
((a b : Lean.Name) → motive (Lean.ExternEntry.adhoc a) (Lean.ExternEntry.adhoc b)) →
((a : Lean.Name) →
(a_1 : String) →
(b : Lean.Name) → (b_1 : String) → motive (Lean.ExternEntry.inline a a_1) (L... | null | false |
Monoid.CoprodI.Word.cons._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i : ι} (m : M i) (w : Monoid.CoprodI.Word M),
m ≠ 1 → ∀ l ∈ ⟨i, m⟩ :: w.toList, l.snd ≠ 1 | null | false |
CategoryTheory.CommRingObjCat.instFaithfulForget | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C], (CategoryTheory.CommRingObjCat.forget C).Faithful | null | true |
CochainComplex.HomComplex.CohomologyClass.toSmallShiftedHom_mk | Mathlib.Algebra.Homology.DerivedCategory.SmallShiftedHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {K L : CochainComplex C ℤ}
{n : ℤ}
[inst_2 :
CategoryTheory.Localization.HasSmallLocalizedShiftedHom (HomologicalComplex.quasiIso C (ComplexShape.up ℤ)) ℤ K L]
(x : CochainComplex.HomComplex.Cocycle K L n),
(Cochain... | null | true |
RightPreLieRing.instLeftPreLieRingMulOpposite | Mathlib.Algebra.NonAssoc.PreLie.Basic | {L : Type u_2} → [RightPreLieRing L] → LeftPreLieRing Lᵐᵒᵖ | Every left pre-Lie ring is a right pre-Lie ring with the opposite multiplication | true |
Lean.Meta.Grind.EMatch.Choice.noConfusion | Lean.Meta.Tactic.Grind.EMatch | {P : Sort u} → {t t' : Lean.Meta.Grind.EMatch.Choice} → t = t' → Lean.Meta.Grind.EMatch.Choice.noConfusionType P t t' | null | false |
IsRightUniformAddGroup.rec | Mathlib.Topology.Algebra.IsUniformGroup.Defs | {G : Type u_4} →
[inst : UniformSpace G] →
[inst_1 : AddGroup G] →
{motive : IsRightUniformAddGroup G → Sort u} →
([toIsTopologicalAddGroup : IsTopologicalAddGroup G] →
(uniformity_eq : uniformity G = Filter.comap (fun x => x.2 + -x.1) (nhds 0)) → motive ⋯) →
(t : IsRightUnifor... | null | false |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.rankFinite_iff_cRank_lt_aleph0._simp_1_6 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u}, Finite α = (Cardinal.mk α < Cardinal.aleph0) | null | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk.inj | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} {inst : CategoryTheory.Category.{u, u} I} {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
{c : CategoryTheory.Limits.Cone D} {hc : CategoryTheory.Limits.IsLimit c} {i : I} {a : D.obj i ⟶ X}
{ha : t... | null | true |
Function.FromTypes.uncurry_apply_cons | Mathlib.Data.Fin.Tuple.Curry | ∀ {n : ℕ} {α : Type u} {p : Fin n → Type u} {τ : Type u} (f : Function.FromTypes (Matrix.vecCons α p) τ) (a : α)
(args : (i : Fin n) → p i), f.uncurry (Fin.cons a args) = (f a).uncurry args | null | true |
Array.«_aux_Init_Data_Array_Perm___macroRules_Array_term_~__1» | Init.Data.Array.Perm | Lean.Macro | null | false |
Monotone.rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β}, Monotone f → Monotone (Function.rightLim f) | null | true |
Lean.Meta.Grind.instInhabitedCasesTypes | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.CasesTypes | null | true |
Aesop.RuleTac.tacGen | Aesop.RuleTac.Tactic | Lean.Name → Aesop.RuleTac | null | true |
Polynomial.SplittingField.instGroupWithZero._proof_3 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (n : ℕ) (a : f.SplittingField), a ^ ↑n.succ = a ^ ↑n * a | null | false |
Lean.Omega.Int.mul_congr | Init.Omega.Int | ∀ {a b c d : ℤ}, a = b → c = d → a * c = b * d | null | true |
Ord.ext | Init.Data.Ord.Basic | ∀ {α : Type u} {x y : Ord α}, compare = compare → x = y | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.nestedAction._regBuiltin.Lean.Parser.Term.nestedAction.formatter_9 | Lean.Parser.Do | IO Unit | null | false |
SpectrumRestricts.nnreal_add | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a b : A},
IsSelfAdjoint a →
IsSelfAdjoint b →
SpectrumRestricts a ⇑ContinuousMap.realToNNReal →
SpectrumRestricts b ⇑ContinuousMap.realToNNReal → SpectrumRestricts (a + b) ⇑ContinuousMap.realToNNReal | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_4 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Mathlib.Tactic.Ring.Common.add_mul | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] {a₁ a₂ b c₁ c₂ d : R},
a₁ * b = c₁ → a₂ * b = c₂ → c₁ + c₂ = d → (a₁ + a₂) * b = d | null | true |
_private.Aesop.Script.StructureStatic.0.Aesop.Script.structureStaticCore.go | Aesop.Script.StructureStatic | Aesop.Script.TacticState → Aesop.Script.StaticStructureM (List Aesop.Script.Step × Aesop.Script.TacticState) | null | true |
_private.Init.Data.List.Find.0.List.lookup_eq_some_iff._simp_1_2 | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
EReal.nsmul_eq_mul | Mathlib.Data.EReal.Operations | ∀ (n : ℕ) (x : EReal), n • x = ↑n * x | null | true |
_private.Init.Prelude.0.Lean.Macro.State.mk._flat_ctor | Init.Prelude | Lean.MacroScope → List (Lean.Name × String) → List Lean.Name → Lean.Macro.State | null | false |
ContinuousOn.cfc_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
Lean.Lsp.InitializeParams.initializationOptions?._default | Lean.Data.Lsp.InitShutdown | Option Lean.Lsp.InitializationOptions | null | false |
bot_lt_affineSpan._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : Set P}, (⊥ < affineSpan k s) = s.Nonempty | null | false |
Matrix.toBilin._proof_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁],
SMulCommClass R₁ R₁ (M₁ →ₗ[R₁] R₁) | null | false |
_private.Mathlib.Order.Int.LeastGreatest.0.Int.coe_greatestOfBdd_eq._proof_1_2 | Mathlib.Order.Int.LeastGreatest | ∀ {P : ℤ → Prop} [inst : DecidablePred P] {b b' : ℤ} (Hb : ∀ (z : ℤ), P z → z ≤ b) (Hb' : ∀ (z : ℤ), P z → z ≤ b')
(Hinh : ∃ z, P z), ↑(b.greatestOfBdd Hb Hinh) = ↑(b'.greatestOfBdd Hb' Hinh) | null | false |
ENNReal.instDistribLattice._proof_6 | Mathlib.Basic.ENNReal.Basic | ∀ (x y z : ENNReal), min (max x y) (max x z) ≤ max x (min y z) | null | false |
IsSelfAdjoint.eq_smul_self_of_isLocalExtrOn | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E},
IsSelfAdjoint T →
∀ {x₀ : E}, IsLocalExtrOn T.reApplyInnerSelf (Metric.sphere 0 ‖x₀‖) x₀ → T x₀ = ↑(T.rayleighQuotient x₀) • x₀ | null | true |
Lean.Parser.Term.prop.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
RelIso.instFunLike._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop},
Function.Injective ((fun e => ⇑e) ∘ RelIso.toEquiv) | null | false |
MulChar.ringHomComp_pow | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommRing R'] {R'' : Type u_3} [inst_2 : CommRing R'']
(χ : MulChar R R') (f : R' →+* R'') (n : ℕ), χ.ringHomComp f ^ n = (χ ^ n).ringHomComp f | null | true |
ringChar | Mathlib.Algebra.CharP.Defs | (R : Type u_1) → [NonAssocSemiring R] → ℕ | Noncomputable function that outputs the unique characteristic of a semiring. | true |
RingCon.unop | Mathlib.RingTheory.Congruence.Opposite | {R : Type u_1} → [inst : Add R] → [inst_1 : Mul R] → RingCon Rᵐᵒᵖ → RingCon R | If `c` is a `RingCon Rᵐᵒᵖ`, then `(a, b) ↦ c b.op a.op` is a `RingCon R`.
| true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_2 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Pi.instAddTorsor._proof_1 | Mathlib.Algebra.Torsor.Basic | ∀ {I : Type u_1} {fg : I → Type u_3} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type u_2}
[(i : I) → AddTorsor (fg i) (fp i)], Nonempty ((a : I) → fp a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.