File: Mathlib/FieldTheory/IsPerfectClosure.lean

full_name: pNilradical
code: /-- Given a natural number `p`, the `p`-nilradical of a ring is defined to be the
nilradical if `p > 1` (`pNilradical_eq_nilradical`), and defined to be the zero ideal if `p ≤ 1`
(`pNilradical_eq_bot'`). Equivalently, it is the ideal consisting of elements `x` such that
`x ^ p ^ n = 0` for some `n` (`mem_pNilradical`). -/
def pNilradical (R : Type*) [CommSemiring R] (p : ℕ) : Ideal R 
goal: Ideal R

full_name: pNilradical_le_nilradical
code: theorem pNilradical_le_nilradical {R : Type*} [CommSemiring R] {p : ℕ} :
    pNilradical R p ≤ nilradical R 
goal: pNilradical R p ≤ nilradical R

full_name: pNilradical_eq_nilradical
code: theorem pNilradical_eq_nilradical {R : Type*} [CommSemiring R] {p : ℕ} (hp : 1 < p) :
    pNilradical R p = nilradical R 
goal: pNilradical R p = nilradical R

full_name: pNilradical_eq_bot
code: theorem pNilradical_eq_bot {R : Type*} [CommSemiring R] {p : ℕ} (hp : ¬ 1 < p) :
    pNilradical R p = ⊥ 
goal: pNilradical R p = ⊥

full_name: pNilradical_eq_bot'
code: theorem pNilradical_eq_bot' {R : Type*} [CommSemiring R] {p : ℕ} (hp : p ≤ 1) :
    pNilradical R p = ⊥ 
goal: pNilradical R p = ⊥

full_name: pNilradical_prime
code: theorem pNilradical_prime {R : Type*} [CommSemiring R] {p : ℕ} (hp : p.Prime) :
    pNilradical R p = nilradical R 
goal: pNilradical R p = nilradical R

full_name: pNilradical_one
code: theorem pNilradical_one {R : Type*} [CommSemiring R] :
    pNilradical R 1 = ⊥ 
goal: pNilradical R 1 = ⊥

full_name: mem_pNilradical
code: theorem mem_pNilradical {R : Type*} [CommSemiring R] {p : ℕ} {x : R} :
    x ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = 0 
goal: x ∈ pNilradical R p ↔ ∃ n, x ^ p ^ n = 0

full_name: sub_mem_pNilradical_iff_pow_expChar_pow_eq
code: theorem sub_mem_pNilradical_iff_pow_expChar_pow_eq {R : Type*} [CommRing R] {p : ℕ} [ExpChar R p]
    {x y : R} : x - y ∈ pNilradical R p ↔ ∃ n : ℕ, x ^ p ^ n = y ^ p ^ n 
goal: x - y ∈ pNilradical R p ↔ ∃ n, x ^ p ^ n = y ^ p ^ n

full_name: pow_expChar_pow_inj_of_pNilradical_eq_bot
code: theorem pow_expChar_pow_inj_of_pNilradical_eq_bot (R : Type*) [CommRing R] (p : ℕ) [ExpChar R p]
    (h : pNilradical R p = ⊥) (n : ℕ) : Function.Injective fun x : R ↦ x ^ p ^ n 
goal: Function.Injective fun x => x ^ p ^ n

full_name: pNilradical_eq_bot_of_frobenius_inj
code: theorem pNilradical_eq_bot_of_frobenius_inj (R : Type*) [CommRing R] (p : ℕ) [ExpChar R p]
    (h : Function.Injective (frobenius R p)) : pNilradical R p = ⊥ 
goal: pNilradical R p = ⊥

full_name: PerfectRing.pNilradical_eq_bot
code: theorem PerfectRing.pNilradical_eq_bot (R : Type*) [CommRing R] (p : ℕ) [ExpChar R p]
    [PerfectRing R p] : pNilradical R p = ⊥ 
goal: pNilradical R p = ⊥

full_name: IsPRadical.ker_le'
code: /-- If `i : K →+* L` is a ring homomorphism of characteristic `p` rings, then it is called
`p`-radical if the following conditions are satisfied:

