name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CochainComplex.HomComplex.coboundaries.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
CochainComplex.HomComplex.coboundaries K L n =
{ carrier := {α | ∃ m, ∃ (_ : m + 1 = n), ∃ β, CochainComplex.HomComplex.δ m n β = ↑α}, add_mem' := ⋯,
zero_mem' := ⋯, neg_mem' := ⋯ } |
FreeAddGroup.reduceCyclically.reduce_flatten_replicate_succ | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α],
FreeAddGroup.IsReduced L →
∀ (n : ℕ),
FreeAddGroup.reduce (List.replicate (n + 1) L).flatten =
FreeAddGroup.reduceCyclically.conjugator L ++
(List.replicate (n + 1) (FreeAddGroup.reduceCyclically L)).flatten ++
FreeAddGroup.negRev (FreeAddGroup.reduceCyclically.conjugator L) |
SubMulAction.algebraMap_mem | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
(algebraMap R A) r ∈ 1 |
IsCauSeq | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_3} →
[inst : Field α] →
[inst_1 : LinearOrder α] → [IsStrictOrderedRing α] → {β : Type u_4} → [Ring β] → (β → α) → (ℕ → β) → Prop |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.type?._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Order.Sublattice.0.Sublattice.le_prod_iff._simp_1_1 | Mathlib.Order.Sublattice | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T |
fderivWithin_csinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x |
Finsupp.equivFunOnFinite | Mathlib.Data.Finsupp.Defs | {α : Type u_1} → {M : Type u_4} → [inst : Zero M] → [Finite α] → (α →₀ M) ≃ (α → M) |
SimpleGraph.ConnectedComponent.map_mk | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} (φ : G →g G') (v : V),
SimpleGraph.ConnectedComponent.map φ (G.connectedComponentMk v) = G'.connectedComponentMk (φ v) |
Set.bounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Bounded (fun x1 x2 => x1 ≤ x2) s |
Std.Internal.List.length_le_length_insertListConst | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)},
l.length ≤ (Std.Internal.List.insertListConst l toInsert).length |
Path.target' | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} (self : Path x y), self.toFun 1 = y |
LinearMap.toMatrixRight'_id | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} [inst_1 : Fintype m] [inst_2 : DecidableEq m],
LinearMap.toMatrixRight' LinearMap.id = 1 |
differentiableAt_of_isInvertible_fderiv | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, (fderiv 𝕜 f x).IsInvertible → DifferentiableAt 𝕜 f x |
Std.DHashMap.Internal.Raw₀.equiv_iff_toList_perm_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m₁ m₂ : Std.DHashMap.Raw α β), m₁.Equiv m₂ ↔ m₁.toList.Perm m₂.toList |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n s : ℕ},
n + 1 ≤ (List.findIdxs p (head :: tail) s).length → n < (List.findIdxs p (head :: tail) s).length |
Polynomial.MonicDegreeEq.degree | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] [Nontrivial R] (p : Polynomial.MonicDegreeEq R n), (↑p).degree = ↑n |
Lean.Server.RequestCancellationToken._sizeOf_inst | Lean.Server.RequestCancellation | SizeOf Lean.Server.RequestCancellationToken |
DirectLimit.instGroup._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {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 : (i : ι) → Group (G i)] [inst_5 : ∀ (i j : ι) (h : i ≤ j), MonoidHomClass (T h) (G i) (G j)] (n : ℕ) (i : ι)
(x : G i),
DirectLimit.map f f (fun x x_1 => x_1 ^ Int.negSucc n) ⋯ ⟦⟨i, x⟩⟧ =
DirectLimit.map f f (fun x x_1 => x_1⁻¹) ⋯ (DirectLimit.map f f (fun x x_1 => x_1 ^ ↑n.succ) ⋯ ⟦⟨i, x⟩⟧) |
Nat.ceilRoot_eq_zero | Mathlib.Data.Nat.Factorization.Root | ∀ {a n : ℕ}, n.ceilRoot a = 0 ↔ n = 0 ∨ a = 0 |
AddSubgroupClass.subtype_injective | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_4} (H : S) [inst_1 : SetLike S G] [inst_2 : AddSubgroupClass S G],
Function.Injective ⇑↑H |
FiberwiseLinear.openPartialHomeomorph._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_3} {B : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {U : Set B} (φ : B → F ≃L[𝕜] F),
∀ _x ∈ U ×ˢ Set.univ, (_x.1, (φ _x.1).symm _x.2) ∈ U ×ˢ Set.univ |
Lean.Elab.Term.precheckFun._regBuiltin.Lean.Elab.Term.precheckFun_1 | Lean.Elab.Binders | IO Unit |
_private.Mathlib.Topology.Compactness.Lindelof.0.IsLindelof.elim_nhds_subcover._simp_1_5 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) |
ValuativeRel.supp._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R] {a b : R},
a ∈ {x | x ≤ᵥ 0} → b ∈ {x | x ≤ᵥ 0} → a + b ≤ᵥ 0 |
Std.ExtTreeSet.get?_max? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.max? = some km → t.get? km = some km |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_12 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (x₁ x₂ y₂ : ℕ), y₂ ≤ x₁ → y₂ ≤ x₂ → x₁ - y₂ = x₂ - y₂ → x₁ = x₂ |
HNNExtension.NormalWord.TransversalPair.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{t : HNNExtension.NormalWord.TransversalPair G A B} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{t' : HNNExtension.NormalWord.TransversalPair G' A' B'} →
G = G' →
inst ≍ inst' →
A ≍ A' → B ≍ B' → t ≍ t' → HNNExtension.NormalWord.TransversalPair.noConfusionType P t t' |
BitVec.getElem_eq_true_of_lt_of_le | Init.Data.BitVec.Lemmas | ∀ {w k : ℕ} {x : BitVec w} (hk' : k < w), x.toNat < 2 ^ (k + 1) → 2 ^ k ≤ x.toNat → x[k] = true |
Metric.ediam_image_le_iff | Mathlib.Topology.EMetricSpace.Diam | ∀ {α : Type u_1} {X : Type u_2} [inst : PseudoEMetricSpace X] {d : ENNReal} {f : α → X} {s : Set α},
Metric.ediam (f '' s) ≤ d ↔ ∀ x ∈ s, ∀ y ∈ s, edist (f x) (f y) ≤ d |
Dense.exists_seq_strictAnti_tendsto_of_lt | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {s : Set α},
Dense s →
∀ {x y : α}, x < y → ∃ u, StrictAnti u ∧ (∀ (n : ℕ), u n ∈ Set.Ioo x y ∩ s) ∧ Filter.Tendsto u Filter.atTop (nhds x) |
_private.Mathlib.Data.Quot.0.Quot.surjective_lift.match_1_1 | Mathlib.Data.Quot | ∀ {α : Sort u_1} {γ : Sort u_2} {f : α → γ} (y : γ) (motive : (∃ a, f a = y) → Prop) (x : ∃ a, f a = y),
(∀ (x : α) (hx : f x = y), motive ⋯) → motive x |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_6 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [inst : SMul M X] [inst_1 : SMul M Y]
[inst_2 : FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X), c • f x = f (c • x) |
Lean.Compiler.LCNF.Simp.State.simplified | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.State → Bool |
Real.one_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, 0 ≤ x → 1 ≤ Real.exp x |
ergodic_mul_left_of_denseRange_zpow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[SecondCountableTopology G] [BorelSpace G] {g : G},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure G) [MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [μ.IsMulLeftInvariant],
Ergodic (fun x => g * x) μ |
Language.map | Mathlib.Computability.Language | {α : Type u_1} → {β : Type u_2} → (α → β) → Language α →+* Language β |
Polynomial.iterate_derivative_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} (p q : Polynomial R),
(⇑Polynomial.derivative)^[n] (p * q) =
∑ k ∈ Finset.range n.succ, n.choose k • ((⇑Polynomial.derivative)^[n - k] p * (⇑Polynomial.derivative)^[k] q) |
Lean.Server.Test.Runner.Client.HighlightedSubexprInfo.ctorElim | Lean.Server.Test.Runner | {motive : Lean.Server.Test.Runner.Client.HighlightedSubexprInfo → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Server.Test.Runner.Client.HighlightedSubexprInfo) →
ctorIdx = t.ctorIdx → Lean.Server.Test.Runner.Client.HighlightedSubexprInfo.ctorElimType ctorIdx → motive t |
List.cyclicPermutations_of_ne_nil | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α),
l ≠ [] → l.cyclicPermutations = (List.zipWith (fun x1 x2 => x1 ++ x2) l.tails l.inits).dropLast |
IsCoprime.isRelPrime | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {a b : R}, IsCoprime a b → IsRelPrime a b |
Lean.Compiler.LCNF.Simp.instInhabitedFunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfo | Inhabited Lean.Compiler.LCNF.Simp.FunDeclInfo |
_private.Mathlib.Analysis.SpecialFunctions.Complex.CircleMap.0.eq_of_circleMap_eq._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | (Complex.I = 0) = False |
List.mem_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {as : List α}, x ∈ as.reverse ↔ x ∈ as |
Std.DTreeMap.Raw.WF.emptyc | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.WF |
finsum_eq_indicator_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M) (a : α),
∑ᶠ (_ : a ∈ s), f a = s.indicator f a |
_private.Mathlib.NumberTheory.Padics.PadicIntegers.0.PadicInt.coe_sum._simp_1_1 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (self : ↥(PadicInt.subring p)), ↑self = PadicInt.Coe.ringHom self |
Lean.Elab.Term.LetIdDeclView.binders | Lean.Elab.Binders | Lean.Elab.Term.LetIdDeclView → Array Lean.Syntax |
UpperSemicontinuousOn.add | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {γ : Type u_5} [inst_1 : AddCommMonoid γ]
[inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] [ContinuousAdd γ]
{f g : α → γ}, UpperSemicontinuousOn f s → UpperSemicontinuousOn g s → UpperSemicontinuousOn (fun z => f z + g z) s |
_private.Init.Data.List.Pairwise.0.List.Pairwise.imp.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} (motive : (x : List α) → List.Pairwise R x → Prop) (x : List α)
(x_1 : List.Pairwise R x),
(∀ (a : Unit), motive [] ⋯) →
(∀ (a : α) (l : List α) (h₁ : ∀ a' ∈ l, R a a') (h₂ : List.Pairwise R l), motive (a :: l) ⋯) → motive x x_1 |
Lean.Name.MatchUpToIndexSuffix.suffixMatch.elim | Batteries.Lean.Meta.UnusedNames | {motive : Lean.Name.MatchUpToIndexSuffix → Sort u} →
(t : Lean.Name.MatchUpToIndexSuffix) →
t.ctorIdx = 2 → ((i : ℕ) → motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) → motive t |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodingStepAux.match_5 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((n : Lean.Name) → (i : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj n i struct)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((v : Lean.Literal) → motive (Lean.Expr.lit v)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((x : Lean.Expr) → motive x) → motive x |
Stream'.Seq.update_cons_succ | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α) (n : ℕ),
(Stream'.Seq.cons hd tl).update (n + 1) f = Stream'.Seq.cons hd (tl.update n f) |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.denom_aux | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ (A B : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
↑(↑(A * B) 1 0) *
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) B)) ↑z =
↑(↑A 1 0) * ↑(↑B).det +
↑(↑B 1 0) *
UpperHalfPlane.denom
(Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) A) *
Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) B))
↑z |
Set.image_sub_const_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => x - a) '' Set.uIcc b c = Set.uIcc (b - a) (c - a) |
LibraryNote.continuity_lemma_statement | Mathlib.Topology.Continuous | Batteries.Util.LibraryNote |
FaithfulSMul.of_injective | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M' : Type u_1} {X : Type u_5} [inst : SMul M' X] {Y : Type u_6} [inst_1 : SMul M' Y] {F : Type u_8}
[inst_2 : FunLike F X Y] [FaithfulSMul M' X] [MulActionHomClass F M' X Y] (f : F),
Function.Injective ⇑f → FaithfulSMul M' Y |
szemeredi_regularity | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (G : SimpleGraph α) [inst_2 : DecidableRel G.Adj] {ε : ℝ}
{l : ℕ},
0 < ε →
l ≤ Fintype.card α →
∃ P, P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε |
SchwartzMap.toZeroAtInfty._proof_2 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (f : SchwartzMap E F), Continuous ⇑f |
Vector.finIdxOf?_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs : Array α} (h : xs.size = n) (x : α),
(Vector.mk xs h).finIdxOf? x = Option.map (Fin.cast h) (xs.finIdxOf? x) |
Finset.toRight | Mathlib.Data.Finset.Sum | {α : Type u_1} → {β : Type u_2} → Finset (α ⊕ β) → Finset β |
DirectedOn.le_of_minimal | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a b : α},
DirectedOn (fun x y => y ≤ x) s → Minimal (fun x => x ∈ s) a → b ∈ s → a ≤ b |
WittVector.instIsocrystalStandardOneDimIsocrystal._proof_2 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] [inst_2 : CharP k p]
[inst_3 : PerfectRing k p],
RingHomCompTriple (↑(WittVector.FractionRing.frobenius p k)) (RingHom.id (FractionRing (WittVector p k)))
↑(WittVector.FractionRing.frobenius p k) |
Sum.instLocallyFiniteOrder._proof_1 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a b x : α ⊕ β), x ∈ Finset.sumLift₂ Finset.Icc Finset.Icc a b ↔ a ≤ x ∧ x ≤ b |
CanonicallyOrderedAddCommMonoid.toAddCancelCommMonoid | Mathlib.Algebra.Order.Sub.Basic | (α : Type u_1) →
[inst : AddCommMonoid α] →
[inst_1 : PartialOrder α] → [inst_2 : Sub α] → [OrderedSub α] → [AddLeftReflectLE α] → AddCancelCommMonoid α |
Submodule.rank_sup_add_rank_inf_eq | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (s t : Submodule R M),
Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥t |
comp_partialSups | Mathlib.Order.PartialSups | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β]
[inst_2 : Preorder ι] [inst_3 : LocallyFiniteOrderBot ι] {F : Type u_4} [inst_4 : FunLike F α β] [SupHomClass F α β]
(f : ι → α) (g : F), ⇑(partialSups (⇑g ∘ f)) = ⇑g ∘ ⇑(partialSups f) |
Module.End.UnifEigenvalues.val | Mathlib.LinearAlgebra.Eigenspace.Basic | {R : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (f : Module.End R M) → (k : ℕ∞) → f.UnifEigenvalues k → R |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_eq_empty_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ε : ℝ} {s : Set α}, 0 < ε → (Metric.thickening ε s = ∅) = (s = ∅) |
CategoryTheory.GradedObject.mapBifunctorLeftUnitor_naturality | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_1} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) (X : C)
(e : F.obj X ≅ CategoryTheory.Functor.id D)
[inst_5 : ∀ (Y : D), CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) (F.flip.obj Y)]
(p : I × J → J) (hp : ∀ (j : J), p (0, j) = j) {Y Y' : CategoryTheory.GradedObject J D} (φ : Y ⟶ Y')
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor F I J).obj ((CategoryTheory.GradedObject.single₀ I).obj X)).obj
Y).HasMap
p]
[inst_7 :
(((CategoryTheory.GradedObject.mapBifunctor F I J).obj ((CategoryTheory.GradedObject.single₀ I).obj X)).obj
Y').HasMap
p],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.mapBifunctorMapMap F p
(CategoryTheory.CategoryStruct.id ((CategoryTheory.GradedObject.single₀ I).obj X)) φ)
(CategoryTheory.GradedObject.mapBifunctorLeftUnitor F X e p hp Y').hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapBifunctorLeftUnitor F X e p hp Y).hom φ |
Finset.addConst_neg_left | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : DecidableEq G] (A B : Finset G), (-A).addConst B = A.subConst B |
CategoryTheory.MorphismProperty.Over.pullbackMapHomPullback._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P : CategoryTheory.MorphismProperty T} {Y Z : T}
(g : Y ⟶ Z) [CategoryTheory.Limits.HasPullbacks T], P.HasPullbacksAlong g |
Congr!.Config._sizeOf_1 | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ |
Std.DHashMap.Internal.Raw₀.toList_map | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} (m : Std.DHashMap.Internal.Raw₀ α β) {f : (a : α) → β a → γ a},
(↑(Std.DHashMap.Internal.Raw₀.map f m)).toList.Perm (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) (↑m).toList) |
Turing.TM2to1.StAct.rec | Mathlib.Computability.TuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.peek a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.pop a)) →
(t : Turing.TM2to1.StAct K Γ σ k) → motive t |
CategoryTheory.Functor.CoconeTypes.IsColimit.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x |
Lean.Parser.doElemParser | Lean.Parser.Do | optParam ℕ 0 → Lean.Parser.Parser |
HasDerivAt.comp_sub_const | Mathlib.Analysis.Calculus.Deriv.Shift | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} (x a : 𝕜),
HasDerivAt f f' (x - a) → HasDerivAt (fun x => f (x - a)) f' x |
Aesop.Script.StepTree.toMessageData | Aesop.Script.UScriptToSScript | Aesop.Script.StepTree → Lean.MessageData |
IsFiniteLength.of_subsingleton._simp_1 | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Subsingleton M],
IsFiniteLength R M = True |
MeasureTheory.Measure.MutuallySingular.zero_left | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, MeasureTheory.Measure.MutuallySingular 0 μ |
Module.Basis.extendLe_subset | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V}
(hs : LinearIndepOn K id s) (hst : s ⊆ t) (ht : ⊤ ≤ Submodule.span K t),
Set.range ⇑(Module.Basis.extendLe hs hst ht) ⊆ t |
Lean.HeadIndex.lam.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.lam = 1 |
_private.Mathlib.Analysis.Normed.Group.Basic.0.nontrivialTopology_iff_exists_nnnorm_ne_zero'._simp_1_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, Inseparable x y = (nndist x y = 0) |
LinearIsometryEquiv.conjStarAlgEquiv._proof_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_2} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H],
SMulCommClass 𝕜 𝕜 H |
Std.Internal.List.minKey?_eq_some_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)} {he : l.isEmpty = false},
Std.Internal.List.minKey? l = some (Std.Internal.List.minKey l he) |
IsOrderedVAdd.vadd_le_vadd_right | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} {inst : LE G} {inst_1 : LE P} {inst_2 : VAdd G P} [self : IsOrderedVAdd G P] (c d : G),
c ≤ d → ∀ (a : P), c +ᵥ a ≤ d +ᵥ a |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal.trace_mem_dual_one._simp_1_2 | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L] [inst_11 : IsDomain A]
[inst_12 : IsFractionRing A K] [inst_13 : FiniteDimensional K L] [inst_14 : Algebra.IsSeparable K L]
[inst_15 : IsIntegralClosure B A L] [inst_16 : IsFractionRing B L] [inst_17 : IsIntegrallyClosed A]
[inst_18 : IsDedekindDomain B] {I : FractionalIdeal (nonZeroDivisors B) L},
I ≠ 0 → ∀ {x : L}, (x ∈ FractionalIdeal.dual A K I) = ∀ a ∈ I, ((Algebra.traceForm K L) x) a ∈ (algebraMap A K).range |
Std.IteratorLoop.WithWF.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{γ : Type x} →
{PlausibleForInStep : β → γ → ForInStep γ → Prop} →
{hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep} →
Std.IterM m β → γ → Std.IteratorLoop.WithWF α m PlausibleForInStep hwf |
RelIso.eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {a b : α}, f a = f b ↔ a = b |
CStarModule.innerₛₗ._proof_4 | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] (z : ℂ) (y : E),
{ toFun := fun y_1 => inner A (z • y) y_1, map_add' := ⋯, map_smul' := ⋯ } =
(starRingEnd ℂ) z • { toFun := fun y_1 => inner A y y_1, map_add' := ⋯, map_smul' := ⋯ } |
Batteries.RBNode.Balanced.del | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {c : Batteries.RBColor} {n : ℕ} {cut : α → Ordering} {t : Batteries.RBNode α},
t.Balanced c n → Batteries.RBNode.DelProp t.isBlack (Batteries.RBNode.del cut t) n |
Fin.insertNth_sub | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Sub (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x - y) (p - q) = i.insertNth x p - i.insertNth y q |
TrivSqZeroExt.instL1NormedRing._proof_16 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] (n : ℕ) (a : TrivSqZeroExt R M),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a |
Quaternion.imK_ratCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (q : ℚ), (↑q).imK = 0 |
_private.Qq.AssertInstancesCommute.0.Qq.Impl._aux_Qq_AssertInstancesCommute___elabRules_Qq_Impl_termAssertInstancesCommuteImpl__1.match_1 | Qq.AssertInstancesCommute | (motive :
Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»))) → Sort u_1) →
(__do_lift : Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»)))) →
((fvar : Lean.FVarId) →
(fst : Q(Lean.Level)) →
(fst_1 : Q(Q(Sort «$fst»))) →
(lhs rhs : Q(Q(«$$fst_1»))) → motive (some (fvar, ⟨fst, ⟨fst_1, (lhs, rhs)⟩⟩))) →
(Unit → motive none) → motive __do_lift |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin._simp_1_5 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) |
OrderAddMonoidHom.fst_apply | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (self : α × β), (OrderAddMonoidHom.fst α β) self = self.1 |
QuotientAddGroup.homQuotientZSMulOfHom_comp | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : AddCommGroup A] [inst_1 : AddCommGroup B] (f : A →+ B) (g : B →+ A) (n : ℤ),
QuotientAddGroup.homQuotientZSMulOfHom (f.comp g) n =
(QuotientAddGroup.homQuotientZSMulOfHom f n).comp (QuotientAddGroup.homQuotientZSMulOfHom g n) |
CategoryTheory.yonedaJointlyReflectsLimits._proof_1 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor J Cᵒᵖ) (c : CategoryTheory.Limits.Cone F)
(hc : (X : C) → CategoryTheory.Limits.IsLimit ((CategoryTheory.yoneda.obj X).mapCone c))
(s : CategoryTheory.Limits.Cone F) (j : J),
(CategoryTheory.CategoryStruct.comp
(Quiver.Hom.op
((hc (Opposite.unop s.pt)).lift ((CategoryTheory.yoneda.obj (Opposite.unop s.pt)).mapCone s)
(CategoryTheory.CategoryStruct.id (Opposite.unop s.pt))))
(c.π.app j)).unop =
(s.π.app j).unop |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.