File: Mathlib/RingTheory/WittVector/FrobeniusFractionField.lean

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

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

full_name: WittVector.RecursionMain.succNthDefiningPoly
code: /-- The root of this polynomial determines the `n+1`st coefficient of our solution. -/
def succNthDefiningPoly (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) : Polynomial k 
goal: Polynomial k

full_name: WittVector.RecursionMain.succNthDefiningPoly_degree
code: theorem succNthDefiningPoly_degree [IsDomain k] (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k)
    (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    (succNthDefiningPoly p n a₁ a₂ bs).degree = p 
goal: (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).degree = ↑p

full_name: WittVector.RecursionMain.root_exists
code: theorem root_exists (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) : ∃ b : k, (succNthDefiningPoly p n a₁ a₂ bs).IsRoot b 
goal: ∃ b, (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).IsRoot b

full_name: WittVector.RecursionMain.succNthVal
code: /-- This is the `n+1`st coefficient of our solution, projected from `root_exists`. -/
def succNthVal (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) : k 
goal: k

full_name: WittVector.RecursionMain.succNthVal_spec
code: theorem succNthVal_spec (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) :
    (succNthDefiningPoly p n a₁ a₂ bs).IsRoot (succNthVal p n a₁ a₂ bs ha₁ ha₂) 
goal: (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).IsRoot
  (WittVector.RecursionMain.succNthVal p n a₁ a₂ bs ha₁ ha₂)

full_name: WittVector.RecursionMain.succNthVal_spec'
code: theorem succNthVal_spec' (n : ℕ) (a₁ a₂ : 𝕎 k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) :
    succNthVal p n a₁ a₂ bs ha₁ ha₂ ^ p * a₁.coeff 0 ^ p ^ (n + 1) +
          a₁.coeff (n + 1) * (bs 0 ^ p) ^ p ^ (n + 1) +
        nthRemainder p n (fun v => bs v ^ p) (truncateFun (n + 1) a₁) =
      succNthVal p n a₁ a₂ bs ha₁ ha₂ * a₂.coeff 0 ^ p ^ (n + 1) +
          a₂.coeff (n + 1) * bs 0 ^ p ^ (n + 1) +
        nthRemainder p n bs (truncateFun (n + 1) a₂) 
goal: WittVector.RecursionMain.succNthVal p n a₁ a₂ bs ha₁ ha₂ ^ p * a₁.coeff 0 ^ p ^ (n + 1) +
      a₁.coeff (n + 1) * (bs 0 ^ p) ^ p ^ (n + 1) +
    WittVector.nthRemainder p n (fun v => bs v ^ p) (WittVector.truncateFun (n + 1) a₁) =
  WittVector.RecursionMain.succNthVal p n a₁ a₂ bs ha₁ ha₂ * a₂.coeff 0 ^ p ^ (n + 1) +
      a₂.coeff (n + 1) * bs 0 ^ p ^ (n + 1) +
    WittVector.nthRemainder p n bs (WittVector.truncateFun (n + 1) a₂)

full_name: WittVector.RecursionBase.solution_pow
code: theorem solution_pow (a₁ a₂ : 𝕎 k) : ∃ x : k, x ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0 
goal: ∃ x, x ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0

full_name: WittVector.RecursionBase.solution
code: /-- The base case (0th coefficient) of our solution vector. -/
def solution (a₁ a₂ : 𝕎 k) : k 
goal: k

full_name: WittVector.RecursionBase.solution_spec
code: theorem solution_spec (a₁ a₂ : 𝕎 k) : solution p a₁ a₂ ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0 
goal: WittVector.RecursionBase.solution p a₁ a₂ ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0

full_name: WittVector.RecursionBase.solution_nonzero
code: theorem solution_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    solution p a₁ a₂ ≠ 0 
goal: WittVector.RecursionBase.solution p a₁ a₂ ≠ 0

full_name: WittVector.RecursionBase.solution_spec'
code: theorem solution_spec' {a₁ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (a₂ : 𝕎 k) :
    solution p a₁ a₂ ^ p * a₁.coeff 0 = solution p a₁ a₂ * a₂.coeff 0 
goal: WittVector.RecursionBase.solution p a₁ a₂ ^ p * a₁.coeff 0 = WittVector.RecursionBase.solution p a₁ a₂ * a₂.coeff 0

full_name: WittVector.frobeniusRotationCoeff
code: /-- Recursively defines the sequence of coefficients for `WittVector.frobeniusRotation`.
-/
-- Constructions by well-founded recursion are by default irreducible.
-- As we rely on definitional properties below, we mark this `@[semireducible]`.
@[semireducible] noncomputable def frobeniusRotationCoeff {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0)
    (ha₂ : a₂.coeff 0 ≠ 0) : ℕ → k
  
goal: ℕ → k

full_name: WittVector.frobeniusRotation
code: /-- For nonzero `a₁` and `a₂`, `frobeniusRotation a₁ a₂` is a Witt vector that satisfies the
equation `frobenius (frobeniusRotation a₁ a₂) * a₁ = (frobeniusRotation a₁ a₂) * a₂`.
-/
def frobeniusRotation {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) : 𝕎 k 
goal: WittVector p k

full_name: WittVector.frobeniusRotation_nonzero
code: theorem frobeniusRotation_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    frobeniusRotation p ha₁ ha₂ ≠ 0 
goal: WittVector.frobeniusRotation p ha₁ ha₂ ≠ 0

full_name: WittVector.frobenius_frobeniusRotation
code: theorem frobenius_frobeniusRotation {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    frobenius (frobeniusRotation p ha₁ ha₂) * a₁ = frobeniusRotation p ha₁ ha₂ * a₂ 
goal: WittVector.frobenius (WittVector.frobeniusRotation p ha₁ ha₂) * a₁ = WittVector.frobeniusRotation p ha₁ ha₂ * a₂

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_FrobeniusFractionField___macroRules_WittVector_termφ_1
code: local notation "φ" => IsFractionRing.fieldEquivOfRingEquiv (frobeniusEquiv p k)
goal: Lean.Macro

full_name: WittVector._aux_Mathlib_RingTheory_WittVector_FrobeniusFractionField___unexpand_IsFractionRing_fieldEquivOfRingEquiv_1
code: local notation "φ" => IsFractionRing.fieldEquivOfRingEquiv (frobeniusEquiv p k)
goal: Lean.PrettyPrinter.Unexpander

full_name: WittVector.exists_frobenius_solution_fractionRing_aux
code: theorem exists_frobenius_solution_fractionRing_aux (m n : ℕ) (r' q' : 𝕎 k) (hr' : r'.coeff 0 ≠ 0)
    (hq' : q'.coeff 0 ≠ 0) (hq : (p : 𝕎 k) ^ n * q' ∈ nonZeroDivisors (𝕎 k)) :
    let b : 𝕎 k := frobeniusRotation p hr' hq'
    IsFractionRing.fieldEquivOfRingEquiv (frobeniusEquiv p k)
          (algebraMap (𝕎 k) (FractionRing (𝕎 k)) b) *
        Localization.mk ((p : 𝕎 k) ^ m * r') ⟨(p : 𝕎 k) ^ n * q', hq⟩ =
      (p : Localization (nonZeroDivisors (𝕎 k))) ^ (m - n : ℤ) *
        algebraMap (𝕎 k) (FractionRing (𝕎 k)) b 
goal: let b := WittVector.frobeniusRotation p hr' hq';
(IsFractionRing.fieldEquivOfRingEquiv (WittVector.frobeniusEquiv p k))
      ((algebraMap (WittVector p k) (FractionRing (WittVector p k))) b) *
    Localization.mk (↑p ^ m * r') ⟨↑p ^ n * q', hq⟩ =
  ↑p ^ (↑m - ↑n) * (algebraMap (WittVector p k) (FractionRing (WittVector p k))) b

full_name: WittVector.exists_frobenius_solution_fractionRing
code: theorem exists_frobenius_solution_fractionRing {a : FractionRing (𝕎 k)} (ha : a ≠ 0) :
    ∃ᵉ (b ≠ 0) (m : ℤ), φ b * a = (p : FractionRing (𝕎 k)) ^ m * b 
goal: ∃ b, b ≠ 0 ∧ ∃ m, (IsFractionRing.fieldEquivOfRingEquiv (WittVector.frobeniusEquiv p k)) b * a = ↑p ^ m * b