Truncated Witt vectors

The ring of truncated Witt vectors (of length n) is a quotient of the ring of Witt vectors. It retains the first n coefficients of each Witt vector. In this file, we set up the basic quotient API for this ring.

The ring of Witt vectors is the projective limit of all the rings of truncated Witt vectors.

Main declarations

• TruncatedWittVector: the underlying type of the ring of truncated Witt vectors
• TruncatedWittVector.instCommRing: the ring structure on truncated Witt vectors
• WittVector.truncate: the quotient homomorphism that truncates a Witt vector, to obtain a truncated Witt vector
• TruncatedWittVector.truncate: the homomorphism that truncates a truncated Witt vector of length n to one of length m (for some m ≤ n)
• WittVector.lift: the unique ring homomorphism into the ring of Witt vectors that is compatible with a family of ring homomorphisms to the truncated Witt vectors: this realizes the ring of Witt vectors as projective limit of the rings of truncated Witt vectors

References

• [Hazewinkel, Witt Vectors][Haze09]

• [Commelin and Lewis, Formalizing the Ring of Witt Vectors][CL21]

def TruncatedWittVector : ℕ → ℕ → Type u_2 → Type u_2

A truncated Witt vector over R is a vector of elements of R, i.e., the first n coefficients of a Witt vector. We will define operations on this type that are compatible with the (untruncated) Witt vector operations.

TruncatedWittVector p n R takes a parameter p : ℕ that is not used in the definition. In practice, this number p is assumed to be a prime number, and under this assumption we construct a ring structure on TruncatedWittVector p n R. (TruncatedWittVector p₁ n R and TruncatedWittVector p₂ n R are definitionally equal as types but will have different ring operations.)

Equations

• TruncatedWittVector x n R = (Fin n → R)

instance instInhabitedTruncatedWittVector (p : ℕ) (n : ℕ) (R : Type u_2) [Inhabited R] : Inhabited (TruncatedWittVector p n R)

Equations

• instInhabitedTruncatedWittVector p n R = { default := fun (x : Fin n) => default }

def TruncatedWittVector.mk (p : ℕ) {n : ℕ} {R : Type u_1} (x : Fin n → R) : TruncatedWittVector p n R

Create a TruncatedWittVector from a vector x.

Equations

• TruncatedWittVector.mk p x = x

def TruncatedWittVector.coeff {p : ℕ} {n : ℕ} {R : Type u_1} (i : Fin n) (x : TruncatedWittVector p n R) : R

x.coeff i is the ith entry of x.

Equations

• TruncatedWittVector.coeff i x = x i

theorem TruncatedWittVector.ext {p : ℕ} {n : ℕ} {R : Type u_1} {x : TruncatedWittVector p n R} {y : TruncatedWittVector p n R} (h : ∀ (i : Fin n), TruncatedWittVector.coeff i x = TruncatedWittVector.coeff i y) : x = y

@[simp]

theorem TruncatedWittVector.coeff_mk {p : ℕ} {n : ℕ} {R : Type u_1} (x : Fin n → R) (i : Fin n) : TruncatedWittVector.coeff i (TruncatedWittVector.mk p x) = x i

@[simp]

theorem TruncatedWittVector.mk_coeff {p : ℕ} {n : ℕ} {R : Type u_1} (x : TruncatedWittVector p n R) : (TruncatedWittVector.mk p fun (i : Fin n) => TruncatedWittVector.coeff i x) = x

def TruncatedWittVector.out {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] (x : TruncatedWittVector p n R) : WittVector p R

We can turn a truncated Witt vector x into a Witt vector by setting all coefficients after x to be 0.

Equations

• x.out = { coeff := fun (i : ℕ) => if h : i < n then TruncatedWittVector.coeff ⟨i, h⟩ x else 0 }

@[simp]

theorem TruncatedWittVector.coeff_out {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] (x : TruncatedWittVector p n R) (i : Fin n) : x.out.coeff ↑i = TruncatedWittVector.coeff i x

theorem TruncatedWittVector.out_injective {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] : Function.Injective TruncatedWittVector.out

def WittVector.truncateFun {p : ℕ} (n : ℕ) {R : Type u_1} (x : WittVector p R) : TruncatedWittVector p n R