- For any element `x` of `L` there is `n : ℕ` such that `x ^ (p ^ n)` is contained in `K`.
- The kernel of `i` is contained in the `p`-nilradical of `K`.

It is a generalization of purely inseparable extension for fields. -/
@[mk_iff]
class IsPRadical : Prop where
  pow_mem' : ∀ x : L, ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
  ker_le' : RingHom.ker i ≤ pNilradical K p
goal: RingHom.ker i ≤ pNilradical K p

full_name: IsPRadical.pow_mem'
code: /-- If `i : K →+* L` is a ring homomorphism of characteristic `p` rings, then it is called
`p`-radical if the following conditions are satisfied:

- For any element `x` of `L` there is `n : ℕ` such that `x ^ (p ^ n)` is contained in `K`.
- The kernel of `i` is contained in the `p`-nilradical of `K`.

It is a generalization of purely inseparable extension for fields. -/
@[mk_iff]
class IsPRadical : Prop where
  pow_mem' : ∀ x : L, ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
  ker_le' : RingHom.ker i ≤ pNilradical K p
goal: ∃ n y, i y = x ^ p ^ n

full_name: isPRadical_iff
code: /-- If `i : K →+* L` is a ring homomorphism of characteristic `p` rings, then it is called
`p`-radical if the following conditions are satisfied:

- For any element `x` of `L` there is `n : ℕ` such that `x ^ (p ^ n)` is contained in `K`.
- The kernel of `i` is contained in the `p`-nilradical of `K`.

It is a generalization of purely inseparable extension for fields. -/
@[mk_iff]
class IsPRadical : Prop where
  pow_mem' : ∀ x : L, ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
  ker_le' : RingHom.ker i ≤ pNilradical K p
goal: IsPRadical i p ↔ (∀ (x : L), ∃ n y, i y = x ^ p ^ n) ∧ RingHom.ker i ≤ pNilradical K p

full_name: IsPRadical
code: /-- If `i : K →+* L` is a ring homomorphism of characteristic `p` rings, then it is called
`p`-radical if the following conditions are satisfied:

- For any element `x` of `L` there is `n : ℕ` such that `x ^ (p ^ n)` is contained in `K`.
- The kernel of `i` is contained in the `p`-nilradical of `K`.

It is a generalization of purely inseparable extension for fields. -/
@[mk_iff]
class IsPRadical : Prop where
  pow_mem' : ∀ x : L, ∃ (n : ℕ) (y : K), i y = x ^ p ^ n
  ker_le' : RingHom.ker i ≤ pNilradical K p
goal: Prop

full_name: IsPRadical.pow_mem
code: theorem IsPRadical.pow_mem [IsPRadical i p] (x : L) :
    ∃ (n : ℕ) (y : K), i y = x ^ p ^ n 
goal: ∃ n y, i y = x ^ p ^ n

full_name: IsPRadical.ker_le
code: theorem IsPRadical.ker_le [IsPRadical i p] :
    RingHom.ker i ≤ pNilradical K p 
goal: RingHom.ker i ≤ pNilradical K p

full_name: IsPRadical.comap_pNilradical
code: theorem IsPRadical.comap_pNilradical [IsPRadical i p] :
    (pNilradical L p).comap i = pNilradical K p 
goal: Ideal.comap i (pNilradical L p) = pNilradical K p

full_name: IsPRadical.of_id
code: instance IsPRadical.of_id : IsPRadical (RingHom.id K) p 
goal: IsPRadical (RingHom.id K) p

full_name: IsPRadical.trans
code: /-- Composition of `p`-radical ring homomorphisms is also `p`-radical. -/
theorem IsPRadical.trans [IsPRadical i p] [IsPRadical f p] :
    IsPRadical (f.comp i) p 
goal: IsPRadical (f.comp i) p

full_name: IsPerfectClosure
code: /-- If `i : K →+* L` is a `p`-radical ring homomorphism, then it makes `L` a perfect closure
of `K`, if `L` is perfect.
In this case the kernel of `i` is equal to the `p`-nilradical of `K`
(see `IsPerfectClosure.ker_eq`).

