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 |
|---|---|---|---|---|---|---|
root_mxminpolya : root p_A a = root (char_poly A) a.
Proof. by rewrite -eigenvalue_root_min eigenvalue_root_char. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
root_mxminpoly
| |
mxminpoly_diag{F : fieldType} {n} (d : 'rV[F]_n.+1)
(u := undup [seq d 0 i | i <- enum 'I_n.+1]) :
mxminpoly (diag_mx d) = \prod_(r <- u) ('X - r%:P).
Proof.
apply/eqP; rewrite -eqp_monic ?mxminpoly_monic ?monic_prod_XsubC// /eqp.
rewrite mxminpoly_min/=; last first.
rewrite horner_mx_diag; apply/matrixP => i j; rewrite !mxE horner_prod.
case: (altP (i =P j)) => [->|neq_ij//]; rewrite mulr1n.
rewrite (bigD1_seq (d 0 j)) ?undup_uniq ?mem_undup ?map_f// /=.
by rewrite hornerD hornerN hornerX hornerC subrr mul0r.
apply: uniq_roots_dvdp; last by rewrite uniq_rootsE undup_uniq.
apply/allP => x; rewrite mem_undup root_mxminpoly char_poly_trig//.
rewrite -(big_map _ predT (fun x => _ - x%:P)) root_prod_XsubC.
by move=> /mapP[i _ ->]; apply/mapP; exists i; rewrite ?(mxE, eqxx).
Qed.
Prenex Implicits degree_mxminpoly mxminpoly mx_inv_horner.
Arguments mx_inv_hornerK {F n' A} [B] AnB.
Arguments horner_rVpoly_inj {F n' A} [u1 u2] eq_u12A : rename.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxminpoly_diag
| |
map_rVpoly(u : 'rV_d) : fp (rVpoly u) = rVpoly u^f.
Proof.
apply/polyP=> k; rewrite coef_map !coef_rVpoly.
by case: (insub k) => [i|]; rewrite /= ?rmorph0 // mxE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_rVpoly
| |
map_poly_rVp : (poly_rV p)^f = poly_rV (fp p) :> 'rV_d.
Proof. by apply/rowP=> j; rewrite !mxE coef_map. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_poly_rV
| |
map_char_poly_mx: map_mx fp (char_poly_mx A) = char_poly_mx A^f.
Proof.
rewrite raddfB /= map_scalar_mx /= map_polyX; congr (_ - _).
by apply/matrixP=> i j; rewrite !mxE map_polyC.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_char_poly_mx
| |
map_char_poly: fp (char_poly A) = char_poly A^f.
Proof. by rewrite -det_map_mx map_char_poly_mx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_char_poly
| |
map_resultant(aR rR : nzRingType) (f : {rmorphism {poly aR} -> rR}) p q :
f (lead_coef p) != 0 -> f (lead_coef q) != 0 ->
f (resultant p q)= resultant (map_poly f p) (map_poly f q).
Proof.
move=> nz_fp nz_fq; rewrite /resultant /Sylvester_mx !size_map_poly_id0 //.
rewrite -det_map_mx /= map_col_mx; congr (\det (col_mx _ _));
by apply: map_lin1_mx => v; rewrite map_poly_rV rmorphM /= map_rVpoly.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_resultant
| |
map_powers_mxe : (powers_mx A e)^f = powers_mx A^f e.
Proof. by apply/row_matrixP=> i; rewrite -map_row !rowK map_mxvec rmorphXn. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_powers_mx
| |
map_horner_mxp : (horner_mx A p)^f = horner_mx A^f (fp p).
Proof.
rewrite -[p](poly_rV_K (leqnn _)) map_rVpoly.
by rewrite !horner_rVpoly map_vec_mx map_mxM map_powers_mx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_horner_mx
| |
map_mx_companion(e := congr1 predn (size_map_poly _ _)) :
(companionmx p)^f = castmx (e, e) (companionmx (fp p)).
Proof.
apply/matrixP => i j; rewrite !(castmxE, mxE) /= (fun_if f).
by rewrite rmorphN coef_map size_map_poly rmorph_nat.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_mx_companion
| |
companion_map_poly(e := esym (congr1 predn (size_map_poly _ _))) :
companionmx (fp p) = castmx (e, e) (companionmx p)^f.
Proof. by rewrite map_mx_companion castmx_comp castmx_id. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
companion_map_poly
| |
degree_mxminpoly_map: degree_mxminpoly A^f = degree_mxminpoly A.
Proof. by apply: eq_ex_minn => e; rewrite -map_powers_mx mxrank_map. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
degree_mxminpoly_map
| |
mxminpoly_map: mxminpoly A^f = fp (mxminpoly A).
Proof.
rewrite rmorphB; congr (_ - _).
by rewrite /= map_polyXn degree_mxminpoly_map.
rewrite degree_mxminpoly_map -rmorphXn /=.
apply/polyP=> i; rewrite coef_map //= !coef_rVpoly degree_mxminpoly_map.
case/insub: i => [i|]; last by rewrite rmorph0.
by rewrite -map_powers_mx -map_pinvmx // -map_mxvec -map_mxM // mxE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxminpoly_map
| |
map_mx_inv_horneru : fp (mx_inv_horner A u) = mx_inv_horner A^f u^f.
Proof.
rewrite map_rVpoly map_mxM map_mxvec map_pinvmx map_powers_mx.
by rewrite /mx_inv_horner degree_mxminpoly_map.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_mx_inv_horner
| |
kermxpolyn (g : 'M_n) (p : {poly K}) : 'M_n :=
kermx ((if n is n.+1 then horner_mx^~ p : 'M_n.+1 -> 'M_n.+1 else \0) g).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpoly
| |
kermxpolyCn (g : 'M_n) c : c != 0 -> kermxpoly g c%:P = 0.
Proof.
move=> c_neq0; case: n => [|n] in g *; first by rewrite thinmx0.
apply/eqP; rewrite /kermxpoly horner_mx_C kermx_eq0 row_free_unit.
by rewrite -scalemx1 scaler_unit ?unitmx1// unitfE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpolyC
| |
kermxpoly1n (g : 'M_n) : kermxpoly g 1 = 0.
Proof. by rewrite kermxpolyC ?oner_eq0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpoly1
| |
kermxpolyXn (g : 'M_n) : kermxpoly g 'X = kermx g.
Proof.
case: n => [|n] in g *; first by rewrite !thinmx0.
by rewrite /kermxpoly horner_mx_X.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpolyX
| |
kermxpoly_minn (g : 'M[K]_n.+1) p :
mxminpoly g %| p -> (kermxpoly g p :=: 1)%MS.
Proof. by rewrite /kermxpoly => /mxminpoly_minP ->; apply: kermx0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpoly_min
| |
comm_mx_stable_kermxpolyn (f g : 'M_n) (p : {poly K}) : comm_mx f g ->
stablemx (kermxpoly f p) g.
Proof.
case: n => [|n] in f g *; first by rewrite !thinmx0.
move=> fg; rewrite /kermxpoly; apply: comm_mx_stable_ker.
by apply/comm_mx_sym/comm_mx_horner/comm_mx_sym.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
comm_mx_stable_kermxpoly
| |
mxdirect_kermxpolyn (g : 'M_n) (p q : {poly K}) :
coprimep p q -> (kermxpoly g p :&: kermxpoly g q = 0)%MS.
Proof.
case: n => [|n] in g *; first by rewrite thinmx0 ?cap0mx ?submx_refl.
move=> /Bezout_eq1_coprimepP [[/= u v]]; rewrite mulrC [v * _]mulrC => cpq.
apply/eqP/rowV0P => x.
rewrite sub_capmx => /andP[/sub_kermxP xgp0 /sub_kermxP xgq0].
move: cpq => /(congr1 (mulmx x \o horner_mx g))/=.
rewrite !(rmorphM, rmorphD, rmorph1, mulmx1, mulmxDr, mulmxA).
by rewrite xgp0 xgq0 !mul0mx add0r.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxdirect_kermxpoly
| |
kermxpolyMn (g : 'M_n) (p q : {poly K}) : coprimep p q ->
(kermxpoly g (p * q) :=: kermxpoly g p + kermxpoly g q)%MS.
Proof.
case: n => [|n] in g *; first by rewrite !thinmx0.
move=> /Bezout_eq1_coprimepP [[/= u v]]; rewrite mulrC [v * _]mulrC => cpq.
apply/eqmxP/andP; split; last first.
apply/sub_kermxP/eqmx0P; rewrite !addsmxMr [in X in (_ + X)%MS]mulrC.
by rewrite !rmorphM/= !mulmxA !mulmx_ker !mul0mx !addsmx0 submx_refl.
move: cpq => /(congr1 (horner_mx g))/=; rewrite rmorph1 rmorphD/=.
rewrite -[X in (X <= _)%MS]mulr1 => <-; rewrite mulrDr [p * u]mulrC addrC.
rewrite addmx_sub_adds//; apply/sub_kermxP; rewrite mulmxE -mulrA -rmorphM.
by rewrite mulrAC [q * p]mulrC rmorphM/= mulrA -!mulmxE mulmx_ker mul0mx.
rewrite -[_ * _ * q]mulrA [u * _]mulrC.
by rewrite rmorphM mulrA -!mulmxE mulmx_ker mul0mx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpolyM
| |
kermxpoly_prodn (g : 'M_n)
(I : finType) (P : {pred I}) (p_ : I -> {poly K}) :
{in P &, forall i j, j != i -> coprimep (p_ i) (p_ j)} ->
(kermxpoly g (\prod_(i | P i) p_ i) :=: \sum_(i | P i) kermxpoly g (p_ i))%MS.
Proof.
move=> p_coprime; elim: index_enum (index_enum_uniq I).
by rewrite !big_nil ?kermxpoly1 ?submx_refl//.
move=> j js ihjs /= /andP[jNjs js_uniq]; apply/eqmxP.
rewrite !big_cons; case: ifP => [Pj|PNj]; rewrite ?ihjs ?submx_refl//.
suff cjjs: coprimep (p_ j) (\prod_(i <- js | P i) p_ i).
by rewrite !kermxpolyM// !(adds_eqmx (eqmx_refl _) (ihjs _)) ?submx_refl.
rewrite (@big_morph _ _ _ true andb) ?big_all_cond ?coprimep1//; last first.
by move=> p q; rewrite coprimepMr.
apply/allP => i i_js; apply/implyP => Pi; apply: p_coprime => //.
by apply: contraNneq jNjs => <-.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
kermxpoly_prod
| |
mxdirect_sum_kermxn (g : 'M_n)
(I : finType) (P : {pred I}) (p_ : I -> {poly K}) :
{in P &, forall i j, j != i -> coprimep (p_ i) (p_ j)} ->
mxdirect (\sum_(i | P i) kermxpoly g (p_ i))%MS.
Proof.
move=> p_coprime; apply/mxdirect_sumsP => i Pi; apply/eqmx0P.
have cpNi : {in [pred j | P j && (j != i)] &,
forall j k : I, k != j -> coprimep (p_ j) (p_ k)}.
by move=> j k /andP[Pj _] /andP[Pk _]; apply: p_coprime.
rewrite -!(cap_eqmx (eqmx_refl _) (kermxpoly_prod g _))//.
rewrite mxdirect_kermxpoly ?submx_refl//.
rewrite (@big_morph _ _ _ true andb) ?big_all_cond ?coprimep1//; last first.
by move=> p q; rewrite coprimepMr.
by apply/allP => j _; apply/implyP => /andP[Pj neq_ji]; apply: p_coprime.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxdirect_sum_kermx
| |
eigenspace_polyn a (f : 'M_n) :
eigenspace f a = kermxpoly f ('X - a%:P).
Proof.
case: n => [|m] in a f *; first by rewrite !thinmx0.
by congr (kermx _); rewrite rmorphB /= ?horner_mx_X ?horner_mx_C.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenspace_poly
| |
geigenspacen (g : 'M_n) a := kermxpoly g (('X - a%:P) ^+ n).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
geigenspace
| |
geigenspaceEn' (g : 'M_n'.+1) a :
geigenspace g a = kermx ((g - a%:M) ^+ n'.+1).
Proof.
by rewrite /geigenspace /kermxpoly rmorphXn/= rmorphB/= horner_mx_X horner_mx_C.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
geigenspaceE
| |
eigenspace_sub_geigenn (g : 'M_n) a :
(eigenspace g a <= geigenspace g a)%MS.
Proof.
case: n => [|n] in g *; rewrite ?thinmx0 ?sub0mx// geigenspaceE.
by apply/sub_kermxP; rewrite exprS mulmxA mulmx_ker mul0mx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenspace_sub_geigen
| |
mxdirect_sum_geigenspace(I : finType) (n : nat) (g : 'M_n) (P : {pred I}) (a_ : I -> K) :
{in P &, injective a_} -> mxdirect (\sum_(i | P i) geigenspace g (a_ i)).
Proof.
move=> /inj_in_eq eq_a; apply: mxdirect_sum_kermx => i j Pi Pj Nji.
by rewrite coprimep_expr ?coprimep_expl// coprimep_XsubC root_XsubC eq_a.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxdirect_sum_geigenspace
| |
eigenpolyn (g : 'M_n) : pred {poly K} :=
(fun p => kermxpoly g p != 0).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenpoly
| |
eigenpolyPn (g : 'M_n) (p : {poly K}) :
reflect (exists2 v : 'rV_n, (v <= kermxpoly g p)%MS & v != 0) (eigenpoly g p).
Proof. exact: rowV0Pn. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenpolyP
| |
eigenvalue_polyn a (f : 'M_n) : eigenvalue f a = eigenpoly f ('X - a%:P).
Proof. by rewrite /eigenpoly /eigenvalue eigenspace_poly. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenvalue_poly
| |
comm_mx_stable_geigenspacen (f g : 'M_n) a : comm_mx f g ->
stablemx (geigenspace f a) g.
Proof. exact: comm_mx_stable_kermxpoly. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
comm_mx_stable_geigenspace
| |
map_kermxpoly(n : nat) (g : 'M_n) (p : {poly aF}) :
map_mx f (kermxpoly g p) = kermxpoly (map_mx f g) (map_poly f p).
Proof.
by case: n => [|n] in g *; rewrite ?thinmx0// map_kermx map_horner_mx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_kermxpoly
| |
map_geigenspace(n : nat) (g : 'M_n) (a : aF) :
map_mx f (geigenspace g a) = geigenspace (map_mx f g) (f a).
Proof. by rewrite map_kermxpoly rmorphXn/= rmorphB /= map_polyX map_polyC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
map_geigenspace
| |
eigenpoly_mapn (g : 'M_n) (p : {poly aF}) :
eigenpoly (map_mx f g) (map_poly f p) = eigenpoly g p.
Proof. by rewrite /eigenpoly -map_kermxpoly map_mx_eq0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eigenpoly_map
| |
integralOver(R K : nzRingType) (RtoK : R -> K) (z : K) :=
exists2 p, p \is monic & root (map_poly RtoK p) z.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integralOver
| |
integralRangeR K RtoK := forall z, @integralOver R K RtoK z.
Variables (B R K : nzRingType) (BtoR : B -> R) (RtoK : {rmorphism R -> K}).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integralRange
| |
integral_rmorphx :
integralOver BtoR x -> integralOver (RtoK \o BtoR) (RtoK x).
Proof. by case=> p; exists p; rewrite // map_poly_comp rmorph_root. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_rmorph
| |
integral_idx : integralOver RtoK (RtoK x).
Proof. by exists ('X - x%:P); rewrite ?monicXsubC ?rmorph_root ?root_XsubC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_id
| |
integral_natn : integralOver RtoK n%:R.
Proof. by rewrite -(rmorph_nat RtoK); apply: integral_id. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_nat
| |
integral0: integralOver RtoK 0. Proof. exact: (integral_nat 0). Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral0
| |
integral1: integralOver RtoK 1. Proof. exact: (integral_nat 1). Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral1
| |
integral_poly(p : {poly K}) :
(forall i, integralOver RtoK p`_i) <-> {in p : seq K, integralRange RtoK}.
Proof.
split=> intRp => [_ /(nthP 0)[i _ <-] // | i]; rewrite -[p]coefK coef_poly.
by case: ifP => [ltip | _]; [apply/intRp/mem_nth | apply: integral0].
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_poly
| |
integral_horner_rootw (p q : {poly K}) :
p \is monic -> root p w ->
{in p : seq K, integralRange RtoK} -> {in q : seq K, integralRange RtoK} ->
integralOver RtoK q.[w].
Proof.
move=> mon_p pw0 intRp intRq.
pose memR y := exists x, y = RtoK x.
have memRid x: memR (RtoK x) by exists x.
have memR_nat n: memR n%:R by rewrite -(rmorph_nat RtoK) /=.
have [memR0 memR1]: memR 0 * memR 1 := (memR_nat 0, memR_nat 1).
have memRN1: memR (- 1) by exists (- 1); rewrite rmorphN1.
pose rVin (E : K -> Prop) n (a : 'rV[K]_n) := forall i, E (a 0 i).
pose pXin (E : K -> Prop) (r : {poly K}) := forall i, E r`_i.
pose memM E n (X : 'rV_n) y := exists a, rVin E n a /\ y = (a *m X^T) 0 0.
pose finM E S := exists n, exists X, forall y, memM E n X y <-> S y.
have tensorM E n1 n2 X Y: finM E (memM (memM E n2 Y) n1 X).
exists (n1 * n2)%N, (mxvec (X^T *m Y)) => y.
split=> [[a [Ea Dy]] | [a1 [/fin_all_exists[a /all_and2[Ea Da1]] ->]]].
exists (Y *m (vec_mx a)^T); split=> [i|].
exists (row i (vec_mx a)); split=> [j|]; first by rewrite !mxE; apply: Ea.
by rewrite -row_mul -{1}[Y]trmxK -trmx_mul !mxE.
by rewrite -[Y]trmxK -!trmx_mul mulmxA -mxvec_dotmul trmx_mul trmxK vec_mxK.
exists (mxvec (\matrix_i a i)); split.
by case/mxvec_indexP=> i j; rewrite mxvecE mxE; apply: Ea.
rewrite -[mxvec _]trmxK -trmx_mul mxvec_dotmul -mulmxA trmx_mul !mxE.
apply: eq_bigr => i _; rewrite Da1 !mxE; congr (_ * _).
by apply: eq_bigr => j _; rewrite !mxE.
suffices [m [X [[u [_ Du]] idealM]]]: exists m,
...
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_horner_root
| |
integral_root_monicu p :
p \is monic -> root p u -> {in p : seq K, integralRange RtoK} ->
integralOver RtoK u.
Proof.
move=> mon_p pu0 intRp; rewrite -[u]hornerX.
apply: integral_horner_root mon_p pu0 intRp _.
by apply/integral_poly => i; rewrite coefX; apply: integral_nat.
Qed.
Let integral0_RtoK := integral0 RtoK.
Let integral1_RtoK := integral1 RtoK.
Let monicXsubC_K := @monicXsubC K.
Hint Resolve integral0_RtoK integral1_RtoK monicXsubC_K : core.
Let XsubC0 (u : K) : root ('X - u%:P) u. Proof. by rewrite root_XsubC. Qed.
Let intR_XsubC u :
integralOver RtoK (- u) -> {in 'X - u%:P : seq K, integralRange RtoK}.
Proof. by move=> intRu v; rewrite polyseqXsubC !inE => /pred2P[]->. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_root_monic
| |
integral_oppu : integralOver RtoK u -> integralOver RtoK (- u).
Proof. by rewrite -{1}[u]opprK => /intR_XsubC/integral_root_monic; apply. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_opp
| |
integral_horner(p : {poly K}) u :
{in p : seq K, integralRange RtoK} -> integralOver RtoK u ->
integralOver RtoK p.[u].
Proof. by move=> ? /integral_opp/intR_XsubC/integral_horner_root; apply. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_horner
| |
integral_subu v :
integralOver RtoK u -> integralOver RtoK v -> integralOver RtoK (u - v).
Proof.
move=> intRu /integral_opp/intR_XsubC/integral_horner/(_ intRu).
by rewrite !hornerE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_sub
| |
integral_addu v :
integralOver RtoK u -> integralOver RtoK v -> integralOver RtoK (u + v).
Proof. by rewrite -{2}[v]opprK => intRu /integral_opp; apply: integral_sub. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_add
| |
integral_mulu v :
integralOver RtoK u -> integralOver RtoK v -> integralOver RtoK (u * v).
Proof.
rewrite -{2}[v]hornerX -hornerZ => intRu; apply: integral_horner.
by apply/integral_poly=> i; rewrite coefZ coefX mulr_natr mulrb; case: ifP.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_mul
| |
algebraicOver(fFtoE : F -> E) u :=
exists2 p, p != 0 & root (map_poly fFtoE p) u.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraicOver
| |
mk_monp := ((lead_coef p)^-1 *: p).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mk_mon
| |
integral_algebraicu : algebraicOver FtoE u <-> integralOver FtoE u.
Proof.
split=> [] [p p_nz pu0]; last by exists p; rewrite ?monic_neq0.
exists (mk_mon p); first by rewrite monicE lead_coefZ mulVf ?lead_coef_eq0.
by rewrite linearZ rootE hornerZ (rootP pu0) mulr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_algebraic
| |
algebraic_ida : algebraicOver FtoE (FtoE a).
Proof. exact/integral_algebraic/integral_id. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_id
| |
algebraic0: algebraicOver FtoE 0.
Proof. exact/integral_algebraic/integral0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic0
| |
algebraic1: algebraicOver FtoE 1.
Proof. exact/integral_algebraic/integral1. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic1
| |
algebraic_oppx : algebraicOver FtoE x -> algebraicOver FtoE (- x).
Proof. by move/integral_algebraic/integral_opp/integral_algebraic. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_opp
| |
algebraic_addx y :
algebraicOver FtoE x -> algebraicOver FtoE y -> algebraicOver FtoE (x + y).
Proof.
move/integral_algebraic=> intFx /integral_algebraic intFy.
exact/integral_algebraic/integral_add.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_add
| |
algebraic_subx y :
algebraicOver FtoE x -> algebraicOver FtoE y -> algebraicOver FtoE (x - y).
Proof. by move=> algFx /algebraic_opp; apply: algebraic_add. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_sub
| |
algebraic_mulx y :
algebraicOver FtoE x -> algebraicOver FtoE y -> algebraicOver FtoE (x * y).
Proof.
move/integral_algebraic=> intFx /integral_algebraic intFy.
exact/integral_algebraic/integral_mul.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_mul
| |
algebraic_invu : algebraicOver FtoE u -> algebraicOver FtoE u^-1.
Proof.
have [-> | /expf_neq0 nz_u_n] := eqVneq u 0; first by rewrite invr0.
case=> p nz_p pu0; exists (Poly (rev p)).
apply/eqP=> /polyP/(_ 0); rewrite coef_Poly coef0 nth_rev ?size_poly_gt0 //.
by apply/eqP; rewrite subn1 lead_coef_eq0.
apply/eqP/(mulfI (nz_u_n (size p).-1)); rewrite mulr0 -(rootP pu0).
rewrite (@horner_coef_wide _ (size p)); last first.
by rewrite size_map_poly -(size_rev p) size_Poly.
rewrite horner_coef mulr_sumr size_map_poly.
rewrite [rhs in _ = rhs](reindex_inj rev_ord_inj) /=.
apply: eq_bigr => i _; rewrite !coef_map coef_Poly nth_rev // mulrCA.
by congr (_ * _); rewrite -{1}(subnKC (valP i)) addSn addnC exprD exprVn ?mulfK.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_inv
| |
algebraic_divx y :
algebraicOver FtoE x -> algebraicOver FtoE y -> algebraicOver FtoE (x / y).
Proof. by move=> algFx /algebraic_inv; apply: algebraic_mul. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
algebraic_div
| |
integral_invx : integralOver FtoE x -> integralOver FtoE x^-1.
Proof. by move/integral_algebraic/algebraic_inv/integral_algebraic. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_inv
| |
integral_divx y :
integralOver FtoE x -> integralOver FtoE y -> integralOver FtoE (x / y).
Proof. by move=> algFx /integral_inv; apply: integral_mul. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_div
| |
integral_rootp u :
p != 0 -> root p u -> {in p : seq E, integralRange FtoE} ->
integralOver FtoE u.
Proof.
move=> nz_p pu0 algFp.
have mon_p1: mk_mon p \is monic.
by rewrite monicE lead_coefZ mulVf ?lead_coef_eq0.
have p1u0: root (mk_mon p) u by rewrite rootE hornerZ (rootP pu0) mulr0.
apply: integral_root_monic mon_p1 p1u0 _ => _ /(nthP 0)[i ltip <-].
rewrite coefZ mulrC; rewrite size_scale ?invr_eq0 ?lead_coef_eq0 // in ltip.
by apply: integral_div; apply/algFp/mem_nth; rewrite -?polySpred.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
integral_root
| |
eval_mx(e : seq F) := @map_mx term F (eval e).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_mx
| |
mx_term:= @map_mx F term GRing.Const.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mx_term
| |
eval_mx_terme m n (A : 'M_(m, n)) : eval_mx e (mx_term A) = A.
Proof. by apply/matrixP=> i j; rewrite !mxE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_mx_term
| |
mulmx_termm n p (A : 'M[term]_(m, n)) (B : 'M_(n, p)) :=
\matrix_(i, k) (\big[Add/0]_j (A i j * B j k))%T.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mulmx_term
| |
eval_mulmxe m n p (A : 'M[term]_(m, n)) (B : 'M_(n, p)) :
eval_mx e (mulmx_term A B) = eval_mx e A *m eval_mx e B.
Proof.
apply/matrixP=> i k; rewrite !mxE /= ((big_morph (eval e)) 0 +%R) //=.
by apply: eq_bigr => j _; rewrite /= !mxE.
Qed.
Local Notation morphAnd f := ((big_morph f) true andb).
Let Schur m n (A : 'M[term]_(1 + m, 1 + n)) (a := A 0 0) :=
\matrix_(i, j) (drsubmx A i j - a^-1 * dlsubmx A i 0%R * ursubmx A 0%R j)%T.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_mulmx
| |
mxrank_form(r m n : nat) : 'M_(m, n) -> form :=
match m, n return 'M_(m, n) -> form with
| m'.+1, n'.+1 => fun A : 'M_(1 + m', 1 + n') =>
let nzA k := A k.1 k.2 != 0 in
let xSchur k := Schur (xrow k.1 0%R (xcol k.2 0%R A)) in
let recf k := Bool (r > 0) /\ mxrank_form r.-1 (xSchur k) in
GRing.Pick nzA recf (Bool (r == 0%N))
| _, _ => fun _ => Bool (r == 0%N)
end%T.
|
Fixpoint
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxrank_form
| |
mxrank_form_qfr m n (A : 'M_(m, n)) : qf_form (mxrank_form r A).
Proof.
by elim: m r n A => [|m IHm] r [|n] A //=; rewrite GRing.Pick_form_qf /=.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
mxrank_form_qf
| |
eval_mxranke r m n (A : 'M_(m, n)) :
qf_eval e (mxrank_form r A) = (\rank (eval_mx e A) == r).
Proof.
elim: m r n A => [|m IHm] r [|n] A /=; try by case r; rewrite unlock.
rewrite GRing.eval_Pick !unlock /=; set pf := fun _ => _.
rewrite -(@eq_pick _ pf) => [|k]; rewrite {}/pf ?mxE // eq_sym.
case: pick => [[i j]|] //=; set B := _ - _; have:= mxrankE B.
case: (Gaussian_elimination_ B) r => [[_ _] _] [|r] //= <-; rewrite {}IHm eqSS.
by congr (\rank _ == r); apply/matrixP=> k l; rewrite !(mxE, big_ord1) !tpermR.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_mxrank
| |
eval_vec_mxe m n (u : 'rV_(m * n)) :
eval_mx e (vec_mx u) = vec_mx (eval_mx e u).
Proof. by apply/matrixP=> i j; rewrite !mxE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_vec_mx
| |
eval_mxvece m n (A : 'M_(m, n)) :
eval_mx e (mxvec A) = mxvec (eval_mx e A).
Proof. by rewrite -{2}[A]mxvecK eval_vec_mx vec_mxK. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_mxvec
| |
submx_form:=
\big[And/True]_(r < n.+1) (mxrank_form r (col_mx A B) ==> mxrank_form r B)%T.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
submx_form
| |
eval_col_mxe :
eval_mx e (col_mx A B) = col_mx (eval_mx e A) (eval_mx e B).
Proof. by apply/matrixP=> i j; do 2![rewrite !mxE //; case: split => ?]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_col_mx
| |
submx_form_qf: qf_form submx_form.
Proof.
by rewrite (morphAnd (@qf_form _)) ?big1 //= => r _; rewrite !mxrank_form_qf.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
submx_form_qf
| |
eval_submxe : qf_eval e submx_form = (eval_mx e A <= eval_mx e B)%MS.
Proof.
rewrite (morphAnd (qf_eval e)) //= big_andE /=.
apply/forallP/idP=> /= [|sAB d]; last first.
rewrite !eval_mxrank eval_col_mx -addsmxE; apply/implyP=> /eqP <-.
by rewrite mxrank_leqif_sup ?addsmxSr // addsmx_sub sAB /=.
move/(_ (inord (\rank (eval_mx e (col_mx A B))))).
rewrite inordK ?ltnS ?rank_leq_col // !eval_mxrank eqxx /= eval_col_mx.
by rewrite -addsmxE mxrank_leqif_sup ?addsmxSr // addsmx_sub; case/andP.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_submx
| |
seq_of_rV(v : 'rV_d) : seq F := fgraph [ffun i => v 0 i].
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
seq_of_rV
| |
size_seq_of_rVv : size (seq_of_rV v) = d.
Proof. by rewrite tuple.size_tuple card_ord. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
size_seq_of_rV
| |
nth_seq_of_rVx0 v (i : 'I_d) : nth x0 (seq_of_rV v) i = v 0 i.
Proof. by rewrite nth_fgraph_ord ffunE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
nth_seq_of_rV
| |
row_vark : 'rV[term]_d := \row_i ('X_(k * d + i))%T.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
row_var
| |
row_env(e : seq 'rV_d) := flatten (map seq_of_rV e).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
row_env
| |
nth_row_enve k (i : 'I_d) : (row_env e)`_(k * d + i) = e`_k 0 i.
Proof.
elim: e k => [|v e IHe] k; first by rewrite !nth_nil mxE.
rewrite /row_env /= nth_cat size_seq_of_rV.
case: k => [|k]; first by rewrite (valP i) nth_seq_of_rV.
by rewrite mulSn -addnA -if_neg -leqNgt leq_addr addKn IHe.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
nth_row_env
| |
eval_row_vare k : eval_mx (row_env e) (row_var k) = e`_k :> 'rV_d.
Proof. by apply/rowP=> i; rewrite !mxE /= nth_row_env. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
eval_row_var
| |
Exists_row_formk (f : form) :=
foldr GRing.Exists f (codom (fun i : 'I_d => k * d + i)%N).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
Exists_row_form
| |
Exists_rowPe k f :
d > 0 ->
((exists v : 'rV[F]_d, holds (row_env (set_nth 0 e k v)) f)
<-> holds (row_env e) (Exists_row_form k f)).
Proof.
move=> d_gt0; pose i_ j := Ordinal (ltn_pmod j d_gt0).
have d_eq j: (j = j %/ d * d + i_ j)%N := divn_eq j d.
split=> [[v f_v] | ]; last case/GRing.foldExistsP=> e' ee' f_e'.
apply/GRing.foldExistsP; exists (row_env (set_nth 0 e k v)) => {f f_v}// j.
rewrite [j]d_eq !nth_row_env nth_set_nth /=; case: eqP => // ->.
by case/imageP; exists (i_ j).
exists (\row_i e'`_(k * d + i)); apply: eq_holds f_e' => j /=.
move/(_ j): ee'; rewrite [j]d_eq !nth_row_env nth_set_nth /=.
case: eqP => [-> | ne_j_k -> //]; first by rewrite mxE.
apply/mapP=> [[r lt_r_d]]; rewrite -d_eq => def_j; case: ne_j_k.
by rewrite def_j divnMDl // divn_small ?addn0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
Exists_rowP
| |
conjmx(m n : nat)
(V : 'M_(m, n)) (f : 'M[F]_n) : 'M_m := V *m f *m pinvmx V.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjmx
| |
restrictmxV := (conjmx (row_base V)).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
restrictmx
| |
stablemx_comp(m n p : nat) (V : 'M[F]_(m, n)) (W : 'M_(n, p)) (f : 'M_p) :
stablemx W f -> stablemx V (conjmx W f) -> stablemx (V *m W) f.
Proof. by move=> Wf /(submxMr W); rewrite -mulmxA mulmxKpV// mulmxA. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
stablemx_comp
| |
stablemx_restrictm n (A : 'M[F]_n) (V : 'M_n) (W : 'M_(m, \rank V)):
stablemx V A -> stablemx W (restrictmx V A) = stablemx (W *m row_base V) A.
Proof.
move=> A_stabV; rewrite mulmxA -[in RHS]mulmxA.
rewrite -(submxMfree _ W (row_base_free V)) mulmxKpV //.
by rewrite mulmx_sub ?stablemx_row_base.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
stablemx_restrict
| |
conjmxM(m n : nat) (V : 'M[F]_(m, n)) :
{in [pred f | stablemx V f] &, {morph conjmx V : f g / f *m g}}.
Proof.
move=> f g; rewrite !inE => Vf Vg /=.
by rewrite /conjmx 2!mulmxA mulmxA mulmxKpV ?stablemx_row_base.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjmxM
| |
conjMmx(m n p : nat) (V : 'M[F]_(m, n)) (W : 'M_(n, p)) (f : 'M_p) :
row_free (V *m W) -> stablemx W f -> stablemx V (conjmx W f) ->
conjmx (V *m W) f = conjmx V (conjmx W f).
Proof.
move=> rfVW Wf VWf; apply: (row_free_inj rfVW); rewrite mulmxKpV ?stablemx_comp//.
by rewrite mulmxA mulmxKpV// -[RHS]mulmxA mulmxKpV ?mulmxA.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjMmx
| |
conjuMmx(m n : nat) (V : 'M[F]_m) (W : 'M_(m, n)) (f : 'M_n) :
V \in unitmx -> row_free W -> stablemx W f ->
conjmx (V *m W) f = conjmx V (conjmx W f).
Proof.
move=> Vu rfW Wf; rewrite conjMmx ?stablemx_unit//.
by rewrite /row_free mxrankMfree// -/(row_free V) row_free_unit.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjuMmx
| |
conjMumx(m n : nat) (V : 'M[F]_(m, n)) (W f : 'M_n) :
W \in unitmx -> row_free V -> stablemx V (conjmx W f) ->
conjmx (V *m W) f = conjmx V (conjmx W f).
Proof.
move=> Wu rfW Wf; rewrite conjMmx ?stablemx_unit//.
by rewrite /row_free mxrankMfree ?row_free_unit.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjMumx
| |
conjuMumx(n : nat) (V W f : 'M[F]_n) :
V \in unitmx -> W \in unitmx ->
conjmx (V *m W) f = conjmx V (conjmx W f).
Proof. by move=> Vu Wu; rewrite conjuMmx ?stablemx_unit ?row_free_unit. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjuMumx
| |
conjmx_scalar(m n : nat) (V : 'M[F]_(m, n)) (a : F) :
row_free V -> conjmx V a%:M = a%:M.
Proof. by move=> rfV; rewrite /conjmx scalar_mxC mulmxKp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conjmx_scalar
| |
conj0mx(m n : nat) f : conjmx (0 : 'M[F]_(m, n)) f = 0.
Proof. by rewrite /conjmx !mul0mx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import div fintype tuple finfun bigop fingroup perm",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv"
] |
algebra/mxpoly.v
|
conj0mx
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.