[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
x : R
⊢ ↑(algebraMap R S) x = ↑h.map (↑C x)
[PROOFSTEP]
rw [h.algebraMap_eq, RingHom.comp_apply]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
⊢ p ∈ RingHom.ker h.map ↔ f ∣ p
[PROOFSTEP]
rw [h.ker_map, Ideal.mem_span_singleton]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
⊢ ↑h.map p = 0 ↔ f ∣ p
[PROOFSTEP]
rw [← h.mem_ker_map, RingHom.mem_ker]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
x : R
⊢ ↑(aeval (root h)) (↑C x) = ↑h.map (↑C x)
[PROOFSTEP]
rw [aeval_C, h.algebraMap_apply]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p✝ p q : R[X]
ihp : ↑(aeval (root h)) p = ↑h.map p
ihq : ↑(aeval (root h)) q = ↑h.map q
⊢ ↑(aeval (root h)) (p + q) = ↑h.map (p + q)
[PROOFSTEP]
rw [AlgHom.map_add, RingHom.map_add, ihp, ihq]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
n : ℕ
x : R
x✝ : ↑(aeval (root h)) (↑C x * X ^ n) = ↑h.map (↑C x * X ^ n)
⊢ ↑(aeval (root h)) (↑C x * X ^ (n + 1)) = ↑h.map (↑C x * X ^ (n + 1))
[PROOFSTEP]
rw [AlgHom.map_mul, aeval_C, AlgHom.map_pow, aeval_X, RingHom.map_mul, ← h.algebraMap_apply, RingHom.map_pow, map_X]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
⊢ ↑(aeval (root h)) f = 0
[PROOFSTEP]
rw [aeval_eq, map_self]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
⊢ repr h 0 ∈ Ideal.span {f}
[PROOFSTEP]
rw [← h.ker_map, RingHom.mem_ker, h.map_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
x y : S
⊢ repr h (x + y) - (repr h x + repr h y) ∈ Ideal.span {f}
[PROOFSTEP]
rw [← h.ker_map, RingHom.mem_ker, map_sub, h.map_repr, map_add, h.map_repr, h.map_repr, sub_self]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h h' : IsAdjoinRoot S f
eq : ∀ (x : R[X]), ↑h.map x = ↑h'.map x
⊢ h = h'
[PROOFSTEP]
cases h
[GOAL]
case mk
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h' : IsAdjoinRoot S f
map✝ : R[X] →+* S
map_surjective✝ : Function.Surjective ↑map✝
ker_map✝ : RingHom.ker map✝ = Ideal.span {f}
algebraMap_eq✝ : algebraMap R S = RingHom.comp map✝ C
eq :
  ∀ (x : R[X]),
    ↑{ map := map✝, map_surjective := map_surjective✝, ker_map := ker_map✝, algebraMap_eq := algebraMap_eq✝ }.map x =
      ↑h'.map x
⊢ { map := map✝, map_surjective := map_surjective✝, ker_map := ker_map✝, algebraMap_eq := algebraMap_eq✝ } = h'
[PROOFSTEP]
cases h'
[GOAL]
case mk.mk
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
map✝¹ : R[X] →+* S
map_surjective✝¹ : Function.Surjective ↑map✝¹
ker_map✝¹ : RingHom.ker map✝¹ = Ideal.span {f}
algebraMap_eq✝¹ : algebraMap R S = RingHom.comp map✝¹ C
map✝ : R[X] →+* S
map_surjective✝ : Function.Surjective ↑map✝
ker_map✝ : RingHom.ker map✝ = Ideal.span {f}
algebraMap_eq✝ : algebraMap R S = RingHom.comp map✝ C
eq :
  ∀ (x : R[X]),
    ↑{ map := map✝¹, map_surjective := map_surjective✝¹, ker_map := ker_map✝¹, algebraMap_eq := algebraMap_eq✝¹ }.map
        x =
      ↑{ map := map✝, map_surjective := map_surjective✝, ker_map := ker_map✝, algebraMap_eq := algebraMap_eq✝ }.map x
⊢ { map := map✝¹, map_surjective := map_surjective✝¹, ker_map := ker_map✝¹, algebraMap_eq := algebraMap_eq✝¹ } =
    { map := map✝, map_surjective := map_surjective✝, ker_map := ker_map✝, algebraMap_eq := algebraMap_eq✝ }
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_map
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
map✝¹ : R[X] →+* S
map_surjective✝¹ : Function.Surjective ↑map✝¹
ker_map✝¹ : RingHom.ker map✝¹ = Ideal.span {f}
algebraMap_eq✝¹ : algebraMap R S = RingHom.comp map✝¹ C
map✝ : R[X] →+* S
map_surjective✝ : Function.Surjective ↑map✝
ker_map✝ : RingHom.ker map✝ = Ideal.span {f}
algebraMap_eq✝ : algebraMap R S = RingHom.comp map✝ C
eq :
  ∀ (x : R[X]),
    ↑{ map := map✝¹, map_surjective := map_surjective✝¹, ker_map := ker_map✝¹, algebraMap_eq := algebraMap_eq✝¹ }.map
        x =
      ↑{ map := map✝, map_surjective := map_surjective✝, ker_map := ker_map✝, algebraMap_eq := algebraMap_eq✝ }.map x
⊢ map✝¹ = map✝
[PROOFSTEP]
exact RingHom.ext eq
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h h' : IsAdjoinRoot S f
eq : root h = root h'
x : R[X]
⊢ ↑h.map x = ↑h'.map x
[PROOFSTEP]
rw [← h.aeval_eq, ← h'.aeval_eq, eq]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw : ↑h.map w = z
⊢ eval₂ i x (repr h z) = eval₂ i x w
[PROOFSTEP]
rw [eq_comm, ← sub_eq_zero, ← h.map_repr z, ← map_sub, h.map_eq_zero_iff] at hzw
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw✝ : z = ↑h.map w
hzw : f ∣ repr h z - w
⊢ eval₂ i x (repr h z) = eval₂ i x w
[PROOFSTEP]
obtain ⟨y, hy⟩ := hzw
[GOAL]
case intro
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw : z = ↑h.map w
y : R[X]
hy : repr h z - w = f * y
⊢ eval₂ i x (repr h z) = eval₂ i x w
[PROOFSTEP]
rw [← sub_eq_zero, ← eval₂_sub, hy, eval₂_mul, hx, zero_mul]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ (fun z => eval₂ i x (repr h z)) 1 = 1
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ eval₂ i x (repr h 1) = 1
[PROOFSTEP]
rw [h.eval₂_repr_eq_eval₂_of_map_eq hx _ _ (map_one _), eval₂_one]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ OneHom.toFun { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
      (z * w) =
    OneHom.toFun { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) } z *
      OneHom.toFun { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) } w
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ eval₂ i x (repr h (z * w)) = eval₂ i x (repr h z) * eval₂ i x (repr h w)
[PROOFSTEP]
rw [h.eval₂_repr_eq_eval₂_of_map_eq hx _ (h.repr z * h.repr w), eval₂_mul]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ ↑h.map (repr h z * repr h w) = z * w
[PROOFSTEP]
rw [map_mul, map_repr, map_repr]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ OneHom.toFun
      (↑{
          toOneHom :=
            { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (z w : S),
                OneHom.toFun
                    { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                    (z * w) =
                  OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      z *
                    OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      w) })
      0 =
    0
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ eval₂ i x (repr h 0) = 0
[PROOFSTEP]
rw [h.eval₂_repr_eq_eval₂_of_map_eq hx _ _ (map_zero _), eval₂_zero]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ OneHom.toFun
      (↑{
          toOneHom :=
            { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
          map_mul' :=
            (_ :
              ∀ (z w : S),
                OneHom.toFun
                    { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                    (z * w) =
                  OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      z *
                    OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      w) })
      (z + w) =
    OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (z w : S),
                  OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      (z * w) =
                    OneHom.toFun
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                        z *
                      OneHom.toFun
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                        w) })
        z +
      OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
            map_mul' :=
              (_ :
                ∀ (z w : S),
                  OneHom.toFun
                      { toFun := fun z => eval₂ i x (repr h z),
                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                      (z * w) =
                    OneHom.toFun
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                        z *
                      OneHom.toFun
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                        w) })
        w
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ eval₂ i x (repr h (z + w)) = eval₂ i x (repr h z) + eval₂ i x (repr h w)
[PROOFSTEP]
rw [h.eval₂_repr_eq_eval₂_of_map_eq hx _ (h.repr z + h.repr w), eval₂_add]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z w : S
⊢ ↑h.map (repr h z + repr h w) = z + w
[PROOFSTEP]
rw [map_add, map_repr, map_repr]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : R[X]
⊢ ↑(lift i x hx h) (↑h.map z) = eval₂ i x z
[PROOFSTEP]
rw [lift, RingHom.coe_mk]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : R[X]
⊢ ↑{
          toMonoidHom :=
            {
              toOneHom :=
                { toFun := fun z => eval₂ i x (repr h z), map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
              map_mul' :=
                (_ :
                  ∀ (z w : S),
                    OneHom.toFun
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                        (z * w) =
                      OneHom.toFun
                          { toFun := fun z => eval₂ i x (repr h z),
                            map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                          z *
                        OneHom.toFun
                          { toFun := fun z => eval₂ i x (repr h z),
                            map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                          w) },
          map_zero' :=
            (_ :
              OneHom.toFun
                  (↑{
                      toOneHom :=
                        { toFun := fun z => eval₂ i x (repr h z),
                          map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
                      map_mul' :=
                        (_ :
                          ∀ (z w : S),
                            OneHom.toFun
                                { toFun := fun z => eval₂ i x (repr h z),
                                  map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                (z * w) =
                              OneHom.toFun
                                  { toFun := fun z => eval₂ i x (repr h z),
                                    map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                  z *
                                OneHom.toFun
                                  { toFun := fun z => eval₂ i x (repr h z),
                                    map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                  w) })
                  0 =
                0),
          map_add' :=
            (_ :
              ∀ (z w : S),
                OneHom.toFun
                    (↑{
                        toOneHom :=
                          { toFun := fun z => eval₂ i x (repr h z),
                            map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
                        map_mul' :=
                          (_ :
                            ∀ (z w : S),
                              OneHom.toFun
                                  { toFun := fun z => eval₂ i x (repr h z),
                                    map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                  (z * w) =
                                OneHom.toFun
                                    { toFun := fun z => eval₂ i x (repr h z),
                                      map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                    z *
                                  OneHom.toFun
                                    { toFun := fun z => eval₂ i x (repr h z),
                                      map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                    w) })
                    (z + w) =
                  OneHom.toFun
                      (↑{
                          toOneHom :=
                            { toFun := fun z => eval₂ i x (repr h z),
                              map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
                          map_mul' :=
                            (_ :
                              ∀ (z w : S),
                                OneHom.toFun
                                    { toFun := fun z => eval₂ i x (repr h z),
                                      map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                    (z * w) =
                                  OneHom.toFun
                                      { toFun := fun z => eval₂ i x (repr h z),
                                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                      z *
                                    OneHom.toFun
                                      { toFun := fun z => eval₂ i x (repr h z),
                                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                      w) })
                      z +
                    OneHom.toFun
                      (↑{
                          toOneHom :=
                            { toFun := fun z => eval₂ i x (repr h z),
                              map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) },
                          map_mul' :=
                            (_ :
                              ∀ (z w : S),
                                OneHom.toFun
                                    { toFun := fun z => eval₂ i x (repr h z),
                                      map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                    (z * w) =
                                  OneHom.toFun
                                      { toFun := fun z => eval₂ i x (repr h z),
                                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                      z *
                                    OneHom.toFun
                                      { toFun := fun z => eval₂ i x (repr h z),
                                        map_one' := (_ : (fun z => eval₂ i x (repr h z)) 1 = 1) }
                                      w) })
                      w) }
      (↑↑h.1 z) =
    eval₂ i x z
[PROOFSTEP]
dsimp
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : R[X]
⊢ eval₂ i x (repr h (↑h.1 z)) = eval₂ i x z
[PROOFSTEP]
rw [h.eval₂_repr_eq_eval₂_of_map_eq hx _ _ rfl]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
⊢ ↑(lift i x hx h) (root h) = x
[PROOFSTEP]
rw [← h.map_X, lift_map, eval₂_X]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
a : R
⊢ ↑(lift i x hx h) (↑(algebraMap R S) a) = ↑i a
[PROOFSTEP]
rw [h.algebraMap_apply, lift_map, eval₂_C]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), ↑g (↑(algebraMap R S) a) = ↑i a
hroot : ↑g (root h) = x
a : S
⊢ ↑g a = ↑(lift i x hx h) a
[PROOFSTEP]
rw [← h.map_repr a, Polynomial.as_sum_range_C_mul_X_pow (h.repr a)]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
g : S →+* T
hmap : ∀ (a : R), ↑g (↑(algebraMap R S) a) = ↑i a
hroot : ↑g (root h) = x
a : S
⊢ ↑g (↑h.map (Finset.sum (Finset.range (natDegree (repr h a) + 1)) fun i => ↑C (coeff (repr h a) i) * X ^ i)) =
    ↑(lift i x hx h)
      (↑h.map (Finset.sum (Finset.range (natDegree (repr h a) + 1)) fun i => ↑C (coeff (repr h a) i) * X ^ i))
[PROOFSTEP]
simp only [map_sum, map_mul, map_pow, h.map_X, hroot, ← h.algebraMap_apply, hmap, lift_root, lift_algebraMap]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring S
f : R[X]
inst✝² : Algebra R S
T : Type u_1
inst✝¹ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
inst✝ : Algebra R T
hx' : ↑(aeval x) f = 0
h : IsAdjoinRoot S f
z : R[X]
⊢ ↑(liftHom x hx' h) (↑h.map z) = ↑(aeval x) z
[PROOFSTEP]
rw [← lift_algebraMap_apply, lift_map, aeval_def]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring S
f : R[X]
inst✝² : Algebra R S
T : Type u_1
inst✝¹ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
inst✝ : Algebra R T
hx' : ↑(aeval x) f = 0
h : IsAdjoinRoot S f
⊢ ↑(liftHom x hx' h) (root h) = x
[PROOFSTEP]
rw [← lift_algebraMap_apply, lift_root]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
⊢ RingHom.ker (mk f) = Ideal.span {f}
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
x✝ : R[X]
⊢ x✝ ∈ RingHom.ker (mk f) ↔ x✝ ∈ Ideal.span {f}
[PROOFSTEP]
rw [RingHom.mem_ker, ← @AdjoinRoot.mk_self _ _ f, AdjoinRoot.mk_eq_mk, Ideal.mem_span_singleton, ←
  dvd_add_left (dvd_refl f), sub_add_cancel]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
⊢ IsAdjoinRoot.root (AdjoinRoot.isAdjoinRoot f) = root f
[PROOFSTEP]
simp only [IsAdjoinRoot.root, AdjoinRoot.root, AdjoinRoot.isAdjoinRoot_map_eq_mk]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
hf : Monic f
⊢ IsAdjoinRoot.root (AdjoinRoot.isAdjoinRootMonic f hf).toIsAdjoinRoot = root f
[PROOFSTEP]
simp only [IsAdjoinRoot.root, AdjoinRoot.root, AdjoinRoot.isAdjoinRootMonic_map_eq_mk]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ ↑h.map (g %ₘ f) = ↑h.map g
[PROOFSTEP]
rw [← RingHom.sub_mem_ker_iff, mem_ker_map, modByMonic_eq_sub_mul_div _ h.Monic, sub_right_comm, sub_self, zero_sub,
  dvd_neg]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ f * (g /ₘ f)
[PROOFSTEP]
exact ⟨_, rfl⟩
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ IsAdjoinRoot.repr h.toIsAdjoinRoot (↑h.map g) - g
[PROOFSTEP]
rw [← h.mem_ker_map, RingHom.sub_mem_ker_iff, map_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
⊢ (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x + (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y
[PROOFSTEP]
conv_lhs =>
  rw [← h.map_repr x, ← h.map_repr y, ← map_add]
  dsimp only
    -- Porting note: added
  rw [h.modByMonic_repr_map, add_modByMonic]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
| (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y)
[PROOFSTEP]
  rw [← h.map_repr x, ← h.map_repr y, ← map_add]
  dsimp only
    -- Porting note: added
  rw [h.modByMonic_repr_map, add_modByMonic]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
| (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y)
[PROOFSTEP]
  rw [← h.map_repr x, ← h.map_repr y, ← map_add]
  dsimp only
    -- Porting note: added
  rw [h.modByMonic_repr_map, add_modByMonic]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
| (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y)
[PROOFSTEP]
rw [← h.map_repr x, ← h.map_repr y, ← map_add]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
| (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f)
    (↑h.map (IsAdjoinRoot.repr h.toIsAdjoinRoot x + IsAdjoinRoot.repr h.toIsAdjoinRoot y))
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
| IsAdjoinRoot.repr h.toIsAdjoinRoot
      (↑h.map (IsAdjoinRoot.repr h.toIsAdjoinRoot x + IsAdjoinRoot.repr h.toIsAdjoinRoot y)) %ₘ
    f
[PROOFSTEP]
rw [h.modByMonic_repr_map, add_modByMonic]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
c : R
x : S
⊢ AddHom.toFun
      { toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
        map_add' :=
          (_ :
            ∀ (x y : S),
              (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
      (c • x) =
    ↑(RingHom.id R) c •
      AddHom.toFun
        { toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
          map_add' :=
            (_ :
              ∀ (x y : S),
                (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x
[PROOFSTEP]
rw [RingHom.id_apply, ← h.map_repr x, Algebra.smul_def, h.algebraMap_apply, ← map_mul]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
c : R
x : S
⊢ AddHom.toFun
      { toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
        map_add' :=
          (_ :
            ∀ (x y : S),
              (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
      (↑h.map (↑C c * IsAdjoinRoot.repr h.toIsAdjoinRoot x)) =
    c •
      AddHom.toFun
        { toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
          map_add' :=
            (_ :
              ∀ (x y : S),
                (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        (↑h.map (IsAdjoinRoot.repr h.toIsAdjoinRoot x))
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
c : R
x : S
⊢ IsAdjoinRoot.repr h.toIsAdjoinRoot (↑h.map (↑C c * IsAdjoinRoot.repr h.toIsAdjoinRoot x)) %ₘ f =
    c • (IsAdjoinRoot.repr h.toIsAdjoinRoot (↑h.map (IsAdjoinRoot.repr h.toIsAdjoinRoot x)) %ₘ f)
[PROOFSTEP]
rw [h.modByMonic_repr_map, ← smul_eq_C_mul, smul_modByMonic, h.map_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
⊢ ↑h.map (↑(modByMonicHom h) x) = x
[PROOFSTEP]
rw [modByMonicHom, LinearMap.coe_mk]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
⊢ ↑h.map
      (↑{ toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
            map_add' :=
              (_ :
                ∀ (x y : S),
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                      (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x) =
    x
[PROOFSTEP]
dsimp
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
⊢ ↑h.map (IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) = x
[PROOFSTEP]
rw [map_modByMonic, map_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hdeg : n < natDegree f
⊢ ↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ n) = X ^ n
[PROOFSTEP]
nontriviality R
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hdeg : n < natDegree f
✝ : Nontrivial R
⊢ ↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ n) = X ^ n
[PROOFSTEP]
rw [← h.map_X, ← map_pow, modByMonicHom_map, modByMonic_eq_self_iff h.Monic, degree_X_pow]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hdeg : n < natDegree f
✝ : Nontrivial R
⊢ ↑n < degree f
[PROOFSTEP]
contrapose! hdeg
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
✝ : Nontrivial R
hdeg : degree f ≤ ↑n
⊢ natDegree f ≤ n
[PROOFSTEP]
simpa [natDegree_le_iff_degree_le] using hdeg
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
hdeg : 1 < natDegree f
⊢ ↑(modByMonicHom h) (root h.toIsAdjoinRoot) = X
[PROOFSTEP]
simpa using modByMonicHom_root_pow h hdeg
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
⊢ (fun x =>
        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
      (x + y) =
    (fun x =>
          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
        x +
      (fun x =>
          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
        y
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
⊢ Finsupp.comapDomain Fin.val (↑(modByMonicHom h) (x + y)).toFinsupp
      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) (x + y)).toFinsupp.support)) =
    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)) +
      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) y).toFinsupp
        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) y).toFinsupp.support))
[PROOFSTEP]
rw [map_add, toFinsupp_add, Finsupp.comapDomain_add_of_injective Fin.val_injective]
  -- Porting note: the original simp proof with the same lemmas does not work
        -- See https://github.com/leanprover-community/mathlib4/issues/5026
        -- simp only [map_add, Finsupp.comapDomain_add_of_injective Fin.val_injective, toFinsupp_add]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
c : R
x : S
⊢ AddHom.toFun
      {
        toFun := fun x =>
          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
        map_add' :=
          (_ :
            ∀ (x y : S),
              (fun x =>
                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                  (x + y) =
                (fun x =>
                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                    x +
                  (fun x =>
                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                    y) }
      (c • x) =
    ↑(RingHom.id R) c •
      AddHom.toFun
        {
          toFun := fun x =>
            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
          map_add' :=
            (_ :
              ∀ (x y : S),
                (fun x =>
                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                    (x + y) =
                  (fun x =>
                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                      x +
                    (fun x =>
                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                      y) }
        x
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
c : R
x : S
⊢ Finsupp.comapDomain Fin.val (↑(modByMonicHom h) (c • x)).toFinsupp
      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) (c • x)).toFinsupp.support)) =
    ↑(RingHom.id R) c •
      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support))
[PROOFSTEP]
rw [map_smul, toFinsupp_smul, Finsupp.comapDomain_smul_of_injective Fin.val_injective, RingHom.id_apply]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
⊢ (fun g => ↑h.map { toFinsupp := Finsupp.mapDomain (?m.1376551 h g) g })
      (AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                map_add' :=
                  (_ :
                    ∀ (x y : S),
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          (x + y) =
                        (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            x +
                          (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            y) },
            map_smul' :=
              (_ :
                ∀ (c : R) (x : S),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      (c • x) =
                    ↑(RingHom.id R) c •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                          map_add' :=
                            (_ :
                              ∀ (x y : S),
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    (x + y) =
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      x +
                                    (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      y) }
                        x) }.toAddHom
        x) =
    x
[PROOFSTEP]
cases subsingleton_or_nontrivial R
[GOAL]
case inl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Subsingleton R
⊢ (fun g => ↑h.map { toFinsupp := Finsupp.mapDomain (?m.1376551 h g) g })
      (AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                map_add' :=
                  (_ :
                    ∀ (x y : S),
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          (x + y) =
                        (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            x +
                          (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            y) },
            map_smul' :=
              (_ :
                ∀ (c : R) (x : S),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      (c • x) =
                    ↑(RingHom.id R) c •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                          map_add' :=
                            (_ :
                              ∀ (x y : S),
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    (x + y) =
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      x +
                                    (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      y) }
                        x) }.toAddHom
        x) =
    x
[PROOFSTEP]
haveI := h.subsingleton
[GOAL]
case inl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Subsingleton R
this : Subsingleton S
⊢ (fun g => ↑h.map { toFinsupp := Finsupp.mapDomain (?m.1376551 h g) g })
      (AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                map_add' :=
                  (_ :
                    ∀ (x y : S),
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          (x + y) =
                        (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            x +
                          (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            y) },
            map_smul' :=
              (_ :
                ∀ (c : R) (x : S),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      (c • x) =
                    ↑(RingHom.id R) c •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                          map_add' :=
                            (_ :
                              ∀ (x y : S),
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    (x + y) =
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      x +
                                    (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      y) }
                        x) }.toAddHom
        x) =
    x
[PROOFSTEP]
exact Subsingleton.elim _ _
[GOAL]
case inr
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
⊢ (fun g => ↑h.map { toFinsupp := Finsupp.mapDomain (?m.1376551 h g) g })
      (AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun x =>
                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                map_add' :=
                  (_ :
                    ∀ (x y : S),
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          (x + y) =
                        (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            x +
                          (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            y) },
            map_smul' :=
              (_ :
                ∀ (c : R) (x : S),
                  AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      (c • x) =
                    ↑(RingHom.id R) c •
                      AddHom.toFun
                        {
                          toFun := fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                          map_add' :=
                            (_ :
                              ∀ (x y : S),
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    (x + y) =
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      x +
                                    (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      y) }
                        x) }.toAddHom
        x) =
    x
[PROOFSTEP]
simp only
[GOAL]
case inr
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
⊢ ↑h.map
      {
        toFinsupp :=
          Finsupp.mapDomain
            (?m.1376551 h
              (Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support))))
            (Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support))) } =
    x
[PROOFSTEP]
rw [Finsupp.mapDomain_comapDomain, Polynomial.eta, h.map_modByMonicHom x]
[GOAL]
case inr.hf
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
⊢ Function.Injective Fin.val
[PROOFSTEP]
exact Fin.val_injective
[GOAL]
case inr.hl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
⊢ ↑(↑(modByMonicHom h) x).toFinsupp.support ⊆ Set.range Fin.val
[PROOFSTEP]
intro i hi
[GOAL]
case inr.hl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : i ∈ ↑(↑(modByMonicHom h) x).toFinsupp.support
⊢ i ∈ Set.range Fin.val
[PROOFSTEP]
refine Set.mem_range.mpr ⟨⟨i, ?_⟩, rfl⟩
[GOAL]
case inr.hl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : i ∈ ↑(↑(modByMonicHom h) x).toFinsupp.support
⊢ i < natDegree f
[PROOFSTEP]
contrapose! hi
[GOAL]
case inr.hl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
⊢ ¬i ∈ ↑(↑(modByMonicHom h) x).toFinsupp.support
[PROOFSTEP]
simp only [Polynomial.toFinsupp_apply, Classical.not_not, Finsupp.mem_support_iff, Ne.def, modByMonicHom,
  LinearMap.coe_mk, Finset.mem_coe]
[GOAL]
case inr.hl
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
⊢ coeff
      (↑{ toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
            map_add' :=
              (_ :
                ∀ (x y : S),
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                      (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x)
      i =
    0
[PROOFSTEP]
by_cases hx : h.toIsAdjoinRoot.repr x %ₘ f = 0
[GOAL]
case pos
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
hx : IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f = 0
⊢ coeff
      (↑{ toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
            map_add' :=
              (_ :
                ∀ (x y : S),
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                      (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x)
      i =
    0
[PROOFSTEP]
simp [hx]
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
hx : ¬IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f = 0
⊢ coeff
      (↑{ toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
            map_add' :=
              (_ :
                ∀ (x y : S),
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                      (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x)
      i =
    0
[PROOFSTEP]
refine coeff_eq_zero_of_natDegree_lt (lt_of_lt_of_le ?_ hi)
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
hx : ¬IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f = 0
⊢ natDegree
      (↑{ toFun := fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f,
            map_add' :=
              (_ :
                ∀ (x y : S),
                  (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) (x + y) =
                    (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) x +
                      (fun x => IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) y) }
        x) <
    natDegree f
[PROOFSTEP]
dsimp
  -- Porting note: added
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
hx : ¬IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f = 0
⊢ natDegree (IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) < natDegree f
[PROOFSTEP]
rw [natDegree_lt_natDegree_iff hx]
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
h✝ : Nontrivial R
i : ℕ
hi : natDegree f ≤ i
hx : ¬IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f = 0
⊢ degree (IsAdjoinRoot.repr h.toIsAdjoinRoot x %ₘ f) < degree f
[PROOFSTEP]
exact degree_modByMonic_lt _ h.Monic
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun x =>
                Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                  (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
              map_add' :=
                (_ :
                  ∀ (x y : S),
                    (fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                        (x + y) =
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          x +
                        (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          y) },
          map_smul' :=
            (_ :
              ∀ (c : R) (x : S),
                AddHom.toFun
                    {
                      toFun := fun x =>
                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                      map_add' :=
                        (_ :
                          ∀ (x y : S),
                            (fun x =>
                                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                (x + y) =
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  x +
                                (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  y) }
                    (c • x) =
                  ↑(RingHom.id R) c •
                    AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      x) }.toAddHom
      ((fun g => ↑h.map { toFinsupp := Finsupp.mapDomain Fin.val g }) g) =
    g
[PROOFSTEP]
nontriviality R
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun x =>
                Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                  (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
              map_add' :=
                (_ :
                  ∀ (x y : S),
                    (fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                        (x + y) =
                      (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          x +
                        (fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                          y) },
          map_smul' :=
            (_ :
              ∀ (c : R) (x : S),
                AddHom.toFun
                    {
                      toFun := fun x =>
                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                      map_add' :=
                        (_ :
                          ∀ (x y : S),
                            (fun x =>
                                  Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                    (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                (x + y) =
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  x +
                                (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  y) }
                    (c • x) =
                  ↑(RingHom.id R) c •
                    AddHom.toFun
                      {
                        toFun := fun x =>
                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                            (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                        map_add' :=
                          (_ :
                            ∀ (x y : S),
                              (fun x =>
                                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                  (x + y) =
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    x +
                                  (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    y) }
                      x) }.toAddHom
      ((fun g => ↑h.map { toFinsupp := Finsupp.mapDomain Fin.val g }) g) =
    g
[PROOFSTEP]
ext i
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ ↑(AddHom.toFun
          {
              toAddHom :=
                {
                  toFun := fun x =>
                    Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                  map_add' :=
                    (_ :
                      ∀ (x y : S),
                        (fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                            (x + y) =
                          (fun x =>
                                Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                  (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                              x +
                            (fun x =>
                                Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                  (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                              y) },
              map_smul' :=
                (_ :
                  ∀ (c : R) (x : S),
                    AddHom.toFun
                        {
                          toFun := fun x =>
                            Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                              (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                          map_add' :=
                            (_ :
                              ∀ (x y : S),
                                (fun x =>
                                      Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                        (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                    (x + y) =
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      x +
                                    (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      y) }
                        (c • x) =
                      ↑(RingHom.id R) c •
                        AddHom.toFun
                          {
                            toFun := fun x =>
                              Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)),
                            map_add' :=
                              (_ :
                                ∀ (x y : S),
                                  (fun x =>
                                        Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                          (_ :
                                            Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                      (x + y) =
                                    (fun x =>
                                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                            (_ :
                                              Set.InjOn Fin.val
                                                (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                        x +
                                      (fun x =>
                                          Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
                                            (_ :
                                              Set.InjOn Fin.val
                                                (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
                                        y) }
                          x) }.toAddHom
          ((fun g => ↑h.map { toFinsupp := Finsupp.mapDomain Fin.val g }) g))
      i =
    ↑g i
[PROOFSTEP]
simp only [h.modByMonicHom_map, Finsupp.comapDomain_apply, Polynomial.toFinsupp_apply]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ coeff ({ toFinsupp := Finsupp.mapDomain Fin.val g } %ₘ f) ↑i = ↑g i
[PROOFSTEP]
rw [(Polynomial.modByMonic_eq_self_iff h.Monic).mpr, Polynomial.coeff]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := Finsupp.mapDomain Fin.val g } with
      | { toFinsupp := p } => ↑p)
      ↑i =
    ↑g i
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ degree { toFinsupp := Finsupp.mapDomain Fin.val g } < degree f
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ ↑(Finsupp.mapDomain Fin.val g) ↑i = ↑g i
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ degree { toFinsupp := Finsupp.mapDomain Fin.val g } < degree f
[PROOFSTEP]
rw [Finsupp.mapDomain_apply Fin.val_injective]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ degree { toFinsupp := Finsupp.mapDomain Fin.val g } < degree f
[PROOFSTEP]
rw [degree_eq_natDegree h.Monic.ne_zero, degree_lt_iff_coeff_zero]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
⊢ ∀ (m : ℕ), natDegree f ≤ m → coeff { toFinsupp := Finsupp.mapDomain Fin.val g } m = 0
[PROOFSTEP]
intro m hm
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
m : ℕ
hm : natDegree f ≤ m
⊢ coeff { toFinsupp := Finsupp.mapDomain Fin.val g } m = 0
[PROOFSTEP]
rw [Polynomial.coeff]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
m : ℕ
hm : natDegree f ≤ m
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := Finsupp.mapDomain Fin.val g } with
      | { toFinsupp := p } => ↑p)
      m =
    0
[PROOFSTEP]
dsimp only
  -- Porting note: added
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
m : ℕ
hm : natDegree f ≤ m
⊢ ↑(Finsupp.mapDomain Fin.val g) m = 0
[PROOFSTEP]
rw [Finsupp.mapDomain_notin_range]
[GOAL]
case h.h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
m : ℕ
hm : natDegree f ≤ m
⊢ ¬m ∈ Set.range Fin.val
[PROOFSTEP]
rw [Set.mem_range, not_exists]
[GOAL]
case h.h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i : Fin (natDegree f)
m : ℕ
hm : natDegree f ≤ m
⊢ ∀ (x : Fin (natDegree f)), ¬↑x = m
[PROOFSTEP]
rintro i rfl
[GOAL]
case h.h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : Fin (natDegree f) →₀ R
✝ : Nontrivial R
i✝ i : Fin (natDegree f)
hm : natDegree f ≤ ↑i
⊢ False
[PROOFSTEP]
exact i.prop.not_le hm
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
i : Fin (natDegree f)
⊢ Finsupp.comapDomain Fin.val (↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ ↑i)).toFinsupp
      (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ ↑i)).toFinsupp.support)) =
    Finsupp.single i 1
[PROOFSTEP]
ext j
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
i j : Fin (natDegree f)
⊢ ↑(Finsupp.comapDomain Fin.val (↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ ↑i)).toFinsupp
          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) (root h.toIsAdjoinRoot ^ ↑i)).toFinsupp.support)))
      j =
    ↑(Finsupp.single i 1) j
[PROOFSTEP]
rw [Finsupp.comapDomain_apply, modByMonicHom_root_pow]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
i j : Fin (natDegree f)
⊢ ↑(X ^ ↑i).toFinsupp ↑j = ↑(Finsupp.single i 1) j
[PROOFSTEP]
rw [X_pow_eq_monomial, toFinsupp_monomial, Finsupp.single_apply_left Fin.val_injective]
[GOAL]
case h.hdeg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
i j : Fin (natDegree f)
⊢ ↑i < natDegree f
[PROOFSTEP]
exact i.is_lt
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
⊢ 0 < natDegree f
[PROOFSTEP]
rcases h.basis.index_nonempty with ⟨⟨i, hi⟩⟩
[GOAL]
case intro.mk
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
i : ℕ
hi : i < natDegree f
⊢ 0 < natDegree f
[PROOFSTEP]
exact (Nat.zero_le _).trans_lt hi
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
i : Fin (natDegree f)
⊢ ↑(↑(basis h).repr x) i = coeff (↑(modByMonicHom h) x) ↑i
[PROOFSTEP]
change (h.modByMonicHom x).toFinsupp.comapDomain _ (Fin.val_injective.injOn _) i = _
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x : S
i : Fin (natDegree f)
⊢ ↑(Finsupp.comapDomain Fin.val (↑(modByMonicHom h) x).toFinsupp
          (_ : Set.InjOn Fin.val (Fin.val ⁻¹' ↑(↑(modByMonicHom h) x).toFinsupp.support)))
      i =
    coeff (↑(modByMonicHom h) x) ↑i
[PROOFSTEP]
rw [Finsupp.comapDomain_apply, Polynomial.toFinsupp_apply]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
hdeg : 1 < natDegree f
⊢ ↑(basis h) { val := 1, isLt := hdeg } = root h.toIsAdjoinRoot
[PROOFSTEP]
rw [h.basis_apply, Fin.val_mk, pow_one]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < natDegree f
⊢ ↑(coeff h) z i = ↑(↑(basis h).repr z) { val := i, isLt := hi }
[PROOFSTEP]
simp only [coeff, LinearMap.comp_apply, Finsupp.lcoeFun_apply, Finsupp.lmapDomain_apply, LinearEquiv.coe_coe,
  liftPolyₗ_apply, LinearMap.coe_mk, h.basis_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < natDegree f
⊢ ↑{ toFun := Polynomial.coeff,
          map_add' := (_ : ∀ (p q : R[X]), Polynomial.coeff (p + q) = Polynomial.coeff p + Polynomial.coeff q) }
      (↑(modByMonicHom h) z) i =
    Polynomial.coeff (↑(modByMonicHom h) z) i
[PROOFSTEP]
rfl
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : natDegree f ≤ i
⊢ ↑(coeff h) z i = 0
[PROOFSTEP]
simp only [coeff, LinearMap.comp_apply, Finsupp.lcoeFun_apply, Finsupp.lmapDomain_apply, LinearEquiv.coe_coe,
  liftPolyₗ_apply, LinearMap.coe_mk, h.basis_repr]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : natDegree f ≤ i
⊢ ↑{ toFun := Polynomial.coeff,
          map_add' := (_ : ∀ (p q : R[X]), Polynomial.coeff (p + q) = Polynomial.coeff p + Polynomial.coeff q) }
      (↑(modByMonicHom h) z) i =
    0
[PROOFSTEP]
nontriviality R
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : natDegree f ≤ i
✝ : Nontrivial R
⊢ ↑{ toFun := Polynomial.coeff,
          map_add' := (_ : ∀ (p q : R[X]), Polynomial.coeff (p + q) = Polynomial.coeff p + Polynomial.coeff q) }
      (↑(modByMonicHom h) z) i =
    0
[PROOFSTEP]
exact
  Polynomial.coeff_eq_zero_of_degree_lt
    ((degree_modByMonic_lt _ h.Monic).trans_le (Polynomial.degree_le_of_natDegree_le hi))
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
⊢ ↑(coeff h) z i = if hi : i < natDegree f then ↑(↑(basis h).repr z) { val := i, isLt := hi } else 0
[PROOFSTEP]
split_ifs with hi
[GOAL]
case pos
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : i < natDegree f
⊢ ↑(coeff h) z i = ↑(↑(basis h).repr z) { val := i, isLt := hi }
[PROOFSTEP]
exact h.coeff_apply_lt z i hi
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : ¬i < natDegree f
⊢ ↑(coeff h) z i = 0
[PROOFSTEP]
exact h.coeff_apply_le z i (le_of_not_lt hi)
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
⊢ ↑(coeff h) (root h.toIsAdjoinRoot ^ n) = Pi.single n 1
[PROOFSTEP]
ext i
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
⊢ ↑(coeff h) (root h.toIsAdjoinRoot ^ n) i = Pi.single n 1 i
[PROOFSTEP]
rw [coeff_apply]
[GOAL]
case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
⊢ (if hi : i < natDegree f then ↑(↑(basis h).repr (root h.toIsAdjoinRoot ^ n)) { val := i, isLt := hi } else 0) =
    Pi.single n 1 i
[PROOFSTEP]
split_ifs with hi
[GOAL]
case pos
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : i < natDegree f
⊢ ↑(↑(basis h).repr (root h.toIsAdjoinRoot ^ n)) { val := i, isLt := hi } = Pi.single n 1 i
[PROOFSTEP]
calc
  h.basis.repr (h.root ^ n) ⟨i, _⟩ = h.basis.repr (h.basis ⟨n, hn⟩) ⟨i, hi⟩ := by rw [h.basis_apply, Fin.val_mk]
  _ = Pi.single (f := fun _ => R) ((⟨n, hn⟩ : Fin _) : ℕ) (1 : (fun _ => R) n) ↑(⟨i, _⟩ : Fin _) := by
    rw [h.basis.repr_self, ← Finsupp.single_eq_pi_single, Finsupp.single_apply_left Fin.val_injective]
  _ = Pi.single (f := fun _ => R) n 1 i := by rw [Fin.val_mk, Fin.val_mk]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : i < natDegree f
⊢ ↑(↑(basis h).repr (root h.toIsAdjoinRoot ^ n)) { val := i, isLt := hi } =
    ↑(↑(basis h).repr (↑(basis h) { val := n, isLt := hn })) { val := i, isLt := hi }
[PROOFSTEP]
rw [h.basis_apply, Fin.val_mk]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : i < natDegree f
⊢ ↑(↑(basis h).repr (↑(basis h) { val := n, isLt := hn })) { val := i, isLt := hi } =
    Pi.single (↑{ val := n, isLt := hn }) 1 ↑{ val := i, isLt := ?m.1551980 }
[PROOFSTEP]
rw [h.basis.repr_self, ← Finsupp.single_eq_pi_single, Finsupp.single_apply_left Fin.val_injective]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : i < natDegree f
⊢ Pi.single (↑{ val := n, isLt := hn }) 1 ↑{ val := i, isLt := hi } = Pi.single n 1 i
[PROOFSTEP]
rw [Fin.val_mk, Fin.val_mk]
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : ¬i < natDegree f
⊢ 0 = Pi.single n 1 i
[PROOFSTEP]
refine (Pi.single_eq_of_ne (f := fun _ => R) ?_ (1 : (fun _ => R) n)).symm
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
n : ℕ
hn : n < natDegree f
i : ℕ
hi : ¬i < natDegree f
⊢ i ≠ n
[PROOFSTEP]
rintro rfl
[GOAL]
case neg
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
i : ℕ
hi : ¬i < natDegree f
hn : i < natDegree f
⊢ False
[PROOFSTEP]
simp [hi] at hn
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
⊢ ↑(coeff h) 1 = Pi.single 0 1
[PROOFSTEP]
rw [← h.coeff_root_pow h.deg_pos, pow_zero]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
hdeg : 1 < natDegree f
⊢ ↑(coeff h) (root h.toIsAdjoinRoot) = Pi.single 1 1
[PROOFSTEP]
rw [← h.coeff_root_pow hdeg, pow_one]
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
⊢ ↑(coeff h) (↑(algebraMap R S) x) = Pi.single 0 x
[PROOFSTEP]
ext i
[GOAL]
case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ ↑(coeff h) (↑(algebraMap R S) x) i = Pi.single 0 x i
[PROOFSTEP]
rw [Algebra.algebraMap_eq_smul_one, map_smul, coeff_one, Pi.smul_apply, smul_eq_mul]
[GOAL]
case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ x * Pi.single 0 1 i = Pi.single 0 x i
[PROOFSTEP]
refine' (Pi.apply_single (fun _ y => x * y) _ 0 1 i).trans (by simp)
[GOAL]
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ Pi.single 0 (x * 1) i = Pi.single 0 x i
[PROOFSTEP]
simp
[GOAL]
case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i : ℕ
⊢ ∀ (i : ℕ), (fun x_1 y => x * y) i 0 = 0
[PROOFSTEP]
intros
[GOAL]
case h
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
x : R
i i✝ : ℕ
⊢ (fun x_1 y => x * y) i✝ 0 = 0
[PROOFSTEP]
simp
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
hxy : ∀ (i : ℕ), i < natDegree f → ↑(coeff h) x i = ↑(coeff h) y i
i : Fin (natDegree f)
⊢ ↑(Basis.equivFun (basis h)) x i = ↑(Basis.equivFun (basis h)) y i
[PROOFSTEP]
rw [Basis.equivFun_apply, ← h.coeff_apply_coe, Basis.equivFun_apply, ← h.coeff_apply_coe, hxy i i.prop]
[GOAL]
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
f : R[X]
h : IsAdjoinRoot S f
x : S
⊢ ↑(lift (algebraMap R S) (root h) (_ : ↑(aeval (root h)) f = 0) h) x = x
[PROOFSTEP]
rw [← h.map_repr x, lift_map, ← aeval_def, h.aeval_eq]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
src✝ : S →ₐ[R] T := liftHom (root h') (_ : ↑(aeval (root h')) f = 0) h
x : S
⊢ ↑(liftHom (root h) (_ : ↑(aeval (root h)) f = 0) h') (↑(liftHom (root h') (_ : ↑(aeval (root h')) f = 0) h) x) = x
[PROOFSTEP]
rw [← h.map_repr x, liftHom_map, aeval_eq, liftHom_map, aeval_eq]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
src✝ : S →ₐ[R] T := liftHom (root h') (_ : ↑(aeval (root h')) f = 0) h
x : T
⊢ ↑(liftHom (root h') (_ : ↑(aeval (root h')) f = 0) h) (↑(liftHom (root h) (_ : ↑(aeval (root h)) f = 0) h') x) = x
[PROOFSTEP]
rw [← h'.map_repr x, liftHom_map, aeval_eq, liftHom_map, aeval_eq]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
z : R[X]
⊢ ↑(aequiv h h') (↑h.map z) = ↑h'.map z
[PROOFSTEP]
rw [aequiv, AlgEquiv.coe_mk, liftHom_map, aeval_eq]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
⊢ ↑(aequiv h h') (root h) = root h'
[PROOFSTEP]
rw [aequiv, AlgEquiv.coe_mk, liftHom_root]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
⊢ aequiv h h = AlgEquiv.refl
[PROOFSTEP]
ext a
[GOAL]
case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
a : S
⊢ ↑(aequiv h h) a = ↑AlgEquiv.refl a
[PROOFSTEP]
exact h.lift_self_apply a
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
⊢ AlgEquiv.symm (aequiv h h') = aequiv h' h
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
a✝ : T
⊢ ↑(AlgEquiv.symm (aequiv h h')) a✝ = ↑(aequiv h' h) a✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
S : Type v
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
inst✝³ : Algebra R S
f : R[X]
T : Type u_1
inst✝² : CommRing T
inst✝¹ : Algebra R T
U : Type u_2
inst✝ : CommRing U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
i : R →+* U
x : U
hx : eval₂ i x f = 0
z : S
⊢ ↑(lift i x hx h') (↑(aequiv h h') z) = ↑(lift i x hx h) z
[PROOFSTEP]
rw [← h.map_repr z, aequiv_map, lift_map, lift_map]
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
h'' : IsAdjoinRoot U f
⊢ AlgEquiv.trans (aequiv h h') (aequiv h' h'') = aequiv h h''
[PROOFSTEP]
ext z
[GOAL]
case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
h'' : IsAdjoinRoot U f
z : S
⊢ ↑(AlgEquiv.trans (aequiv h h') (aequiv h' h'')) z = ↑(aequiv h h'') z
[PROOFSTEP]
exact h.aequiv_aequiv h' h'' z
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
⊢ RingHom.ker (RingHom.comp (↑↑e) h.map) = Ideal.span {f}
[PROOFSTEP]
rw [← RingHom.comap_ker, RingHom.ker_coe_equiv, ← RingHom.ker_eq_comap_bot, h.ker_map]
[GOAL]
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
⊢ algebraMap R T = RingHom.comp (RingHom.comp (↑↑e) h.map) C
[PROOFSTEP]
ext
[GOAL]
case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
x✝ : R
⊢ ↑(algebraMap R T) x✝ = ↑(RingHom.comp (RingHom.comp (↑↑e) h.map) C) x✝
[PROOFSTEP]
simp only [AlgEquiv.commutes, RingHom.comp_apply, AlgEquiv.coe_ringEquiv, RingEquiv.coe_toRingHom, ← h.algebraMap_apply]
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
e : T ≃ₐ[R] U
⊢ aequiv h (ofEquiv h' e) = AlgEquiv.trans (aequiv h h') e
[PROOFSTEP]
ext a
[GOAL]
case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
e : T ≃ₐ[R] U
a : S
⊢ ↑(aequiv h (ofEquiv h' e)) a = ↑(AlgEquiv.trans (aequiv h h') e) a
[PROOFSTEP]
rw [← h.map_repr a, aequiv_map, AlgEquiv.trans_apply, aequiv_map, ofEquiv_map_apply]
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot U f
e : S ≃ₐ[R] T
⊢ aequiv (ofEquiv h e) h' = AlgEquiv.trans (AlgEquiv.symm e) (aequiv h h')
[PROOFSTEP]
ext a
[GOAL]
case h
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
U : Type u_2
inst✝¹ : CommRing U
inst✝ : Algebra R U
h : IsAdjoinRoot S f
h' : IsAdjoinRoot U f
e : S ≃ₐ[R] T
a : T
⊢ ↑(aequiv (ofEquiv h e) h') a = ↑(AlgEquiv.trans (AlgEquiv.symm e) (aequiv h h')) a
[PROOFSTEP]
rw [← (h.ofEquiv e).map_repr a, aequiv_map, AlgEquiv.trans_apply, ofEquiv_map_apply, e.symm_apply_apply, aequiv_map]
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
h : IsAdjoinRootMonic S f
hirr : Irreducible f
q : R[X]
hq : f = minpoly R (IsAdjoinRoot.root h.toIsAdjoinRoot) * q
⊢ Associated f (minpoly R (IsAdjoinRoot.root h.toIsAdjoinRoot))
[PROOFSTEP]
convert
  Associated.mul_left (minpoly R h.root) <|
    associated_one_iff_isUnit.2 <| (hirr.isUnit_or_isUnit hq).resolve_left <| minpoly.not_isUnit R h.root
[GOAL]
case h.e'_4
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
h : IsAdjoinRootMonic S f
hirr : Irreducible f
q : R[X]
hq : f = minpoly R (IsAdjoinRoot.root h.toIsAdjoinRoot) * q
⊢ minpoly R (IsAdjoinRoot.root h.toIsAdjoinRoot) = minpoly R (IsAdjoinRoot.root h.toIsAdjoinRoot) * 1
[PROOFSTEP]
rw [mul_one]
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx' : IsIntegral R x
⊢ minpoly R x = minpoly R (powerBasis' hx').gen
[PROOFSTEP]
haveI := isDomain_of_prime (prime_of_isIntegrallyClosed hx')
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx' : IsIntegral R x
this : IsDomain (AdjoinRoot (minpoly R x))
⊢ minpoly R x = minpoly R (powerBasis' hx').gen
[PROOFSTEP]
haveI :=
  noZeroSMulDivisors_of_prime_of_degree_ne_zero (prime_of_isIntegrallyClosed hx') (ne_of_lt (degree_pos hx')).symm
[GOAL]
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx' : IsIntegral R x
this✝ : IsDomain (AdjoinRoot (minpoly R x))
this : NoZeroSMulDivisors R (AdjoinRoot (minpoly R x))
⊢ minpoly R x = minpoly R (powerBasis' hx').gen
[PROOFSTEP]
rw [← minpolyGen_eq, adjoin.powerBasis', minpolyGen_map, minpolyGen_eq, AdjoinRoot.powerBasis'_gen, ←
  isAdjoinRootMonic_root_eq_root _ (monic hx'), minpoly_eq]
[GOAL]
case hirr
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
f : R[X]
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx' : IsIntegral R x
this✝ : IsDomain (AdjoinRoot (minpoly R x))
this : NoZeroSMulDivisors R (AdjoinRoot (minpoly R x))
⊢ Irreducible (minpoly R x)
[PROOFSTEP]
exact irreducible hx'