From mathcomp Require Import all_ssreflect all_fingroup all_algebra. From mathcomp Require Import all_solvable all_field polyrcf. From Abel Require Import various classic_ext map_gal algR. From Abel Require Import char0 cyclotomic_ext real_closed_ext. (*****************************************************************************) (* We work inside a enclosing splittingFieldType L over a base field F0 *) (* *) (* radical U x n := x is a radical element of degree n over U *) (* pradical U x p := x is a radical element of prime degree p over U *) (* r.-tower U e pw := e is a chain of elements of L such that *) (* forall i, r <> e`_i pw`_i *) (* r.-ext U V := there exists e and pw such that <> = V *) (* and r.-tower U e p w. *) (* solvable_by r E F := there is a field K, such that F <= K and r.-ext E K *) (* if p has roots rs, solvable_by radicals E <> *) (* solvable_ext_poly p := the Galois group of p is solvable in any splitting *) (* field L for p. (i.e. p has roots rs in a splitting *) (* then, 'Gal(<<1 & rs>>/1) is solbable. *) (* This is equivalent to general classical existence *) (* or constructive existence over rat, of a splitting *) (* field for p, in which its Galois group is solvable *) (* solvable_by_radical_poly p := solvable_by radical 1 <<1; rs>> in L *) (* L being any splitting field L where p has roots rs *) (* and which contains a n nth primitive root of unity, *) (* (we me make n explicit in ext_solvable_by_radical) *) (* This is equivalent to general classical existence *) (* or constructive existence over rat, of a splitting *) (* field for p, in which the roots of p are rs, and in *) (* which solvable_by radical 1 <<1; rs>> in L. *) (*****************************************************************************) Set Implicit Arguments. Unset Strict Implicit. Unset Printing Implicit Defensive. Import GRing.Theory. Local Open Scope ring_scope. Local Notation "p ^^ f" := (map_poly f p) (at level 30, f at level 30, format "p ^^ f"). Local Notation "2" := 2%:R : ring_scope. Local Notation "3" := 3%:R : ring_scope. Local Notation "4" := 4%:R : ring_scope. Local Notation "5" := 5%:R : ring_scope. CoInductive unsplit_spec m n (i : 'I_(m + n)) : 'I_m + 'I_n -> bool -> Type := | UnsplitLo (j : 'I_m) of i = lshift _ j : unsplit_spec i (inl _ j) true | UnsplitHi (k : 'I_n) of i = rshift _ k : unsplit_spec i (inr _ k) false. Lemma unsplitP m n (i : 'I_(m + n)) : unsplit_spec i (split i) (i < m)%N. Proof. by case: splitP=> j eq_j; constructor; apply/val_inj. Qed. Section RadicalExtension. Variables (F0 : fieldType) (L : splittingFieldType F0). Hypothesis (charL : has_char0 L). Section Defs. Implicit Types (U V : {vspace L}). Definition radical U x n := [&& (n > 0)%N & x ^+ n \in U]. Definition pradical U x p := [&& prime p & x ^+ p \in U]. Lemma radicalP U x n : reflect [/\ (n > 0)%N & x ^+ n \in U] [&& (n > 0)%N & x ^+ n \in U]. Proof. exact/andP. Qed. Lemma pradicalP U x p : reflect [/\ prime p & x ^+ p \in U] [&& prime p & x ^+ p \in U]. Proof. exact/andP. Qed. Implicit Types r : {vspace L} -> L -> nat -> bool. Definition tower r n U (e : n.-tuple L) (pw : n.-tuple nat) := [forall i : 'I_n, r << U & take i e >>%VS (tnth e i) (tnth pw i)]. Lemma towerP r n U (e : n.-tuple L) (pw : n.-tuple nat) : reflect (forall i : 'I_n, r << U & take i e >>%VS (tnth e i) (tnth pw i)) (tower r U e pw). Proof. exact/forallP. Qed. Local Notation "r .-tower" := (@tower r _) (at level 2, format "r .-tower") : ring_scope. Record ext_data := ExtData { ext_size : nat; ext_ep : ext_size.-tuple L; ext_pw : ext_size.-tuple nat }. Arguments ExtData [ext_size]. Definition trivExt := ExtData [tuple] [tuple]. Definition extension_of r U V := exists2 e : ext_data, r.-tower U (ext_ep e) (ext_pw e) & << U & ext_ep e >>%VS = V. Local Notation "r .-ext" := (extension_of r) (at level 2, format "r .-ext") : ring_scope. Definition solvable_by r (U V : {vspace L}) := exists2 E : {subfield L}, r.-ext U E & (V <= E)%VS. End Defs. Local Notation "r .-tower" := (@tower r _) (at level 2, format "r .-tower") : ring_scope. Local Notation "r .-ext" := (extension_of r) (at level 2, format "r .-ext") : ring_scope. Section Properties. Implicit Types r : {vspace L} -> L -> nat -> bool. Implicit Types (U V : {subfield L}). Lemma rext_refl r (E : {subfield L}) : r.-ext E E. Proof. by exists trivExt; rewrite ?Fadjoin_nil//=; apply/towerP => -[]. Qed. Lemma rext_r r n (U : {subfield L}) x : r U x n -> r.-ext U << U; x >>%VS. Proof. move=> rUxn; exists (ExtData [tuple x] [tuple n]); last by rewrite adjoin_seq1. by apply/towerP => /= i; rewrite ord1/= !tnth0 Fadjoin_nil. Qed. Lemma rext_trans r (F E K : {subfield L}) : r.-ext E F -> r.-ext F K -> r.-ext E K. Proof. move=> [[/= n1 e1 pw1] Ee FE] [[/= n2 e2 pw2] Fe KE]. exists (ExtData [tuple of e1 ++ e2] [tuple of pw1 ++ pw2]) => /=; last first. by rewrite adjoin_cat FE. apply/towerP => /= i; case: (unsplitP i) => [j eq_ij|k eq_i_n1Dk]. - rewrite eq_ij !tnth_lshift takel_cat /=; last first. by rewrite size_tuple ltnW. by move/forallP/(_ j): Ee. - rewrite eq_i_n1Dk take_cat size_tuple ltnNge leq_addr /= addKn. by rewrite adjoin_cat FE !tnth_rshift; move/forallP/(_ k): Fe. Qed. Lemma rext_r_trans r n (E F K : {subfield L}) x : r.-ext E F -> r F x n -> r.-ext E << F; x>>%VS. Proof. by move=> rEF /rext_r; apply: rext_trans. Qed. Lemma rext_subspace r E F : r.-ext E F -> (E <= F)%VS. Proof. by case=> [[/= n e pw] _ <-]; apply: subv_adjoin_seq. Qed. Lemma solvable_by_radicals_radicalext (E F : {subfield L}) : radical.-ext E F -> solvable_by radical E F. Proof. by move=> extEF; exists F. Qed. Lemma radical_Fadjoin (n : nat) (x : L) (E : {subfield L}) : (0 < n)%N -> x ^+ n \in E -> radical E x n. Proof. by move=> ? ?; apply/radicalP. Qed. Lemma pradical_Fadjoin (n : nat) (x : L) (E : {subfield L}) : prime n -> x ^+ n \in E -> pradical E x n. Proof. by move=> ? ?; apply/pradicalP. Qed. Lemma radical_ext_Fadjoin (n : nat) (x : L) (E : {subfield L}) : (0 < n)%N -> x ^+ n \in E -> radical.-ext E <>%VS. Proof. by move=> n_gt0 xnE; apply/rext_r/(radical_Fadjoin n_gt0 xnE). Qed. Lemma pradical_ext_Fadjoin (p : nat) (x : L) (E : {subfield L}) : prime p -> x ^+ p \in E -> pradical.-ext E <>%AS. Proof. by move=> p_prime Exn; apply/rext_r/(pradical_Fadjoin p_prime Exn). Qed. Lemma pradicalext_radical n (x : L) (E : {subfield L}) : radical E x n -> pradical.-ext E << E; x >>%VS. Proof. move=> /radicalP[n_gt0 xnE]; have [k] := ubnP n. elim: k => // k IHk in n x E n_gt0 xnE *; rewrite ltnS => lenk. have [prime_n|primeN_n] := boolP (prime n). by apply: (@pradical_ext_Fadjoin n). case/boolP: (2 <= n)%N; last first. case: n {lenk primeN_n} => [|[]]// in xnE n_gt0 * => _. suff ->: <>%VS = E by apply: rext_refl. by rewrite (Fadjoin_idP _). move: primeN_n => /primePn[|[d /andP[d_gt1 d_ltn] dvd_dn n_gt1]]. by case: ltngtP. have [m n_eq_md]: {k : nat | n = (k * d)%N}. by exists (n %/ d)%N; rewrite [LHS](divn_eq _ d) (eqP dvd_dn) addn0. have m_gt0 : (m > 0)%N. by move: n_gt0; rewrite !lt0n n_eq_md; apply: contra_neq => ->. apply: (@rext_trans _ <>) => //. apply: (@IHk m (x ^+ d)) => //. by rewrite -exprM mulnC -n_eq_md//. by rewrite (leq_trans _ lenk)// n_eq_md ltn_Pmulr. suff -> : <>%AS = <<<>; x>>%AS. apply: (IHk d) => //. - by rewrite (leq_trans _ d_gt1)//. - by rewrite memv_adjoin. - by rewrite (leq_trans _ lenk). apply/val_inj; rewrite /= adjoinC [<<_; x ^+ d>>%VS](Fadjoin_idP _)//. by rewrite rpredX// memv_adjoin. Qed. Lemma tower_sub r1 r2 n E (e : n.-tuple L) (pw : n.-tuple nat) : (forall U x n, r1 U x n -> r2 U x n) -> r1.-tower E e pw -> r2.-tower E e pw. Proof. by move=> sub_r /forallP /= h; apply/forallP=> /= i; apply/sub_r/h. Qed. Lemma radical_pradical U x p : pradical U x p -> radical U x p. Proof. case/pradicalP=> prime_p xpU; apply/radicalP; split=> //. by case/primeP: prime_p => /ltnW. Qed. Lemma radicalext_pradicalext (E F : {subfield L}) : pradical.-ext E F -> radical.-ext E F. Proof. case=> [[n e pw] Ee FE]; exists (ExtData e pw) => //. by apply: (tower_sub radical_pradical). Qed. Lemma pradicalext_radicalext (E F : {subfield L}) : radical.-ext E F -> pradical.-ext E F. Proof. case=> [[/= n e pw]]; elim: n e pw E => [|n ih] e pw E Ee FE. by rewrite -FE tuple0 /= Fadjoin_nil; apply: rext_refl. apply: (@rext_trans _ << E; tnth e 0 >>). apply: (@pradicalext_radical (tnth pw 0)). by move/forallP/(_ ord0): Ee; rewrite take0 Fadjoin_nil. apply: (ih [tuple of behead e] [tuple of behead pw]) => /=; last first. by rewrite -adjoin_cons -drop1 (tnth_nth 0) -drop_nth 1?(drop0, size_tuple). apply/forallP=> /= i; move/forallP/(_ (rshift 1 i)): Ee => /=. rewrite !(tnth_nth 0, tnth_nth 0%N) !nth_behead [_ (rshift 1 i)]/=. by rewrite -adjoin_cons takeD drop1 (take_nth 0) 1?size_tuple // take0. Qed. Lemma solvable_by_radical_pradical (E F : {subfield L}) : solvable_by pradical E F -> solvable_by radical E F. Proof. by case=> [R /radicalext_pradicalext ERe FR]; exists R. Qed. Lemma solvable_by_pradical_radical (E F : {subfield L}) : solvable_by radical E F -> solvable_by pradical E F. Proof. by case=> [R /pradicalext_radicalext ERe FR]; exists R. Qed. Lemma radicalext_Fadjoin_cyclotomic (E : {subfield L}) (w : L) (n : nat) : n.-primitive_root w -> radical.-ext E <>%AS. Proof. move=> wprim; apply: (@radical_ext_Fadjoin n w E). exact: prim_order_gt0 wprim. by rewrite (prim_expr_order wprim) mem1v. Qed. End Properties. End RadicalExtension. Arguments tower {F0 L}. Arguments extension_of {F0 L}. Arguments radical {F0 L}. Local Notation "r .-tower" := (tower r) (at level 2, format "r .-tower") : ring_scope. Local Notation "r .-ext" := (extension_of r) (at level 2, format "r .-ext") : ring_scope. (* Following the french wikipedia proof : https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_d%27Abel_(alg%C3%A8bre)#D%C3%A9monstration_du_th%C3%A9or%C3%A8me_de_Galois *) Section Abel. (******************************************************************************) (* *) (* Part 1 : solvable -> radical.-ext *) (* *) (* With the hypothesis that F has a (order of the galois group)-primitive *) (* root of the unity : *) (* Part 1a : if G = Gal(F/E) is abelian, then F has a basis (as an E-vspace) *) (* with only radical elements on E *) (* Part 1b : recurrence on the solvability chain or the order of the group, *) (* using part1a and radicalext_fixedField *) (* *) (* With the hypothesis that L contains a (order of the galois group) - *) (* primitive root of the unity : *) (* Part 1c : F is once again a radical extension of E *) (* *) (******************************************************************************) Section Part1. Variables (F0 : fieldType) (L : splittingFieldType F0). Implicit Types (E F K : {subfield L}) (w : L) (n : nat). Lemma cyclic_radical_ext w E F (n := \dim_E F) : n.-primitive_root w -> w \in E -> galois E F -> cyclic 'Gal(F / E) -> radical.-ext E F. Proof. set G := (X in cyclic X) => w_root wE galois_EF /cyclicP[g GE]. have EF := galois_subW galois_EF. have n_gt0 : (n > 0)%N by rewrite /n -dim_aspaceOver ?adim_gt0. have Gg : generator G g by rewrite GE generator_cycle. have gG : g \in G by rewrite GE cycle_id. have HT90g := Hilbert's_theorem_90 Gg (subvP EF _ wE). have /eqP/HT90g[x [xF xN0]] : galNorm E F w = 1. rewrite /galNorm; under eq_bigr => g' g'G. rewrite (fixed_gal EF g'G)//. over. by rewrite prodr_const -galois_dim// (prim_expr_order w_root). have gxN0 : g x != 0 by rewrite fmorph_eq0. have wN0 : w != 0 by rewrite (primitive_root_eq0 w_root) -lt0n. move=> /(canLR (mulfVK gxN0))/(canRL (mulKf wN0)) gx. have gXx i : (g ^+ i)%g x = w ^- i * x. elim: i => [|i IHi]. by rewrite expg0 expr0 invr1 mul1r gal_id. rewrite expgSr exprSr invfM galM// IHi rmorphM/= gx mulrA. by rewrite (fixed_gal EF gG) ?rpredV ?rpredX. have ExF : (<> <= F)%VS by exact/FadjoinP. suff -> : F = <>%AS. apply: radical_ext_Fadjoin n_gt0 _. rewrite -(galois_fixedField galois_EF) -/G GE. apply/fixedFieldP; first by rewrite rpredX. move=> _ /cycleP[i ->]; rewrite rmorphX/= gXx exprMn exprVn exprAC. by rewrite (prim_expr_order w_root)// expr1n invr1 mul1r. apply/val_inj/eqP => /=. have -> : F = fixedField (1%g : {set gal_of F}) :> {vspace L}. by apply/esym/eqP; rewrite -galois_eq ?galvv ?galois_refl//. rewrite -galois_eq; last by apply: galoisS galois_EF; rewrite subv_adjoin. rewrite -subG1; apply/subsetP => g' g'G'. have /cycleP[i g'E]: g' \in <[g]>%g. rewrite -GE gal_kHom//; apply/kAHomP => y yE. by rewrite (fixed_gal _ g'G') ?subvP_adjoin. rewrite g'E in g'G' *. have : (g ^+ i)%g x = x by rewrite (fixed_gal _ g'G') ?memv_adjoin. rewrite gXx => /(canRL (mulfK xN0))/eqP; rewrite divff// invr_eq1. rewrite -(prim_order_dvd w_root) => dvdni. have /exponentP->// : (exponent G %| i)%N. by rewrite GE exponent_cycle orderE -GE -galois_dim. Qed. Lemma solvableWradical_ext w E F (n := \dim_E F) : n.-primitive_root w -> w \in E -> galois E F -> solvable 'Gal(F / E) -> radical.-ext E F. Proof. move=> + + galEF; have [k] := ubnP n; elim: k => // k IHk in w E F n galEF *. rewrite ltnS => le_nk; have subEF : (E <= F)%VS by case/andP: galEF. have n_gt0 : (0 < n)%N by rewrite ltn_divRL ?field_dimS// mul0n adim_gt0. move=> wn Ew solEF; have [n_le1|n_gt1] := leqP n 1%N. have /eqP : n = 1%N by case: {+}n n_gt0 n_le1 => [|[]]. rewrite -eqn_mul ?adim_gt0 ?field_dimS// mul1n eq_sym dimv_leqif_eq//. by rewrite val_eqE => /eqP<-; apply: rext_refl. have /sol_prime_factor_exists[|H Hnormal] := solEF. by rewrite -cardG_gt1 -galois_dim. have [<-|H_neq] := eqVneq H ('Gal(F / E))%G; first by rewrite indexgg. have galEH := normal_fixedField_galois galEF Hnormal. have subEH : (E <= fixedField H)%VS by case/andP: galEH. rewrite -dim_fixed_galois ?normal_sub// galois_dim//=. pose d := \dim_E (fixedField H); pose p := \dim_(fixedField H) F. have p_gt0 : (p > 0)%N by rewrite divn_gt0 ?adim_gt0 ?dimvS ?fixedField_bound. have n_eq : n = (p * d)%N by rewrite /p /d -dim_fixedField dim_fixed_galois; rewrite ?Lagrange ?normal_sub -?galois_dim. have Ewm : w ^+ (n %/ d) \in E by rewrite rpredX. move=> /prime_cyclic/cyclic_radical_ext-/(_ _ _ Ewm galEH)/=. rewrite dvdn_prim_root// => [/(_ isT)|]; last by rewrite n_eq dvdn_mull. move=> /rext_trans; apply; apply: (IHk (w ^+ (n %/ p))) => /=. - exact: fixedField_galois. - rewrite (leq_trans _ le_nk)// -dim_fixedField /n galois_dim// proper_card//. by rewrite properEneq H_neq normal_sub. - by rewrite dvdn_prim_root// n_eq dvdn_mulr. - by rewrite rpredX//; apply: subvP Ew. - by rewrite gal_fixedField (solvableS (normal_sub Hnormal)). Qed. Lemma galois_solvable_by_radical w E F (n := \dim_E F) : n.-primitive_root w -> galois E F -> solvable 'Gal(F / E) -> solvable_by radical E F. Proof. move=> w_root galEF solEF; have [EF Ew] := (galois_subW galEF, subv_adjoin E w). exists (F * <>)%AS; last by rewrite field_subvMr. apply: rext_trans (radicalext_Fadjoin_cyclotomic _ w_root) _. have galEwFEw: galois <> (F * <>) by apply: galois_prodvr galEF. pose m := \dim_<> (F * <>); pose w' := w ^+ (n %/ m). have w'Ew : w' \in <>%VS by rewrite rpredX ?memv_adjoin. have w'prim : m.-primitive_root w'. rewrite dvdn_prim_root // /m /n !galois_dim//. by rewrite (card_isog (galois_isog galEF _)) ?cardSg ?galS ?subv_cap ?EF//. apply: (@solvableWradical_ext w'); rewrite // (isog_sol (galois_isog galEF _))//. by rewrite (solvableS _ solEF) ?galS// subv_cap EF. Qed. (* Main lemma of part 1 *) Lemma ext_solvable_by_radical w E F (n := \dim_E (normalClosure E F)) : n.-primitive_root w -> solvable_ext E F -> solvable_by radical E F. Proof. move=> wprim /andP[sepEF]; have galEF := normalClosure_galois sepEF. move=> /(galois_solvable_by_radical wprim galEF) [M EM EFM]; exists M => //. by rewrite (subv_trans _ EFM) ?normalClosureSr. Qed. End Part1. (******************************************************************************) (* *) (* Part 2 : solvable_by_radicals -> solvable *) (* *) (******************************************************************************) Section RadicalRoots. Variables (F : fieldType) (n : nat) (x w : F). Hypothesis w_root : (n.-primitive_root w)%R. Notation ws := [seq x * w ^+ val i | i : 'I_n]. Lemma uniq_roots_Xn_sub_xn : x != 0 -> uniq ws. Proof using w_root. move=> xN0; rewrite /image_mem (map_comp (fun i => x * w ^+ i)) val_enum_ord. apply/(uniqP 0) => i j; rewrite !inE size_map size_iota/= => ip jp. rewrite !(nth_map 0%N) ?size_iota// ?nth_iota// => /(mulfI xN0). by move/eqP; rewrite (eq_prim_root_expr w_root) !modn_small// => /eqP. Qed. Lemma Xn_sub_xnE : (n > 0)%N -> 'X^n - (x ^+ n)%:P = \prod_(i < n) ('X - (x * w ^+ i)%:P). Proof using w_root. move=> n_gt0; have [->|xN0] := eqVneq x 0. under eq_bigr do rewrite mul0r subr0. by rewrite expr0n gtn_eqF// subr0 prodr_const card_ord. rewrite [LHS](@all_roots_prod_XsubC _ _ ws). - by rewrite (monicP _) ?monic_XnsubC// scale1r big_map big_enum. - by rewrite size_XnsubC// size_map size_enum_ord. - rewrite all_map; apply/allP => i _ /=; rewrite /root !hornerE hornerXn. by rewrite exprMn exprAC [w ^+ _]prim_expr_order// expr1n mulr1 subrr. - by rewrite uniq_rootsE uniq_roots_Xn_sub_xn. Qed. End RadicalRoots. Section galois_pradical. Variables (p : nat) (F0 : fieldType) (L : splittingFieldType F0). Variables (w : L) (x : L). Hypothesis w_root : (p.-primitive_root w)%R. Implicit Types (E : {subfield L}). Lemma dvdp_minpoly_Xn_subn E : (x ^+ p)%R \in E -> minPoly E x %| ('X^p - (x ^+ p)%:P). Proof using. move=> xpE; have [->|p_gt0] := posnP p; first by rewrite !expr0 subrr dvdp0. by rewrite minPoly_dvdp /root ?poly_XnsubC_over// !hornerE hornerXn subrr. Qed. Lemma galois_cyclo_radical E : (p > 0)%N -> x ^+ p \in E -> galois E <<<>; x>>. Proof. move=> p_gt0 xpE; have [xE|xNE] := boolP (x \in E). rewrite (Fadjoin_idP _) ?(galois_Fadjoin_cyclotomic _ w_root)//. by rewrite (subvP (subv_adjoin _ _)). have [x0|xN0] := eqVneq x 0; first by rewrite x0 rpred0 in xNE. have [pB1_eq0|pB1_gt0] := posnP p.-1. by case: {+}p p_gt0 pB1_eq0 xpE xNE => [|[]]//=; rewrite expr1 => _ _ ->. apply/splitting_galoisField; exists ('X^p - (x ^+ p)%:P)%R. split; first by rewrite rpredB ?rpredX ?polyOverX ?polyOverC//. rewrite (Xn_sub_xnE _ w_root)// -(big_map _ predT (fun x => 'X - x%:P)). rewrite separable_prod_XsubC -[index_enum _]enumT. by rewrite (uniq_roots_Xn_sub_xn w_root). exists [seq x * w ^+ val i | i : 'I_p]. by rewrite (Xn_sub_xnE _ w_root)// big_map big_enum//= eqpxx. apply/eqP; rewrite /image_mem (map_comp (fun i => x * w ^+ i)) val_enum_ord. rewrite -[p]prednK//= mulr1 -[p.-1]prednK//= expr1 !adjoin_cons. have -> : <<<>; x * w>>%VS = <<<>; x>>%VS. apply/eqP; rewrite [X in _ == X]adjoinC eqEsubv/= !Fadjoin_sub//. by rewrite -(@fpredMl _ _ _ _ x)// ?memv_adjoin//= adjoinC memv_adjoin. by rewrite rpredM// ?memv_adjoin//= adjoinC memv_adjoin. rewrite (Fadjoin_seq_idP _)// all_map; apply/allP => i _/=. by rewrite rpredM ?rpredX//= ?memv_adjoin// adjoinC memv_adjoin. Qed. Lemma galois_radical E : w \in E -> (p > 0)%N -> x ^+ p \in E -> galois E <>. Proof. by move=> + pp /(galois_cyclo_radical pp) => /(@Fadjoin_idP _)->. Qed. Variable (E : {subfield L}). Hypothesis p_prime : prime p. Hypothesis wE : w \in E. Hypothesis xNE : x \notin E. Hypothesis xpE : x ^+ p \in E. Let p_gt0 := prime_gt0 p_prime. Lemma minPoly_pradical : minPoly E x = 'X^p - (x ^+ p)%:P. Proof using w_root p_prime wE xNE xpE p_gt0. have xN0 : x != 0 by apply: contraNneq xNE => ->; rewrite rpred0. have := dvdp_minpoly_Xn_subn xpE; rewrite (Xn_sub_xnE _ w_root)// -big_enum/=. move=> /dvdp_prod_XsubC[m]; rewrite eqp_monic ?monic_minPoly//; last first. by rewrite monic_prod// => i _; rewrite monic_XsubC. have [{}m sm ->] := resize_mask m (enum 'I_p); set s := mask _ _ => /eqP mEx. have [|smp_gt0] := posnP (size s). case: s mEx => // /(congr1 (horner^~x))/esym/eqP. by rewrite minPolyxx big_nil hornerC oner_eq0. suff leq_pm : (p <= size s)%N. move: mEx; suff /eqP->: s == enum 'I_p by []. by rewrite -(geq_leqif (size_subseq_leqif _)) ?mask_subseq// size_enum_ord. have xXE (i : nat) : x ^+ i \in E -> (p %| i)%N. move=> xiE; apply: contraNT xNE; rewrite -prime_coprime// => /coprimeP[]// u. have [/eqP->//|uip] := leqP (u.1 * p)%N (u.2 * i)%N; rewrite -[x]expr1 => <-. by rewrite expfB// rpredM ?rpredV// mulnC exprM rpredX. have /polyOverP/(_ 0%N) := minPolyOver E x; rewrite {}mEx coef0_prod. under eq_bigr do rewrite coefB coefX coefC add0r -mulrN/=. have w_neq0 : w != 0 by rewrite (primitive_root_eq0 w_root) -lt0n. rewrite big_split/= fpredMr; last first. - by rewrite prodf_seq_eq0; apply/hasPn => i _/=; rewrite oppr_eq0 expf_neq0. - by rewrite rpred_prod// => i _/=; rewrite rpredN rpredX. by rewrite big_tnth prodr_const cardT/= size_enum_ord => /xXE; apply: dvdn_leq. Qed. Lemma size_minPoly_pradical: size (minPoly E x) = p.+1. Proof. by rewrite minPoly_pradical ?size_XnsubC. Qed. Local Notation G := 'Gal(<> / E)%g. (* - Gal(E(x) / E) has order n *) Lemma order_galois_pradical : #|G| = p. Proof. rewrite -galois_dim 1?galois_radical// -adjoin_degreeE. by have := size_minPoly E x; rewrite size_minPoly_pradical// => -[]. Qed. Lemma pradical_cyclic : cyclic G. Proof. by apply/prime_cyclic; rewrite order_galois_pradical. Qed. Lemma pradical_abelian : abelian G. Proof. exact/cyclic_abelian/pradical_cyclic. Qed. Lemma pradical_solvable : solvable G. Proof. by rewrite abelian_sol ?pradical_abelian/= ?subvv. Qed. End galois_pradical. Lemma pradical_solvable_ext (p : nat) (F0 : fieldType) (L : splittingFieldType F0) (E : {subfield L}) (x : L) : prime p -> p%:R != 0 :> F0 -> x ^+ p \in E -> solvable_ext E <>. Proof. move=> p_prime p_neq0 xpE; have p_gt0 := prime_gt0 p_prime. wlog [w w_root] : L E x xpE / {w : L | p.-primitive_root w} => [hwlog|]. apply: (@classic_cycloSplitting _ L p p_neq0) => -[L' [w [f wf rw]]]. rewrite -(solvable_ext_aimg f) aimg_adjoin hwlog -?rmorphX ?memv_img//. by exists w. have galEw := galois_Fadjoin_cyclotomic E w_root. have solEw := solvable_Fadjoin_cyclotomic E w_root. have [xEw|xNEw] := boolP (x \in <>%VS). by apply/solvable_extP; exists <>%AS; rewrite galEw solEw Fadjoin_sub. have xpEw : x ^+ p \in <>%VS by rewrite (subvP (subv_adjoin _ _)). have galEwx : galois E <<<>; x>> by rewrite (@galois_cyclo_radical p). apply/solvable_extP; exists <<<>; w>>%AS; rewrite subv_adjoin/= adjoinC. rewrite galEwx (@series_sol _ _ ('Gal(<<<>; x>> / <>))); last by rewrite normalField_normal ?subv_adjoin ?galois_normalW. rewrite (@pradical_solvable p _ _ w)// ?memv_adjoin//. by rewrite (isog_sol (normalField_isog _ _ _)) ?galois_normalW ?subv_adjoin. Qed. Lemma radical_ext_solvable_ext (F0 : fieldType) (L : splittingFieldType F0) (E F : {subfield L}) : has_char0 L -> (E <= F)%VS -> solvable_by radical E F -> solvable_ext E F. Proof. move=> charL EF. move=> [_ /pradicalext_radicalext[[/= n e pw] /towerP epwP <- FK]]. have charF0 : [char F0] =i pred0 by move=> i; rewrite -charL char_lalg. pose k := n; suff {FK} : solvable_ext E <>. by rewrite take_oversize ?size_tuple//; apply: sub_solvable_ext. elim: k => /= [|k IHsol]; first by rewrite take0 Fadjoin_nil. have [kn|nk] := ltnP k n; last first. by move: IHsol; rewrite !take_oversize ?size_tuple// leqW. rewrite (take_nth 0) ?size_tuple// adjoin_rcons. apply: solvable_ext_trans IHsol _. by rewrite /= subv_adjoin_seq subv_adjoin. have := epwP (Ordinal kn); rewrite (tnth_nth 0) (tnth_nth 0%N)/=. move=> /pradicalP[pwk_prime epwEk]. apply: (pradical_solvable_ext pwk_prime) => //. by have /charf0P-> := charF0; rewrite -lt0n prime_gt0. Qed. (******************************************************************************) (* *) (* Abel/Galois Theorem *) (* *) (******************************************************************************) (** Ok **) Lemma AbelGalois (F0 : fieldType) (L : splittingFieldType F0) (w : L) (E F : {subfield L}) : (E <= F)%VS -> has_char0 L -> (\dim_E (normalClosure E F)).-primitive_root w -> solvable_by radical E F <-> solvable_ext E F. Proof. move=> EF charL wprim; split; first exact: radical_ext_solvable_ext. exact: (ext_solvable_by_radical wprim). Qed. End Abel. Definition solvable_by_radical_poly (F : fieldType) (p : {poly F}) := forall (L : splittingFieldType F) (rs : seq L), p ^^ in_alg L %= \prod_(x <- rs) ('X - x%:P) -> forall w : L, (\dim <<1 & rs>>%VS).-primitive_root w -> solvable_by radical 1 <<1 & rs>>. Definition solvable_ext_poly (F : fieldType) (p : {poly F}) := forall (L : splittingFieldType F) (rs : seq L), p ^^ in_alg L %= \prod_(x <- rs) ('X - x%:P) -> solvable 'Gal(<<1 & rs>> / 1). Lemma galois_solvable (F0 : fieldType) (L : splittingFieldType F0) (E F : {subfield L}) : galois E F -> solvable_ext E F = solvable 'Gal(F / E). Proof. by move=> /and3P[EF sEF nEF]; rewrite /solvable_ext sEF normalClosure_id. Qed. Lemma normal_solvable (F0 : fieldType) (L : splittingFieldType F0) (E F : {subfield L}) : has_char0 L -> (E <= F)%VS -> normalField E F -> solvable_ext E F = solvable 'Gal(F / E). Proof. by move=> charL EF /(char0_galois charL EF)/galois_solvable. Qed. Lemma AbelGaloisPoly (F : fieldType) (p : {poly F}) : has_char0 F -> solvable_ext_poly p <-> solvable_by_radical_poly p. Proof. move=> charF; split=> + L rs pE => [/(_ L rs pE) + w w_prim|solrs]/=. have charL : has_char0 L by move=> i; rewrite char_lalg. have normal_rs : normalField 1 <<1 & rs>>. apply/splitting_normalField; rewrite ?sub1v//. by exists (p ^^ in_alg _); [apply/polyOver1P; exists p | exists rs]. by move=> solrs; apply/(@AbelGalois _ _ w); rewrite ?char0_solvable_extE ?normalClosure_id ?sub1v ?dimv1 ?divn1. have charL : has_char0 L by move=> i; rewrite char_lalg. have seprs: separable 1 <<1 & rs>> by apply/char0_separable. have normal_rs : normalField 1 <<1 & rs>>. apply/splitting_normalField; rewrite ?sub1v//. by exists (p ^^ in_alg _); [apply/polyOver1P; exists p | exists rs]. pose n := \dim <<1 & rs>>. have nFN0 : n%:R != 0 :> F by have /charf0P-> := charF; rewrite -lt0n adim_gt0. apply: (@classic_cycloSplitting _ L _ nFN0) => - [L' [w [iota wL' w_prim]]]. suff: solvable_ext 1 <<1 & rs>>. by rewrite /solvable_ext seprs normalClosure_id ?sub1v. rewrite -(solvable_ext_aimg iota). have charL' : [char L'] =i pred0 by move=> i; rewrite char_lalg. apply/(@AbelGalois _ _ w) => //. - by rewrite limgS// sub1v. - rewrite -aimg_normalClosure //= aimg1 dimv1 divn1 dim_aimg/=. by rewrite normalClosure_id ?dimv1 ?divn1 ?sub1v//. have /= := solrs L' (map iota rs) _ w. rewrite -(aimg1 iota) -!aimg_adjoin_seq dim_aimg. apply => //; have := pE; rewrite -(eqp_map [rmorphism of iota]). by rewrite -map_poly_comp/= (eq_map_poly (rmorph_alg _)) map_prod_XsubC. Qed. Lemma solvable_ext_polyP (F : fieldType) (p : {poly F}) : p != 0 -> has_char0 F -> solvable_ext_poly p <-> classically (exists (L : splittingFieldType F) (rs : seq L), p ^^ in_alg L %= \prod_(x <- rs) ('X - x%:P) /\ solvable 'Gal(<<1 & rs>> / 1)). Proof. move=> p_neq0 charF; split => sol_p. have FoE (v : F^o) : v = in_alg F^o v by rewrite /= /(_%:A)/= mulr1. apply: classic_bind (@classic_fieldExtFor _ _ (p : {poly F^o}) p_neq0). move=> [L [rs [iota rsf p_eq]]]; apply/classicW. have iotaF : iota =1 in_alg L by move=> v; rewrite [v in LHS]FoE rmorph_alg. have splitL : SplittingField.axiom L. exists (p ^^ iota). by apply/polyOver1P; exists p; apply: eq_map_poly. exists rs => //; suff <- : limg iota = 1%VS by []. apply/eqP; rewrite eqEsubv sub1v andbT; apply/subvP => v. by move=> /memv_imgP[u _ ->]; rewrite iotaF/= rpredZ// rpred1. pose S := SplittingFieldType F L splitL. exists S, rs; split => //=; first by rewrite -(eq_map_poly iotaF). by apply: (sol_p S rs); rewrite -(eq_map_poly iotaF). move=> L rs prs; apply: sol_p => -[M [rs' [prs']]]. have charL : has_char0 L by move=> n; rewrite char_lalg charF. have charM : has_char0 M by move=> n; rewrite char_lalg charF. pose K := [fieldExtType F of subvs_of <<1 & rs>>%VS]. pose rsK := map (vsproj <<1 & rs>>%VS) rs. have pKrs : p ^^ in_alg K %= \prod_(x <- rsK) ('X - x%:P). rewrite -(eqp_map [rmorphism of vsval])/= map_prod_XsubC/= -map_poly_comp/=. rewrite -map_comp (@eq_map_poly _ _ _ (in_alg L)); last first. by move=> v; rewrite /= algid1. have /eq_in_map-> : {in rs, cancel (vsproj <<1 & rs>>%VS) vsval}. by move=> x xrs; rewrite vsprojK// seqv_sub_adjoin. by rewrite big_map. have splitK : splittingFieldFor 1 (p ^^ in_alg K) fullv. exists rsK => //; apply/eqP; rewrite eqEsubv subvf/=. rewrite -(@limg_ker0 _ _ _ (linfun vsval)) ?AHom_lker0//. rewrite aimg_adjoin_seq/= aimg1 -map_comp/=. have /eq_in_map-> : {in rs, cancel (vsproj <<1 & rs>>%VS) (linfun vsval)}. by move=> x xrs; rewrite lfunE/= vsprojK// seqv_sub_adjoin. rewrite map_id; apply/subvP => _/memv_imgP[v _ ->]. by rewrite lfunE subvsP. have sfK : SplittingField.axiom K. by exists (p ^^ in_alg K) => //; apply/polyOver1P; exists p. pose S := SplittingFieldType F K sfK. have splitS : splittingFieldFor 1 (p ^^ in_alg S) fullv by []. have splitM : splittingFieldFor 1 (p ^^ in_alg M) <<1 & rs'>> by exists rs'. have splitL : splittingFieldFor 1 (p ^^ in_alg L) <<1 & rs>> by exists rs. have [f imgf] := splitting_ahom splitS splitM. have [g imgg] := splitting_ahom splitS splitL. rewrite -imgf -(aimg1 f)/= -img_map_gal injm_sol ?map_gal_inj ?subsetT//. by rewrite -imgg -(aimg1 g)/= -img_map_gal injm_sol ?map_gal_inj ?subsetT//. Qed. Lemma solvable_by_radical_polyP (F : fieldType) (p : {poly F}) : p != 0 -> has_char0 F -> solvable_by_radical_poly p <-> classically (exists (L : splittingFieldType F) (rs : seq L), p ^^ in_alg L %= \prod_(x <- rs) ('X - x%:P) /\ solvable_by radical 1 <<1 & rs>>). Proof. move=> p_neq0 charF0; split => sol_p; last first. apply/AbelGaloisPoly => //; apply/solvable_ext_polyP => //. apply: classic_bind sol_p => -[L [rs [prs sol_p]]]; apply/classicW. exists L, rs; split => //; rewrite -galois_solvable. apply: radical_ext_solvable_ext; rewrite ?sub1v// => v. by rewrite char_lalg charF0. have charL : has_char0 L by move=> n; rewrite char_lalg charF0. rewrite char0_galois// ?sub1v//. apply/splitting_normalField; rewrite ?sub1v//. by exists (p ^^ in_alg _); [apply/polyOver1P; exists p | exists rs]. have FoE (v : F^o) : v = in_alg F^o v by rewrite /= /(_%:A)/= mulr1. apply: classic_bind (@classic_fieldExtFor _ _ (p : {poly F^o}) p_neq0). move=> [L [rs [f rsf p_eq]]]. have fF : f =1 in_alg L by move=> v; rewrite [v in LHS]FoE rmorph_alg. have splitL : SplittingField.axiom L. exists (p ^^ f); first by apply/polyOver1P; exists p; apply: eq_map_poly. exists rs => //; suff <- : limg f = 1%VS by []. apply/eqP; rewrite eqEsubv sub1v andbT; apply/subvP => v. by move=> /memv_imgP[u _ ->]; rewrite fF/= rpredZ// rpred1. pose S := SplittingFieldType F L splitL. pose d := \dim <<1 & (rs : seq S)>>. have /classic_cycloSplitting-/(_ S) : d%:R != 0 :> F. by have /charf0P-> := charF0; rewrite -lt0n adim_gt0. apply/classic_bind => -[C [w [g wg w_prim]]]; apply/classicW. have gf : g \o f =1 in_alg C by move=> v /=; rewrite fF rmorph_alg. have pgrs : p ^^ in_alg C %= \prod_(x <- [seq g i | i <- rs]) ('X - x%:P). by rewrite -(eq_map_poly gf) map_poly_comp/= -map_prod_XsubC eqp_map//. exists C, (map g rs); split => //=; apply: (sol_p C (map g rs) _ w) => //. by rewrite -(aimg1 g) -aimg_adjoin_seq dim_aimg. Qed. Import GRing.Theory Order.Theory Num.Theory. Lemma solvable_poly_rat (p : {poly rat}) : p != 0 -> solvable_by_radical_poly p -> {L : splittingFieldType rat & {iota : {rmorphism L -> algC} & { rs : seq L | p ^^ in_alg L %= \prod_(x <- rs) ('X - x%:P) /\ solvable_by radical 1 <<1 & rs>>}}}. Proof. move=> p_neq0 p_sol. have [/= rsalg pE] := closed_field_poly_normal (p ^^ (ratr : _ -> algC)). have {}pE : p ^^ ratr %= \prod_(z <- rsalg) ('X - z%:P). rewrite pE (eqp_trans (eqp_scale _ _)) ?eqpxx//. by rewrite lead_coef_map//= fmorph_eq0 lead_coef_eq0. have [L [iota [rs iota_rs rsf]]] := num_field_exists rsalg. have prs : p ^^ in_alg L %= \prod_(z <- rs) ('X - z%:P). rewrite -(eqp_map iota) map_prod_XsubC iota_rs -map_poly_comp. by rewrite (eq_map_poly (fmorph_eq_rat _)). have splitL : SplittingField.axiom L. by exists (p ^^ in_alg L); [by apply/polyOver1P; exists p | exists rs]. pose S := SplittingFieldType rat L splitL. pose d := \dim <<1 & (rs : seq S)>>. have d_gt0 : (d > 0)%N by rewrite adim_gt0. have [ralg ralg_prim] := C_prim_root_exists d_gt0. have [L' [iota' [[]//= w rs' [iotaw iota_rs' wrsf]]]] := num_field_exists (ralg :: rsalg). have prs' : p ^^ in_alg L' %= \prod_(z <- rs') ('X - z%:P). rewrite -(eqp_map iota') map_prod_XsubC iota_rs' -map_poly_comp. by rewrite (eq_map_poly (fmorph_eq_rat _)). have w_prim : d.-primitive_root w. by move: ralg_prim; rewrite -iotaw fmorph_primitive_root. have splitL' : SplittingField.axiom L'. exists (cyclotomic w d * p ^^ in_alg L'). by rewrite rpredM ?cyclotomic_over//; apply/polyOver1P; exists p. have [us cycloE usw] := splitting_Fadjoin_cyclotomic 1%AS w_prim. exists (us ++ rs'); last by rewrite adjoin_cat usw -adjoin_cons. by rewrite big_cat/= (eqp_trans (eqp_mulr _ cycloE))// eqp_mull//. pose S' := SplittingFieldType rat L' splitL'. have splitS : splittingFieldFor 1 (p ^^ in_alg S) fullv by exists rs. have splitS' : splittingFieldFor 1 (p ^^ in_alg S') <<1 & rs'>> by exists rs'. have [f /= imgf] := splitting_ahom splitS splitS'. exists S', iota', rs'; split => //. by apply: (p_sol S' rs' prs' w); rewrite -imgf dim_aimg/= -rsf. Qed. Lemma splitting_num_field (p : {poly rat}) : {L : splittingFieldType rat & { LtoC : {rmorphism L -> algC} | (p != 0 -> splittingFieldFor 1 (p ^^ in_alg L) {:L}) /\ (p = 0 -> L = [splittingFieldType rat of rat^o]) }}. Proof. have [->|p_neq0] := eqVneq p 0. by exists [splittingFieldType rat of rat^o], [rmorphism of ratr]; split. have [/= rsalg pE] := closed_field_poly_normal (p ^^ (ratr : _ -> algC)). have {}pE : p ^^ ratr %= \prod_(z <- rsalg) ('X - z%:P). by rewrite pE (eqp_trans (eqp_scale _ _)) ?eqpxx// lead_coef_eq0 map_poly_eq0. have [L' [L'toC [rs' rs'E rs'f]]] := num_field_exists rsalg. have splitL' : splittingFieldFor 1 (p ^^ in_alg L') {: L'}%AS. exists rs' => //; rewrite -(eqp_map L'toC). by rewrite -map_poly_comp map_prod_XsubC rs'E (eq_map_poly (fmorph_eq_rat _)). have splitaxL' : SplittingField.axiom L'. by exists (p ^^ in_alg L'); first by apply/polyOver1P; exists p. exists (SplittingFieldType rat L' splitaxL'), L'toC; split => //. by move=> p_eq0; rewrite p_eq0 eqxx in p_neq0. Qed. Lemma solvable_poly_ratP (p : {poly rat}) : p != 0 -> solvable_by_radical_poly p <-> exists L : splittingFieldType rat, exists2 K : {subfield L}, splittingFieldFor 1 (p ^^ in_alg L) K & solvable_by radical 1 K. Proof. move=> p_neq0; split. move=> /(solvable_poly_rat p_neq0)[L [_ [rs [prs rssol]]]]. by exists L, <<1 & rs>>%AS; first by exists rs. have charrat : [char rat] =i pred0 by exact: char_num. move=> [L [K [rs prs <-] solK]]; apply/solvable_by_radical_polyP => //. by apply/classicW; exists L, rs. Qed. Definition numfield (p : {poly rat}) : splittingFieldType rat := projT1 (splitting_num_field p). Lemma numfield0 : numfield 0 = [splittingFieldType rat of rat^o]. Proof. by rewrite /numfield; case: splitting_num_field => //= ? [? [_ ->]]. Qed. Definition numfield_inC (p : {poly rat}) : {rmorphism numfield p -> algC} := projT1 (projT2 (splitting_num_field p)). Lemma numfieldP (p : {poly rat}) : p != 0 -> splittingFieldFor 1 (p ^^ in_alg (numfield p)) fullv. Proof. by rewrite /numfield; case: splitting_num_field => //= ? [? []]. Qed. Lemma char_numfield (p : {poly rat}) : [char (numfield p)] =i pred0. Proof. exact: char_ext. Qed. Hint Resolve char_numfield : core. Lemma normal_numfield (p : {poly rat}) : normalField 1 {: numfield p}. Proof. have [{p}->|p_neq0] := eqVneq p 0. by rewrite numfield0 regular_fullv normalField_refl. apply/splitting_normalField; rewrite ?sub1v//. exists (p ^^ in_alg _); last exact: numfieldP. by apply/polyOver1P; exists p. Qed. Lemma galois_numfield (p : {poly rat}) : galois 1 {: numfield p}. Proof. by apply/char0_galois; [exact/char_ext|rewrite sub1v|exact: normal_numfield]. Qed. Theorem AbelGaloisPolyRat (p : {poly rat}) : reflect (solvable_by_radical_poly p) (solvable 'Gal({: numfield p} / 1)). Proof. have [{p}->|p_neq0] := eqVneq p 0. rewrite numfield0 regular_fullv galvv solvable1; constructor. move=> L rs; rewrite eqp_sym rmorph0 eqp0 prodf_seq_eq0. by move=> /hasP[x _ /=]; rewrite polyXsubC_eq0. have charrat : [char rat] =i pred0 by exact: char_num. pose charnumfield := char_ext (numfield p). apply: (equivP idP); rewrite -AbelGaloisPoly//. have [rs prs <-] := numfieldP p_neq0. split; last by move=> /(_ (numfield p) rs prs). move=> solp; apply/solvable_ext_polyP => //. by apply/classicW; exists (numfield p); exists rs; split. Qed. Definition numfield_roots (p : {poly rat}) := if (p != 0) =P true isn't ReflectT p_neq0 then [::] else projT1 (sig2_eqW (numfieldP p_neq0)). Lemma poly_numfield_eqp (p : {poly rat}) : p != 0 -> p ^^ in_alg _ %= \prod_(x <- numfield_roots p) ('X - x%:P). Proof. by move=> p_neq0; rewrite /numfield_roots; case: eqP => //= ?; case: sig2_eqW. Qed. Lemma adjoin_numfield_roots (p : {poly rat}) : (<<1 & numfield_roots p>> = fullv)%VS. Proof. rewrite /numfield_roots; case: eqP => [p0|/negP]; first by case: sig2_eqW. by rewrite negbK => /eqP->; rewrite numfield0 regular_fullv Fadjoin_nil. Qed. Open Scope ring_scope. Module PrimeDegreeTwoNonRealRoots. Section PrimeDegreeTwoNonRealRoots. Variables (p : {poly rat}). Let L := numfield p. Let charL : has_char0 L := char_numfield p. Let iota : {rmorphism L -> algC} := numfield_inC p. Let rp' : seq L := numfield_roots p. Hypothesis p_irr : irreducible_poly p. Let p_neq0 : p != 0. Proof. have := p_irr; rewrite /irreducible_poly => -[+ _]. by apply: contraTneq => ->; rewrite size_poly0. Qed. Let ratr_p' : map_poly ratr p %= \prod_(x <- rp') ('X - x%:P). Proof. by have := poly_numfield_eqp p_neq0; rewrite (eq_map_poly (fmorph_eq_rat _)). Qed. Let rp'_uniq : uniq rp'. Proof. rewrite -separable_prod_XsubC -(eqp_separable ratr_p'). rewrite -char0_ratrE separable_map. apply/coprimepP => d; have [sp_gt1 eqp] := p_irr => /eqp. rewrite size_poly_eq1; have [//|dN1 /(_ isT)] := boolP (d %= 1). move=> /eqp_dvdl-> /dvdp_leq; rewrite -size_poly_eq0 polyorder.size_deriv. by case: (size p) sp_gt1 => [|[|n]]//= _; rewrite ltnn; apply. Qed. Let d := (size p).-1. Hypothesis d_prime : prime d. Hypothesis count_rp' : count [pred x | iota x \isn't Num.real] rp' = 2%N. Let rp := [seq x <- rp' | iota x \isn't Num.real] ++ [seq x <- rp' | iota x \is Num.real]. Let rp_perm : perm_eq rp rp'. Proof. by rewrite perm_catC perm_filterC. Qed. Let rp_uniq : uniq rp. Proof. by rewrite (perm_uniq rp_perm). Qed. Let ratr_p : map_poly ratr p %= \prod_(x <- rp) ('X - x%:P). Proof. rewrite (eqp_trans ratr_p')// eqp_monic ?monic_prod_XsubC//. exact/eqP/esym/perm_big. Qed. Lemma nth_rp_real i : (iota rp`_i \is Num.real) = (i > 1)%N. Proof. rewrite nth_cat size_filter count_rp'; case: ltnP => // iP; [apply/negbTE|]. apply: (allP (filter_all [predC (mem Creal) \o iota] _)) _ (mem_nth 0 _). by rewrite size_filter count_rp'. have [i_big|i_small] := leqP (size [seq x <- rp' | iota x \is Creal]) (i - 2). by rewrite nth_default// rmorph0 rpred0. exact: (allP (filter_all (mem Creal \o iota) _)) _ (mem_nth 0 _). Qed. Let K := <<1 & rp'>>%AS. Let K_eq : K = <<1 & rp>>%AS :> {vspace _}. Proof. exact/esym/eq_adjoin/perm_mem. Qed. Let K_split_p : splittingFieldFor 1%AS (map_poly ratr p) K. Proof. by exists rp => //; rewrite ratr_p eqpxx. Qed. Let p_sep : separable_poly p. Proof. rewrite -(separable_map [rmorphism of char0_ratr charL]). by rewrite (eqp_separable ratr_p) separable_prod_XsubC. Qed. Let d_gt0 : (d > 0)%N. Proof. by rewrite prime_gt0. Qed. Let d_gt1 : (d > 1)%N. Proof. by rewrite prime_gt1. Qed. Lemma size_rp : size rp = d. Proof. have /eqp_size := ratr_p; rewrite -char0_ratrE size_map_poly. by rewrite size_prod_XsubC polySpred// => -[]. Qed. Let i0 := Ordinal d_gt0. Let i1 := Ordinal d_gt1. Lemma ratr_p_over : map_poly (ratr : rat -> L) p \is a polyOver 1%AS. Proof. apply/polyOverP => i; rewrite -char0_ratrE coef_map /=. by rewrite char0_ratrE -alg_num_field rpredZ ?mem1v. Qed. Lemma galois1K : galois 1%VS K. Proof. apply/splitting_galoisField; exists (map_poly ratr p); split => //. exact: ratr_p_over. by rewrite -char0_ratrE separable_map. Qed. Lemma all_rpK : all (mem K) rp. Proof. by rewrite K_eq; apply/allP/seqv_sub_adjoin. Qed. Lemma root_p : root (p ^^ ratr) =i rp. Proof. by move=> x; rewrite -topredE/= (eqp_root ratr_p) root_prod_XsubC. Qed. Lemma rp_roots : all (root (map_poly ratr p)) rp. Proof. by apply/allP => x; rewrite -root_p. Qed. Lemma ratr_p_rp i : (i < d)%N -> (map_poly ratr p).[rp`_i] = 0. Proof. by move=> ltid; apply/eqP; rewrite [_ == _]root_p mem_nth ?size_rp. Qed. Lemma rpK i : (i < d)%N -> rp`_i \in K. Proof. by move=> ltid; rewrite [_ \in _](allP all_rpK) ?mem_nth ?size_rp. Qed. Lemma eq_size_rp : size rp == d. Proof. exact/eqP/size_rp. Qed. Let trp := Tuple eq_size_rp. Lemma gal_perm_eq (g : gal_of K) : perm_eq [seq g x | x <- trp] trp. Proof. apply: prod_XsubC_eq; apply/eqP; rewrite -eqp_monic ?monic_prod_XsubC//. rewrite -(eqp_rtrans ratr_p) big_map. apply: (@eqp_trans _ (map_poly (g \o ratr) p)); last first. apply/eqpW/eq_map_poly => x /=; rewrite (fixed_gal _ (gal1 g)) ?sub1v//. by rewrite -alg_num_field rpredZ ?mem1v. rewrite map_poly_comp/=; have := ratr_p; rewrite -(eqp_map [rmorphism of g])/=. move=> /eqp_rtrans/=->; apply/eqpW; rewrite rmorph_prod. by apply: eq_bigr => x; rewrite rmorphB/= map_polyX map_polyC/=. Qed. Definition gal_perm g : 'S_d := projT1 (sig_eqW (tuple_permP (gal_perm_eq g))). Lemma gal_permP g i : rp`_(gal_perm g i) = g (rp`_i). Proof. rewrite /gal_perm; case: sig_eqW => /= s. move=> /(congr1 (((@nth _ 0))^~ i)); rewrite (nth_map 0) ?size_rp// => ->. by rewrite (nth_map i) ?size_enum_ord// (tnth_nth 0)/= nth_ord_enum. Qed. (** N/A **) Lemma gal_perm_is_morphism : {in ('Gal(K / 1%AS))%G &, {morph gal_perm : x y / (x * y)%g >-> (x * y)%g}}. Proof. move=> u v _ _; apply/permP => i; apply/val_inj. apply: (uniqP 0 rp_uniq); rewrite ?inE ?size_rp ?ltn_ord//=. by rewrite permM !gal_permP galM// ?rpK. Qed. Canonical gal_perm_morphism := Morphism gal_perm_is_morphism. Lemma minPoly_rp x : x \in rp -> minPoly 1%VS x %= map_poly ratr p. Proof. move=> xrp; have : minPoly 1 x %| map_poly ratr p. by rewrite minPoly_dvdp ?ratr_p_over ?[root _ _]root_p//=. have : size (minPoly 1 x) != 1%N by rewrite size_minPoly. have /polyOver1P[q ->] := minPolyOver 1 x. have /eq_map_poly -> : in_alg L =1 ratr. by move=> r; rewrite in_algE alg_num_field. by rewrite -char0_ratrE /eqp !dvdp_map -/(_ %= _) size_map_poly; apply: p_irr. Qed. Lemma injm_gal_perm : ('injm gal_perm)%g. Proof. apply/subsetP => u /mker/= gu1; apply/set1gP/eqP/gal_eqP => x Kx. have fixrp : all (fun r => frel u r r) rp. apply/allP => r/= /(nthP 0)[i]; rewrite size_rp => ltid <-. have /permP/(_ (Ordinal ltid))/(congr1 val)/= := gu1. by rewrite perm1/= => {2}<-; rewrite gal_permP. rewrite K_eq /= in Kx. elim/last_ind: rp x Kx fixrp => [|s r IHs] x. rewrite adjoin_nil subfield_closed => x1 _. by rewrite (fixed_gal _ (gal1 u)) ?sub1v ?gal_id. rewrite adjoin_rcons => /Fadjoin_poly_eq <-. rewrite all_rcons => /andP[/eqP ur /IHs us]. rewrite gal_id -horner_map/= ur map_poly_id//=. move=> a /(nthP 0)[i i_lt <-]; rewrite us ?gal_id//. exact/polyOverP/Fadjoin_polyOver. Qed. Lemma dvd_dG : (d %| #|'Gal(K / 1%VS)%g|)%N. Proof. rewrite dim_fixedField (galois_fixedField _) ?galois1K ?dimv1 ?divn1//. rewrite (@dvdn_trans (\dim_(1%VS : {vspace L}) <<1; rp`_0>>%VS))//. rewrite -adjoin_degreeE -[X in (_ %| X)%N]/(_.+1.-1). rewrite -size_minPoly (eqp_size (minPoly_rp _)) ?mem_nth ?size_rp//. by rewrite -char0_ratrE size_map_poly. rewrite dimv1 divn1 K_eq field_dimS//= -adjoin_seq1 adjoin_seqSr//. have: (0 < size rp)%N by rewrite size_rp. by case: rp => //= x l _ y; rewrite inE => /eqP->; rewrite inE eqxx. Qed. Definition gal_cycle : gal_of K := projT1 (Cauchy d_prime dvd_dG). Lemma gal_cycle_order : #[gal_cycle]%g = d. Proof. by rewrite /gal_cycle; case: Cauchy. Qed. Lemma gal_perm_cycle_order : #[(gal_perm gal_cycle)]%g = d. Proof. by rewrite order_injm ?gal_cycle_order ?injm_gal_perm ?gal1. Qed. Definition conjL : {lrmorphism L -> L} := projT1 (restrict_aut_to_normal_num_field iota conjC). Definition iotaJ : {morph iota : x / conjL x >-> x^*} := projT2 (restrict_aut_to_normal_num_field _ _). Lemma conjLK : involutive conjL. Proof. by move=> x; apply: (fmorph_inj iota); rewrite !iotaJ conjCK. Qed. Lemma conjL_rp : {mono conjL : x / x \in rp}. Proof. suff rpJ : {homo conjL : x / x \in rp}. by move=> x; apply/idP/idP => /rpJ//; rewrite conjLK. move=> ?/(nthP 0)[i]; rewrite size_rp => ltid <-. rewrite -!root_p -!topredE /root/=. have /eq_map_poly<- : conjL \o char0_ratr charL =1 _ := fmorph_eq_rat _. by rewrite map_poly_comp horner_map ratr_p_rp ?rmorph0. Qed. Lemma conjL_K : {mono conjL : x / x \in K}. Proof. suff rpJ : {homo conjL : x / x \in K}. by move=> x; apply/idP/idP => /rpJ//; rewrite conjLK. move=> x; rewrite K_eq => xK. have : conjL x \in (linfun conjL @: <<1 & rp>>)%VS. by apply/memv_imgP; exists x => //; rewrite lfunE. rewrite aimg_adjoin_seq aimg1/= (@eq_adjoin _ _ _ _ rp)// => y. apply/mapP/idP => [[z zrp->]|yrp]; first by rewrite lfunE conjL_rp. by exists (conjL y); rewrite ?conjL_rp//= !lfunE [RHS]conjLK. Qed. Lemma conj_rp0 : conjL rp`_i0 = rp`_i1. Proof. have /(nthP 0)[j jlt /esym rpj_eq]: conjL rp`_i0 \in rp. by rewrite conjL_rp mem_nth ?size_rp. rewrite size_rp in jlt; rewrite rpj_eq; congr nth. have: j != i0. apply: contra_eq_neq rpj_eq => ->. by rewrite -(inj_eq (fmorph_inj iota)) iotaJ -CrealE nth_rp_real. have: (j < 2)%N by rewrite ltnNge -nth_rp_real -rpj_eq iotaJ CrealJ nth_rp_real. by case: j {jlt rpj_eq} => [|[|[]]]. Qed. Lemma conj_rp1 : conjL rp`_i1 = rp`_i0. Proof. by apply: (canLR conjLK); rewrite conj_rp0. Qed. Lemma conj_nth_rp (i : 'I_d) : conjL (rp`_i) = rp`_(tperm i0 i1 i). Proof. rewrite permE/=; case: eqVneq => [->|Ni0]; first by rewrite conj_rp0. case: eqVneq => [->|Ni1]; first by rewrite conj_rp1. have i_gt : (i > 1)%N by case: i Ni0 Ni1 => [[|[|[]]]]. apply: (fmorph_inj iota); rewrite iotaJ. by rewrite conj_Creal ?nth_rp_real// tpermD// -val_eqE/= ltn_eqF// ltnW. Qed. Definition galJ : gal_of K := gal K (AHom (linfun_is_ahom conjL)). Lemma galJ_tperm : gal_perm galJ = tperm i0 i1. Proof. apply/permP => i; apply/val_inj. apply: (uniqP 0 rp_uniq); rewrite ?inE ?size_rp ?ltn_ord//=. rewrite gal_permP /galJ/= galK ?rpK//= ?lfunE ?[LHS]conj_nth_rp//. by apply/subvP => /= _/memv_imgP[x Ex ->]; rewrite lfunE conjL_K. Qed. Lemma surj_gal_perm : (gal_perm @* 'Gal (K / 1%AS) = 'Sym_('I_d))%g. Proof. apply/eqP; rewrite eqEsubset subsetT/=. rewrite -(@gen_tperm_cycle _ i0 i1 (gal_perm gal_cycle)); do ?by rewrite ?dpair_ij0 ?card_ord ?gal_perm_cycle_order. by rewrite gen_subG; apply/subsetP => s /set2P[]->; rewrite -?galJ_tperm ?mem_morphim ?gal1. Qed. Lemma isog_gal_perm : 'Gal (K / 1%AS) \isog 'Sym_('I_d). Proof. apply/isogP; exists gal_perm_morphism; first exact: injm_gal_perm. exact: surj_gal_perm. Qed. Lemma isog_gal : 'Gal ({:numfield p} / 1%AS) \isog 'Sym_('I_d). Proof. by rewrite -adjoin_numfield_roots isog_gal_perm. Qed. End PrimeDegreeTwoNonRealRoots. End PrimeDegreeTwoNonRealRoots. Module PDTNRR := PrimeDegreeTwoNonRealRoots. Section Example1. Definition poly_example_int : {poly int} := 'X^5 - 4 *: 'X + 2. Definition poly_example : {poly rat} := 'X^5 - 4 *: 'X + 2. Local Definition pesimp := (coefD, coefN, coefB, coefZ, coefXn, coefX, coefC, hornerD, hornerN, hornerC, hornerZ, hornerX, hornerXn, rmorph_nat). Lemma polyCn (R : ringType) n : n%:R%:P = n%:R :> {poly R}. Proof. by rewrite rmorph_nat. Qed. Lemma poly_exampleEint : poly_example = map_poly intr poly_example_int. Proof. pose simp := (rmorphB, rmorphD, map_polyZ, map_polyXn, map_polyX, map_polyC). by do !rewrite [map_poly _ _]simp/= ?natz. Qed. Lemma size_poly_example_int : size poly_example_int = 6%N. Proof. rewrite /poly_example_int -addrA size_addl ?size_polyXn//. by rewrite size_addl ?size_opp ?size_scale ?size_polyX -?polyCn ?size_polyC. Qed. Lemma size_poly_example : size poly_example = 6%N. Proof. rewrite /poly_example -addrA size_addl ?size_polyXn//. by rewrite size_addl ?size_opp ?size_scale ?size_polyX -?polyCn ?size_polyC. Qed. Lemma poly_example_int_neq0 : poly_example_int != 0. Proof. by rewrite -size_poly_eq0 size_poly_example_int. Qed. Lemma poly_example_neq0 : poly_example != 0. Proof. by rewrite -size_poly_eq0 size_poly_example. Qed. Hint Resolve poly_example_neq0 : core. Lemma poly_example_monic : poly_example \is monic. Proof. by rewrite monicE lead_coefE !pesimp size_poly_example. Qed. Hint Resolve poly_example_monic : core. Lemma irreducible_example : irreducible_poly poly_example. Proof. rewrite poly_exampleEint; apply: (@eisenstein 2) => // [|||i]; rewrite ?lead_coefE ?size_poly_example_int ?pesimp//. by move: i; do 6!case=> //. Qed. Hint Resolve irreducible_example : core. Lemma separable_example : separable_poly poly_example. Proof. apply/coprimepP => q /(irredp_XsubCP irreducible_example) [//| eqq]. have size_deriv_example : size poly_example^`() = 5%N. rewrite !derivCE addr0 alg_polyC -scaler_nat addr0. by rewrite size_addl ?size_scale ?size_opp ?size_polyXn ?size_polyC. rewrite gtNdvdp -?size_poly_eq0 ?size_deriv_example//. by rewrite (eqp_size eqq) ?size_poly_example. Qed. Hint Resolve separable_example : core. Lemma prime_example : prime (size poly_example).-1. Proof. by rewrite size_poly_example. Qed. (* Using the package real_closed, we should be able to monitor the sign of *) (* the derivative, and find that the polynomial has exactly three real roots. *) Definition example_roots : seq algC := map (numfield_inC poly_example) (numfield_roots poly_example). Lemma ratr_example_poly : poly_example ^^ ratr = \prod_(x <- example_roots) ('X - x%:P). Proof. rewrite /example_roots -map_prod_XsubC/=. have := poly_numfield_eqp poly_example_neq0. rewrite eqp_monic ?monic_prod_XsubC ?monic_map// => /eqP<-. by rewrite -map_poly_comp [in RHS](eq_map_poly (fmorph_eq_rat _)). Qed. Lemma size_example_roots : size example_roots = 5%N. Proof. have /(congr1 (fun p : {poly _} => size p)) := ratr_example_poly. by rewrite size_map_poly size_poly_example size_prod_XsubC => -[]. Qed. Lemma example_roots_uniq : uniq example_roots. Proof. rewrite -separable_prod_XsubC -ratr_example_poly. by rewrite separable_map separable_example. Qed. Lemma deriv_poly_example : poly_example^`() = 5%:R *: 'X^4 - 4%:R%:P. Proof. by rewrite /poly_example !derivE addr0 alg_polyC scaler_nat ?addr0. Qed. Lemma deriv_poly_example_neq0 : poly_example^`() != 0. Proof. apply/eqP => /(congr1 (fun p => p.[0])). by rewrite deriv_poly_example !pesimp => /eqP; compute. Qed. Hint Resolve deriv_poly_example_neq0 : core. Definition alpha : algR := Num.sqrt (2%:R / Num.sqrt 5%:R). Lemma alpha_gt0 : alpha > 0. Proof. by rewrite sqrtr_gt0 mulr_gt0 ?invr_gt0 ?sqrtr_gt0 ?ltr0n. Qed. Lemma rootsR_deriv_poly_example : rootsR (poly_example^`() ^^ ratr) = [:: - alpha; alpha]. Proof. apply: lt_sorted_eq; rewrite ?sorted_roots//. by rewrite /= andbT -subr_gt0 opprK ?addr_gt0 ?alpha_gt0. move=> x; rewrite mem_rootsR ?map_poly_eq0// !inE -topredE/= orbC. rewrite deriv_poly_example /root. rewrite rmorphB linearZ/= map_polyC/= map_polyXn !pesimp. rewrite -[5%:R]sqr_sqrtr ?ler0n// (exprM _ 2 2) -exprMn (natrX _ 2 2) subr_sqr. rewrite mulf_eq0 [_ + 2%:R == 0]gt_eqF ?orbF; last first. by rewrite ltr_spaddr ?ltr0n// mulr_ge0 ?sqrtr_ge0// exprn_even_ge0. have sqrt5N0 : Num.sqrt (5%:R : algR) != 0 by rewrite gt_eqF// sqrtr_gt0 ?ltr0n. rewrite subr_eq0 (can2_eq (mulKf _) (mulVKf _))// mulrC -subr_eq0. rewrite -[X in _ - X]sqr_sqrtr; last first. by rewrite mulr_ge0 ?invr_ge0 ?sqrtr_ge0 ?ler0n. by rewrite subr_sqr mulf_eq0 subr_eq0 addr_eq0. Qed. Lemma count_roots_ex : count [predC Creal] example_roots = 2%N. Proof. rewrite -!sum1_count; pose pR : {poly algR} := poly_example ^^ ratr. have pR0 : pR != 0 by rewrite map_poly_eq0. suff cR : (\sum_(j <- example_roots | j \is Num.real) 1)%N = 3%N. have := size_example_roots; rewrite -sum1_size (bigID (mem Num.real))/=. by rewrite cR => -[->]. rewrite -big_filter (perm_big (map algRval (rootsR pR))); last first. rewrite uniq_perm ?filter_uniq ?example_roots_uniq//. by rewrite (map_inj_uniq (fmorph_inj _)) uniq_roots. move=> x; rewrite mem_filter -root_prod_XsubC -ratr_example_poly. rewrite -(eq_map_poly (fmorph_eq_rat [rmorphism of algRval \o ratr]))/=. rewrite map_poly_comp/=. apply/andP/mapP => [[xR xroot]|[y + ->]]. exists (in_algR xR); rewrite // mem_rootsR// -topredE/=. by rewrite -(mapf_root algRval_rmorphism)/=. rewrite mem_rootsR// -[y \in _]topredE/=. by split; [apply/algRvalP|rewrite mapf_root]. apply/eqP; rewrite sum1_size size_map eqn_leq. rewrite (leq_trans (size_root_leSderiv _))//=; last first. by rewrite deriv_map rootsR_deriv_poly_example. have pRE x : Num.sg pR.[x%:~R] = locked ratr (Num.sg poly_example.[x%:~R]). by rewrite -lock ratr_sg -horner_map/= ratr_int. have pN2 : Num.sg pR.[(- 2%:Z)%:~R] = - 1 by rewrite pRE !pesimp -lock rmorphN1. have pN1 : Num.sg pR.[(- 1%:Z)%:~R] = 1 by rewrite pRE !pesimp -lock rmorph1. have p1 : Num.sg pR.[1%:~R] = - 1 by rewrite pRE !pesimp -lock rmorphN1. have p2 : Num.sg pR.[2%:~R] = 1 by rewrite pRE !pesimp -lock rmorph1. have simp := (pN2, pN1, p1, p2, mulN1r, mulrN1). have [||x0 /andP[_ x0N1] rx0] := @ivt_sign _ pR (- 2%:R) (- 1); rewrite ?simp//. by rewrite -subr_ge0 opprK addKr ler01. have [||x1 /andP[x10 x11] rx1] := @ivt_sign _ pR (-1) 1; rewrite ?simp//. by rewrite -subr_ge0 opprK addr_ge0 ?ler01. have [||x2 /andP[/= x21 _] rx2] := @ivt_sign _ pR 1 2%:R; rewrite ?simp//. by rewrite -subr_ge0 addrK ler01. have: sorted <%R [:: x0; x1; x2] by rewrite /= (lt_trans x0N1) ?(lt_trans x11). rewrite lt_sorted_uniq_le => /andP[uniqx012 _]. apply: (@uniq_leq_size _ [:: x0; x1; x2]) => //. by move=> x; rewrite !inE => /or3P[]/eqP->/=; rewrite mem_rootsR. Qed. Lemma example_not_solvable_by_radicals : ~ solvable_by_radical_poly ('X^5 - 4 *: 'X + 2 : {poly rat}). Proof. move=> /AbelGaloisPolyRat; pose sol_gal := isog_sol (PDTNRR.isog_gal _ _ _). rewrite sol_gal ?size_poly_example ?solvable_SymF ?card_ord//. by rewrite -(count_map _ [predC Creal]) count_roots_ex. Qed. End Example1. Section Formula. Definition prim1root_ n := projT1 (@C_prim_root_exists n.-1.+1 isT). Lemma prim1rootP n : (n > 0)%N -> n.-primitive_root (prim1root_ n). Proof. by case: n => [|n]// _; rewrite /prim1root_; case: C_prim_root_exists. Qed. Inductive const := Zero | One | URoot of nat. Inductive binOp := Add | Mul. Inductive unOp := Opp | Inv | Exp of nat | Root of nat. Inductive algterm (F : Type) : Type := | Base of F | Const of const | UnOp of unOp & algterm F | BinOp of binOp & algterm F & algterm F. Arguments Const {F}. Definition encode_const (c : const) : nat := match c with Zero => 0 | One => 1 | URoot n => n.+2 end. Definition decode_const (n : nat) : const := match n with 0 => Zero | 1 => One | n.+2 => URoot n end. Lemma code_constK : cancel encode_const decode_const. Proof. by case. Qed. Definition const_eqMixin := CanEqMixin code_constK. Canonical const_eqType := EqType const const_eqMixin. Definition const_choiceMixin := CanChoiceMixin code_constK. Canonical const_choiceType := ChoiceType const const_choiceMixin. Definition const_countMixin := CanCountMixin code_constK. Canonical const_countType := CountType const const_countMixin. Definition encode_binOp (c : binOp) : bool := match c with Add => false | Mul => true end. Definition decode_binOp (b : bool) : binOp := match b with false => Add | _ => Mul end. Lemma code_binOpK : cancel encode_binOp decode_binOp. Proof. by case. Qed. Definition binOp_eqMixin := CanEqMixin code_binOpK. Canonical binOp_eqType := EqType binOp binOp_eqMixin. Definition binOp_choiceMixin := CanChoiceMixin code_binOpK. Canonical binOp_choiceType := ChoiceType binOp binOp_choiceMixin. Definition binOp_countMixin := CanCountMixin code_binOpK. Canonical binOp_countType := CountType binOp binOp_countMixin. Definition encode_unOp (c : unOp) : nat + nat := match c with Opp => inl _ 0%N | Inv => inl _ 1%N | Exp n => inl _ n.+2 | Root n => inr _ n end. Definition decode_unOp (n : nat + nat) : unOp := match n with inl 0 => Opp | inl 1 => Inv | inl n.+2 => Exp n | inr n => Root n end. Lemma code_unOpK : cancel encode_unOp decode_unOp. Proof. by case. Qed. Definition unOp_eqMixin := CanEqMixin code_unOpK. Canonical unOp_eqType := EqType unOp unOp_eqMixin. Definition unOp_choiceMixin := CanChoiceMixin code_unOpK. Canonical unOp_choiceType := ChoiceType unOp unOp_choiceMixin. Definition unOp_countMixin := CanCountMixin code_unOpK. Canonical unOp_countType := CountType unOp unOp_countMixin. Fixpoint encode_algT F (f : algterm F) : GenTree.tree (F + const) := let T_ isbin := if isbin then binOp else unOp in match f with | Base x => GenTree.Leaf (inl x) | Const c => GenTree.Leaf (inr c) | UnOp u f1 => GenTree.Node (pickle (inl u : unOp + binOp)) [:: encode_algT f1] | BinOp b f1 f2 => GenTree.Node (pickle (inr b : unOp + binOp)) [:: encode_algT f1; encode_algT f2] end. Fixpoint decode_algT F (t : GenTree.tree (F + const)) : algterm F := match t with | GenTree.Leaf (inl x) => Base x | GenTree.Leaf (inr c) => Const c | GenTree.Node n fs => match locked (unpickle n), fs with | Some (inl u), f1 :: _ => UnOp u (decode_algT f1) | Some (inr b), f1 :: f2 :: _ => BinOp b (decode_algT f1) (decode_algT f2) | _, _ => Const Zero end end. Lemma code_algTK F : cancel (@encode_algT F) (@decode_algT F). Proof. by elim => // [u f IHf|b f IHf f' IHf']/=; rewrite pickleK -lock ?IHf ?IHf'. Qed. Definition algT_eqMixin (F : eqType) := CanEqMixin (@code_algTK F). Canonical algT_eqType (F : eqType) := EqType (algterm F) (@algT_eqMixin F). Definition algT_choiceMixin (F : choiceType) := CanChoiceMixin (@code_algTK F). Canonical algT_choiceType (F : choiceType) := ChoiceType (algterm F) (@algT_choiceMixin F). Definition algT_countMixin (F : countType) := CanCountMixin (@code_algTK F). Canonical algT_countType (F : countType) := CountType (algterm F) (@algT_countMixin F). Declare Scope algT_scope. Delimit Scope algT_scope with algT. Bind Scope algT_scope with algterm. Local Notation "0" := (Const Zero) : algT_scope. Local Notation "1" := (Const One) : algT_scope. Local Notation "- x" := (UnOp Opp x) : algT_scope. Local Notation "- 1" := (- (1)) : algT_scope. Local Infix "+" := (BinOp Add) : algT_scope. Local Notation "x ^-1" := (UnOp Inv x) : algT_scope. Local Infix "*" := (BinOp Mul) : algT_scope. Local Notation "x ^+ n" := (UnOp (Exp n) x) : algT_scope. Local Notation "n '.+1-root'" := (UnOp (Root n)) (at level 2, format "n '.+1-root'") : algT_scope. Local Notation "n '.+1-prim1root'" := (Const (URoot n)) (at level 2, format "n '.+1-prim1root'") : algT_scope. Section eval. Variables (F : fieldType) (iota : F -> algC). Fixpoint algT_eval (f : algterm F) : algC := match f with | Base x => iota x | 0%algT => 0 | 1%algT => 1 | (f1 + f2)%algT => algT_eval f1 + algT_eval f2 | (- f1)%algT => - algT_eval f1 | (f1 * f2)%algT => algT_eval f1 * algT_eval f2 | (f1 ^-1)%algT => (algT_eval f1)^-1 | (f1 ^+ n)%algT => (algT_eval f1) ^+ n | (n.+1-root f1)%algT => n.+1.-root (algT_eval f1) | (j.+1-prim1root)%algT => prim1root_ j.+1 end. Fixpoint subeval (f : algterm F) : seq algC := algT_eval f :: match f with | UnOp _ f1 => subeval f1 | BinOp _ f1 f2 => subeval f1 ++ subeval f2 | _ => [::] end. Lemma subevalE f : subeval f = algT_eval f :: behead (subeval f). Proof. by case: f => *. Qed. End eval. Lemma solvable_formula (p : {poly rat}) : p != 0 -> solvable_by_radical_poly p <-> {in root (p ^^ ratr), forall x, exists f : algterm rat, algT_eval ratr f = x}. Proof. have Cchar := Cchar => p_neq0; split. move=> /solvable_poly_rat[]// L [iota [rs [prs [E rE KE]]]] x. have pirs : p ^^ ratr %= \prod_(x <- map iota rs) ('X - x%:P). have := prs; rewrite -(eqp_map iota) map_prod_XsubC => /eqp_rtrans<-. by rewrite -map_poly_comp (eq_map_poly (fmorph_eq_rat _)) eqpxx. rewrite -topredE/= (eqp_root pirs) root_prod_XsubC => /mapP[{}r rrs ->]. suff [f <- /=]: exists f : algterm (subvs_of (1%VS : {vspace L})), algT_eval (iota \o vsval) f = iota r. elim: f => //= [[/= _/vlineP[s ->]]|cst|op|op]. - exists (Base s) => /=. by rewrite [RHS](fmorph_eq_rat [rmorphism of iota \o in_alg L]). - by exists (Const cst). - by move=> _ [f1 <-]; exists (UnOp op f1). - by move=> _ [f1 <-] _ [f2 <-]; exists (BinOp op f1 f2). have: r \in E by rewrite (subvP KE)// seqv_sub_adjoin. case: rE => -[/= n e pw] epw <-. rewrite -[1%VS]/(1%AS : {vspace _}) in epw *. elim: n 1%AS => [|n IHn] k /= in e pw epw *. by rewrite tuple0 Fadjoin_nil => rk; exists (Base (Subvs rk)). case: (tupleP e) (tupleP pw) epw => [u e'] [i pw']/= epw. rewrite adjoin_cons => /IHn-/(_ pw')[]. apply/towerP => j /=. have /towerP/(_ (lift ord0 j))/= := epw. by rewrite !tnthS/= adjoin_cons. move=> f <-; elim: f => //= [s|cst|op|op]; last 3 first. - by exists (Const cst). - by move=> _ [f1 <-]; exists (UnOp op f1). - by move=> _ [f1 <-] _ [f2 <-]; exists (BinOp op f1 f2). have /Fadjoin_polyP[q qk ->] := subvsP s. have /towerP/(_ ord0) := epw; rewrite !tnth0/= Fadjoin_nil. move=> /radicalP[]; case: i => // i in epw * => _ uik. pose v := i.+1.-root (iota (u ^+ i.+1)). have : ('X ^+ i.+1 - (v ^+ i.+1)%:P).[iota u] == 0. by rewrite !hornerE hornerXn rootCK// rmorphX subrr. have /Xn_sub_xnE->// := prim1rootP (isT : 0 < i.+1)%N. rewrite horner_prod prodf_seq_eq0/= => /hasP[/= l _]. rewrite hornerXsubC subr_eq0 => /eqP u_eq. pose fu := (i.+1-root (Base (Subvs uik)) * (i.+1-prim1root ^+ l))%algT. rewrite -horner_map; have -> : iota u = algT_eval (iota \o vsval) fu by []. move: fu => fu; elim/poly_ind: q qk => //= [|q c IHq] qXDck. by exists 0%algT; rewrite rmorph0 horner0. have ck : c \in k. by have /polyOverP/(_ 0%N) := qXDck; rewrite coefD coefMX coefC/= add0r. have qk : q \is a polyOver k. apply/polyOverP => j; have /polyOverP/(_ j.+1) := qXDck. by rewrite coefD coefMX coefC/= addr0. case: IHq => // fq fq_eq. exists (fq * fu + Base (Subvs ck))%algT => /=. by rewrite rmorphD rmorphM/= map_polyX map_polyC !hornerE fq_eq. move=> mkalg; apply/solvable_by_radical_polyP => //=; first exact: char_num. have [/= rsalg pE] := closed_field_poly_normal (p ^^ (ratr : _ -> algC)). have {}pE : p ^^ ratr %= \prod_(z <- rsalg) ('X - z%:P). rewrite pE (eqp_trans (eqp_scale _ _)) ?eqpxx//. by rewrite lead_coef_map//= fmorph_eq0 lead_coef_eq0. have [fs fsE] : exists fs, map (algT_eval ratr) fs = rsalg. have /(_ _ _)/sig_eqW-/(all_sig_cond (Base 0)) [h hE] : forall x : algC, x \in rsalg -> exists f, algT_eval ratr f = x. by move=> *; apply: mkalg; rewrite -topredE/= (eqp_root pE) root_prod_XsubC. by exists (map h rsalg); rewrite -map_comp map_id_in//. pose algs := flatten (map (subeval ratr) fs). pose mp := \prod_(x <- algs) projT1 (minCpolyP x). have mp_monic : mp \is monic. by rewrite monic_prod => // i _; case: minCpolyP => /= ? []. have mpratr : mp ^^ ratr = \prod_(x <- algs) minCpoly x. rewrite rmorph_prod/=; apply: eq_bigr => x _. by case: minCpolyP => //= ? []. have [rsmpalg mpE] := closed_field_poly_normal (mp ^^ ratr : {poly algC}). have mp_neq0 : mp != 0. rewrite prodf_seq_eq0; apply/hasPn => /= x xalgs. by case: minCpolyP => //= ? [_ /monic_neq0->]. have {}mpE : mp ^^ ratr = \prod_(z <- rsmpalg) ('X - z%:P). by rewrite mpE lead_coef_map/= (eqP mp_monic) rmorph1 scale1r. have [L [iota [rsmp iota_rs rsf]]] := num_field_exists rsmpalg. have charL : has_char0 L by move=> x; rewrite char_lalg char_num. have mprs : mp ^^ in_alg L %= \prod_(z <- rsmp) ('X - z%:P). rewrite -(eqp_map iota) map_prod_XsubC iota_rs -map_poly_comp -mpE. by rewrite -char0_ratrE// (eq_map_poly (fmorph_eq_rat _)) eqpxx. have splitL : SplittingField.axiom L. by exists (mp ^^ in_alg L); [apply/polyOver1P; exists mp | exists rsmp]. pose S := SplittingFieldType rat L splitL. have algsW: {subset rsalg <= algs}. move=> x; rewrite -fsE => /mapP[{x}f ffs ->]. apply/flattenP; exists (subeval ratr f); rewrite ?map_f//. by rewrite subevalE mem_head. have rsmpW: {subset algs <= rsmpalg}. move=> x xalgs; rewrite -root_prod_XsubC -mpE mpratr. by rewrite (big_rem _ xalgs)/= rootM root_minCpoly. have := rsmpW; rewrite -iota_rs => /subset_mapP[als _ /esym alsE]. have := algsW; rewrite -alsE => /subset_mapP[rs _ /esym rsE]. have prs : p ^^ in_alg S %= \prod_(x <- rs) ('X - x%:P). rewrite -(eqp_map iota) -map_poly_comp (eq_map_poly (fmorph_eq_rat _)). by rewrite map_prod_XsubC rsE. apply/classicW; exists S, rs; split => //. exists <<1 & als>>%AS; last first. rewrite adjoin_seqSr// => x /(map_f iota); rewrite rsE => /algsW. by rewrite -[X in _ \in X]alsE (mem_map (fmorph_inj _)). rewrite {p p_neq0 mkalg pE prs rsmp iota_rs mprs rsf rs rsE mp mp_monic mpratr rsmpalg mp_neq0 mpE algsW rsmpW charL}/=. suff: forall (L : splittingFieldType rat) (iota : {rmorphism L -> algC}) als, map iota als = algs -> radical.-ext 1%VS <<1 & als>>%VS. by move=> /(_ S iota als alsE). move=> {}L {}iota {splitL S} {}als {}alsE; rewrite {}/algs in alsE. elim: fs => [|f fs IHfs]//= in rsalg fsE als alsE *. case: als => []// in alsE *. by rewrite Fadjoin_nil; apply: rext_refl. move: rsalg fsE => [|r rsalg]// [fr fsE]. pose n := size (subeval ratr f); rewrite -[als](cat_take_drop n). have /(congr1 (take n)) := alsE; rewrite take_size_cat//. rewrite -map_take; move: (take _ _) => als1 als1E. have /(congr1 (drop n)) := alsE; rewrite drop_size_cat//. rewrite -map_drop; move: (drop _ _) => als2 als2E. have /rext_trans := IHfs _ fsE _ als2E; apply. have -> : <<1 & als1 ++ als2>>%AS = <<<<1 & als2>>%AS & als1>>%AS. apply/val_inj; rewrite /= -adjoin_cat; apply/eq_adjoin => x. by rewrite !mem_cat orbC. move: <<1 & als2>>%AS => /= k {als2 als2E n fs fsE IHfs rsalg als alsE}. elim: f => //= [x|c|u f1 IHf1|b f1 IHf1 f2 IHf2] in k {r fr} als1 als1E *. - case: als1 als1E => [|y []]//= [yx]/=. rewrite adjoin_seq1 (Fadjoin_idP _); first exact: rext_refl. suff: y \in 1%VS by apply/subvP; rewrite sub1v. apply/vlineP; exists x; apply: (fmorph_inj iota); rewrite yx. by rewrite [RHS](fmorph_eq_rat [rmorphism of iota \o in_alg _]). - case: als1 als1E => [|y []]//= []/=; rewrite adjoin_seq1. case: c => [/eqP|/eqP|n yomega]. + rewrite fmorph_eq0 => /eqP->; rewrite (Fadjoin_idP _) ?rpred0//. exact: rext_refl. + rewrite fmorph_eq1 => /eqP->; rewrite (Fadjoin_idP _) ?rpred1//. exact: rext_refl. + apply/(@rext_r _ _ _ n.+1)/radicalP; split => //. rewrite prim_expr_order ?rpred1//. by rewrite -(fmorph_primitive_root iota) yomega prim1rootP. - case: als1 als1E => //= a l [IHl IHlu]. rewrite -(eq_adjoin _ (mem_rcons _ _)) adjoin_rcons. apply: rext_trans (IHf1 k l IHlu) _ => /=. move: IHlu; rewrite subevalE; case: l => // x1 l [iotax1 _]. rewrite -iotax1 -rmorphN -fmorphV in IHl. have x1kx1 : x1 \in <>%VS by rewrite seqv_sub_adjoin ?mem_head. case: u => [||n|n]/= in IHl. + rewrite (Fadjoin_idP _); first exact: rext_refl. by have /fmorph_inj-> := IHl; rewrite rpredN. + rewrite (Fadjoin_idP _); first exact: rext_refl. by have /fmorph_inj-> := IHl; rewrite rpredV. + rewrite (Fadjoin_idP _); first exact: rext_refl. by have := IHl; rewrite -rmorphX => /fmorph_inj->; rewrite rpredX. apply/(@rext_r _ _ _ n.+1)/radicalP; split => //. have /(congr1 ((@GRing.exp _)^~ n.+1)) := IHl. by rewrite rootCK// -rmorphX => /fmorph_inj->. - case: als1 als1E => //= a l [IHl IHlu]. rewrite -(eq_adjoin _ (mem_rcons _ _)) adjoin_rcons. pose n := size (subeval ratr f1); rewrite -[l](cat_take_drop n). have /(congr1 (take n)) := IHlu; rewrite take_size_cat//. rewrite -map_take; move: (take _ _) => l1 l1E. have /(congr1 (drop n)) := IHlu; rewrite drop_size_cat//. rewrite -map_drop; move: (drop _ _) => l2 l2E. apply: rext_trans (IHf1 _ l1 l1E) _ => /=. apply: rext_trans (IHf2 _ l2 l2E) _ => /=. rewrite -adjoin_cat (Fadjoin_idP _); first exact: rext_refl. rewrite subevalE in l1E; rewrite subevalE in l2E. case: l1 l1E => // b1 l1 [iotab1 _]. case: l2 l2E => // b2 l2 [iotab2 _]. rewrite -iotab1 -iotab2 -rmorphM -rmorphD in IHl. have b2l : b2 \in (b1 :: l1) ++ (b2 :: l2) by rewrite mem_cat mem_head orbT. have b1l : b1 \in (b1 :: l1) ++ (b2 :: l2) by rewrite mem_head. by case: b IHl => /fmorph_inj ->; rewrite ?(rpredD, rpredM)// seqv_sub_adjoin. Qed. End Formula.