On Some Local Rings (Maassarani, 2025) -- Section 01 -- Part 2

Lean contributors (project-level attribution): Liang Xiao, Haochen Ju, Zichen Wang.

Source header Β· Attribution source

namespace SomeLocalRingsopen Polynomialopen scoped BigOperatorsvariable {π•œ : Type*} [Field π•œ]

The AdjoinRoot sorry : Type u_1AdjoinRoot Unknown identifier `P`P-dimension of AdjoinRoot (sorry ^ sorry) : Type u_1AdjoinRoot (Unknown identifier `P`P^Unknown identifier `k`k) is Unknown identifier `k`k under the scalar tower hypothesis.

lemma finrank_target_over_adjoinRoot_eq_k (P : Polynomial π•œ) (hP : Irreducible P) (k : β„•) [Algebra (AdjoinRoot P) (AdjoinRoot (P ^ k))] [IsScalarTower π•œ (AdjoinRoot P) (AdjoinRoot (P ^ k))] : Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) = k := by classical haveI : Fact (Irreducible P) := ⟨hP⟩ have hPk0 : (P ^ k) β‰  0 := pow_ne_zero k hP.ne_zero have hP0 : P β‰  0 := hP.ne_zero haveI : Module.Finite π•œ (AdjoinRoot P) := Module.Finite.of_basis (AdjoinRoot.powerBasis (K := π•œ) hP0).basis haveI : Module.Finite π•œ (AdjoinRoot (P ^ k)) := Module.Finite.of_basis (AdjoinRoot.powerBasis (K := π•œ) hPk0).basis -- Ensure the finrank over `AdjoinRoot P` is defined, using finiteness over `π•œ`. haveI : Module.Finite (AdjoinRoot P) (AdjoinRoot (P ^ k)) := Module.Finite.right π•œ (AdjoinRoot P) (AdjoinRoot (P ^ k)) have hdegPpos : 0 < P.natDegree := by -- An irreducible polynomial over a field has positive degree. exact (Polynomial.natDegree_pos_iff_degree_pos).2 (Polynomial.degree_pos_of_irreducible hP) have finrank_base : Module.finrank π•œ (AdjoinRoot P) = P.natDegree := by simpa [AdjoinRoot.powerBasis_dim (K := π•œ) (f := P) hP0] using (PowerBasis.finrank (AdjoinRoot.powerBasis (K := π•œ) hP0)) have finrank_target : Module.finrank π•œ (AdjoinRoot (P ^ k)) = (P ^ k).natDegree := by simpa [AdjoinRoot.powerBasis_dim (K := π•œ) (f := P ^ k) hPk0] using (PowerBasis.finrank (AdjoinRoot.powerBasis (K := π•œ) hPk0)) -- Apply the tower finrank formula and cancel `P.natDegree`. have hmul : Module.finrank π•œ (AdjoinRoot P) * Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) = Module.finrank π•œ (AdjoinRoot (P ^ k)) := by simpa [Nat.mul_comm] using (Module.finrank_mul_finrank π•œ (AdjoinRoot P) (AdjoinRoot (P ^ k))) -- Rewrite the finranks in terms of `natDegree`. have hmul' : P.natDegree * Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) = (P ^ k).natDegree := by simpa [finrank_base, finrank_target, Nat.mul_comm, Nat.mul_left_comm, Nat.mul_assoc] using hmul -- `natDegree (P^k) = k * natDegree P`. have hdegpow : (P ^ k).natDegree = k * P.natDegree := by simp [Polynomial.natDegree_pow] -- Cancel `P.natDegree`. have : P.natDegree * Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) = P.natDegree * k := by simpa [hdegpow, Nat.mul_comm, Nat.mul_left_comm, Nat.mul_assoc] using hmul' exact mul_left_cancelβ‚€ (Nat.ne_of_gt hdegPpos) this

Theorem 1.7. Let Unknown identifier `π•œ`π•œ be a field and Unknown identifier `P`P be an irreducible polynomial over Unknown identifier `π•œ`π•œ. If Unknown identifier `P'`sorry β‰  0 : PropP' β‰  0, then failed to synthesize instance of type class GetElem Prop Prop (Type ?u.626256) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P`P ^ Unknown identifier `k`k) is isomorphic, as an failed to synthesize instance of type class GetElem Prop Prop (Type ?u.633035) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P`P)-algebra (and hence as a Unknown identifier `π•œ`π•œ-algebra), to failed to prove index is valid, possible solutions: - Use `have`-expressions to prove the index is valid - Use `a[i]!` notation instead, runtime check is performed, and 'Panic' error message is produced if index is not valid - Use `a[i]?` notation instead, result is an `Option` type - Use `a[i]'h` notation instead, where `h` is a proof that index is valid ⊒ ?m.4 (sorry[sorry] β§Έ sorry) sorry(sorry[sorry] β§Έ sorry)[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)(failed to synthesize instance of type class GetElem Prop Prop (Type ?u.638886) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P`P))[Unknown identifier `Y`Y]β§Έ(Unknown identifier `Y`Y ^ Unknown identifier `k`k). The isomorphism is given by .

