fact
stringlengths 8
1.54k
| type
stringclasses 19
values | library
stringclasses 8
values | imports
listlengths 1
10
| filename
stringclasses 98
values | symbolic_name
stringlengths 1
42
| docstring
stringclasses 1
value |
|---|---|---|---|---|---|---|
rmodp0p : rmodp p 0 = p. Proof. by rewrite /rmodp unlock eqxx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp0
| |
rscalp_smallp q : size p < size q -> rscalp p q = 0.
Proof.
rewrite /rscalp unlock; case: eqP => _ // spq.
by case sp: (size p) => [| s] /=; rewrite spq.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rscalp_small
| |
ltn_rmodpp q : (size (rmodp p q) < size q) = (q != 0).
Proof.
rewrite /rdivp /rmodp /rscalp unlock; have [->|q0] := eqVneq q 0.
by rewrite /= size_poly0 ltn0.
elim: (size p) 0%N 0 {1 3}p (leqnn (size p)) => [|n ihn] k q1 r.
move/size_poly_leq0P->.
by rewrite /= size_poly0 size_poly_gt0 q0 size_poly0 size_poly_gt0.
move=> hr /=; case: (ltnP (size r)) => // hsrq; apply/ihn/leq_sizeP => j hnj.
rewrite coefB -scalerAl !coefZ coefXnM coefMC ltn_subRL ltnNge.
have sq: 0 < size q by rewrite size_poly_gt0.
have sr: 0 < size r by apply: leq_trans hsrq.
have hj: (size r).-1 <= j by apply: leq_trans hnj; rewrite -ltnS prednK.
move: (leq_add sq hj); rewrite add1n prednK // => -> /=.
move: hj; rewrite leq_eqVlt prednK // => /predU1P [<- | hj].
by rewrite -predn_sub subKn // !lead_coefE subrr.
have/leq_sizeP -> //: size q <= j - (size r - size q).
by rewrite subnBA // leq_subRL ?leq_add2r // (leq_trans hj) // leq_addr.
by move/leq_sizeP: hj => -> //; rewrite mul0r mulr0 subr0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
ltn_rmodp
| |
ltn_rmodpN0p q : q != 0 -> size (rmodp p q) < size q.
Proof. by rewrite ltn_rmodp. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
ltn_rmodpN0
| |
rmodp1p : rmodp p 1 = 0.
Proof.
apply/eqP; have := ltn_rmodp p 1.
by rewrite !oner_neq0 -size_poly_eq0 size_poly1 ltnS leqn0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp1
| |
rmodp_smallp q : size p < size q -> rmodp p q = p.
Proof.
rewrite /rmodp unlock; have [->|_] := eqP; first by rewrite size_poly0.
by case sp: (size p) => [| s] Hs /=; rewrite sp Hs /=.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_small
| |
leq_rmodpm d : size (rmodp m d) <= size m.
Proof.
have [/rmodp_small -> //|h] := ltnP (size m) (size d).
have [->|d0] := eqVneq d 0; first by rewrite rmodp0.
by apply: leq_trans h; apply: ltnW; rewrite ltn_rmodp.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
leq_rmodp
| |
rmodpCp c : c != 0 -> rmodp p c%:P = 0.
Proof.
move=> Hc; apply/eqP; rewrite -size_poly_leq0 -ltnS.
have -> : 1%N = nat_of_bool (c != 0) by rewrite Hc.
by rewrite -size_polyC ltn_rmodp polyC_eq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpC
| |
rdvdp0d : rdvdp d 0. Proof. by rewrite /rdvdp rmod0p. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp0
| |
rdvd0pn : rdvdp 0 n = (n == 0). Proof. by rewrite /rdvdp rmodp0. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvd0p
| |
rdvd0pPn : reflect (n = 0) (rdvdp 0 n).
Proof. by apply: (iffP idP); rewrite rdvd0p; move/eqP. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvd0pP
| |
rdvdpN0p q : rdvdp p q -> q != 0 -> p != 0.
Proof. by move=> pq hq; apply: contraTneq pq => ->; rewrite rdvd0p. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdpN0
| |
rdvdp1d : rdvdp d 1 = (size d == 1).
Proof.
rewrite /rdvdp; have [->|] := eqVneq d 0.
by rewrite rmodp0 size_poly0 (negPf (oner_neq0 _)).
rewrite -size_poly_leq0 -ltnS; case: ltngtP => // [|/eqP] hd _.
by rewrite rmodp_small ?size_poly1 // oner_eq0.
have [c cn0 ->] := size_poly1P _ hd.
rewrite /rmodp unlock -size_poly_eq0 size_poly1 /= size_poly1 size_polyC cn0 /=.
by rewrite polyC_eq0 (negPf cn0) !lead_coefC !scale1r subrr !size_poly0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp1
| |
rdvd1pm : rdvdp 1 m. Proof. by rewrite /rdvdp rmodp1. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvd1p
| |
Nrdvdp_small(n d : {poly R}) :
n != 0 -> size n < size d -> rdvdp d n = false.
Proof. by move=> nn0 hs; rewrite /rdvdp (rmodp_small hs); apply: negPf. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
Nrdvdp_small
| |
rmodp_eq0Pp q : reflect (rmodp p q = 0) (rdvdp q p).
Proof. exact: (iffP eqP). Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_eq0P
| |
rmodp_eq0p q : rdvdp q p -> rmodp p q = 0. Proof. exact: rmodp_eq0P. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_eq0
| |
rdvdp_leqp q : rdvdp p q -> q != 0 -> size p <= size q.
Proof. by move=> dvd_pq; rewrite leqNgt; apply: contra => /rmodp_small <-. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_leq
| |
rgcdpp q :=
let: (p1, q1) := if size p < size q then (q, p) else (p, q) in
if p1 == 0 then q1 else
let fix loop (n : nat) (pp qq : {poly R}) {struct n} :=
let rr := rmodp pp qq in
if rr == 0 then qq else
if n is n1.+1 then loop n1 qq rr else rr in
loop (size p1) p1 q1.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgcdp
| |
rgcd0p: left_id 0 rgcdp.
Proof.
move=> p; rewrite /rgcdp size_poly0 size_poly_gt0 if_neg.
case: ifP => /= [_ | nzp]; first by rewrite eqxx.
by rewrite polySpred !(rmodp0, nzp) //; case: _.-1 => [|m]; rewrite rmod0p eqxx.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgcd0p
| |
rgcdp0: right_id 0 rgcdp.
Proof.
move=> p; have:= rgcd0p p; rewrite /rgcdp size_poly0 size_poly_gt0.
by case: eqVneq => p0; rewrite ?(eqxx, p0) //= eqxx.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgcdp0
| |
rgcdpEp q :
rgcdp p q = if size p < size q
then rgcdp (rmodp q p) p else rgcdp (rmodp p q) q.
Proof.
pose rgcdp_rec := fix rgcdp_rec (n : nat) (pp qq : {poly R}) {struct n} :=
let rr := rmodp pp qq in
if rr == 0 then qq else
if n is n1.+1 then rgcdp_rec n1 qq rr else rr.
have Irec: forall m n p q, size q <= m -> size q <= n
-> size q < size p -> rgcdp_rec m p q = rgcdp_rec n p q.
+ elim=> [|m Hrec] [|n] //= p1 q1.
- move/size_poly_leq0P=> -> _; rewrite size_poly0 size_poly_gt0 rmodp0.
by move/negPf->; case: n => [|n] /=; rewrite rmod0p eqxx.
- move=> _ /size_poly_leq0P ->; rewrite size_poly0 size_poly_gt0 rmodp0.
by move/negPf->; case: m {Hrec} => [|m] /=; rewrite rmod0p eqxx.
case: eqVneq => Epq Sm Sn Sq //; have [->|nzq] := eqVneq q1 0.
by case: n m {Sm Sn Hrec} => [|m] [|n] //=; rewrite rmod0p eqxx.
apply: Hrec; last by rewrite ltn_rmodp.
by rewrite -ltnS (leq_trans _ Sm) // ltn_rmodp.
by rewrite -ltnS (leq_trans _ Sn) // ltn_rmodp.
have [->|nzp] := eqVneq p 0.
by rewrite rmod0p rmodp0 rgcd0p rgcdp0 if_same.
have [->|nzq] := eqVneq q 0.
by rewrite rmod0p rmodp0 rgcd0p rgcdp0 if_same.
rewrite /rgcdp -/rgcdp_rec !ltn_rmodp (negPf nzp) (negPf nzq) /=.
have [ltpq|leqp] := ltnP; rewrite !(negPf nzp, negPf nzq) //= polySpred //=.
have [->|nzqp] := eqVneq.
by case: (size p) => [|[|s]]; rewrite /= rmodp0 (negPf nzp) // rmod0p eqxx.
apply: Irec => //; last by rewrite ltn_rmodp.
by rewrite -ltnS -polySpred // (leq_tr
...
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgcdpE
| |
comm_redivp_specm d : nat * {poly R} * {poly R} -> Type :=
ComEdivnSpec k (q r : {poly R}) of
(GRing.comm d (lead_coef d)%:P -> m * (lead_coef d ^+ k)%:P = q * d + r) &
(d != 0 -> size r < size d) : comm_redivp_spec m d (k, q, r).
|
Variant
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
comm_redivp_spec
| |
comm_redivpPm d : comm_redivp_spec m d (redivp m d).
Proof.
rewrite unlock; have [->|Hd] := eqVneq d 0.
by constructor; rewrite !(simp, eqxx).
have: GRing.comm d (lead_coef d)%:P -> m * (lead_coef d ^+ 0)%:P = 0 * d + m.
by rewrite !simp.
elim: (size m) 0%N 0 {1 4 6}m (leqnn (size m)) => [|n IHn] k q r Hr /=.
move/size_poly_leq0P: Hr ->.
suff hsd: size (0: {poly R}) < size d by rewrite hsd => /= ?; constructor.
by rewrite size_poly0 size_poly_gt0.
case: ltnP => Hlt Heq; first by constructor.
apply/IHn=> [|Cda]; last first.
rewrite mulrDl addrAC -addrA subrK exprSr polyCM mulrA Heq //.
by rewrite mulrDl -mulrA Cda mulrA.
apply/leq_sizeP => j Hj; rewrite coefB coefMC -scalerAl coefZ coefXnM.
rewrite ltn_subRL ltnNge (leq_trans Hr) /=; last first.
by apply: leq_ltn_trans Hj _; rewrite -add1n leq_add2r size_poly_gt0.
move: Hj; rewrite leq_eqVlt; case/predU1P => [<-{j} | Hj]; last first.
rewrite !nth_default ?simp ?oppr0 ?(leq_trans Hr) //.
by rewrite -{1}(subKn Hlt) leq_sub2r // (leq_trans Hr).
move: Hr; rewrite leq_eqVlt ltnS; case/predU1P=> Hqq; last first.
by rewrite !nth_default ?simp ?oppr0 // -{1}(subKn Hlt) leq_sub2r.
rewrite /lead_coef Hqq polySpred // subSS subKn ?addrN //.
by rewrite -subn1 leq_subLR add1n -Hqq.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
comm_redivpP
| |
rmodppp : GRing.comm p (lead_coef p)%:P -> rmodp p p = 0.
Proof.
move=> hC; rewrite /rmodp unlock; have [-> //|] := eqVneq.
rewrite -size_poly_eq0 /redivp_rec; case sp: (size p)=> [|n] // _.
rewrite sp ltnn subnn expr0 hC alg_polyC !simp subrr.
by case: n sp => [|n] sp; rewrite size_polyC /= eqxx.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpp
| |
rcoprimep(p q : {poly R}) := size (rgcdp p q) == 1.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rcoprimep
| |
rgdcop_recq p n :=
if n is m.+1 then
if rcoprimep p q then p
else rgdcop_rec q (rdivp p (rgcdp p q)) m
else (q == 0)%:R.
|
Fixpoint
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgdcop_rec
| |
rgdcopq p := rgdcop_rec q p (size p).
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgdcop
| |
rgdcop0q : rgdcop q 0 = (q == 0)%:R.
Proof. by rewrite /rgdcop size_poly0. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rgdcop0
| |
redivp_eqq r :
size r < size d ->
let k := (redivp (q * d + r) d).1.1 in
let c := (lead_coef d ^+ k)%:P in
redivp (q * d + r) d = (k, q * c, r * c).
Proof.
move=> lt_rd; case: comm_redivpP=> k q1 r1 /(_ Cdl) Heq.
have dn0: d != 0 by case: (size d) lt_rd (size_poly_eq0 d) => // n _ <-.
move=> /(_ dn0) Hs.
have eC : q * d * (lead_coef d ^+ k)%:P = q * (lead_coef d ^+ k)%:P * d.
by rewrite -mulrA polyC_exp (commrX k Cdl) mulrA.
suff e1 : q1 = q * (lead_coef d ^+ k)%:P.
congr (_, _, _) => //=; move/eqP: Heq.
by rewrite [_ + r1]addrC -subr_eq e1 mulrDl addrAC eC subrr add0r; move/eqP.
have : (q1 - q * (lead_coef d ^+ k)%:P) * d = r * (lead_coef d ^+ k)%:P - r1.
apply: (@addIr _ r1); rewrite subrK.
apply: (@addrI _ ((q * (lead_coef d ^+ k)%:P) * d)).
by rewrite mulrDl mulNr !addrA [_ + (q1 * d)]addrC addrK -eC -mulrDl.
move/eqP; rewrite -[_ == _ - _]subr_eq0 rreg_div0 //.
by case/andP; rewrite subr_eq0; move/eqP.
rewrite size_polyN; apply: (leq_ltn_trans (size_polyD _ _)); rewrite size_polyN.
rewrite gtn_max Hs (leq_ltn_trans (size_polyMleq _ _)) //.
rewrite size_polyC; case: (_ == _); last by rewrite addnS addn0.
by rewrite addn0; apply: leq_ltn_trans lt_rd; case: size.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
redivp_eq
| |
rdivp_eqp :
p * (lead_coef d ^+ (rscalp p d))%:P = (rdivp p d) * d + (rmodp p d).
Proof.
by rewrite /rdivp /rmodp /rscalp; case: comm_redivpP=> k q1 r1 Hc _; apply: Hc.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_eq
| |
eq_rdvdpk q1 p:
p * ((lead_coef d)^+ k)%:P = q1 * d -> rdvdp d p.
Proof.
move=> he.
have Hnq0 := rreg_lead0 Rreg; set lq := lead_coef d.
pose v := rscalp p d; pose m := maxn v k.
rewrite /rdvdp -(rreg_polyMC_eq0 _ (@rregX _ _ (m - v) Rreg)).
suff:
((rdivp p d) * (lq ^+ (m - v))%:P - q1 * (lq ^+ (m - k))%:P) * d +
(rmodp p d) * (lq ^+ (m - v))%:P == 0.
rewrite rreg_div0 //; first by case/andP.
by rewrite rreg_size ?ltn_rmodp //; exact: rregX.
rewrite mulrDl addrAC mulNr -!mulrA polyC_exp -(commrX (m-v) Cdl).
rewrite -polyC_exp mulrA -mulrDl -rdivp_eq // [(_ ^+ (m - k))%:P]polyC_exp.
rewrite -(commrX (m-k) Cdl) -polyC_exp mulrA -he -!mulrA -!polyCM -/v.
by rewrite -!exprD addnC subnK ?leq_maxl // addnC subnK ?subrr ?leq_maxr.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
eq_rdvdp
| |
rdvdp_specp q : {poly R} -> bool -> Type :=
| Rdvdp k q1 & p * ((lead_coef q)^+ k)%:P = q1 * q : rdvdp_spec p q 0 true
| RdvdpN & rmodp p q != 0 : rdvdp_spec p q (rmodp p q) false.
|
Variant
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_spec
| |
rdvdp_eqPp : rdvdp_spec p d (rmodp p d) (rdvdp d p).
Proof.
case hdvd: (rdvdp d p); last by apply: RdvdpN; move/rmodp_eq0P/eqP: hdvd.
move/rmodp_eq0P: (hdvd)->; apply: (@Rdvdp _ _ (rscalp p d) (rdivp p d)).
by rewrite rdivp_eq //; move/rmodp_eq0P: (hdvd)->; rewrite addr0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_eqP
| |
rdvdp_mullp : rdvdp d (p * d).
Proof. by apply: (@eq_rdvdp 0 p); rewrite expr0 mulr1. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_mull
| |
rmodp_mullp : rmodp (p * d) d = 0. Proof. exact/eqP/rdvdp_mull. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_mull
| |
rmodpp: rmodp d d = 0.
Proof. by rewrite -[d in rmodp d _]mul1r rmodp_mull. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpp
| |
rdivpp: rdivp d d = (lead_coef d ^+ rscalp d d)%:P.
Proof.
have dn0 : d != 0 by rewrite -lead_coef_eq0 rreg_neq0.
move: (rdivp_eq d); rewrite rmodpp addr0.
suff ->: GRing.comm d (lead_coef d ^+ rscalp d d)%:P by move/(rreg_lead Rreg)->.
by rewrite polyC_exp; apply: commrX.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpp
| |
rdvdpp: rdvdp d d. Proof. exact/eqP/rmodpp. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdpp
| |
rdivpKp : rdvdp d p ->
rdivp p d * d = p * (lead_coef d ^+ rscalp p d)%:P.
Proof. by rewrite rdivp_eq /rdvdp; move/eqP->; rewrite addr0. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpK
| |
redivp_eqq r : size r < size d ->
let k := (redivp (q * d + r) d).1.1 in
redivp (q * d + r) d = (k, q, r).
Proof.
case: (monic_comreg mond)=> Hc Hr /(redivp_eq Hc Hr q).
by rewrite (eqP mond) => -> /=; rewrite expr1n !mulr1.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
redivp_eq
| |
rdivp_eqp : p = rdivp p d * d + rmodp p d.
Proof.
rewrite -rdivp_eq (eqP mond); last exact: commr1.
by rewrite expr1n mulr1.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_eq
| |
rdivpp: rdivp d d = 1.
Proof.
by case: (monic_comreg mond) => hc hr; rewrite rdivpp // (eqP mond) expr1n.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpp
| |
rdivp_addl_mul_smallq r : size r < size d -> rdivp (q * d + r) d = q.
Proof.
by move=> Hd; case: (monic_comreg mond)=> Hc Hr; rewrite /rdivp redivp_eq.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_addl_mul_small
| |
rdivp_addl_mulq r : rdivp (q * d + r) d = q + rdivp r d.
Proof.
case: (monic_comreg mond)=> Hc Hr; rewrite [r in _ * _ + r]rdivp_eq addrA.
by rewrite -mulrDl rdivp_addl_mul_small // ltn_rmodp monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_addl_mul
| |
rdivpDlq r : rdvdp d q -> rdivp (q + r) d = rdivp q d + rdivp r d.
Proof.
case: (monic_comreg mond)=> Hc Hr; rewrite [r in q + r]rdivp_eq addrA.
rewrite [q in q + _ + _]rdivp_eq; move/rmodp_eq0P->.
by rewrite addr0 -mulrDl rdivp_addl_mul_small // ltn_rmodp monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpDl
| |
rdivpDrq r : rdvdp d r -> rdivp (q + r) d = rdivp q d + rdivp r d.
Proof. by rewrite addrC; move/rdivpDl->; rewrite addrC. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpDr
| |
rdivp_mullp : rdivp (p * d) d = p.
Proof. by rewrite -[p * d]addr0 rdivp_addl_mul rdiv0p addr0. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_mull
| |
rmodp_mullp : rmodp (p * d) d = 0.
Proof.
by apply: rmodp_mull; rewrite (eqP mond); [apply: commr1 | apply: rreg1].
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_mull
| |
rmodpp: rmodp d d = 0.
Proof.
by apply: rmodpp; rewrite (eqP mond); [apply: commr1 | apply: rreg1].
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpp
| |
rmodp_addl_mul_smallq r : size r < size d -> rmodp (q * d + r) d = r.
Proof.
by move=> Hd; case: (monic_comreg mond)=> Hc Hr; rewrite /rmodp redivp_eq.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_addl_mul_small
| |
rmodp_id(p : {poly R}) : rmodp (rmodp p d) d = rmodp p d.
Proof.
by rewrite rmodp_small // ltn_rmodpN0 // monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_id
| |
rmodpDp q : rmodp (p + q) d = rmodp p d + rmodp q d.
Proof.
rewrite [p in LHS]rdivp_eq [q in LHS]rdivp_eq addrACA -mulrDl.
rewrite rmodp_addl_mul_small //; apply: (leq_ltn_trans (size_polyD _ _)).
by rewrite gtn_max !ltn_rmodp // monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpD
| |
rmodpNp : rmodp (- p) d = - (rmodp p d).
Proof.
rewrite {1}(rdivp_eq p) opprD // -mulNr rmodp_addl_mul_small //.
by rewrite size_polyN ltn_rmodp // monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpN
| |
rmodpBp q : rmodp (p - q) d = rmodp p d - rmodp q d.
Proof. by rewrite rmodpD rmodpN. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpB
| |
rmodpZa p : rmodp (a *: p) d = a *: (rmodp p d).
Proof.
case: (altP (a =P 0%R)) => [-> | cn0]; first by rewrite !scale0r rmod0p.
have -> : ((a *: p) = (a *: (rdivp p d)) * d + a *: (rmodp p d))%R.
by rewrite -scalerAl -scalerDr -rdivp_eq.
rewrite rmodp_addl_mul_small //.
rewrite -mul_polyC; apply: leq_ltn_trans (size_polyMleq _ _) _.
rewrite size_polyC cn0 addSn add0n /= ltn_rmodp.
exact: monic_neq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpZ
| |
rmodp_sum(I : Type) (r : seq I) (P : pred I) (F : I -> {poly R}) :
rmodp (\sum_(i <- r | P i) F i) d = (\sum_(i <- r | P i) (rmodp (F i) d)).
Proof.
by elim/big_rec2: _ => [|i p q _ <-]; rewrite ?(rmod0p, rmodpD).
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_sum
| |
rmodp_mulmrp q : rmodp (p * (rmodp q d)) d = rmodp (p * q) d.
Proof.
by rewrite [q in RHS]rdivp_eq mulrDr rmodpD mulrA rmodp_mull add0r.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_mulmr
| |
rdvdpp: rdvdp d d.
Proof.
by apply: rdvdpp; rewrite (eqP mond); [apply: commr1 | apply: rreg1].
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdpp
| |
eq_rdvdpq1 p : p = q1 * d -> rdvdp d p.
Proof.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
eq_rdvdp
| |
rdvdp_mullp : rdvdp d (p * d).
Proof.
by apply: rdvdp_mull; rewrite (eqP mond) //; [apply: commr1 | apply: rreg1].
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_mull
| |
rdvdpPp : reflect (exists qq, p = qq * d) (rdvdp d p).
Proof.
case: (monic_comreg mond)=> Hc Hr; apply: (iffP idP) => [|[qq] /eq_rdvdp //].
by case: rdvdp_eqP=> // k qq; rewrite (eqP mond) expr1n mulr1 => ->; exists qq.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdpP
| |
rdivpKp : rdvdp d p -> (rdivp p d) * d = p.
Proof. by move=> dvddp; rewrite [RHS]rdivp_eq rmodp_eq0 ?addr0. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivpK
| |
drop_poly_rdivpn p : drop_poly n p = rdivp p 'X^n.
Proof.
rewrite -[p in RHS](poly_take_drop n) addrC rdivp_addl_mul ?monicXn//.
by rewrite rdivp_small ?addr0// size_polyXn ltnS size_take_poly.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
drop_poly_rdivp
| |
take_poly_rmodpn p : take_poly n p = rmodp p 'X^n.
Proof.
have mX := monicXn R n; rewrite -[p in RHS](poly_take_drop n) rmodpD//.
by rewrite rmodp_small ?rmodp_mull ?addr0// size_polyXn ltnS size_take_poly.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
take_poly_rmodp
| |
rmodp_mulmlp q : rmodp (rmodp p d * q) d = rmodp (p * q) d.
Proof. by rewrite [in LHS]mulrC [in RHS]mulrC rmodp_mulmr. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_mulml
| |
rmodpXp n : rmodp ((rmodp p d) ^+ n) d = rmodp (p ^+ n) d.
Proof.
elim: n => [|n IH]; first by rewrite !expr0.
rewrite !exprS -rmodp_mulmr // IH rmodp_mulmr //.
by rewrite mulrC rmodp_mulmr // mulrC.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodpX
| |
rmodp_comprp q : rmodp (p \Po (rmodp q d)) d = (rmodp (p \Po q) d).
Proof.
elim/poly_ind: p => [|p c IH]; first by rewrite !comp_polyC !rmod0p.
rewrite !comp_polyD !comp_polyM addrC rmodpD //.
rewrite mulrC -rmodp_mulmr // IH rmodp_mulmr //.
rewrite !comp_polyX !comp_polyC.
by rewrite mulrC rmodp_mulmr // -rmodpD // addrC.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rmodp_compr
| |
rdivp1p : rdivp p 1 = p.
Proof. by rewrite -[p in LHS]mulr1 rdivp_mull // monic1. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp1
| |
rdvdp_XsubClp x : rdvdp ('X - x%:P) p = root p x.
Proof.
have [HcX Hr] := monic_comreg (monicXsubC x).
apply/rmodp_eq0P/factor_theorem => [|[p1 ->]]; last exact/rmodp_mull/monicXsubC.
move=> e0; exists (rdivp p ('X - x%:P)).
by rewrite [LHS](rdivp_eq (monicXsubC x)) e0 addr0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_XsubCl
| |
polyXsubCPp x : reflect (p.[x] = 0) (rdvdp ('X - x%:P) p).
Proof. by apply: (iffP idP); rewrite rdvdp_XsubCl; move/rootP. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
polyXsubCP
| |
root_factor_theoremp x : root p x = (rdvdp ('X - x%:P) p).
Proof. by rewrite rdvdp_XsubCl. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
root_factor_theorem
| |
redivp_spec(m d : {poly R}) : nat * {poly R} * {poly R} -> Type :=
EdivnSpec k (q r: {poly R}) of
(lead_coef d ^+ k) *: m = q * d + r &
(d != 0 -> size r < size d) : redivp_spec m d (k, q, r).
|
Variant
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
redivp_spec
| |
redivpPm d : redivp_spec m d (redivp m d).
Proof.
rewrite redivp_def; constructor; last by move=> dn0; rewrite ltn_rmodp.
by rewrite -mul_polyC mulrC rdivp_eq //= /GRing.comm mulrC.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
redivpP
| |
rdivp_eqd p :
(lead_coef d ^+ rscalp p d) *: p = rdivp p d * d + rmodp p d.
Proof.
by rewrite /rdivp /rmodp /rscalp; case: redivpP=> k q1 r1 Hc _; apply: Hc.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdivp_eq
| |
rdvdp_eqPd p : rdvdp_spec p d (rmodp p d) (rdvdp d p).
Proof.
case hdvd: (rdvdp d p); last by move/rmodp_eq0P/eqP/RdvdpN: hdvd.
move/rmodp_eq0P: (hdvd)->; apply: (@Rdvdp _ _ _ (rscalp p d) (rdivp p d)).
by rewrite mulrC mul_polyC rdivp_eq; move/rmodp_eq0P: (hdvd)->; rewrite addr0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_eqP
| |
rdvdp_eqq p :
rdvdp q p = (lead_coef q ^+ rscalp p q *: p == rdivp p q * q).
Proof.
rewrite rdivp_eq; apply/rmodp_eq0P/eqP => [->|/eqP]; first by rewrite addr0.
by rewrite eq_sym addrC -subr_eq subrr; move/eqP<-.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
rdvdp_eq
| |
uniq_roots_rdvdpp rs :
all (root p) rs -> uniq_roots rs -> rdvdp (\prod_(z <- rs) ('X - z%:P)) p.
Proof.
move=> rrs /(uniq_roots_prod_XsubC rrs) [q ->].
exact/RingMonic.rdvdp_mull/monic_prod_XsubC.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
uniq_roots_rdvdp
| |
edivp_expanded_defp q :=
let: (k, d, r) as edvpq := redivp p q in
if lead_coef q \in GRing.unit then
(0, (lead_coef q)^-k *: d, (lead_coef q)^-k *: r)
else edvpq.
Fact edivp_key : unit. Proof. by []. Qed.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_expanded_def
| |
edivp:= locked_with edivp_key edivp_expanded_def.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp
| |
edivp_unlockable:= [unlockable fun edivp].
|
Canonical
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_unlockable
| |
divpp q := ((edivp p q).1).2.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
divp
| |
modpp q := (edivp p q).2.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
modp
| |
scalpp q := ((edivp p q).1).1.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
scalp
| |
dvdpp q := modp q p == 0.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
dvdp
| |
eqpp q := (dvdp p q) && (dvdp q p).
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
eqp
| |
edivp_defp q : edivp p q = (scalp p q, divp p q, modp p q).
Proof. by rewrite /scalp /divp /modp; case: (edivp p q) => [[]] /=. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_def
| |
edivp_redivpp q : lead_coef q \in GRing.unit = false ->
edivp p q = redivp p q.
Proof. by move=> hu; rewrite unlock hu; case: (redivp p q) => [[? ?] ?]. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_redivp
| |
divpEp q :
p %/ q = if lead_coef q \in GRing.unit
then lead_coef q ^- rscalp p q *: rdivp p q
else rdivp p q.
Proof. by case: ifP; rewrite /divp unlock redivp_def => ->. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
divpE
| |
modpEp q :
p %% q = if lead_coef q \in GRing.unit
then lead_coef q ^- rscalp p q *: (rmodp p q)
else rmodp p q.
Proof. by case: ifP; rewrite /modp unlock redivp_def => ->. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
modpE
| |
scalpEp q :
scalp p q = if lead_coef q \in GRing.unit then 0 else rscalp p q.
Proof. by case: ifP; rewrite /scalp unlock redivp_def => ->. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
scalpE
| |
dvdpEp q : p %| q = rdvdp p q.
Proof.
rewrite /dvdp modpE /rdvdp; case ulcq: (lead_coef p \in GRing.unit)=> //.
rewrite -[in LHS]size_poly_eq0 size_scale ?size_poly_eq0 //.
by rewrite invr_eq0 expf_neq0 //; apply: contraTneq ulcq => ->; rewrite unitr0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
dvdpE
| |
lc_expn_scalp_neq0p q : lead_coef q ^+ scalp p q != 0.
Proof.
have [->|nzq] := eqVneq q 0; last by rewrite expf_neq0 ?lead_coef_eq0.
by rewrite /scalp 2!unlock /= eqxx lead_coef0 unitr0 /= oner_neq0.
Qed.
Hint Resolve lc_expn_scalp_neq0 : core.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
lc_expn_scalp_neq0
| |
edivp_spec(m d : {poly R}) :
nat * {poly R} * {poly R} -> bool -> Type :=
|Redivp_spec k (q r: {poly R}) of
(lead_coef d ^+ k) *: m = q * d + r & lead_coef d \notin GRing.unit &
(d != 0 -> size r < size d) : edivp_spec m d (k, q, r) false
|Fedivp_spec (q r: {poly R}) of m = q * d + r & (lead_coef d \in GRing.unit) &
(d != 0 -> size r < size d) : edivp_spec m d (0, q, r) true.
|
Variant
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_spec
| |
edivpPm d : edivp_spec m d (edivp m d) (lead_coef d \in GRing.unit).
Proof.
have hC : GRing.comm d (lead_coef d)%:P by rewrite /GRing.comm mulrC.
case ud: (lead_coef d \in GRing.unit); last first.
rewrite edivp_redivp // redivp_def; constructor; rewrite ?ltn_rmodp // ?ud //.
by rewrite rdivp_eq.
have cdn0: lead_coef d != 0 by apply: contraTneq ud => ->; rewrite unitr0.
rewrite unlock ud redivp_def; constructor => //.
rewrite -scalerAl -scalerDr -mul_polyC.
have hn0 : (lead_coef d ^+ rscalp m d)%:P != 0.
by rewrite polyC_eq0; apply: expf_neq0.
apply: (mulfI hn0); rewrite !mulrA -exprVn !polyC_exp -exprMn -polyCM.
by rewrite divrr // expr1n mul1r -polyC_exp mul_polyC rdivp_eq.
move=> dn0; rewrite size_scale ?ltn_rmodp // -exprVn expf_eq0 negb_and.
by rewrite invr_eq0 cdn0 orbT.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivpP
| |
edivp_eqd q r : size r < size d -> lead_coef d \in GRing.unit ->
edivp (q * d + r) d = (0, q, r).
Proof.
have hC : GRing.comm d (lead_coef d)%:P by apply: mulrC.
move=> hsrd hu; rewrite unlock hu; case et: (redivp _ _) => [[s qq] rr].
have cdn0 : lead_coef d != 0 by case: eqP hu => //= ->; rewrite unitr0.
move: (et); rewrite RingComRreg.redivp_eq //; last exact/rregP.
rewrite et /= mulrC (mulrC r) !mul_polyC; case=> <- <-.
by rewrite !scalerA mulVr ?scale1r // unitrX.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
edivp_eq
| |
divp_eqp q : (lead_coef q ^+ scalp p q) *: p = (p %/ q) * q + (p %% q).
Proof.
rewrite divpE modpE scalpE.
case uq: (lead_coef q \in GRing.unit); last by rewrite rdivp_eq.
rewrite expr0 scale1r; have [->|qn0] := eqVneq q 0.
by rewrite lead_coef0 expr0n /rscalp unlock eqxx invr1 !scale1r rmodp0 !simp.
by rewrite -scalerAl -scalerDr -rdivp_eq scalerA mulVr (scale1r, unitrX).
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
divp_eq
| |
dvdp_eqq p : (q %| p) = (lead_coef q ^+ scalp p q *: p == (p %/ q) * q).
Proof.
rewrite dvdpE rdvdp_eq scalpE divpE; case: ifP => ulcq //.
rewrite expr0 scale1r -scalerAl; apply/eqP/eqP => [<- | {2}->].
by rewrite scalerA mulVr ?scale1r // unitrX.
by rewrite scalerA mulrV ?scale1r // unitrX.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
dvdp_eq
| |
divpKd p : d %| p -> p %/ d * d = (lead_coef d ^+ scalp p d) *: p.
Proof. by rewrite dvdp_eq; move/eqP->. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
divpK
| |
divpKCd p : d %| p -> d * (p %/ d) = (lead_coef d ^+ scalp p d) *: p.
Proof. by move=> ?; rewrite mulrC divpK. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
divpKC
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.