File: Mathlib/RingTheory/WittVector/Frobenius.lean

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Frobenius___unexpand_WittVector_1
code: local notation "𝕎" => WittVector p
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Frobenius___macroRules_WittVector_term𝕎_1
code: local notation "𝕎" => WittVector p
goal: Lean.Macro

full_name: WittVector.frobeniusPolyRat
code: /-- The rational polynomials that give the coefficients of `frobenius x`,
in terms of the coefficients of `x`.
These polynomials actually have integral coefficients,
see `frobeniusPoly` and `map_frobeniusPoly`. -/
def frobeniusPolyRat (n : ℕ) : MvPolynomial ℕ ℚ 
goal: MvPolynomial ℕ ℚ

full_name: WittVector.bind₁_frobeniusPolyRat_wittPolynomial
code: theorem bind₁_frobeniusPolyRat_wittPolynomial (n : ℕ) :
    bind₁ (frobeniusPolyRat p) (wittPolynomial p ℚ n) = wittPolynomial p ℚ (n + 1) 
goal: (MvPolynomial.bind₁ (WittVector.frobeniusPolyRat p)) (wittPolynomial p ℚ n) = wittPolynomial p ℚ (n + 1)

full_name: _private.Mathlib.RingTheory.WittVector.Frobenius.0.WittVector.pnat_multiplicity
code: /-- An auxiliary definition, to avoid an excessive amount of finiteness proofs
for `multiplicity p n`. -/
private def pnat_multiplicity (n : ℕ+) : ℕ 
goal: ℕ

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Frobenius___unexpand__private_Mathlib_RingTheory_WittVector_Frobenius_0_WittVector_pnat_multiplicity_1
code: local notation "v" => pnat_multiplicity
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_Frobenius___macroRules_WittVector_termV_1
code: local notation "v" => pnat_multiplicity
goal: Lean.Macro

full_name: WittVector.frobeniusPolyAux
code: /-- An auxiliary polynomial over the integers, that satisfies
`p * (frobeniusPolyAux p n) + X n ^ p = frobeniusPoly p n`.
This makes it easy to show that `frobeniusPoly p n` is congruent to `X n ^ p`
modulo `p`. -/
noncomputable def frobeniusPolyAux : ℕ → MvPolynomial ℕ ℤ
  
goal: ℕ → MvPolynomial ℕ ℤ

full_name: WittVector.frobeniusPolyAux_eq
code: theorem frobeniusPolyAux_eq (n : ℕ) :
    frobeniusPolyAux p n =
      X (n + 1) - ∑ i ∈ range n,
          ∑ j ∈ range (p ^ (n - i)),
            (X i ^ p) ^ (p ^ (n - i) - (j + 1)) * frobeniusPolyAux p i ^ (j + 1) *
              C ↑((p ^ (n - i)).choose (j + 1) / p ^ (n - i - v p ⟨j + 1, Nat.succ_pos j⟩) *
                ↑p ^ (j - v p ⟨j + 1, Nat.succ_pos j⟩) : ℕ) 
goal: WittVector.frobeniusPolyAux p n =
  MvPolynomial.X (n + 1) -
    ∑ i ∈ Finset.range n,
      ∑ j ∈ Finset.range (p ^ (n - i)),
        (MvPolynomial.X i ^ p) ^ (p ^ (n - i) - (j + 1)) * WittVector.frobeniusPolyAux p i ^ (j + 1) *
          MvPolynomial.C
            ↑((p ^ (n - i)).choose (j + 1) / p ^ (n - i - WittVector.pnat_multiplicity p ⟨j + 1, ⋯⟩) *
                p ^ (j - WittVector.pnat_multiplicity p ⟨j + 1, ⋯⟩))

full_name: WittVector.frobeniusPoly
code: /-- The polynomials that give the coefficients of `frobenius x`,
in terms of the coefficients of `x`. -/
def frobeniusPoly (n : ℕ) : MvPolynomial ℕ ℤ 
goal: MvPolynomial ℕ ℤ