Our definition makes it synonymous to `IsPRadical` if `PerfectRing L p` is present. A caveat is
that you need to write `[PerfectRing L p] [IsPerfectClosure i p]`. This is similar to
`PerfectRing` which has `ExpChar` as a prerequisite. -/
@[nolint unusedArguments]
abbrev IsPerfectClosure [PerfectRing L p] 
goal: Prop

full_name: RingHom.pNilradical_le_ker_of_perfectRing
code: /-- If `i : K →+* L` is a ring homomorphism of exponential characteristic `p` rings, such that `L`
is perfect, then the `p`-nilradical of `K` is contained in the kernel of `i`. -/
theorem RingHom.pNilradical_le_ker_of_perfectRing [PerfectRing L p] :
    pNilradical K p ≤ RingHom.ker i 
goal: pNilradical K p ≤ RingHom.ker i

full_name: IsPerfectClosure.ker_eq
code: theorem IsPerfectClosure.ker_eq [PerfectRing L p] [IsPerfectClosure i p] :
    RingHom.ker i = pNilradical K p 
goal: RingHom.ker i = pNilradical K p

full_name: PerfectRing.lift_aux
code: theorem lift_aux (x : L) : ∃ y : ℕ × K, i y.2 = x ^ p ^ y.1 
goal: ∃ y, i y.2 = x ^ p ^ y.1

full_name: PerfectRing.liftAux
code: /-- If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical (in fact only the `IsPRadical.pow_mem` is required) and `M` is a perfect ring,
then one can define a map `L → M` which maps an element `x` of `L` to `y ^ (p ^ -n)` if
`x ^ (p ^ n)` is equal to some element `y` of `K`. -/
def liftAux (x : L) : M 
goal: M

full_name: PerfectRing.liftAux_self_apply
code: @[simp]
theorem liftAux_self_apply [PerfectRing L p] (x : L) : liftAux i i p x = x 
goal: PerfectRing.liftAux i i p x = x

full_name: PerfectRing.liftAux_self
code: @[simp]
theorem liftAux_self [PerfectRing L p] : liftAux i i p = id 
goal: PerfectRing.liftAux i i p = id

full_name: PerfectRing.liftAux_id_apply
code: @[simp]
theorem liftAux_id_apply (x : K) : liftAux (RingHom.id K) j p x = j x 
goal: PerfectRing.liftAux (RingHom.id K) j p x = j x

full_name: PerfectRing.liftAux_id
code: @[simp]
theorem liftAux_id : liftAux (RingHom.id K) j p = j 
goal: PerfectRing.liftAux (RingHom.id K) j p = ⇑j

full_name: IsPRadical.injective_comp_of_pNilradical_eq_bot
code: /-- If `i : K →+* L` is `p`-radical, then for any ring `M` of exponential charactistic `p` whose
`p`-nilradical is zero, the map `(L →+* M) → (K →+* M)` induced by `i` is injective. -/
theorem injective_comp_of_pNilradical_eq_bot [IsPRadical i p] (h : pNilradical M p = ⊥) :
    Function.Injective fun f : L →+* M ↦ f.comp i 
goal: Function.Injective fun f => f.comp i

full_name: IsPRadical.injective_comp
code: /-- If `i : K →+* L` is `p`-radical, then for any reduced ring `M` of exponential charactistic `p`,
the map `(L →+* M) → (K →+* M)` induced by `i` is injective.
A special case of `IsPRadical.injective_comp_of_pNilradical_eq_bot`
and a generalization of `IsPurelyInseparable.injective_comp_algebraMap`. -/
theorem injective_comp [IsPRadical i p] [IsReduced M] :
    Function.Injective fun f : L →+* M ↦ f.comp i 
goal: Function.Injective fun f => f.comp i

