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 |
|---|---|---|---|---|---|---|
divpKd p : d %| p -> p %/ d * d = p.
Proof.
case: (eqVneq d 0) => [-> /dvd0pP -> | dn0]; first by rewrite mulr0.
by apply: IdomainUnit.divpK; rewrite unitfE lead_coef_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
|
divpK
| |
divpKCd p : d %| p -> d * (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
| |
dvdp_eq_divd p q : d != 0 -> d %| p -> (q == p %/ d) = (q * d == p).
Proof.
by move=> dn0; apply: IdomainUnit.dvdp_eq_div; rewrite unitfE lead_coef_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
|
dvdp_eq_div
| |
dvdp_eq_muld p q : d != 0 -> d %| p -> (p == q * d) = (p %/ d == q).
Proof. by move=> dn0 dv_d_p; rewrite eq_sym -dvdp_eq_div // eq_sym. 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_mul
| |
divp_mulAd p q : d %| q -> p * (q %/ d) = p * q %/ d.
Proof.
case: (eqVneq d 0) => [-> /dvd0pP -> | dn0]; first by rewrite !divp0 mulr0.
by apply: IdomainUnit.divp_mulA; rewrite unitfE lead_coef_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
|
divp_mulA
| |
divp_mulACd m n : d %| m -> m %/ d * n = m * n %/ d.
Proof. by move=> hdm; rewrite mulrC (mulrC m); apply: divp_mulA. 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_mulAC
| |
divp_mulCAd p q : d %| p -> d %| q -> p * (q %/ d) = q * (p %/ d).
Proof. by move=> hdp hdq; rewrite mulrC divp_mulAC // divp_mulA. 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_mulCA
| |
expp_subd m n : d != 0 -> m >= n -> (d ^+ (m - n))%N = d ^+ m %/ d ^+ n.
Proof. by move=> dn0 /subnK=> {2}<-; rewrite exprD mulpK // expf_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
|
expp_sub
| |
divp_pmul2ld q p : d != 0 -> q != 0 -> d * p %/ (d * q) = p %/ q.
Proof.
by move=> dn0 qn0; apply: IdomainUnit.divp_pmul2l; rewrite unitfE lead_coef_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
|
divp_pmul2l
| |
divp_pmul2rd p q : d != 0 -> p != 0 -> q * d %/ (p * d) = q %/ p.
Proof. by move=> dn0 qn0; rewrite -!(mulrC d) divp_pmul2l. 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_pmul2r
| |
divp_divlr p q : q %/ p %/ r = q %/ (p * r).
Proof.
have [-> | rn0] := eqVneq r 0; first by rewrite mulr0 !divp0.
have [-> | pn0] := eqVneq p 0; first by rewrite mul0r !divp0 div0p.
by apply: IdomainUnit.divp_divl; rewrite unitfE lead_coef_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
|
divp_divl
| |
divpACd p q : q %/ d %/ p = q %/ p %/ d.
Proof. by rewrite !divp_divl // 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
|
divpAC
| |
edivp_defp q : edivp p q = (0, p %/ q, p %% q).
Proof.
rewrite Idomain.edivp_def; congr (_, _, _); rewrite /scalp 2!unlock /=.
have [-> | qn0] := eqVneq; first by rewrite lead_coef0 unitr0.
by rewrite unitfE lead_coef_eq0 qn0 /=; case: (redivp_rec _ _ _ _) => [[]].
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
| |
divpEp q : p %/ q = (lead_coef q)^-(rscalp p q) *: (rdivp p q).
Proof.
have [-> | qn0] := eqVneq q 0; first by rewrite rdivp0 divp0 scaler0.
by rewrite Idomain.divpE unitfE lead_coef_eq0 qn0.
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 = (lead_coef q)^-(rscalp p q) *: (rmodp p q).
Proof.
have [-> | qn0] := eqVneq q 0.
by rewrite rmodp0 modp0 /rscalp unlock eqxx lead_coef0 expr0 invr1 scale1r.
by rewrite Idomain.modpE unitfE lead_coef_eq0 qn0.
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 = 0.
Proof.
have [-> | qn0] := eqVneq q 0; first by rewrite scalp0.
by rewrite Idomain.scalpE unitfE lead_coef_eq0 qn0.
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. exact: Idomain.dvdpE. 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
| |
edivp_specm d : nat * {poly F} * {poly F} -> Type :=
EdivpSpec n q r of
m = q * d + r & (d != 0) ==> (size r < size d) : edivp_spec m d (n, 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
|
edivp_spec
| |
edivpPm d : edivp_spec m d (edivp m d).
Proof.
rewrite edivp_def; constructor; first exact: divp_eq.
by apply/implyP=> dn0; rewrite ltn_modp.
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 -> edivp (q * d + r) d = (0, q, r).
Proof.
move=> srd; apply: Idomain.edivp_eq; rewrite // unitfE lead_coef_eq0.
by rewrite -size_poly_gt0; apply: leq_trans srd.
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
| |
modp_mulp q m : (p * (q %% m)) %% m = (p * q) %% m.
Proof. by rewrite [in RHS](divp_eq q m) mulrDr modpD mulrA modp_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
|
modp_mul
| |
horner_modp q x : root q x -> (p %% q).[x] = p.[x].
Proof.
by rewrite [in RHS](divp_eq p q) !hornerE => /eqP->; rewrite mulr0 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
|
horner_mod
| |
dvdpPp q : reflect (exists qq, p = qq * q) (q %| p).
Proof.
have [-> | qn0] := eqVneq q 0; last first.
by apply: IdomainUnit.dvdpP; rewrite unitfE lead_coef_eq0.
by rewrite dvd0p; apply: (iffP eqP) => [->| [? ->]]; [exists 1|]; rewrite mulr0.
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
|
dvdpP
| |
Bezout_eq1_coprimepPp q :
reflect (exists u, u.1 * p + u.2 * q = 1) (coprimep p q).
Proof.
apply: (iffP idP)=> [hpq|]; last first.
by case=> -[u v] /= e; apply/Bezout_coprimepP; exists (u, v); rewrite e eqpxx.
case/Bezout_coprimepP: hpq => [[u v]] /=.
case/eqpP=> [[c1 c2]] /andP /= [c1n0 c2n0] e.
exists (c2^-1 *: (c1 *: u), c2^-1 *: (c1 *: v)); rewrite /= -!scalerAl.
by rewrite -!scalerDr e scalerA mulVf // scale1r.
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
|
Bezout_eq1_coprimepP
| |
dvdp_gdcorp q : q != 0 -> p %| (gdcop q p) * (q ^+ size p).
Proof.
rewrite /gdcop => nz_q; have [n hsp] := ubnPleq (size p).
elim: n => [|n IHn] /= in p hsp *; first by rewrite (negPf nz_q) mul0r dvdp0.
have [_ | ncop_pq] := ifPn; first by rewrite dvdp_mulr.
have g_gt1: 1 < size (gcdp p q).
rewrite ltn_neqAle eq_sym ncop_pq size_poly_gt0 gcdp_eq0.
by rewrite negb_and nz_q orbT.
have [-> | nz_p] := eqVneq p 0.
by rewrite div0p exprSr mulrA dvdp_mulr // IHn // size_poly0.
have le_d_p: size (p %/ gcdp p q) < size p.
rewrite size_divp -?size_poly_eq0 -(subnKC g_gt1) // add2n /=.
by rewrite polySpred // ltnS subSS leq_subr.
rewrite -[p in p %| _](divpK (dvdp_gcdl p q)) exprSr mulrA.
by rewrite dvdp_mul ?IHn ?dvdp_gcdr // -ltnS (leq_trans le_d_p).
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_gdcor
| |
reducible_cubic_rootp q :
size p <= 4 -> 1 < size q < size p -> q %| p -> {r | root p r}.
Proof.
move=> p_le4 /andP[]; rewrite leq_eqVlt eq_sym.
have [/poly2_root[x qx0] _ _ | _ /= q_gt2 p_gt_q] := size q =P 2.
by exists x; rewrite -!dvdp_XsubCl in qx0 *; apply: (dvdp_trans qx0).
case/dvdpP/sig_eqW=> r def_p; rewrite def_p.
suffices /poly2_root[x rx0]: size r = 2 by exists x; rewrite rootM rx0.
have /norP[nz_r nz_q]: ~~ [|| r == 0 | q == 0].
by rewrite -mulf_eq0 -def_p -size_poly_gt0 (leq_ltn_trans _ p_gt_q).
rewrite def_p size_mul // -subn1 leq_subLR ltn_subRL in p_gt_q p_le4.
by apply/eqP; rewrite -(eqn_add2r (size q)) eqn_leq (leq_trans p_le4).
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
|
reducible_cubic_root
| |
cubic_irreduciblep :
1 < size p <= 4 -> (forall x, ~~ root p x) -> irreducible_poly p.
Proof.
move=> /andP[p_gt1 p_le4] root'p; split=> // q sz_q_neq1 q_dv_p.
have nz_p: p != 0 by rewrite -size_poly_gt0 ltnW.
have nz_q: q != 0 by apply: contraTneq q_dv_p => ->; rewrite dvd0p.
have q_gt1: size q > 1 by rewrite ltn_neqAle eq_sym sz_q_neq1 size_poly_gt0.
rewrite -dvdp_size_eqp // eqn_leq dvdp_leq //= leqNgt; apply/negP=> p_gt_q.
by have [|x /idPn//] := reducible_cubic_root p_le4 _ q_dv_p; rewrite q_gt1.
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
|
cubic_irreducible
| |
mupx q :=
[arg max_(n > (ord0 : 'I_(size q).+1) | ('X - x%:P) ^+ n %| q) n] : nat.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
mup
| |
mup_geqx q n : q != 0 -> (n <= mup x q)%N = (('X - x%:P) ^+ n %| q).
Proof.
move=> q_neq0; rewrite /mup; symmetry.
case: arg_maxnP; rewrite ?expr0 ?dvd1p//= => i i_dvd gti.
case: ltnP => [|/dvdp_exp2l/dvdp_trans]; last exact.
apply: contraTF => dvdq; rewrite -leqNgt.
suff n_small : (n < (size q).+1)%N by exact: (gti (Ordinal n_small)).
by rewrite ltnS ltnW// -(size_exp_XsubC _ x) dvdp_leq.
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
|
mup_geq
| |
mup_leqx q n : q != 0 ->
(mup x q <= n)%N = ~~ (('X - x%:P) ^+ n.+1 %| q).
Proof. by move=> qN0; rewrite leqNgt mup_geq. 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
|
mup_leq
| |
mup_ltnx q n : q != 0 -> (mup x q < n)%N = ~~ (('X - x%:P) ^+ n %| q).
Proof. by move=> qN0; rewrite ltnNge mup_geq. 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
|
mup_ltn
| |
XsubC_dvdx q : q != 0 -> ('X - x%:P %| q) = (0 < mup x q)%N.
Proof. by move=> /mup_geq-/(_ _ 1%N)/esym; apply. 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
|
XsubC_dvd
| |
mup_XsubCXn x y :
mup x (('X - y%:P) ^+ n) = (if (y == x) then n else 0)%N.
Proof.
have Xxn0 : ('X - y%:P) ^+ n != 0 by rewrite ?expf_neq0 ?polyXsubC_eq0.
apply/eqP; rewrite eqn_leq mup_leq ?mup_geq//.
have [->|Nxy] := eqVneq x y.
by rewrite /= dvdpp ?dvdp_Pexp2l ?size_XsubC ?ltnn.
by rewrite dvd1p dvdp_XsubCl /root horner_exp !hornerE expf_neq0// subr_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
|
mup_XsubCX
| |
mupNrootx q : ~~ root q x -> mup x q = 0%N.
Proof.
move=> qNx; have qN0 : q != 0 by apply: contraNneq qNx => ->; rewrite root0.
by move: qNx; rewrite -dvdp_XsubCl XsubC_dvd// lt0n negbK => /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
|
mupNroot
| |
mupMrx q1 q2 : ~~ root q1 x -> mup x (q1 * q2) = mup x q2.
Proof.
move=> q1Nx; have q1N0 : q1 != 0 by apply: contraNneq q1Nx => ->; rewrite root0.
have [->|q2N0] := eqVneq q2 0; first by rewrite mulr0.
apply/esym/eqP; rewrite eqn_leq mup_geq ?mulf_neq0// dvdp_mull -?mup_geq//=.
rewrite mup_leq ?mulf_neq0// Gauss_dvdpr -?mup_ltn//.
by rewrite coprimep_expl// coprimep_sym coprimep_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
|
mupMr
| |
mupMlx q1 q2 : ~~ root q2 x -> mup x (q1 * q2) = mup x q1.
Proof. by rewrite mulrC; apply/mupMr. 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
|
mupMl
| |
mupMx q1 q2 : q1 != 0 -> q2 != 0 ->
mup x (q1 * q2) = (mup x q1 + mup x q2)%N.
Proof.
move=> q1N0 q2N0; apply/eqP; rewrite eqn_leq mup_leq ?mulf_neq0//.
rewrite mup_geq ?mulf_neq0// exprD ?dvdp_mul; do ?by rewrite -mup_geq.
have [m1 [r1]] := multiplicity_XsubC q1 x; rewrite q1N0 /= => r1Nx ->.
have [m2 [r2]] := multiplicity_XsubC q2 x; rewrite q2N0 /= => r2Nx ->.
rewrite !mupMr// ?mup_XsubCX eqxx/= mulrACA exprS exprD.
rewrite dvdp_mul2r ?mulf_neq0 ?expf_neq0 ?polyXsubC_eq0//.
by rewrite dvdp_XsubCl rootM negb_or r1Nx r2Nx.
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
|
mupM
| |
mu_prod_XsubCx (s : seq F) :
mup x (\prod_(y <- s) ('X - y%:P)) = count_mem x s.
Proof.
elim: s => [|y s IHs]; rewrite (big_cons, big_nil)/=.
by rewrite mupNroot// root1.
rewrite mupM ?polyXsubC_eq0// ?monic_neq0 ?monic_prod_XsubC//.
by rewrite IHs (@mup_XsubCX 1).
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
|
mu_prod_XsubC
| |
prod_XsubC_eq(s t : seq F) :
\prod_(x <- s) ('X - x%:P) = \prod_(x <- t) ('X - x%:P) -> perm_eq s t.
Proof.
move=> eq_prod; apply/allP => x _ /=; apply/eqP.
by have /(congr1 (mup x)) := eq_prod; rewrite !mu_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
|
prod_XsubC_eq
| |
redivp_mapa b :
redivp a^f b^f = (rscalp a b, (rdivp a b)^f, (rmodp a b)^f).
Proof.
rewrite /rdivp /rscalp /rmodp !unlock map_poly_eq0 size_map_poly.
have [// | q_nz] := ifPn; rewrite -(rmorph0 (map_poly f)) //.
have [m _] := ubnPeq (size a); elim: m 0%N 0 a => [|m IHm] qq r a /=.
rewrite -!mul_polyC !size_map_poly !lead_coef_map // -(map_polyXn f).
by rewrite -!(map_polyC f) -!rmorphM -rmorphB -rmorphD; case: (_ < _).
rewrite -!mul_polyC !size_map_poly !lead_coef_map // -(map_polyXn f).
by rewrite -!(map_polyC f) -!rmorphM -rmorphB -rmorphD /= IHm; case: (_ < _).
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_map
| |
edivp_mapa b :
edivp a^f b^f = (0, (a %/ b)^f, (a %% b)^f).
Proof.
have [-> | bn0] := eqVneq b 0.
rewrite (rmorph0 (map_poly f)) WeakIdomain.edivp_def !modp0 !divp0.
by rewrite (rmorph0 (map_poly f)) scalp0.
rewrite unlock redivp_map lead_coef_map rmorph_unit; last first.
by rewrite unitfE lead_coef_eq0.
rewrite modpE divpE !map_polyZ [in RHS]rmorphV ?rmorphXn // unitfE.
by rewrite expf_neq0 // lead_coef_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
|
edivp_map
| |
scalp_mapp q : scalp p^f q^f = scalp p q.
Proof. by rewrite /scalp edivp_map edivp_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
|
scalp_map
| |
map_divpp q : (p %/ q)^f = p^f %/ q^f.
Proof. by rewrite /divp edivp_map edivp_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
|
map_divp
| |
map_modpp q : (p %% q)^f = p^f %% q^f.
Proof. by rewrite /modp edivp_map edivp_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
|
map_modp
| |
egcdp_mapp q :
egcdp (map_poly f p) (map_poly f q)
= (map_poly f (egcdp p q).1, map_poly f (egcdp p q).2).
Proof.
wlog le_qp: p q / size q <= size p.
move=> IH; have [/IH// | lt_qp] := leqP (size q) (size p).
have /IH := ltnW lt_qp; rewrite /egcdp !size_map_poly ltnW // leqNgt lt_qp /=.
by case: (egcdp_rec _ _ _) => u v [-> ->].
rewrite /egcdp !size_map_poly {}le_qp; move: (size q) => n.
elim: n => /= [|n IHn] in p q *; first by rewrite rmorph1 rmorph0.
rewrite map_poly_eq0; have [_ | nz_q] := ifPn; first by rewrite rmorph1 rmorph0.
rewrite -map_modp (IHn q (p %% q)); case: (egcdp_rec _ _ n) => u v /=.
rewrite map_polyZ lead_coef_map -rmorphXn scalp_map rmorphB rmorphM.
by rewrite -map_divp.
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
|
egcdp_map
| |
dvdp_mapp q : (p^f %| q^f) = (p %| q).
Proof. by rewrite /dvdp -map_modp map_poly_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
|
dvdp_map
| |
eqp_mapp q : (p^f %= q^f) = (p %= q).
Proof. by rewrite /eqp !dvdp_map. 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
|
eqp_map
| |
gcdp_mapp q : (gcdp p q)^f = gcdp p^f q^f.
Proof.
wlog lt_p_q: p q / size p < size q.
move=> IHpq; case: (ltnP (size p) (size q)) => [|le_q_p]; first exact: IHpq.
rewrite gcdpE (gcdpE p^f) !size_map_poly ltnNge le_q_p /= -map_modp.
have [-> | q_nz] := eqVneq q 0; first by rewrite rmorph0 !gcdp0.
by rewrite IHpq ?ltn_modp.
have [m le_q_m] := ubnP (size q); elim: m => // m IHm in p q lt_p_q le_q_m *.
rewrite gcdpE (gcdpE p^f) !size_map_poly lt_p_q -map_modp.
have [-> | q_nz] := eqVneq p 0; first by rewrite rmorph0 !gcdp0.
by rewrite IHm ?(leq_trans lt_p_q) ?ltn_modp.
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
|
gcdp_map
| |
coprimep_mapp q : coprimep p^f q^f = coprimep p q.
Proof. by rewrite -!gcdp_eqp1 -eqp_map rmorph1 gcdp_map. 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
|
coprimep_map
| |
gdcop_rec_mapp q n : (gdcop_rec p q n)^f = gdcop_rec p^f q^f n.
Proof.
elim: n p q => [|n IH] => /= p q.
by rewrite map_poly_eq0; case: eqP; rewrite ?rmorph1 ?rmorph0.
rewrite /coprimep -gcdp_map size_map_poly.
by case: eqP => Hq0 //; rewrite -map_divp -IH.
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
|
gdcop_rec_map
| |
gdcop_mapp q : (gdcop p q)^f = gdcop p^f q^f.
Proof. by rewrite /gdcop gdcop_rec_map !size_map_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
|
gdcop_map
| |
leq_trunc_divp:= leq_divMp.
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import fintype bigop ssralg poly"
] |
algebra/polydiv.v
|
leq_trunc_divp
| |
root_coprimep(p q : {poly F}) :
(forall x, root p x -> q.[x] != 0) -> coprimep p q.
Proof.
move=> Ncmn; rewrite -gcdp_eqp1 -size_poly_eq1; apply/closed_rootP.
by case=> r; rewrite root_gcd !rootE=> /andP [/Ncmn/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
|
root_coprimep
| |
coprimepP(p q : {poly F}) :
reflect (forall x, root p x -> q.[x] != 0) (coprimep p q).
Proof. by apply: (iffP idP)=> [/coprimep_root|/root_coprimep]. 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
|
coprimepP
| |
swapXY_defu : {poly {poly R}} := (u ^ map_poly polyC).['Y].
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_def
| |
swapXY:= locked_with swapXY_key swapXY_def.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY
| |
swapXY_unlockable:= [unlockable fun swapXY].
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_unlockable
| |
sizeYu : nat := \max_(i < size u) (size u`_i).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sizeY
| |
poly_XaYp : {poly {poly R}} := p^:P \Po ('X + 'Y).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XaY
| |
poly_XmYp : {poly {poly R}} := p^:P \Po ('X * 'Y).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XmY
| |
sub_annihilantp q := resultant (poly_XaY p) q^:P.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sub_annihilant
| |
div_annihilantp q := resultant (poly_XmY p) q^:P.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
div_annihilant
| |
swapXY_polyCp : swapXY p%:P = p^:P.
Proof. by rewrite unlock map_polyC hornerC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_polyC
| |
swapXY_X: swapXY 'X = 'Y.
Proof. by rewrite unlock map_polyX hornerX. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_X
| |
swapXY_Y: swapXY 'Y = 'X.
Proof. by rewrite swapXY_polyC map_polyX. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_Y
| |
swapXY_is_zmod_morphism: zmod_morphism swapXY.
Proof. by move=> u v; rewrite unlock rmorphB !hornerE. Qed.
#[warning="-deprecated-since-mathcomp-2.5.0", deprecated(since="mathcomp 2.5.0",
note="use `swapXY_is_zmod_morphism` instead")]
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_is_zmod_morphism
| |
swapXY_is_additive:= swapXY_is_zmod_morphism.
HB.instance Definition _ :=
GRing.isZmodMorphism.Build {poly {poly R}} {poly {poly R}} swapXY
swapXY_is_zmod_morphism.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_is_additive
| |
coef_swapXYu i j : (swapXY u)`_i`_j = u`_j`_i.
Proof.
elim/poly_ind: u => [|u p IHu] in i j *; first by rewrite raddf0 !coef0.
rewrite raddfD !coefD /= swapXY_polyC coef_map /= !coefC coefMX.
rewrite !(fun_if (fun q : {poly R} => q`_i)) coef0 -IHu; congr (_ + _).
by rewrite unlock rmorphM /= map_polyX hornerMX coefMC coefMX.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
coef_swapXY
| |
swapXYK: involutive swapXY.
Proof. by move=> u; apply/polyP=> i; apply/polyP=> j; rewrite !coef_swapXY. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXYK
| |
swapXY_map_polyCp : swapXY p^:P = p%:P.
Proof. by rewrite -swapXY_polyC swapXYK. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_map_polyC
| |
swapXY_eq0u : (swapXY u == 0) = (u == 0).
Proof. by rewrite (inv_eq swapXYK) raddf0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_eq0
| |
swapXY_is_monoid_morphism: monoid_morphism swapXY.
Proof.
split=> [|u v]; first by rewrite swapXY_polyC map_polyC.
apply/polyP=> i; apply/polyP=> j; rewrite coef_swapXY !coefM !coef_sum.
rewrite (eq_bigr _ (fun _ _ => coefM _ _ _)) exchange_big /=.
apply: eq_bigr => j1 _; rewrite coefM; apply: eq_bigr=> i1 _.
by rewrite !coef_swapXY.
Qed.
#[warning="-deprecated-since-mathcomp-2.5.0", deprecated(since="mathcomp 2.5.0",
note="use `swapXY_is_monoid_morphism` instead")]
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_is_monoid_morphism
| |
swapXY_is_multiplicative:=
(fun g => (g.2,g.1)) swapXY_is_monoid_morphism.
HB.instance Definition _ :=
GRing.isMonoidMorphism.Build {poly {poly R}} {poly {poly R}} swapXY
swapXY_is_monoid_morphism.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_is_multiplicative
| |
swapXY_is_scalable: scalable_for (map_poly polyC \; *%R) swapXY.
Proof. by move=> p u /=; rewrite -mul_polyC rmorphM /= swapXY_polyC. Qed.
HB.instance Definition _ :=
GRing.isScalable.Build {poly R} {poly {poly R}} {poly {poly R}}
(map_poly polyC \; *%R) swapXY swapXY_is_scalable.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_is_scalable
| |
swapXY_comp_polyp u : swapXY (p^:P \Po u) = p^:P \Po swapXY u.
Proof.
rewrite -horner_map; congr _.[_]; rewrite -!map_poly_comp /=.
by apply: eq_map_poly => x; rewrite /= swapXY_polyC map_polyC.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_comp_poly
| |
max_size_coefXYu i : size u`_i <= sizeY u.
Proof.
have [ltiu | /(nth_default 0)->] := ltnP i (size u); last by rewrite size_poly0.
exact: (bigmax_sup (Ordinal ltiu)).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
max_size_coefXY
| |
max_size_lead_coefXYu : size (lead_coef u) <= sizeY u.
Proof. by rewrite lead_coefE max_size_coefXY. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
max_size_lead_coefXY
| |
max_size_evalXu : size u.['X] <= sizeY u + (size u).-1.
Proof.
rewrite horner_coef (leq_trans (size_sum _ _ _)) //; apply/bigmax_leqP=> i _.
rewrite (leq_trans (size_polyMleq _ _)) // size_polyXn addnS.
by rewrite leq_add ?max_size_coefXY //= -ltnS (leq_trans _ (leqSpred _)).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
max_size_evalX
| |
max_size_evalCu x : size u.[x%:P] <= sizeY u.
Proof.
rewrite horner_coef (leq_trans (size_sum _ _ _)) //; apply/bigmax_leqP=> i _.
rewrite (leq_trans (size_polyMleq _ _)) // -polyC_exp size_polyC addnC -subn1.
by rewrite (leq_trans _ (max_size_coefXY _ i)) // leq_subLR leq_add2r leq_b1.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
max_size_evalC
| |
sizeYEu : sizeY u = size (swapXY u).
Proof.
apply/eqP; rewrite eqn_leq; apply/andP; split.
apply/bigmax_leqP=> /= i _; apply/leq_sizeP => j /(nth_default 0) u_j_0.
by rewrite -coef_swapXY u_j_0 coef0.
apply/leq_sizeP=> j le_uY_j; apply/polyP=> i; rewrite coef_swapXY coef0.
by rewrite nth_default // (leq_trans _ le_uY_j) ?max_size_coefXY.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sizeYE
| |
sizeY_eq0u : (sizeY u == 0) = (u == 0).
Proof. by rewrite sizeYE size_poly_eq0 swapXY_eq0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sizeY_eq0
| |
sizeY_mulXu : sizeY (u * 'X) = sizeY u.
Proof.
rewrite !sizeYE rmorphM /= swapXY_X rreg_size //.
by have /monic_comreg[_ /rreg_lead] := monicX R.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sizeY_mulX
| |
swapXY_poly_XaYp : swapXY (poly_XaY p) = poly_XaY p.
Proof. by rewrite swapXY_comp_poly rmorphD /= swapXY_X swapXY_Y addrC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_poly_XaY
| |
swapXY_poly_XmYp : swapXY (poly_XmY p) = poly_XmY p.
Proof.
by rewrite swapXY_comp_poly rmorphM /= swapXY_X swapXY_Y commr_polyX.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_poly_XmY
| |
poly_XaY0: poly_XaY 0 = 0.
Proof. by rewrite /poly_XaY rmorph0 comp_poly0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XaY0
| |
poly_XmY0: poly_XmY 0 = 0.
Proof. by rewrite /poly_XmY rmorph0 comp_poly0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XmY0
| |
swapXY_map(R S : nzRingType) (f : {additive R -> S}) u :
swapXY (u ^ map_poly f) = swapXY u ^ map_poly f.
Proof.
by apply/polyP=> i; apply/polyP=> j; rewrite !(coef_map, coef_swapXY).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
swapXY_map
| |
horner_swapXYu x : (swapXY u).[x%:P] = u ^ eval x.
Proof.
apply/polyP=> i /=; rewrite coef_map /= /eval horner_coef coef_sum -sizeYE.
rewrite (horner_coef_wide _ (max_size_coefXY u i)); apply: eq_bigr=> j _.
by rewrite -polyC_exp coefMC coef_swapXY.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
horner_swapXY
| |
horner_polyCu x : u.[x%:P] = swapXY u ^ eval x.
Proof. by rewrite -horner_swapXY swapXYK. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
horner_polyC
| |
horner2_swapXYu x y : (swapXY u).[x, y] = u.[y, x].
Proof. by rewrite horner_swapXY -{1}(hornerC y x) horner_map. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
horner2_swapXY
| |
horner_poly_XaYp v : (poly_XaY p).[v] = p \Po (v + 'X).
Proof. by rewrite horner_comp !hornerE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
horner_poly_XaY
| |
horner_poly_XmYp v : (poly_XmY p).[v] = p \Po (v * 'X).
Proof. by rewrite horner_comp !hornerE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
horner_poly_XmY
| |
size_poly_XaYp : size (poly_XaY p) = size p.
Proof. by rewrite size_comp_poly2 ?size_XaddC // size_map_polyC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
size_poly_XaY
| |
poly_XaY_eq0p : (poly_XaY p == 0) = (p == 0).
Proof. by rewrite -!size_poly_eq0 size_poly_XaY. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XaY_eq0
| |
size_poly_XmYp : size (poly_XmY p) = size p.
Proof. by rewrite size_comp_poly2 ?size_XmulC ?polyX_eq0 ?size_map_polyC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
size_poly_XmY
| |
poly_XmY_eq0p : (poly_XmY p == 0) = (p == 0).
Proof. by rewrite -!size_poly_eq0 size_poly_XmY. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
poly_XmY_eq0
| |
lead_coef_poly_XaYp : lead_coef (poly_XaY p) = (lead_coef p)%:P.
Proof.
rewrite lead_coef_comp ?size_XaddC // -['Y]opprK -polyCN lead_coefXsubC.
by rewrite expr1n mulr1 lead_coef_map_inj //; apply: polyC_inj.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
lead_coef_poly_XaY
| |
sub_annihilant_in_idealp q :
1 < size p -> 1 < size q ->
{uv : {poly {poly R}} * {poly {poly R}}
| size uv.1 < size q /\ size uv.2 < size p
& forall x y,
(sub_annihilant p q).[y] = uv.1.[x, y] * p.[x + y] + uv.2.[x, y] * q.[x]}.
Proof.
rewrite -size_poly_XaY -(size_map_polyC q) => p1_gt1 q1_gt1.
have [uv /= [ub_u ub_v Dr]] := resultant_in_ideal p1_gt1 q1_gt1.
exists uv => // x y; rewrite -[r in r.[y] = _](hornerC _ x%:P) Dr.
by rewrite !(hornerE, horner_comp).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sub_annihilant_in_ideal
| |
sub_annihilantPp q x y :
p != 0 -> q != 0 -> p.[x] = 0 -> q.[y] = 0 ->
(sub_annihilant p q).[x - y] = 0.
Proof.
move=> nz_p nz_q px0 qy0.
have p_gt1: size p > 1 by have /rootP/root_size_gt1-> := px0.
have q_gt1: size q > 1 by have /rootP/root_size_gt1-> := qy0.
have [uv /= _ /(_ y)->] := sub_annihilant_in_ideal p_gt1 q_gt1.
by rewrite (addrC y) subrK px0 qy0 !mulr0 addr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sub_annihilantP
| |
sub_annihilant_neq0p q : p != 0 -> q != 0 -> sub_annihilant p q != 0.
Proof.
rewrite resultant_eq0; set p1 := poly_XaY p => nz_p nz_q.
have [nz_p1 nz_q1]: p1 != 0 /\ q^:P != 0 by rewrite poly_XaY_eq0 map_polyC_eq0.
rewrite -leqNgt eq_leq //; apply/eqP/Bezout_coprimepPn=> // [[[u v]]] /=.
rewrite !size_poly_gt0 -andbA => /and4P[nz_u ltuq nz_v _] Duv.
have /eqP/= := congr1 (size \o (lead_coef \o swapXY)) Duv.
rewrite ltn_eqF // !rmorphM !lead_coefM (leq_trans (leq_ltn_trans _ ltuq)) //=.
rewrite -{2}[u]swapXYK -sizeYE swapXY_poly_XaY lead_coef_poly_XaY.
by rewrite mulrC mul_polyC size_scale ?max_size_lead_coefXY ?lead_coef_eq0.
rewrite swapXY_map_polyC lead_coefC size_map_polyC.
set v1 := lead_coef _; have nz_v1: v1 != 0 by rewrite lead_coef_eq0 swapXY_eq0.
rewrite [leqRHS]polySpred ?mulf_neq0 // size_mul //.
by rewrite (polySpred nz_v1) addnC addnS polySpred // ltnS leq_addr.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat seq",
"From mathcomp Require Import fintype tuple finfun bigop fingroup perm div",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra",
"From mathcomp Require Import poly polydiv mxpoly binomial"
] |
algebra/polyXY.v
|
sub_annihilant_neq0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.