full_name: WittVector.map_frobeniusPoly.key₁
code: /-- A key divisibility fact for the proof of `WittVector.map_frobeniusPoly`. -/
theorem map_frobeniusPoly.key₁ (n j : ℕ) (hj : j < p ^ n) :
    p ^ (n - v p ⟨j + 1, j.succ_pos⟩) ∣ (p ^ n).choose (j + 1) 
goal: p ^ (n - WittVector.pnat_multiplicity p ⟨j + 1, ⋯⟩) ∣ (p ^ n).choose (j + 1)

full_name: WittVector.map_frobeniusPoly.key₂
code: /-- A key numerical identity needed for the proof of `WittVector.map_frobeniusPoly`. -/
theorem map_frobeniusPoly.key₂ {n i j : ℕ} (hi : i ≤ n) (hj : j < p ^ (n - i)) :
    j - v p ⟨j + 1, j.succ_pos⟩ + n = i + j + (n - i - v p ⟨j + 1, j.succ_pos⟩) 
goal: j - WittVector.pnat_multiplicity p ⟨j + 1, ⋯⟩ + n = i + j + (n - i - WittVector.pnat_multiplicity p ⟨j + 1, ⋯⟩)

full_name: WittVector.map_frobeniusPoly
code: theorem map_frobeniusPoly (n : ℕ) :
    MvPolynomial.map (Int.castRingHom ℚ) (frobeniusPoly p n) = frobeniusPolyRat p n 
goal: (MvPolynomial.map (Int.castRingHom ℚ)) (WittVector.frobeniusPoly p n) = WittVector.frobeniusPolyRat p n

full_name: WittVector.frobeniusPoly_zmod
code: theorem frobeniusPoly_zmod (n : ℕ) :
    MvPolynomial.map (Int.castRingHom (ZMod p)) (frobeniusPoly p n) = X n ^ p 
goal: (MvPolynomial.map (Int.castRingHom (ZMod p))) (WittVector.frobeniusPoly p n) = MvPolynomial.X n ^ p

full_name: WittVector.bind₁_frobeniusPoly_wittPolynomial
code: @[simp]
theorem bind₁_frobeniusPoly_wittPolynomial (n : ℕ) :
    bind₁ (frobeniusPoly p) (wittPolynomial p ℤ n) = wittPolynomial p ℤ (n + 1) 
goal: (MvPolynomial.bind₁ (WittVector.frobeniusPoly p)) (wittPolynomial p ℤ n) = wittPolynomial p ℤ (n + 1)

full_name: WittVector.frobeniusFun
code: /-- `frobeniusFun` is the function underlying the ring endomorphism
`frobenius : 𝕎 R →+* frobenius 𝕎 R`. -/
def frobeniusFun (x : 𝕎 R) : 𝕎 R 
goal: WittVector p R

full_name: WittVector.coeff_frobeniusFun
code: theorem coeff_frobeniusFun (x : 𝕎 R) (n : ℕ) :
    coeff (frobeniusFun x) n = MvPolynomial.aeval x.coeff (frobeniusPoly p n) 
goal: x.frobeniusFun.coeff n = (MvPolynomial.aeval x.coeff) (WittVector.frobeniusPoly p n)

full_name: WittVector.frobeniusFun_isPoly
code: /-- `frobeniusFun` is tautologically a polynomial function.

See also `frobenius_isPoly`. -/
-- Porting note: replaced `@[is_poly]` with `instance`.
instance frobeniusFun_isPoly : IsPoly p fun R _Rcr => @frobeniusFun p R _ _Rcr 
goal: WittVector.IsPoly p fun R _Rcr => WittVector.frobeniusFun

full_name: WittVector.ghostComponent_frobeniusFun
code: @[ghost_simps]
theorem ghostComponent_frobeniusFun (n : ℕ) (x : 𝕎 R) :
    ghostComponent n (frobeniusFun x) = ghostComponent (n + 1) x 
