ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Algebra.trace_trace
@[simp]
theorem trace_trace [Algebra S T] [IsScalarTower R S T]
    [Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T] (x : T) :
    trace R S (trace S T x) = trace R T x 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] [Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T] (x : T)
Goal: (Algebra.trace R S) ((Algebra.trace S T) x) = (Algebra.trace R T) x
-- Algebra.trace_comp_trace
@[simp]
theorem trace_comp_trace [Algebra S T] [IsScalarTower R S T]
    [Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T] :
    (trace R S).comp ((trace S T).restrictScalars R) = trace R T 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T] [Module.Free R S] [Module.Finite R S] [Module.Free S T] [Module.Finite S T]
Goal: Algebra.trace R S ∘ₗ ↑R (Algebra.trace S T) = Algebra.trace R T
-- Algebra.trace_prod_apply
@[simp]
theorem trace_prod_apply [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T]
    (x : S × T) : trace R (S × T) x = trace R S x.fst + trace R T x.snd 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T] (x : S × T)
Goal: (Algebra.trace R (S × T)) x = (Algebra.trace R S) x.1 + (Algebra.trace R T) x.2
-- Algebra.trace_prod
theorem trace_prod [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T] :
    trace R (S × T) = (trace R S).coprod (trace R T) 
Arguments: {R : Type u_1} {S : Type u_2} {T : Type u_3} [CommRing R] [CommRing S] [CommRing T] [Algebra R S] [Algebra R T] [Module.Free R S] [Module.Free R T] [Module.Finite R S] [Module.Finite R T]
Goal: Algebra.trace R (S × T) = (Algebra.trace R S).coprod (Algebra.trace R T)
-- Algebra.traceForm_apply
@[simp]
theorem traceForm_apply (x y : S) : traceForm R S x y = trace R S (x * y) 
Arguments: (R : Type u_1) {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] (x y : S)
Goal: ((Algebra.traceForm R S) x) y = (Algebra.trace R S) (x * y)
-- Algebra.traceForm_isSymm
theorem traceForm_isSymm : (traceForm R S).IsSymm 
Arguments: (R : Type u_1) {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S]
Goal: (Algebra.traceForm R S).IsSymm
-- Algebra.traceForm_toMatrix
theorem traceForm_toMatrix [DecidableEq ι] (i j) :
    BilinForm.toMatrix b (traceForm R S) i j = trace R S (b i * b j) 