full_name: IsPRadical.injective_comp_of_perfect
code: /-- If `i : K →+* L` is `p`-radical, then for any perfect ring `M` of exponential charactistic `p`,
the map `(L →+* M) → (K →+* M)` induced by `i` is injective.
A special case of `IsPRadical.injective_comp_of_pNilradical_eq_bot`. -/
theorem injective_comp_of_perfect [IsPRadical i p] [PerfectRing M p] :
    Function.Injective fun f : L →+* M ↦ f.comp i 
goal: Function.Injective fun f => f.comp i

full_name: PerfectRing.liftAux_apply
code: /-- If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring, then `PerfectRing.liftAux` is well-defined. -/
theorem liftAux_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
    liftAux i j p x = (iterateFrobeniusEquiv M p n).symm (j y) 
goal: PerfectRing.liftAux i j p x = (iterateFrobeniusEquiv M p n).symm (j y)

full_name: PerfectRing.lift
code: /-- If `i : K →+* L` and `j : K →+* M` are ring homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring, then `PerfectRing.liftAux`
is a ring homomorphism. This is similar to `IsAlgClosed.lift` and `IsSepClosed.lift`. -/
def lift : L →+* M 
goal: L →+* M

full_name: PerfectRing.lift_apply
code: theorem lift_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
    lift i j p x = (iterateFrobeniusEquiv M p n).symm (j y) 
goal: (PerfectRing.lift i j p) x = (iterateFrobeniusEquiv M p n).symm (j y)

full_name: PerfectRing.lift_comp_apply
code: @[simp]
theorem lift_comp_apply (x : K) : lift i j p (i x) = j x 
goal: (PerfectRing.lift i j p) (i x) = j x

full_name: PerfectRing.lift_comp
code: @[simp]
theorem lift_comp : (lift i j p).comp i = j 
goal: (PerfectRing.lift i j p).comp i = j

full_name: PerfectRing.lift_self_apply
code: theorem lift_self_apply [PerfectRing L p] (x : L) : lift i i p x = x 
goal: (PerfectRing.lift i i p) x = x

full_name: PerfectRing.lift_self
code: @[simp]
theorem lift_self [PerfectRing L p] : lift i i p = RingHom.id L 
goal: PerfectRing.lift i i p = RingHom.id L

full_name: PerfectRing.lift_id_apply
code: theorem lift_id_apply (x : K) : lift (RingHom.id K) j p x = j x 
goal: (PerfectRing.lift (RingHom.id K) j p) x = j x

full_name: PerfectRing.lift_id
code: @[simp]
theorem lift_id : lift (RingHom.id K) j p = j 
goal: PerfectRing.lift (RingHom.id K) j p = j

full_name: PerfectRing.comp_lift
code: @[simp]
theorem comp_lift : lift i (f.comp i) p = f 
goal: PerfectRing.lift i (f.comp i) p = f

full_name: PerfectRing.comp_lift_apply
code: theorem comp_lift_apply (x : L) : lift i (f.comp i) p x = f x 
goal: (PerfectRing.lift i (f.comp i) p) x = f x

full_name: PerfectRing.liftEquiv
code: /-- If `i : K →+* L` is a homomorphisms of characteristic `p` rings, such that
`i` is `p`-radical, and `M` is a perfect ring of characteristic `p`,
then `K →+* M` is one-to-one correspondence to
`L →+* M`, given by `PerfectRing.lift`. This is a generalization to `PerfectClosure.lift`. -/
def liftEquiv : (K →+* M) ≃ (L →+* M) 
goal: (K →+* M) ≃ (L →+* M)

full_name: PerfectRing.liftEquiv_apply
code: theorem liftEquiv_apply : liftEquiv M i p j = lift i j p 
goal: (PerfectRing.liftEquiv M i p) j = PerfectRing.lift i j p

full_name: PerfectRing.liftEquiv_symm_apply
code: theorem liftEquiv_symm_apply : (liftEquiv M i p).symm f = f.comp i 
goal: (PerfectRing.liftEquiv M i p).symm f = f.comp i

full_name: PerfectRing.liftEquiv_id_apply
code: theorem liftEquiv_id_apply : liftEquiv M (RingHom.id K) p j = j 
goal: (PerfectRing.liftEquiv M (RingHom.id K) p) j = j