theorem exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (P : Polynomial π•œ) (hP : Irreducible P) (hP' : P.derivative β‰  0) (k : β„•) (hk : 1 ≀ k) [Algebra (AdjoinRoot P) (AdjoinRoot (P ^ k))] [IsScalarTower π•œ (AdjoinRoot P) (AdjoinRoot (P ^ k))] : βˆƒ e : AdjoinRoot ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k) ≃ₐ[AdjoinRoot P] AdjoinRoot (P ^ k), e (AdjoinRoot.root ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k)) = AdjoinRoot.mk (P ^ k) P := by classical haveI : Fact (Irreducible P) := ⟨hP⟩ let ψ : AdjoinRoot ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k) →ₐ[AdjoinRoot P] AdjoinRoot (P ^ k) := psiK (P := P) (k := k) have hψroot : ψ (AdjoinRoot.root ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k)) = AdjoinRoot.mk (P ^ k) P := by simpa [ψ] using (psiK_def_and_root (P := P) (k := k)) have hψ_inj : Function.Injective ψ := by simpa [ψ] using (psiK_injective (P := P) (hP := hP) (hP' := hP') (k := k) (hk := hk)) -- Compare finranks over `AdjoinRoot P` to deduce surjectivity. have finrank_dom : Module.finrank (AdjoinRoot P) (AdjoinRoot ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k)) = k := by simpa using (finrank_domain_over_adjoinRoot_eq_k (P := P) (hP := hP) (k := k)) have finrank_cod : Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) = k := by simpa using (finrank_target_over_adjoinRoot_eq_k (P := P) (hP := hP) (k := k)) have hfin : Module.finrank (AdjoinRoot P) (AdjoinRoot ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k)) = Module.finrank (AdjoinRoot P) (AdjoinRoot (P ^ k)) := by simp [finrank_dom, finrank_cod] have hψ_surj : Function.Surjective ψ := by -- Use the finite-dimensional linear algebra lemma over the field `AdjoinRoot P`. haveI : Module.Finite π•œ (AdjoinRoot P) := Module.Finite.of_basis (AdjoinRoot.powerBasis (K := π•œ) hP.ne_zero).basis haveI : Module.Finite π•œ (AdjoinRoot (P ^ k)) := Module.Finite.of_basis (AdjoinRoot.powerBasis (K := π•œ) (pow_ne_zero k hP.ne_zero)).basis haveI : Module.Finite (AdjoinRoot P) (AdjoinRoot (P ^ k)) := Module.Finite.right π•œ (AdjoinRoot P) (AdjoinRoot (P ^ k)) haveI : FiniteDimensional (AdjoinRoot P) (AdjoinRoot ((Polynomial.X : Polynomial (AdjoinRoot P)) ^ k)) := by classical let g : Polynomial (AdjoinRoot P) := (Polynomial.X : Polynomial (AdjoinRoot P)) ^ k have hg : g β‰  0 := by simp [g] exact Module.Basis.finiteDimensional_of_finite (AdjoinRoot.powerBasis (K := AdjoinRoot P) hg).basis haveI : FiniteDimensional (AdjoinRoot P) (AdjoinRoot (P ^ k)) := by classical exact Module.Basis.finiteDimensional_of_finite (Module.finBasis (AdjoinRoot P) (AdjoinRoot (P ^ k))) have hsurj_lin : Function.Surjective (ψ.toLinearMap : _ β†’β‚—[AdjoinRoot P] _) := (LinearMap.injective_iff_surjective_of_finrank_eq_finrank hfin).1 (by -- `ψ.toLinearMap` has the same underlying function as `ψ`. simpa using hψ_inj) simpa using hsurj_lin refine ⟨AlgEquiv.ofBijective ψ ⟨hψ_inj, hψ_surj⟩, ?_⟩ simp [AlgEquiv.ofBijective_apply, hψroot]

A ring equivalence preserves the nilradical ideal.

lemma nilradical_map_eq_of_ringEquiv {R S : Type*} [CommSemiring R] [CommSemiring S] (e : R ≃+* S) : (nilradical R).map (e : R β†’+* S) = nilradical S := by ext y constructor Β· intro hy rcases (Ideal.mem_map_iff_of_surjective (e : R β†’+* S) e.surjective).1 hy with ⟨x, hx, rfl⟩ exact (mem_nilradical).2 (((mem_nilradical).1 hx).map (e : R β†’+* S)) Β· intro hy refine (Ideal.mem_map_iff_of_surjective (e : R β†’+* S) e.surjective).2 ?_ refine ⟨e.symm y, ?_, by simp⟩ exact (mem_nilradical).2 (((mem_nilradical).1 hy).map (e.symm : S β†’+* R))

The quotient of failed to synthesize instance of type class GetElem Prop Prop ?m.13 Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `A`sorry[sorry] / sorry ^ sorry : ?m.15A[Unknown identifier `Y`Y]/(Unknown identifier `Y`Y^Unknown identifier `k`k) by the ideal (Unknown identifier `Y`Y) is canonically isomorphic to Unknown identifier `A`A.

We present failed to synthesize instance of type class GetElem Prop Prop ?m.13 Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `A`sorry[sorry] / sorry ^ sorry : ?m.15A[Unknown identifier `Y`Y]/(Unknown identifier `Y`Y^Unknown identifier `k`k) as AdjoinRoot (sorry ^ sorry) : Type u_1AdjoinRoot (Unknown identifier `X`X^Unknown identifier `k`k) and the ideal (Unknown identifier `Y`Y) as the span of the adjoined root.

noncomputable def quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A : Type*) [CommRing A] (k : β„•) (hk : 1 ≀ k) : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ≃+* A := by classical -- Work in the polynomial ring and apply the third isomorphism theorem. let I : Ideal (Polynomial A) := Ideal.span ({(X : Polynomial A) ^ k} : Set (Polynomial A)) let J : Ideal (Polynomial A) := Ideal.span ({(X : Polynomial A)} : Set (Polynomial A)) have hIJ : I ≀ J := by -- Since `k β‰₯ 1`, we have `X^k ∈ (X)`. cases k with | zero => cases (Nat.not_succ_le_zero 0 hk) | succ k => refine Ideal.span_le.2 ?_ intro y hy have hX : (X : Polynomial A) ∈ J := by try 'simp' instead of 'simpa' Note: This linter can be disabled with `set_option linter.unnecessarySimpa false`simpa [J] using (Ideal.subset_span (by 'simp' tactic does nothing Note: This linter can be disabled with `set_option linter.unusedTactic false`this tactic is never executed Note: This linter can be disabled with `set_option linter.unreachableTactic false`simp : (X : Polynomial A) ∈ ({X} : Set _))) -- `X^(k+1) = X^k * X`. have hXpow : (X : Polynomial A) ^ (Nat.succ k) ∈ J := by simpa [pow_succ] using (J.mul_mem_left ((X : Polynomial A) ^ k) hX) have : y = (X : Polynomial A) ^ (Nat.succ k) := by simpa [I] using hy simpa [this] using hXpow -- Identify the ideal generated by the class of `X` in the quotient. have hJmap : J.map (Ideal.Quotient.mk I) = Ideal.span ({(Ideal.Quotient.mk I) (X : Polynomial A)} : Set (Polynomial A β§Έ I)) := by simp [J, Ideal.map_span] -- Rewrite the ideal generated by the adjoined root as the image of `(X)`. have hIdeal : Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set (AdjoinRoot ((X : Polynomial A) ^ k))) = J.map (Ideal.Quotient.mk I) := by -- `J.map (mk I)` is the ideal generated by the class of `X` in `A[X]/I`. simpa [AdjoinRoot, AdjoinRoot.root, AdjoinRoot.mk, I] using hJmap.symm -- Apply the third isomorphism theorem, then identify `A[X]/(X)` with `A` via evaluation at `0`. refine (Ideal.quotEquivOfEq hIdeal).trans ?_ have e₃ : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ J.map (Ideal.Quotient.mk I)) ≃+* Polynomial A β§Έ J := by simpa [AdjoinRoot, I] using (DoubleQuot.quotQuotEquivQuotOfLE (R := Polynomial A) (I := I) (J := J) hIJ) refine e₃.trans ?_ have hJ0 : J = Ideal.span ({(X : Polynomial A) - C (0 : A)} : Set (Polynomial A)) := by simp [J] exact (Ideal.quotEquivOfEq hJ0).trans (Polynomial.quotientSpanXSubCAlgEquiv (R := A) (x := (0 : A))).toRingEquiv
set_option maxHeartbeats 800000 in /-- The isomorphism `A[Y]/(Y^k)/(Y) ≃ A` sends scalars to scalars. -/ lemma quotient_span_root_adjoinRoot_X_pow_ringEquiv_base_algebraMap (A : Type*) [CommRing A] (k : β„•) (hk : 1 ≀ k) (a : A) : quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) a) = a := by classical -- Rewrite the scalar into the quotient using the `A`-scalar tower. have ha : (algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) a = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a) := by -- `algebraMap (AdjoinRoot ..) (quotient)` is the quotient map. simpa [Ideal.Quotient.algebraMap_eq, RingHom.comp_apply] using congrArg (fun f => f a) (IsScalarTower.algebraMap_eq A (AdjoinRoot ((X : Polynomial A) ^ k)) (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) -- Reduce to the explicit normal form used in the definition, then evaluate at `0`. rw [ha] show quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) (Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a)) = a have key : (quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk)).symm a = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a) := by unfold quotient_span_root_adjoinRoot_X_pow_ringEquiv_base simp only [RingEquiv.symm_trans, This simp argument is unused: RingEquiv.symm_trans_apply Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RΜ΅inΜ΅gΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅.Μ΅sΜ΅yΜ΅mΜ΅mΜ΅_Μ΅tΜ΅rΜ΅aΜ΅nΜ΅sΜ΅_Μ΅aΜ΅pΜ΅pΜ΅lΜ΅yΜ΅,Μ΅ Μ΅iΜ΅d_eq, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅Ideal.quotEquivOfEq_mk, Ideal.quotEquivOfEq_symm, AlgEquiv.toRingEquiv_symm, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, DoubleQuot.quotQuotEquivQuotOfLE_symm_mk, DoubleQuot.quotQuotMk] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`RingEquiv.symm_trans_apply, id_eq, This simp argument is unused: Ideal.quotEquivOfEq_mk Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RingEquiv.symm_trans_apply, id_eq, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅Ideal.quotEquivOfEq_mΜ΅kΜ΅,Μ΅ Μ΅IΜ΅dΜ΅eΜ΅aΜ΅lΜ΅.Μ΅qΜ΅uΜ΅oΜ΅tΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅OΜ΅fΜ΅EΜ΅qΜ΅_Μ΅symm, AlgEquiv.toRingEquiv_symm, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, DoubleQuot.quotQuotEquivQuotOfLE_symm_mk, DoubleQuot.quotQuotMk] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`Ideal.quotEquivOfEq_mk, Ideal.quotEquivOfEq_symm, This simp argument is unused: AlgEquiv.toRingEquiv_symm Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RingEquiv.symm_trans_apply, id_eq, Ideal.quotEquivOfEq_mk, Μ² Μ² Μ² Μ² Μ² Μ²Ideal.quotEquivOfEq_symm, AΜ΅lΜ΅gΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅.Μ΅tΜ΅oΜ΅RΜ΅iΜ΅nΜ΅gΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅_Μ΅sΜ΅yΜ΅mΜ΅mΜ΅,Μ΅Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, DoubleQuot.quotQuotEquivQuotOfLE_symm_mk, DoubleQuot.quotQuotMk] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`AlgEquiv.toRingEquiv_symm, This simp argument is unused: Polynomial.quotientSpanXSubCAlgEquiv_symm_apply Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RingEquiv.symm_trans_apply, id_eq, Ideal.quotEquivOfEq_mk, Μ² Μ² Μ² Μ² Μ² Μ²Ideal.quotEquivOfEq_symm, AlgEquiv.toRingEquiv_symm, PΜ΅oΜ΅lΜ΅yΜ΅nΜ΅oΜ΅mΜ΅iΜ΅aΜ΅lΜ΅.Μ΅qΜ΅uΜ΅oΜ΅tΜ΅iΜ΅eΜ΅nΜ΅tΜ΅SΜ΅pΜ΅aΜ΅nΜ΅XΜ΅SΜ΅uΜ΅bΜ΅CΜ΅AΜ΅lΜ΅gΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅_Μ΅sΜ΅yΜ΅mΜ΅mΜ΅_Μ΅aΜ΅pΜ΅pΜ΅lΜ΅yΜ΅,Μ΅DoubleQuot.quotQuotEquivQuotOfLE_symm_mk, DoubleQuot.quotQuotMk] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, This simp argument is unused: DoubleQuot.quotQuotEquivQuotOfLE_symm_mk Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RingEquiv.symm_trans_apply, id_eq, Ideal.quotEquivOfEq_mk, Μ² Μ² Μ² Μ² Μ² Μ²Ideal.quotEquivOfEq_symm, AlgEquiv.toRingEquiv_symm, Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, DΜ΅oΜ΅uΜ΅bΜ΅lΜ΅eΜ΅QΜ΅uΜ΅oΜ΅tΜ΅.Μ΅qΜ΅uΜ΅oΜ΅tΜ΅QΜ΅uΜ΅oΜ΅tΜ΅EΜ΅qΜ΅uΜ΅iΜ΅vΜ΅QΜ΅uΜ΅oΜ΅tΜ΅OΜ΅fΜ΅LΜ΅EΜ΅_Μ΅sΜ΅yΜ΅mΜ΅mΜ΅_Μ΅mΜ΅kΜ΅,Μ΅ Μ΅DoubleQuot.quotQuotMk] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`DoubleQuot.quotQuotEquivQuotOfLE_symm_mk, This simp argument is unused: DoubleQuot.quotQuotMk Hint: Omit it from the simp argument list. simp only [RingEquiv.symm_trans, RingEquiv.symm_trans_apply, id_eq, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅Ideal.quotEquivOfEq_mk, Μ² Μ² Μ² Μ² Μ² Μ²Ideal.quotEquivOfEq_symm, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅AlgEquiv.toRingEquiv_symm, Polynomial.quotientSpanXSubCAlgEquiv_symm_apply, Μ΅ Μ΅ Μ΅ Μ΅ Μ΅ Μ΅DoubleQuot.quotQuotEquivQuotOfLE_symm_mk,Μ΅ Μ΅DΜ΅oΜ΅uΜ΅bΜ΅lΜ΅eΜ΅QΜ΅uΜ΅oΜ΅tΜ΅.Μ΅qΜ΅uΜ΅oΜ΅tΜ΅QΜ΅uΜ΅oΜ΅tΜ΅MΜ΅kΜ΅] Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`DoubleQuot.quotQuotMk] rfl rw [← key, RingEquiv.apply_symm_apply]

For a field Unknown identifier `A`A, the nilradical of failed to synthesize instance of type class GetElem Prop Prop ?m.13 Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `A`sorry[sorry] / sorry ^ sorry : ?m.15A[Unknown identifier `Y`Y]/(Unknown identifier `Y`Y^Unknown identifier `k`k) (presented as AdjoinRoot (sorry ^ sorry) : Type u_1AdjoinRoot (Unknown identifier `X`X^Unknown identifier `k`k)) is the ideal generated by Unknown identifier `Y`Y, i.e. the span of the adjoined root.

lemma nilradical_adjoinRoot_X_pow_eq_span_root (A : Type*) [Field A] (k : β„•) (hk : 1 ≀ k) : nilradical (AdjoinRoot ((X : Polynomial A) ^ k)) = Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _) := by classical let T := AdjoinRoot ((X : Polynomial A) ^ k) -- The adjoined root is nilpotent of index `k`. have hrootk : (AdjoinRoot.root ((X : Polynomial A) ^ k) : T) ^ k = 0 := by -- Evaluate `(X^k)` at the root. simpa [Polynomial.evalβ‚‚_pow] using (AdjoinRoot.evalβ‚‚_root ((X : Polynomial A) ^ k)) -- First inclusion: `(root) ≀ nilradical`. have hspan_le : Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T) ≀ nilradical T := by intro x hx -- Elements in a principal ideal are multiples of the generator. rcases Ideal.mem_span_singleton.mp (by simpa using hx) with ⟨a, rfl⟩ refine (mem_nilradical).2 ?_ refine ⟨k, ?_⟩ simp [mul_pow, hrootk] -- Second inclusion: `nilradical ≀ (root)` since `(root)` is a prime ideal. have hprime : (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T)).IsPrime := by -- The quotient by `(root)` is isomorphic to the field `A`, hence a domain. let e := quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) haveI : IsDomain (T β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T)) := e.toMulEquiv.isDomain A exact (Ideal.Quotient.isDomain_iff_prime (I := Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T))).1 (by infer_instance) have hnil_le : nilradical T ≀ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T) := by haveI : (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T)).IsPrime := hprime exact nilradical_le_prime (J := Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set T)) exact le_antisymm hnil_le hspan_le

For fields Unknown identifier `A`A and Unknown identifier `B`B, the truncated polynomial rings failed to synthesize instance of type class GetElem Prop Prop ?m.13 Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `A`sorry[sorry] / sorry ^ sorry : ?m.15A[Unknown identifier `Y`Y]/(Unknown identifier `Y`Y^Unknown identifier `k`k) and failed to synthesize instance of type class GetElem Prop Prop ?m.13 Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `B`sorry[sorry] / sorry ^ sorry : ?m.15B[Unknown identifier `Y`Y]/(Unknown identifier `Y`Y^Unknown identifier `k`k) (presented as AdjoinRoot (sorry ^ sorry) : Type u_1AdjoinRoot (Unknown identifier `X`X^Unknown identifier `k`k)) are isomorphic if and only if Unknown identifier `A`A and Unknown identifier `B`B are isomorphic.

lemma nonempty_ringEquiv_adjoinRoot_X_pow_iff_nonempty_ringEquiv_base (A B : Type*) [Field A] [Field B] (k : β„•) (hk : 1 ≀ k) : Nonempty (AdjoinRoot ((X : Polynomial A) ^ k) ≃+* AdjoinRoot ((X : Polynomial B) ^ k)) ↔ Nonempty (A ≃+* B) := by classical constructor Β· rintro ⟨e⟩ -- Pass to quotients by nilradicals to recover the base fields. have hmap : nilradical (AdjoinRoot ((X : Polynomial B) ^ k)) = (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))).map (e : _ β†’+* _) := by simpa using (nilradical_map_eq_of_ringEquiv e).symm let eQuot : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃+* (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) := Ideal.quotientEquiv (I := nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) (J := nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) e hmap have hnilA : nilradical (AdjoinRoot ((X : Polynomial A) ^ k)) = Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _) := nilradical_adjoinRoot_X_pow_eq_span_root (A := A) (k := k) (hk := hk) have hnilB : nilradical (AdjoinRoot ((X : Polynomial B) ^ k)) = Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _) := nilradical_adjoinRoot_X_pow_eq_span_root (A := B) (k := k) (hk := hk) let eA : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃+* A := (Ideal.quotEquivOfEq hnilA).trans (quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk)) let eB : (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ≃+* B := (Ideal.quotEquivOfEq hnilB).trans (quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk)) refine ⟨eA.symm.trans (eQuot.trans eB)⟩ Β· rintro ⟨e⟩ refine ⟨AdjoinRoot.mapRingEquiv e ((X : Polynomial A) ^ k) ((X : Polynomial B) ^ k) ?_⟩ exact Associated.of_eq (by simp)
set_option maxHeartbeats 1600000 in /-- For `π•œ`-algebra fields `A` and `B`, the truncated polynomial rings `A[Y]/(Y^k)` and `B[Y]/(Y^k)` (presented as `AdjoinRoot (X^k)`) are isomorphic as `π•œ`-algebras if and only if `A` and `B` are isomorphic as `π•œ`-algebras. -/ lemma nonempty_algEquiv_adjoinRoot_X_pow_iff_nonempty_algEquiv_base (A B : Type*) [Field A] [Field B] [Algebra π•œ A] [Algebra π•œ B] (k : β„•) (hk : 1 ≀ k) : Nonempty (AdjoinRoot ((X : Polynomial A) ^ k) ≃ₐ[π•œ] AdjoinRoot ((X : Polynomial B) ^ k)) ↔ Nonempty (A ≃ₐ[π•œ] B) := by classical constructor Β· rintro ⟨e⟩ -- Pass to quotients by nilradicals to recover the base fields. have hmap : nilradical (AdjoinRoot ((X : Polynomial B) ^ k)) = (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))).map (e.toRingEquiv : _ β†’+* _) := by simpa using (nilradical_map_eq_of_ringEquiv e.toRingEquiv).symm let eQuotRing : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃+* (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) := Ideal.quotientEquiv (I := nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) (J := nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) e.toRingEquiv hmap have hcommQuot : βˆ€ x : π•œ, eQuotRing ((algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) x) = (algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) x := by intro x have hxA : (algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) x = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ((algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k))) x) := by -- Use the scalar tower `π•œ β†’ AdjoinRoot β†’ quotient`. simp have hxB : (algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) x = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ((algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k))) x) := by simp -- Reduce to the formula for `Ideal.quotientEquiv` on quotient maps. -- Then use `e.commutes` to pass through scalars. calc eQuotRing ((algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) x) = eQuotRing (Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ((algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k))) x)) := by rw [hxA] _ = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) (e.toRingEquiv ((algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k))) x)) := by simp [eQuotRing] _ = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ((algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k))) x) := by exact congrArg (Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) (e.commutes x) _ = (algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) x := by rw [hxB] let eQuot : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃ₐ[π•œ] (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) := AlgEquiv.ofRingEquiv (f := eQuotRing) hcommQuot have hnilA : nilradical (AdjoinRoot ((X : Polynomial A) ^ k)) = Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _) := nilradical_adjoinRoot_X_pow_eq_span_root (A := A) (k := k) (hk := hk) have hnilB : nilradical (AdjoinRoot ((X : Polynomial B) ^ k)) = Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _) := nilradical_adjoinRoot_X_pow_eq_span_root (A := B) (k := k) (hk := hk) let eA_ring : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃+* A := (Ideal.quotEquivOfEq hnilA).trans (quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk)) let eB_ring : (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ≃+* B := (Ideal.quotEquivOfEq hnilB).trans (quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk)) have hcommA_overA : βˆ€ a : A, eA_ring ((algebraMap A _) a) = a := by intro a have haNil : (algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) a = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a) := by simpa [Ideal.Quotient.algebraMap_eq, RingHom.comp_apply] using congrArg (fun f => f a) (IsScalarTower.algebraMap_eq A (AdjoinRoot ((X : Polynomial A) ^ k)) (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) have haSpan : (algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) a = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a) := by simpa [Ideal.Quotient.algebraMap_eq, RingHom.comp_apply] using congrArg (fun f => f a) (IsScalarTower.algebraMap_eq A (AdjoinRoot ((X : Polynomial A) ^ k)) (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) have hstep : quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilA) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) a)) = a := by -- Move from the nilradical quotient to the quotient by `(Y)`. have haSpan' : (algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) a = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((AdjoinRoot.of ((X : Polynomial A) ^ k)) a) := by simpa [AdjoinRoot.algebraMap_eq] using haSpan calc quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilA) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) a)) = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilA) (Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a))) := by simp [haNil] _ = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) (Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _)) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k))) a)) := by simp [Ideal.quotEquivOfEq_mk] _ = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial A) ^ k)} : Set _))) a) := by simp [haSpan'] _ = a := quotient_span_root_adjoinRoot_X_pow_ringEquiv_base_algebraMap (A := A) (k := k) (hk := hk) a -- `eA_ring` is the composition of the two maps above. change quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := A) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilA) ((algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) a)) = a exact hstep have hcommB_overB : βˆ€ b : B, eB_ring ((algebraMap B _) b) = b := by intro b have hbNil : (algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) b = Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k))) b) := by simpa [Ideal.Quotient.algebraMap_eq, RingHom.comp_apply] using congrArg (fun f => f b) (IsScalarTower.algebraMap_eq B (AdjoinRoot ((X : Polynomial B) ^ k)) (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) have hbSpan : (algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _))) b = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _)) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k))) b) := by simpa [Ideal.Quotient.algebraMap_eq, RingHom.comp_apply] using congrArg (fun f => f b) (IsScalarTower.algebraMap_eq B (AdjoinRoot ((X : Polynomial B) ^ k)) (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _))) have hstep : quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilB) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) b)) = b := by have hbSpan' : (algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _))) b = Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _)) ((AdjoinRoot.of ((X : Polynomial B) ^ k)) b) := by simpa [AdjoinRoot.algebraMap_eq] using hbSpan calc quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilB) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) b)) = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilB) (Ideal.Quotient.mk (nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k))) b))) := by simp [hbNil] _ = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) (Ideal.Quotient.mk (Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _)) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k))) b)) := by simp [Ideal.quotEquivOfEq_mk] _ = quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ Ideal.span ({AdjoinRoot.root ((X : Polynomial B) ^ k)} : Set _))) b) := by simp [hbSpan'] _ = b := quotient_span_root_adjoinRoot_X_pow_ringEquiv_base_algebraMap (A := B) (k := k) (hk := hk) b change quotient_span_root_adjoinRoot_X_pow_ringEquiv_base (A := B) (k := k) (hk := hk) ((Ideal.quotEquivOfEq hnilB) ((algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) b)) = b exact hstep have hcommA : βˆ€ x : π•œ, eA_ring ((algebraMap π•œ _) x) = (algebraMap π•œ A) x := by intro x -- Use the scalar tower `π•œ β†’ A β†’ ...`. have hx : (algebraMap π•œ (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) x = (algebraMap A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) ((algebraMap π•œ A) x) := by simpa [RingHom.comp_apply] using congrArg (fun f => f x) (IsScalarTower.algebraMap_eq π•œ A (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k)))) -- Now apply the `A`-compatibility proved above. simpa [hx] using hcommA_overA ((algebraMap π•œ A) x) have hcommB : βˆ€ x : π•œ, eB_ring ((algebraMap π•œ _) x) = (algebraMap π•œ B) x := by intro x have hx : (algebraMap π•œ (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) x = (algebraMap B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) ((algebraMap π•œ B) x) := by simpa [RingHom.comp_apply] using congrArg (fun f => f x) (IsScalarTower.algebraMap_eq π•œ B (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k)))) simpa [hx] using hcommB_overB ((algebraMap π•œ B) x) let eA : (AdjoinRoot ((X : Polynomial A) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial A) ^ k))) ≃ₐ[π•œ] A := AlgEquiv.ofRingEquiv (f := eA_ring) hcommA let eB : (AdjoinRoot ((X : Polynomial B) ^ k) β§Έ nilradical (AdjoinRoot ((X : Polynomial B) ^ k))) ≃ₐ[π•œ] B := AlgEquiv.ofRingEquiv (f := eB_ring) hcommB exact ⟨eA.symm.trans (eQuot.trans eB)⟩ Β· rintro ⟨e⟩ refine ⟨AdjoinRoot.mapAlgEquiv e ((X : Polynomial A) ^ k) ((X : Polynomial B) ^ k) ?_⟩ exact Associated.of_eq (by simp)

Theorem 1.8. Let Unknown identifier `π•œ`π•œ be a field. Let Unknown identifier `P₁`P₁ and Unknown identifier `Pβ‚‚`Pβ‚‚ be irreducible polynomials over Unknown identifier `π•œ`π•œ and let Unknown identifier `k`k be a positive integer. If Unknown identifier `P₁`P₁ and Unknown identifier `Pβ‚‚`Pβ‚‚ are separable (i.e. Unknown identifier `Pα΅’'`sorry β‰  0 : PropPα΅’' β‰  0), then the local rings failed to synthesize instance of type class GetElem Prop Prop (Type ?u.716832) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P₁`P₁ ^ Unknown identifier `k`k) and failed to synthesize instance of type class GetElem Prop Prop (Type ?u.723611) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `Pβ‚‚`Pβ‚‚ ^ Unknown identifier `k`k) are isomorphic if and only if their residue fields failed to synthesize instance of type class GetElem Prop Prop (Type ?u.730390) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P₁`P₁) and failed to synthesize instance of type class GetElem Prop Prop (Type ?u.736225) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `Pβ‚‚`Pβ‚‚) are isomorphic.