goal: (WittVector.ghostComponent n) x.frobeniusFun = (WittVector.ghostComponent (n + 1)) x

full_name: WittVector.frobenius
code: /-- If `R` has characteristic `p`, then there is a ring endomorphism
that raises `r : R` to the power `p`.
By applying `WittVector.map` to this endomorphism,
we obtain a ring endomorphism `frobenius R p : 𝕎 R →+* 𝕎 R`.

The underlying function of this morphism is `WittVector.frobeniusFun`.
-/
def frobenius : 𝕎 R →+* 𝕎 R 
goal: WittVector p R →+* WittVector p R

full_name: WittVector.coeff_frobenius
code: theorem coeff_frobenius (x : 𝕎 R) (n : ℕ) :
    coeff (frobenius x) n = MvPolynomial.aeval x.coeff (frobeniusPoly p n) 
goal: (WittVector.frobenius x).coeff n = (MvPolynomial.aeval x.coeff) (WittVector.frobeniusPoly p n)

full_name: WittVector.ghostComponent_frobenius
code: @[ghost_simps]
theorem ghostComponent_frobenius (n : ℕ) (x : 𝕎 R) :
    ghostComponent n (frobenius x) = ghostComponent (n + 1) x 
goal: (WittVector.ghostComponent n) (WittVector.frobenius x) = (WittVector.ghostComponent (n + 1)) x

full_name: WittVector.frobenius_isPoly
code: /-- `frobenius` is tautologically a polynomial function. -/
-- Porting note: replaced `@[is_poly]` with `instance`.
instance frobenius_isPoly : IsPoly p fun R _Rcr => @frobenius p R _ _Rcr 
goal: WittVector.IsPoly p fun R _Rcr => ⇑WittVector.frobenius

full_name: WittVector.coeff_frobenius_charP
code: @[simp]
theorem coeff_frobenius_charP (x : 𝕎 R) (n : ℕ) : coeff (frobenius x) n = x.coeff n ^ p 
goal: (WittVector.frobenius x).coeff n = x.coeff n ^ p

full_name: WittVector.frobenius_eq_map_frobenius
code: theorem frobenius_eq_map_frobenius : @frobenius p R _ _ = map (_root_.frobenius R p) 
goal: WittVector.frobenius = WittVector.map (frobenius R p)

full_name: WittVector.frobenius_zmodp
code: @[simp]
theorem frobenius_zmodp (x : 𝕎 (ZMod p)) : frobenius x = x 
goal: WittVector.frobenius x = x

full_name: WittVector.frobeniusEquiv_apply
code: /-- `WittVector.frobenius` as an equiv. -/
@[simps (config := .asFn)]
def frobeniusEquiv [PerfectRing R p] : WittVector p R ≃+* WittVector p R 
goal: ⇑(WittVector.frobeniusEquiv p R) = ⇑WittVector.frobenius

full_name: WittVector.frobeniusEquiv_symm_apply
code: /-- `WittVector.frobenius` as an equiv. -/
@[simps (config := .asFn)]
def frobeniusEquiv [PerfectRing R p] : WittVector p R ≃+* WittVector p R 
goal: ⇑(WittVector.frobeniusEquiv p R).symm = ⇑(WittVector.map ↑(frobeniusEquiv R p).symm)

full_name: WittVector.frobeniusEquiv
code: /-- `WittVector.frobenius` as an equiv. -/
@[simps (config := .asFn)]
def frobeniusEquiv [PerfectRing R p] : WittVector p R ≃+* WittVector p R 
goal: WittVector p R ≃+* WittVector p R

full_name: WittVector.frobenius_bijective
code: theorem frobenius_bijective [PerfectRing R p] :
    Function.Bijective (@WittVector.frobenius p R _ _) 
goal: Function.Bijective ⇑WittVector.frobenius