full_name: PerfectRing.liftEquiv_id
code: @[simp]
theorem liftEquiv_id : liftEquiv M (RingHom.id K) p = Equiv.refl _ 
goal: PerfectRing.liftEquiv M (RingHom.id K) p = Equiv.refl (K →+* M)

full_name: PerfectRing.lift_comp_lift
code: @[simp]
theorem lift_comp_lift : (lift j k p).comp (lift i j p) = lift i k p 
goal: (PerfectRing.lift j k p).comp (PerfectRing.lift i j p) = PerfectRing.lift i k p

full_name: PerfectRing.lift_comp_lift_apply
code: @[simp]
theorem lift_comp_lift_apply (x : L) : lift j k p (lift i j p x) = lift i k p x 
goal: (PerfectRing.lift j k p) ((PerfectRing.lift i j p) x) = (PerfectRing.lift i k p) x

full_name: PerfectRing.lift_comp_lift_apply_eq_self
code: theorem lift_comp_lift_apply_eq_self [PerfectRing L p] (x : L) :
    lift j i p (lift i j p x) = x 
goal: (PerfectRing.lift j i p) ((PerfectRing.lift i j p) x) = x

full_name: PerfectRing.lift_comp_lift_eq_id
code: theorem lift_comp_lift_eq_id [PerfectRing L p] :
    (lift j i p).comp (lift i j p) = RingHom.id L 
goal: (PerfectRing.lift j i p).comp (PerfectRing.lift i j p) = RingHom.id L

full_name: PerfectRing.lift_lift
code: @[simp]
theorem lift_lift : lift g (lift i j p) p = lift (g.comp i) j p 
goal: PerfectRing.lift g (PerfectRing.lift i j p) p = PerfectRing.lift (g.comp i) j p

full_name: PerfectRing.lift_lift_apply
code: theorem lift_lift_apply (x : N) : lift g (lift i j p) p x = lift (g.comp i) j p x 
goal: (PerfectRing.lift g (PerfectRing.lift i j p) p) x = (PerfectRing.lift (g.comp i) j p) x

full_name: PerfectRing.liftEquiv_comp_apply
code: @[simp]
theorem liftEquiv_comp_apply :
    liftEquiv M g p (liftEquiv M i p j) = liftEquiv M (g.comp i) p j 
goal: (PerfectRing.liftEquiv M g p) ((PerfectRing.liftEquiv M i p) j) = (PerfectRing.liftEquiv M (g.comp i) p) j

full_name: PerfectRing.liftEquiv_trans
code: @[simp]
theorem liftEquiv_trans :
    (liftEquiv M i p).trans (liftEquiv M g p) = liftEquiv M (g.comp i) p 
goal: (PerfectRing.liftEquiv M i p).trans (PerfectRing.liftEquiv M g p) = PerfectRing.liftEquiv M (g.comp i) p

full_name: IsPerfectClosure.equiv
code: /-- If `L` and `M` are both perfect closures of `K`, then there is a ring isomorphism `L ≃+* M`.
This is similar to `IsAlgClosure.equiv` and `IsSepClosure.equiv`. -/
def equiv : L ≃+* M 
goal: L ≃+* M

full_name: IsPerfectClosure.equiv_toRingHom
code: theorem equiv_toRingHom : (equiv i j p).toRingHom = PerfectRing.lift i j p 
goal: (IsPerfectClosure.equiv i j p).toRingHom = PerfectRing.lift i j p

full_name: IsPerfectClosure.equiv_symm
code: @[simp]
theorem equiv_symm : (equiv i j p).symm = equiv j i p 
goal: (IsPerfectClosure.equiv i j p).symm = IsPerfectClosure.equiv j i p

full_name: IsPerfectClosure.equiv_symm_toRingHom
code: theorem equiv_symm_toRingHom :
    (equiv i j p).symm.toRingHom = PerfectRing.lift j i p 
goal: (IsPerfectClosure.equiv i j p).symm.toRingHom = PerfectRing.lift j i p