Arguments: (R : Type u_1) {S : Type u_2} [CommRing R] [CommRing S] [Algebra R S] {ι : Type w} [Fintype ι] (b : Basis ι R S) [DecidableEq ι] (i j : ι)
Goal: (BilinForm.toMatrix b) (Algebra.traceForm R S) i j = (Algebra.trace R S) (b i * b j)
-- WittVector.wittPolyProd_vars
theorem wittPolyProd_vars (n : ℕ) : (wittPolyProd p n).vars ⊆ univ ×ˢ range (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (WittVector.wittPolyProd p n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- WittVector.wittPolyProdRemainder_vars
theorem wittPolyProdRemainder_vars (n : ℕ) :
    (wittPolyProdRemainder p n).vars ⊆ univ ×ˢ range n 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (WittVector.wittPolyProdRemainder p n).vars ⊆ Finset.univ ×ˢ Finset.range n
-- WittVector.remainder_vars
theorem remainder_vars (n : ℕ) : (remainder p n).vars ⊆ univ ×ˢ range (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (WittVector.remainder p n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- WittVector.mul_polyOfInterest_aux1
theorem mul_polyOfInterest_aux1 (n : ℕ) :
    ∑ i ∈ range (n + 1), (p : 𝕄) ^ i * wittMul p i ^ p ^ (n - i) = wittPolyProd p n 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: ∑ i ∈ Finset.range (n + 1), ↑p ^ i * WittVector.wittMul p i ^ p ^ (n - i) = WittVector.wittPolyProd p n
-- WittVector.mul_polyOfInterest_aux2
theorem mul_polyOfInterest_aux2 (n : ℕ) :
    (p : 𝕄) ^ n * wittMul p n + wittPolyProdRemainder p n = wittPolyProd p n 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: ↑p ^ n * WittVector.wittMul p n + WittVector.wittPolyProdRemainder p n = WittVector.wittPolyProd p n
-- WittVector.mul_polyOfInterest_aux3
theorem mul_polyOfInterest_aux3 (n : ℕ) : wittPolyProd p (n + 1) =
    -((p : 𝕄) ^ (n + 1) * X (0, n + 1)) * ((p : 𝕄) ^ (n + 1) * X (1, n + 1)) +
    (p : 𝕄) ^ (n + 1) * X (0, n + 1) * rename (Prod.mk (1 : Fin 2)) (wittPolynomial p ℤ (n + 1)) +
    (p : 𝕄) ^ (n + 1) * X (1, n + 1) * rename (Prod.mk (0 : Fin 2)) (wittPolynomial p ℤ (n + 1)) +
    remainder p n 
Arguments: (p n : ℕ)
Goal: WittVector.wittPolyProd p (n + 1) =
  -(↑p ^ (n + 1) * MvPolynomial.X (0, n + 1)) * (↑p ^ (n + 1) * MvPolynomial.X (1, n + 1)) +
        ↑p ^ (n + 1) * MvPolynomial.X (0, n + 1) * (MvPolynomial.rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) +
      ↑p ^ (n + 1) * MvPolynomial.X (1, n + 1) * (MvPolynomial.rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)) +
    WittVector.remainder p n
-- WittVector.mul_polyOfInterest_aux4
theorem mul_polyOfInterest_aux4 (n : ℕ) :
    (p : 𝕄) ^ (n + 1) * wittMul p (n + 1) =
    -((p : 𝕄) ^ (n + 1) * X (0, n + 1)) * ((p : 𝕄) ^ (n + 1) * X (1, n + 1)) +
    (p : 𝕄) ^ (n + 1) * X (0, n + 1) * rename (Prod.mk (1 : Fin 2)) (wittPolynomial p ℤ (n + 1)) +
    (p : 𝕄) ^ (n + 1) * X (1, n + 1) * rename (Prod.mk (0 : Fin 2)) (wittPolynomial p ℤ (n + 1)) +
    (remainder p n - wittPolyProdRemainder p (n + 1)) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: ↑p ^ (n + 1) * WittVector.wittMul p (n + 1) =
  -(↑p ^ (n + 1) * MvPolynomial.X (0, n + 1)) * (↑p ^ (n + 1) * MvPolynomial.X (1, n + 1)) +
        ↑p ^ (n + 1) * MvPolynomial.X (0, n + 1) * (MvPolynomial.rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) +
      ↑p ^ (n + 1) * MvPolynomial.X (1, n + 1) * (MvPolynomial.rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)) +
    (WittVector.remainder p n - WittVector.wittPolyProdRemainder p (n + 1))
-- WittVector.mul_polyOfInterest_aux5
theorem mul_polyOfInterest_aux5 (n : ℕ) :
    (p : 𝕄) ^ (n + 1) * polyOfInterest p n = remainder p n - wittPolyProdRemainder p (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: ↑p ^ (n + 1) * WittVector.polyOfInterest p n = WittVector.remainder p n - WittVector.wittPolyProdRemainder p (n + 1)
-- WittVector.mul_polyOfInterest_vars
theorem mul_polyOfInterest_vars (n : ℕ) :
    ((p : 𝕄) ^ (n + 1) * polyOfInterest p n).vars ⊆ univ ×ˢ range (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (↑p ^ (n + 1) * WittVector.polyOfInterest p n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- WittVector.polyOfInterest_vars_eq
theorem polyOfInterest_vars_eq (n : ℕ) : (polyOfInterest p n).vars =
    ((p : 𝕄) ^ (n + 1) * (wittMul p (n + 1) + (p : 𝕄) ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
      X (0, n + 1) * rename (Prod.mk (1 : Fin 2)) (wittPolynomial p ℤ (n + 1)) -
      X (1, n + 1) * rename (Prod.mk (0 : Fin 2)) (wittPolynomial p ℤ (n + 1)))).vars 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (WittVector.polyOfInterest p n).vars =
  (↑p ^ (n + 1) *
      (WittVector.wittMul p (n + 1) + ↑p ^ (n + 1) * MvPolynomial.X (0, n + 1) * MvPolynomial.X (1, n + 1) -
          MvPolynomial.X (0, n + 1) * (MvPolynomial.rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
        MvPolynomial.X (1, n + 1) * (MvPolynomial.rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
-- WittVector.polyOfInterest_vars
theorem polyOfInterest_vars (n : ℕ) : (polyOfInterest p n).vars ⊆ univ ×ˢ range (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: (WittVector.polyOfInterest p n).vars ⊆ Finset.univ ×ˢ Finset.range (n + 1)
-- WittVector.peval_polyOfInterest
theorem peval_polyOfInterest (n : ℕ) (x y : 𝕎 k) :
    peval (polyOfInterest p n) ![fun i => x.coeff i, fun i => y.coeff i] =
    (x * y).coeff (n + 1) + p ^ (n + 1) * x.coeff (n + 1) * y.coeff (n + 1) -
      y.coeff (n + 1) * ∑ i ∈ range (n + 1 + 1), p ^ i * x.coeff i ^ p ^ (n + 1 - i) -
      x.coeff (n + 1) * ∑ i ∈ range (n + 1 + 1), p ^ i * y.coeff i ^ p ^ (n + 1 - i) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [CommRing k] (n : ℕ) (x y : WittVector p k)
Goal: WittVector.peval (WittVector.polyOfInterest p n) ![fun i => x.coeff i, fun i => y.coeff i] =
  (x * y).coeff (n + 1) + ↑p ^ (n + 1) * x.coeff (n + 1) * y.coeff (n + 1) -
      y.coeff (n + 1) * ∑ i ∈ Finset.range (n + 1 + 1), ↑p ^ i * x.coeff i ^ p ^ (n + 1 - i) -
    x.coeff (n + 1) * ∑ i ∈ Finset.range (n + 1 + 1), ↑p ^ i * y.coeff i ^ p ^ (n + 1 - i)
-- WittVector.peval_polyOfInterest'
theorem peval_polyOfInterest' (n : ℕ) (x y : 𝕎 k) :
    peval (polyOfInterest p n) ![fun i => x.coeff i, fun i => y.coeff i] =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) -
        x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [CommRing k] [CharP k p] (n : ℕ) (x y : WittVector p k)
Goal: WittVector.peval (WittVector.polyOfInterest p n) ![fun i => x.coeff i, fun i => y.coeff i] =
  (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) - x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)
-- WittVector.nth_mul_coeff'
theorem nth_mul_coeff' (n : ℕ) :
    ∃ f : TruncatedWittVector p (n + 1) k → TruncatedWittVector p (n + 1) k → k,
    ∀ x y : 𝕎 k, f (truncateFun (n + 1) x) (truncateFun (n + 1) y) =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) -
        x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (k : Type u_1) [CommRing k] [CharP k p] (n : ℕ)
Goal: ∃ f,
  ∀ (x y : WittVector p k),
    f (WittVector.truncateFun (n + 1) x) (WittVector.truncateFun (n + 1) y) =
      (x * y).coeff (n + 1) - y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) - x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1)
-- WittVector.nth_mul_coeff
theorem nth_mul_coeff (n : ℕ) :
    ∃ f : TruncatedWittVector p (n + 1) k → TruncatedWittVector p (n + 1) k → k,
    ∀ x y : 𝕎 k, (x * y).coeff (n + 1) =
      x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) + y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) +
      f (truncateFun (n + 1) x) (truncateFun (n + 1) y) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (k : Type u_1) [CommRing k] [CharP k p] (n : ℕ)
Goal: ∃ f,
  ∀ (x y : WittVector p k),
    (x * y).coeff (n + 1) =
      x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) + y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) +
        f (WittVector.truncateFun (n + 1) x) (WittVector.truncateFun (n + 1) y)
-- WittVector.nthRemainder_spec
theorem nthRemainder_spec (n : ℕ) (x y : 𝕎 k) : (x * y).coeff (n + 1) =
    x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) + y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) +
    nthRemainder p n (truncateFun (n + 1) x) (truncateFun (n + 1) y) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [CommRing k] [CharP k p] (n : ℕ) (x y : WittVector p k)