theorem nonempty_ringEquiv_adjoinRoot_pow_iff_nonempty_ringEquiv_adjoinRoot (P₁ Pβ‚‚ : Polynomial π•œ) (hP₁ : Irreducible P₁) (hPβ‚‚ : Irreducible Pβ‚‚) (hP₁' : P₁.derivative β‰  0) (hPβ‚‚' : Pβ‚‚.derivative β‰  0) (k : β„•) (hk : 1 ≀ k) : Nonempty (AdjoinRoot (P₁ ^ k) ≃+* AdjoinRoot (Pβ‚‚ ^ k)) ↔ Nonempty (AdjoinRoot P₁ ≃+* AdjoinRoot Pβ‚‚) := by classical haveI : Fact (Irreducible P₁) := ⟨hPβ‚βŸ© haveI : Fact (Irreducible Pβ‚‚) := ⟨hPβ‚‚βŸ© constructor Β· rintro ⟨ePow⟩ -- Use Corollary 1.4 to put a `π•œ`-compatible algebra tower structure on each `AdjoinRoot (Pα΅’^k)`. obtain ⟨S₁, hSβ‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk obtain ⟨Sβ‚‚, hSβ‚‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk rcases hS₁ with ⟨eSβ‚βŸ© rcases hSβ‚‚ with ⟨eSβ‚‚βŸ© let f₁ : AdjoinRoot P₁ →ₐ[π•œ] AdjoinRoot (P₁ ^ k) := S₁.val.comp eS₁.toAlgHom let fβ‚‚ : AdjoinRoot Pβ‚‚ →ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := Sβ‚‚.val.comp eSβ‚‚.toAlgHom letI : Algebra (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := (f₁.toRingHom).toAlgebra letI : Algebra (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := (fβ‚‚.toRingHom).toAlgebra haveI : IsScalarTower π•œ (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (f₁.commutes x).symm haveI : IsScalarTower π•œ (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (fβ‚‚.commutes x).symm rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk with ⟨e₁, -⟩ rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk with ⟨eβ‚‚, -⟩ let r₁ : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃+* AdjoinRoot (P₁ ^ k) := e₁.toRingEquiv let rβ‚‚ : AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) ≃+* AdjoinRoot (Pβ‚‚ ^ k) := eβ‚‚.toRingEquiv let eTrunc : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃+* AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) := r₁.trans (ePow.trans rβ‚‚.symm) -- Recover the residue fields from the truncated models. exact (nonempty_ringEquiv_adjoinRoot_X_pow_iff_nonempty_ringEquiv_base (A := AdjoinRoot P₁) (B := AdjoinRoot Pβ‚‚) (k := k) hk).1 ⟨eTrunc⟩ Β· rintro ⟨eBase⟩ obtain ⟨S₁, hSβ‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk obtain ⟨Sβ‚‚, hSβ‚‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk rcases hS₁ with ⟨eSβ‚βŸ© rcases hSβ‚‚ with ⟨eSβ‚‚βŸ© let f₁ : AdjoinRoot P₁ →ₐ[π•œ] AdjoinRoot (P₁ ^ k) := S₁.val.comp eS₁.toAlgHom let fβ‚‚ : AdjoinRoot Pβ‚‚ →ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := Sβ‚‚.val.comp eSβ‚‚.toAlgHom letI : Algebra (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := (f₁.toRingHom).toAlgebra letI : Algebra (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := (fβ‚‚.toRingHom).toAlgebra haveI : IsScalarTower π•œ (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (f₁.commutes x).symm haveI : IsScalarTower π•œ (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (fβ‚‚.commutes x).symm rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk with ⟨e₁, -⟩ rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk with ⟨eβ‚‚, -⟩ let r₁ : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃+* AdjoinRoot (P₁ ^ k) := e₁.toRingEquiv let rβ‚‚ : AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) ≃+* AdjoinRoot (Pβ‚‚ ^ k) := eβ‚‚.toRingEquiv have hTrunc : Nonempty (AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃+* AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k)) := (nonempty_ringEquiv_adjoinRoot_X_pow_iff_nonempty_ringEquiv_base (A := AdjoinRoot P₁) (B := AdjoinRoot Pβ‚‚) (k := k) hk).2 ⟨eBase⟩ rcases hTrunc with ⟨eTrunc⟩ exact ⟨r₁.symm.trans (eTrunc.trans rβ‚‚)⟩

Proposition 1.10. Let Unknown identifier `P₁`P₁ and Unknown identifier `Pβ‚‚`Pβ‚‚ be two irreducible polynomials over Unknown identifier `π•œ`π•œ and Unknown identifier `k`k a positive integer. If Unknown identifier `P₁`P₁ and Unknown identifier `Pβ‚‚`Pβ‚‚ are separable (i.e. Unknown identifier `Pα΅’'`sorry β‰  0 : PropPα΅’' β‰  0), then the local rings failed to synthesize instance of type class GetElem Prop Prop (Type ?u.742171) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P₁`P₁ ^ Unknown identifier `k`k) and failed to synthesize instance of type class GetElem Prop Prop (Type ?u.748950) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry ^ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `Pβ‚‚`Pβ‚‚ ^ Unknown identifier `k`k) are isomorphic as Unknown identifier `π•œ`π•œ-algebras if and only if their residue fields failed to synthesize instance of type class GetElem Prop Prop (Type ?u.755734) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `P₁`P₁) and failed to synthesize instance of type class GetElem Prop Prop (Type ?u.761569) Iff Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.Unknown identifier `π•œ`sorry[sorry] β§Έ sorry : Type (max u_1 u_2)π•œ[Unknown identifier `X`X]β§Έ(Unknown identifier `Pβ‚‚`Pβ‚‚) are isomorphic as Unknown identifier `π•œ`π•œ-algebras.

theorem nonempty_algEquiv_adjoinRoot_pow_iff_nonempty_algEquiv_adjoinRoot (P₁ Pβ‚‚ : Polynomial π•œ) (hP₁ : Irreducible P₁) (hPβ‚‚ : Irreducible Pβ‚‚) (hP₁' : P₁.derivative β‰  0) (hPβ‚‚' : Pβ‚‚.derivative β‰  0) (k : β„•) (hk : 1 ≀ k) : Nonempty (AdjoinRoot (P₁ ^ k) ≃ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k)) ↔ Nonempty (AdjoinRoot P₁ ≃ₐ[π•œ] AdjoinRoot Pβ‚‚) := by classical haveI : Fact (Irreducible P₁) := ⟨hPβ‚βŸ© haveI : Fact (Irreducible Pβ‚‚) := ⟨hPβ‚‚βŸ© constructor Β· rintro ⟨ePow⟩ -- Use Corollary 1.4 to put a `π•œ`-compatible algebra tower structure on each `AdjoinRoot (Pα΅’^k)`. obtain ⟨S₁, hSβ‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk obtain ⟨Sβ‚‚, hSβ‚‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk rcases hS₁ with ⟨eSβ‚βŸ© rcases hSβ‚‚ with ⟨eSβ‚‚βŸ© let f₁ : AdjoinRoot P₁ →ₐ[π•œ] AdjoinRoot (P₁ ^ k) := S₁.val.comp eS₁.toAlgHom let fβ‚‚ : AdjoinRoot Pβ‚‚ →ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := Sβ‚‚.val.comp eSβ‚‚.toAlgHom letI : Algebra (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := (f₁.toRingHom).toAlgebra letI : Algebra (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := (fβ‚‚.toRingHom).toAlgebra haveI : IsScalarTower π•œ (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (f₁.commutes x).symm haveI : IsScalarTower π•œ (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (fβ‚‚.commutes x).symm rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk with ⟨e₁, -⟩ rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk with ⟨eβ‚‚, -⟩ let r₁ : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃ₐ[π•œ] AdjoinRoot (P₁ ^ k) := AlgEquiv.restrictScalars π•œ e₁ let rβ‚‚ : AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) ≃ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := AlgEquiv.restrictScalars π•œ eβ‚‚ let eTrunc : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃ₐ[π•œ] AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) := r₁.trans (ePow.trans rβ‚‚.symm) exact (nonempty_algEquiv_adjoinRoot_X_pow_iff_nonempty_algEquiv_base (π•œ := π•œ) (A := AdjoinRoot P₁) (B := AdjoinRoot Pβ‚‚) (k := k) hk).1 ⟨eTrunc⟩ Β· rintro ⟨eBase⟩ obtain ⟨S₁, hSβ‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk obtain ⟨Sβ‚‚, hSβ‚‚βŸ© := exists_residueField_algEquiv_subalgebra_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk rcases hS₁ with ⟨eSβ‚βŸ© rcases hSβ‚‚ with ⟨eSβ‚‚βŸ© let f₁ : AdjoinRoot P₁ →ₐ[π•œ] AdjoinRoot (P₁ ^ k) := S₁.val.comp eS₁.toAlgHom let fβ‚‚ : AdjoinRoot Pβ‚‚ →ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := Sβ‚‚.val.comp eSβ‚‚.toAlgHom letI : Algebra (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := (f₁.toRingHom).toAlgebra letI : Algebra (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := (fβ‚‚.toRingHom).toAlgebra haveI : IsScalarTower π•œ (AdjoinRoot P₁) (AdjoinRoot (P₁ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (f₁.commutes x).symm haveI : IsScalarTower π•œ (AdjoinRoot Pβ‚‚) (AdjoinRoot (Pβ‚‚ ^ k)) := IsScalarTower.of_algebraMap_eq fun x => by simpa [RingHom.algebraMap_toAlgebra] using (fβ‚‚.commutes x).symm rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := P₁) hP₁ hP₁' k hk with ⟨e₁, -⟩ rcases exists_algEquiv_adjoinRoot_X_pow_to_adjoinRoot_pow (π•œ := π•œ) (P := Pβ‚‚) hPβ‚‚ hPβ‚‚' k hk with ⟨eβ‚‚, -⟩ let r₁ : AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃ₐ[π•œ] AdjoinRoot (P₁ ^ k) := AlgEquiv.restrictScalars π•œ e₁ let rβ‚‚ : AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k) ≃ₐ[π•œ] AdjoinRoot (Pβ‚‚ ^ k) := AlgEquiv.restrictScalars π•œ eβ‚‚ have hTrunc : Nonempty (AdjoinRoot ((X : Polynomial (AdjoinRoot P₁)) ^ k) ≃ₐ[π•œ] AdjoinRoot ((X : Polynomial (AdjoinRoot Pβ‚‚)) ^ k)) := (nonempty_algEquiv_adjoinRoot_X_pow_iff_nonempty_algEquiv_base (π•œ := π•œ) (A := AdjoinRoot P₁) (B := AdjoinRoot Pβ‚‚) (k := k) hk).2 ⟨eBase⟩ rcases hTrunc with ⟨eTrunc⟩ exact ⟨r₁.symm.trans (eTrunc.trans rβ‚‚)⟩
end SomeLocalRings