full_name: IsPerfectClosure.equiv_apply
code: theorem equiv_apply (x : L) (n : ℕ) (y : K) (h : i y = x ^ p ^ n) :
    equiv i j p x = (iterateFrobeniusEquiv M p n).symm (j y) 
goal: (IsPerfectClosure.equiv i j p) x = (iterateFrobeniusEquiv M p n).symm (j y)

full_name: IsPerfectClosure.equiv_symm_apply
code: theorem equiv_symm_apply (x : M) (n : ℕ) (y : K) (h : j y = x ^ p ^ n) :
    (equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y) 
goal: (IsPerfectClosure.equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y)

full_name: IsPerfectClosure.equiv_self_apply
code: theorem equiv_self_apply (x : L) : equiv i i p x = x 
goal: (IsPerfectClosure.equiv i i p) x = x

full_name: IsPerfectClosure.equiv_self
code: @[simp]
theorem equiv_self : equiv i i p = RingEquiv.refl L 
goal: IsPerfectClosure.equiv i i p = RingEquiv.refl L

full_name: IsPerfectClosure.equiv_comp_apply
code: @[simp]
theorem equiv_comp_apply (x : K) : equiv i j p (i x) = j x 
goal: (IsPerfectClosure.equiv i j p) (i x) = j x

full_name: IsPerfectClosure.equiv_comp
code: @[simp]
theorem equiv_comp : RingHom.comp (equiv i j p) i = j 
goal: (↑(IsPerfectClosure.equiv i j p)).comp i = j

full_name: IsPerfectClosure.equiv_comp_equiv_apply
code: @[simp]
theorem equiv_comp_equiv_apply (x : L) :
    equiv j k p (equiv i j p x) = equiv i k p x 
goal: (IsPerfectClosure.equiv j k p) ((IsPerfectClosure.equiv i j p) x) = (IsPerfectClosure.equiv i k p) x

full_name: IsPerfectClosure.equiv_comp_equiv
code: @[simp]
theorem equiv_comp_equiv : (equiv i j p).trans (equiv j k p) = equiv i k p 
goal: (IsPerfectClosure.equiv i j p).trans (IsPerfectClosure.equiv j k p) = IsPerfectClosure.equiv i k p

full_name: IsPerfectClosure.equiv_comp_equiv_apply_eq_self
code: theorem equiv_comp_equiv_apply_eq_self (x : L) :
    equiv j i p (equiv i j p x) = x 
goal: (IsPerfectClosure.equiv j i p) ((IsPerfectClosure.equiv i j p) x) = x

full_name: IsPerfectClosure.equiv_comp_equiv_eq_id
code: theorem equiv_comp_equiv_eq_id :
    (equiv i j p).trans (equiv j i p) = RingEquiv.refl L 
goal: (IsPerfectClosure.equiv i j p).trans (IsPerfectClosure.equiv j i p) = RingEquiv.refl L

full_name: PerfectClosure.isPRadical
code: /-- The absolute perfect closure `PerfectClosure` is a `p`-radical extension over the base ring.
In particular, it is a perfect closure of the base ring, that is,
`IsPerfectClosure (PerfectClosure.of K p) p`. -/
instance isPRadical : IsPRadical (PerfectClosure.of K p) p 
goal: IsPRadical (PerfectClosure.of K p) p

full_name: IsPRadical.isPurelyInseparable
code: /-- If `L / K` is a `p`-radical field extension, then it is purely inseparable. -/
theorem IsPRadical.isPurelyInseparable [IsPRadical (algebraMap K L) p] :
    IsPurelyInseparable K L 
goal: IsPurelyInseparable K L

full_name: IsPurelyInseparable.isPRadical
code: /-- If `L / K` is a purely inseparable field extension, then it is `p`-radical. In particular, if
`L` is perfect, then the (relative) perfect closure `perfectClosure K L` is a perfect closure
of `K`, that is, `IsPerfectClosure (algebraMap K (perfectClosure K L)) p`. -/
instance IsPurelyInseparable.isPRadical [IsPurelyInseparable K L] :
    IsPRadical (algebraMap K L) p 
goal: IsPRadical (algebraMap K L) p