truncateFun n x uses the first n entries of x to construct a TruncatedWittVector, which has the same base p as x. This function is bundled into a ring homomorphism in WittVector.truncate

Equations

• WittVector.truncateFun n x = TruncatedWittVector.mk p fun (i : Fin n) => x.coeff ↑i

@[simp]

theorem WittVector.coeff_truncateFun {p : ℕ} {n : ℕ} {R : Type u_1} (x : WittVector p R) (i : Fin n) : TruncatedWittVector.coeff i (WittVector.truncateFun n x) = x.coeff ↑i

@[simp]

theorem WittVector.out_truncateFun {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] (x : WittVector p R) : (WittVector.truncateFun n x).out = WittVector.init n x

@[simp]

theorem TruncatedWittVector.truncateFun_out {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] (x : TruncatedWittVector p n R) : WittVector.truncateFun n x.out = x

instance TruncatedWittVector.instZero (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Zero (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instZero p n R = { zero := WittVector.truncateFun n 0 }

instance TruncatedWittVector.instOne (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : One (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instOne p n R = { one := WittVector.truncateFun n 1 }

instance TruncatedWittVector.instNatCast (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : NatCast (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instNatCast p n R = { natCast := fun (i : ℕ) => WittVector.truncateFun n ↑i }

instance TruncatedWittVector.instIntCast (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : IntCast (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instIntCast p n R = { intCast := fun (i : ℤ) => WittVector.truncateFun n ↑i }

instance TruncatedWittVector.instAdd (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Add (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instAdd p n R = { add := fun (x y : TruncatedWittVector p n R) => WittVector.truncateFun n (x.out + y.out) }

instance TruncatedWittVector.instMul (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Mul (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instMul p n R = { mul := fun (x y : TruncatedWittVector p n R) => WittVector.truncateFun n (x.out * y.out) }

instance TruncatedWittVector.instNeg (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Neg (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instNeg p n R = { neg := fun (x : TruncatedWittVector p n R) => WittVector.truncateFun n (-x.out) }

instance TruncatedWittVector.instSub (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Sub (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instSub p n R = { sub := fun (x y : TruncatedWittVector p n R) => WittVector.truncateFun n (x.out - y.out) }

instance TruncatedWittVector.hasNatScalar (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : SMul ℕ (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.hasNatScalar p n R = { smul := fun (m : ℕ) (x : TruncatedWittVector p n R) => WittVector.truncateFun n (m • x.out) }

instance TruncatedWittVector.hasIntScalar (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : SMul ℤ (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.hasIntScalar p n R = { smul := fun (m : ℤ) (x : TruncatedWittVector p n R) => WittVector.truncateFun n (m • x.out) }

instance TruncatedWittVector.hasNatPow (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Pow (TruncatedWittVector p n R) ℕ

Equations

• TruncatedWittVector.hasNatPow p n R = { pow := fun (x : TruncatedWittVector p n R) (m : ℕ) => WittVector.truncateFun n (x.out ^ m) }

@[simp]

theorem TruncatedWittVector.coeff_zero (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] (i : Fin n) : TruncatedWittVector.coeff i 0 = 0

def witt_truncateFun_tac : Lean.ParserDescr

A macro tactic used to prove that truncateFun respects ring operations.

Equations

• witt_truncateFun_tac = Lean.ParserDescr.node `witt_truncateFun_tac 1024 (Lean.ParserDescr.nonReservedSymbol "witt_truncateFun_tac" false)

theorem WittVector.truncateFun_surjective (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] : Function.Surjective (WittVector.truncateFun n)

@[simp]

theorem WittVector.truncateFun_zero (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : WittVector.truncateFun n 0 = 0

@[simp]

theorem WittVector.truncateFun_one (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : WittVector.truncateFun n 1 = 1

@[simp]

theorem WittVector.truncateFun_add {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) (y : WittVector p R) : WittVector.truncateFun n (x + y) = WittVector.truncateFun n x + WittVector.truncateFun n y

@[simp]

theorem WittVector.truncateFun_mul {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) (y : WittVector p R) : WittVector.truncateFun n (x * y) = WittVector.truncateFun n x * WittVector.truncateFun n y

theorem WittVector.truncateFun_neg {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) : WittVector.truncateFun n (-x) = -WittVector.truncateFun n x

theorem WittVector.truncateFun_sub {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) (y : WittVector p R) : WittVector.truncateFun n (x - y) = WittVector.truncateFun n x - WittVector.truncateFun n y

theorem WittVector.truncateFun_nsmul {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℕ) (x : WittVector p R) : WittVector.truncateFun n (m • x) = m • WittVector.truncateFun n x

theorem WittVector.truncateFun_zsmul {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℤ) (x : WittVector p R) : WittVector.truncateFun n (m • x) = m • WittVector.truncateFun n x

theorem WittVector.truncateFun_pow {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) (m : ℕ) : WittVector.truncateFun n (x ^ m) = WittVector.truncateFun n x ^ m

theorem WittVector.truncateFun_natCast {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℕ) : WittVector.truncateFun n ↑m = ↑m

@[deprecated WittVector.truncateFun_natCast]

theorem WittVector.truncateFun_nat_cast {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℕ) : WittVector.truncateFun n ↑m = ↑m

Alias of WittVector.truncateFun_natCast.

theorem WittVector.truncateFun_intCast {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℤ) : WittVector.truncateFun n ↑m = ↑m

@[deprecated WittVector.truncateFun_intCast]

theorem WittVector.truncateFun_int_cast {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (m : ℤ) : WittVector.truncateFun n ↑m = ↑m

Alias of WittVector.truncateFun_intCast.

instance TruncatedWittVector.instCommRing (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : CommRing (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instCommRing p n R = Function.Surjective.commRing (WittVector.truncateFun n) ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯

noncomputable def WittVector.truncate {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] : WittVector p R →+* TruncatedWittVector p n R

truncate n is a ring homomorphism that truncates x to its first n entries to obtain a TruncatedWittVector, which has the same base p as x.

Equations

• WittVector.truncate n = { toFun := WittVector.truncateFun n, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

theorem WittVector.truncate_surjective (p : ℕ) (n : ℕ) (R : Type u_1) [CommRing R] [Fact (Nat.Prime p)] : Function.Surjective ⇑(WittVector.truncate n)

@[simp]

theorem WittVector.coeff_truncate {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) (i : Fin n) : TruncatedWittVector.coeff i ((WittVector.truncate n) x) = x.coeff ↑i

theorem WittVector.mem_ker_truncate {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (x : WittVector p R) : x ∈ RingHom.ker (WittVector.truncate n) ↔ ∀ i < n, x.coeff i = 0

@[simp]

theorem WittVector.truncate_mk' (p : ℕ) (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] (f : ℕ → R) : (WittVector.truncate n) { coeff := f } = TruncatedWittVector.mk p fun (k : Fin n) => f ↑k

def TruncatedWittVector.truncate {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) : TruncatedWittVector p m R →+* TruncatedWittVector p n R

A ring homomorphism that truncates a truncated Witt vector of length m to a truncated Witt vector of length n, for n ≤ m.

Equations

• TruncatedWittVector.truncate hm = ((WittVector.truncate m).liftOfRightInverse TruncatedWittVector.out ⋯) ⟨WittVector.truncate n, ⋯⟩

@[simp]

theorem TruncatedWittVector.truncate_comp_wittVector_truncate {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) : (TruncatedWittVector.truncate hm).comp (WittVector.truncate m) = WittVector.truncate n

@[simp]

theorem TruncatedWittVector.truncate_wittVector_truncate {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) (x : WittVector p R) : (TruncatedWittVector.truncate hm) ((WittVector.truncate m) x) = (WittVector.truncate n) x

@[simp]

theorem TruncatedWittVector.truncate_truncate {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {n₁ : ℕ} {n₂ : ℕ} {n₃ : ℕ} (h1 : n₁ ≤ n₂) (h2 : n₂ ≤ n₃) (x : TruncatedWittVector p n₃ R) : (TruncatedWittVector.truncate h1) ((TruncatedWittVector.truncate h2) x) = (TruncatedWittVector.truncate ⋯) x

@[simp]

theorem TruncatedWittVector.truncate_comp {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {n₁ : ℕ} {n₂ : ℕ} {n₃ : ℕ} (h1 : n₁ ≤ n₂) (h2 : n₂ ≤ n₃) : (TruncatedWittVector.truncate h1).comp (TruncatedWittVector.truncate h2) = TruncatedWittVector.truncate ⋯

theorem TruncatedWittVector.truncate_surjective {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) : Function.Surjective ⇑(TruncatedWittVector.truncate hm)

@[simp]

theorem TruncatedWittVector.coeff_truncate {p : ℕ} {n : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) (i : Fin n) (x : TruncatedWittVector p m R) : TruncatedWittVector.coeff i ((TruncatedWittVector.truncate hm) x) = TruncatedWittVector.coeff (Fin.castLE hm i) x

instance TruncatedWittVector.instFintype {p : ℕ} {n : ℕ} {R : Type u_2} [Fintype R] : Fintype (TruncatedWittVector p n R)

Equations

• TruncatedWittVector.instFintype = Pi.fintype

theorem TruncatedWittVector.card (p : ℕ) (n : ℕ) {R : Type u_2} [Fintype R] : Fintype.card (TruncatedWittVector p n R) = Fintype.card R ^ n

theorem TruncatedWittVector.iInf_ker_truncate {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] : ⨅ (i : ℕ), RingHom.ker (WittVector.truncate i) = ⊥

def WittVector.liftFun {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] (f : (k : ℕ) → S →+* TruncatedWittVector p k R) (s : S) : WittVector p R

Given a family fₖ : S → TruncatedWittVector p k R and s : S, we produce a Witt vector by defining the kth entry to be the final entry of fₖ s.

Equations

• WittVector.liftFun f s = { coeff := fun (k : ℕ) => TruncatedWittVector.coeff (Fin.last k) ((f (k + 1)) s) }

@[simp]

theorem WittVector.truncate_liftFun {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] {f : (k : ℕ) → S →+* TruncatedWittVector p k R} (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) (s : S) : (WittVector.truncate n) (WittVector.liftFun f s) = (f n) s

def WittVector.lift {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] (f : (k : ℕ) → S →+* TruncatedWittVector p k R) (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) : S →+* WittVector p R

Given compatible ring homs from S into TruncatedWittVector n for each n, we can lift these to a ring hom S → 𝕎 R.

lift defines the universal property of 𝕎 R as the inverse limit of TruncatedWittVector n.

Equations

• WittVector.lift f f_compat = { toFun := WittVector.liftFun f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }

@[simp]

theorem WittVector.truncate_lift {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] {f : (k : ℕ) → S →+* TruncatedWittVector p k R} (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) (s : S) : (WittVector.truncate n) ((WittVector.lift f f_compat) s) = (f n) s

@[simp]

theorem WittVector.truncate_comp_lift {p : ℕ} (n : ℕ) {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] {f : (k : ℕ) → S →+* TruncatedWittVector p k R} (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) : (WittVector.truncate n).comp (WittVector.lift f f_compat) = f n

theorem WittVector.lift_unique {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] {f : (k : ℕ) → S →+* TruncatedWittVector p k R} (f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) (g : S →+* WittVector p R) (g_compat : ∀ (k : ℕ), (WittVector.truncate k).comp g = f k) : WittVector.lift f f_compat = g

The uniqueness part of the universal property of 𝕎 R.

def WittVector.liftEquiv {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] : { f : (k : ℕ) → S →+* TruncatedWittVector p k R // ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁ } ≃ (S →+* WittVector p R)

The universal property of 𝕎 R as projective limit of truncated Witt vector rings.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem WittVector.liftEquiv_apply {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] (f : { f : (k : ℕ) → S →+* TruncatedWittVector p k R // ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁ }) : WittVector.liftEquiv f = WittVector.lift ↑f ⋯

@[simp]

theorem WittVector.liftEquiv_symm_apply_coe {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] (g : S →+* WittVector p R) (k : ℕ) : ↑(WittVector.liftEquiv.symm g) k = (WittVector.truncate k).comp g

theorem WittVector.hom_ext {p : ℕ} {R : Type u_1} [CommRing R] [Fact (Nat.Prime p)] {S : Type u_2} [Semiring S] (g₁ : S →+* WittVector p R) (g₂ : S →+* WittVector p R) (h : ∀ (k : ℕ), (WittVector.truncate k).comp g₁ = (WittVector.truncate k).comp g₂) : g₁ = g₂