Goal: (x * y).coeff (n + 1) =
  x.coeff (n + 1) * y.coeff 0 ^ p ^ (n + 1) + y.coeff (n + 1) * x.coeff 0 ^ p ^ (n + 1) +
    WittVector.nthRemainder p n (WittVector.truncateFun (n + 1) x) (WittVector.truncateFun (n + 1) y)
-- WittVector.RecursionMain.succNthDefiningPoly_degree
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 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [CommRing k] [CharP k p] [IsDomain k] (n : ℕ) (a₁ a₂ : WittVector p k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).degree = ↑p
-- WittVector.RecursionMain.root_exists
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 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] (n : ℕ) (a₁ a₂ : WittVector p k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: ∃ b, (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).IsRoot b
-- WittVector.RecursionMain.succNthVal_spec
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₂) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] (n : ℕ) (a₁ a₂ : WittVector p k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: (WittVector.RecursionMain.succNthDefiningPoly p n a₁ a₂ bs).IsRoot
  (WittVector.RecursionMain.succNthVal p n a₁ a₂ bs ha₁ ha₂)
-- WittVector.RecursionMain.succNthVal_spec'
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₂) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] (n : ℕ) (a₁ a₂ : WittVector p k) (bs : Fin (n + 1) → k) (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
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₂)
-- WittVector.RecursionBase.solution_pow
theorem solution_pow (a₁ a₂ : 𝕎 k) : ∃ x : k, x ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [IsAlgClosed k] (a₁ a₂ : WittVector p k)
Goal: ∃ x, x ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0
-- WittVector.RecursionBase.solution_spec
theorem solution_spec (a₁ a₂ : 𝕎 k) : solution p a₁ a₂ ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [IsAlgClosed k] (a₁ a₂ : WittVector p k)
Goal: WittVector.RecursionBase.solution p a₁ a₂ ^ (p - 1) = a₂.coeff 0 / a₁.coeff 0
-- WittVector.RecursionBase.solution_nonzero
theorem solution_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    solution p a₁ a₂ ≠ 0 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [IsAlgClosed k] {a₁ a₂ : WittVector p k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: WittVector.RecursionBase.solution p a₁ a₂ ≠ 0
-- WittVector.RecursionBase.solution_spec'
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 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [IsAlgClosed k] {a₁ : WittVector p k} (ha₁ : a₁.coeff 0 ≠ 0) (a₂ : WittVector p k)
Goal: WittVector.RecursionBase.solution p a₁ a₂ ^ p * a₁.coeff 0 = WittVector.RecursionBase.solution p a₁ a₂ * a₂.coeff 0
-- WittVector.frobeniusRotation_nonzero
theorem frobeniusRotation_nonzero {a₁ a₂ : 𝕎 k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0) :
    frobeniusRotation p ha₁ ha₂ ≠ 0 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] {a₁ a₂ : WittVector p k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: WittVector.frobeniusRotation p ha₁ ha₂ ≠ 0
-- WittVector.frobenius_frobeniusRotation
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₂ 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] {a₁ a₂ : WittVector p k} (ha₁ : a₁.coeff 0 ≠ 0) (ha₂ : a₂.coeff 0 ≠ 0)
Goal: WittVector.frobenius (WittVector.frobeniusRotation p ha₁ ha₂) * a₁ = WittVector.frobeniusRotation p ha₁ ha₂ * a₂
-- WittVector.exists_frobenius_solution_fractionRing_aux
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 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] (m n : ℕ) (r' q' : WittVector p k) (hr' : r'.coeff 0 ≠ 0) (hq' : q'.coeff 0 ≠ 0) (hq : ↑p ^ n * q' ∈ nonZeroDivisors (WittVector p k))
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
-- WittVector.exists_frobenius_solution_fractionRing
theorem exists_frobenius_solution_fractionRing {a : FractionRing (𝕎 k)} (ha : a ≠ 0) :
    ∃ᵉ (b ≠ 0) (m : ℤ), φ b * a = (p : FractionRing (𝕎 k)) ^ m * b 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [Field k] [CharP k p] [IsAlgClosed k] {a : FractionRing (WittVector p k)} (ha : a ≠ 0)
Goal: ∃ b, b ≠ 0 ∧ ∃ m, (IsFractionRing.fieldEquivOfRingEquiv (WittVector.frobeniusEquiv p k)) b * a = ↑p ^ m * b
-- WittVector.mapFun.injective
theorem injective (f : α → β) (hf : Injective f) : Injective (mapFun f : 𝕎 α → 𝕎 β) 
Arguments: {p : ℕ} {α : Type u_4} {β : Type u_5} (f : α → β) (hf : Function.Injective f)
Goal: Function.Injective (WittVector.mapFun f)
-- WittVector.mapFun.surjective
theorem surjective (f : α → β) (hf : Surjective f) : Surjective (mapFun f : 𝕎 α → 𝕎 β) 
Arguments: {p : ℕ} {α : Type u_4} {β : Type u_5} (f : α → β) (hf : Function.Surjective f)
Goal: Function.Surjective (WittVector.mapFun f)
-- WittVector.mapFun.zero
theorem zero : mapFun f (0 : 𝕎 R) = 0 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S)
Goal: WittVector.mapFun (⇑f) 0 = 0
-- WittVector.mapFun.one
theorem one : mapFun f (1 : 𝕎 R) = 1 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S)
Goal: WittVector.mapFun (⇑f) 1 = 1
-- WittVector.mapFun.add
theorem add : mapFun f (x + y) = mapFun f x + mapFun f y 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (x y : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (x + y) = WittVector.mapFun (⇑f) x + WittVector.mapFun (⇑f) y
-- WittVector.mapFun.sub
theorem sub : mapFun f (x - y) = mapFun f x - mapFun f y 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (x y : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (x - y) = WittVector.mapFun (⇑f) x - WittVector.mapFun (⇑f) y
-- WittVector.mapFun.mul
theorem mul : mapFun f (x * y) = mapFun f x * mapFun f y 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (x y : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (x * y) = WittVector.mapFun (⇑f) x * WittVector.mapFun (⇑f) y
-- WittVector.mapFun.neg
theorem neg : mapFun f (-x) = -mapFun f x 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (x : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (-x) = -WittVector.mapFun (⇑f) x
-- WittVector.mapFun.nsmul
theorem nsmul (n : ℕ) (x : WittVector p R) : mapFun f (n • x) = n • mapFun f x 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (n : ℕ) (x : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (n • x) = n • WittVector.mapFun (⇑f) x
-- WittVector.mapFun.zsmul
theorem zsmul (z : ℤ) (x : WittVector p R) : mapFun f (z • x) = z • mapFun f x 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (z : ℤ) (x : 𝕎 R)
Goal: WittVector.mapFun (⇑f) (z • x) = z • WittVector.mapFun (⇑f) x
-- WittVector.mapFun.pow
theorem pow (n : ℕ) : mapFun f (x ^ n) = mapFun f x ^ n 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (x : 𝕎 R) (n : ℕ)
Goal: WittVector.mapFun (⇑f) (x ^ n) = WittVector.mapFun (⇑f) x ^ n
-- WittVector.mapFun.natCast
theorem natCast (n : ℕ) : mapFun f (n : 𝕎 R) = n 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (n : ℕ)
Goal: WittVector.mapFun ⇑f ↑n = ↑n
-- WittVector.mapFun.intCast
theorem intCast (n : ℤ) : mapFun f (n : 𝕎 R) = n 
Arguments: {p : ℕ} {R : Type u_1} {S : Type u_2} [hp : Fact (Nat.Prime p)] [CommRing R] [CommRing S] (f : R →+* S) (n : ℤ)
Goal: WittVector.mapFun ⇑f ↑n = ↑n
-- WittVector.matrix_vecEmpty_coeff
@[local simp]
theorem matrix_vecEmpty_coeff {R} (i j) :
    @coeff p R (Matrix.vecEmpty i) j = (Matrix.vecEmpty i : ℕ → R) j 
Arguments: {p : ℕ} {R : Type u_6} (i : Fin 0) (j : ℕ)
Goal: (![] i).coeff j = ![] i j
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_zero
private theorem ghostFun_zero : ghostFun (0 : 𝕎 R) = 0 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R]
Goal: WittVector.ghostFun 0 = 0
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_one
private theorem ghostFun_one : ghostFun (1 : 𝕎 R) = 1 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R]
Goal: WittVector.ghostFun 1 = 1
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_add
private theorem ghostFun_add : ghostFun (x + y) = ghostFun x + ghostFun y 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (x y : 𝕎 R)
Goal: WittVector.ghostFun (x + y) = WittVector.ghostFun x + WittVector.ghostFun y
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_natCast
private theorem ghostFun_natCast (i : ℕ) : ghostFun (i : 𝕎 R) = i 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (i : ℕ)
Goal: WittVector.ghostFun ↑i = ↑i
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_sub
private theorem ghostFun_sub : ghostFun (x - y) = ghostFun x - ghostFun y 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (x y : 𝕎 R)
Goal: WittVector.ghostFun (x - y) = WittVector.ghostFun x - WittVector.ghostFun y
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_mul
private theorem ghostFun_mul : ghostFun (x * y) = ghostFun x * ghostFun y 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (x y : 𝕎 R)
Goal: WittVector.ghostFun (x * y) = WittVector.ghostFun x * WittVector.ghostFun y
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_neg
private theorem ghostFun_neg : ghostFun (-x) = -ghostFun x 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (x : 𝕎 R)
Goal: WittVector.ghostFun (-x) = -WittVector.ghostFun x
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_intCast
private theorem ghostFun_intCast (i : ℤ) : ghostFun (i : 𝕎 R) = i 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (i : ℤ)
Goal: WittVector.ghostFun ↑i = ↑i
-- _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_nsmul
private lemma ghostFun_nsmul (m : ℕ) (x : WittVector p R) : ghostFun (m • x) = m • ghostFun x 
Arguments: {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [CommRing R] (m : ℕ) (x : 𝕎 R)
Goal: WittVector.ghostFun (m • x) = m • WittVector.ghostFun x