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 |
|---|---|---|---|---|---|---|
conjmx0(m n : nat) (V : 'M[F]_(m, n)) : conjmx V 0 = 0.
Proof. by rewrite /conjmx mulmx0 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
|
conjmx0
| |
conjumx(n : nat) (V : 'M_n) (f : 'M[F]_n) : V \in unitmx ->
conjmx V f = V *m f *m invmx V.
Proof. by move=> uV; rewrite /conjmx pinvmxE. 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
|
conjumx
| |
conj1mx(n : nat) (f : 'M[F]_n) : conjmx 1%:M f = f.
Proof. by rewrite conjumx ?unitmx1// invmx1 mulmx1 mul1mx. 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
|
conj1mx
| |
conjVmx(n : nat) (V : 'M_n) (f : 'M[F]_n) : V \in unitmx ->
conjmx (invmx V) f = invmx V *m f *m V.
Proof. by move=> Vunit; rewrite conjumx ?invmxK ?unitmx_inv. 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
|
conjVmx
| |
conjmxK(n : nat) (V f : 'M[F]_n) :
V \in unitmx -> conjmx (invmx V) (conjmx V f) = f.
Proof. by move=> Vu; rewrite -conjuMumx ?unitmx_inv// mulVmx ?conj1mx. 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
|
conjmxK
| |
conjmxVK(n : nat) (V f : 'M[F]_n) :
V \in unitmx -> conjmx V (conjmx (invmx V) f) = f.
Proof. by move=> Vu; rewrite -conjuMumx ?unitmx_inv// mulmxV ?conj1mx. 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
|
conjmxVK
| |
horner_mx_conjm n p (V : 'M[F]_(n.+1, m.+1)) (f : 'M_m.+1) :
row_free V -> stablemx V f ->
horner_mx (conjmx V f) p = conjmx V (horner_mx f p).
Proof.
move=> V_free V_stab; rewrite/conjmx; elim/poly_ind: p => [|p c].
by rewrite !rmorph0 mulmx0 mul0mx.
rewrite !(rmorphD, rmorphM)/= !(horner_mx_X, horner_mx_C) => ->.
rewrite [_ * _]mulmxA [_ *m (V *m _)]mulmxA mulmxKpV ?horner_mx_stable//.
apply: (row_free_inj V_free); rewrite [_ *m V]mulmxDl.
pose stablemxE := (stablemxD, stablemxM, stablemxC, horner_mx_stable).
by rewrite !mulmxKpV -?[V *m _ *m _]mulmxA ?stablemxE// mulmxDr -scalar_mxC.
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
|
horner_mx_conj
| |
horner_mx_uconjn p (V : 'M[F]_(n.+1)) (f : 'M_n.+1) :
V \is a GRing.unit ->
horner_mx (V *m f *m invmx V) p = V *m horner_mx f p *m invmx V.
Proof.
move=> V_unit; rewrite -!conjumx//.
by rewrite horner_mx_conj ?row_free_unit ?stablemx_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
|
horner_mx_uconj
| |
horner_mx_uconjCn p (V : 'M[F]_(n.+1)) (f : 'M_n.+1) :
V \is a GRing.unit ->
horner_mx (invmx V *m f *m V) p = invmx V *m horner_mx f p *m V.
Proof.
move=> V_unit; rewrite -[X in _ *m X](invmxK V).
by rewrite horner_mx_uconj ?invmxK ?unitmx_inv.
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
|
horner_mx_uconjC
| |
mxminpoly_conjm n (V : 'M[F]_(m.+1, n.+1)) (f : 'M_n.+1) :
row_free V -> stablemx V f -> mxminpoly (conjmx V f) %| mxminpoly f.
Proof.
by move=> *; rewrite mxminpoly_min// horner_mx_conj// mx_root_minpoly conjmx0.
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_conj
| |
mxminpoly_uconjn (V : 'M[F]_(n.+1)) (f : 'M_n.+1) :
V \in unitmx -> mxminpoly (conjmx V f) = mxminpoly f.
Proof.
have simp := (row_free_unit, stablemx_unit, unitmx_inv, unitmx1).
move=> Vu; apply/eqP; rewrite -eqp_monic ?mxminpoly_monic// /eqp.
apply/andP; split; first by rewrite mxminpoly_conj ?simp.
by rewrite -[f in X in X %| _](conjmxK _ Vu) mxminpoly_conj ?simp.
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_uconj
| |
sub_kermxpoly_conjmxV f p W : stablemx V f -> row_free V ->
(W <= kermxpoly (conjmx V f) p)%MS = (W *m V <= kermxpoly f p)%MS.
Proof.
case: n m => [|n'] [|m'] in V f W * => fV rfV; rewrite ?thinmx0//.
by rewrite /row_free mxrank.unlock in rfV.
by rewrite mul0mx !sub0mx.
apply/sub_kermxP/sub_kermxP; rewrite horner_mx_conj//; last first.
by move=> /(congr1 (mulmxr (pinvmx V)))/=; rewrite mul0mx !mulmxA.
move=> /(congr1 (mulmxr V))/=; rewrite ![W *m _]mulmxA ?mul0mx mulmxKpV//.
by rewrite -mulmxA mulmx_sub// horner_mx_stable//.
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
|
sub_kermxpoly_conjmx
| |
sub_eigenspace_conjmxV f a W : stablemx V f -> row_free V ->
(W <= eigenspace (conjmx V f) a)%MS = (W *m V <= eigenspace f a)%MS.
Proof. by move=> fV rfV; rewrite !eigenspace_poly sub_kermxpoly_conjmx. 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
|
sub_eigenspace_conjmx
| |
eigenpoly_conjmxV f : stablemx V f -> row_free V ->
{subset eigenpoly (conjmx V f) <= eigenpoly f}.
Proof.
move=> fV rfV a /eigenpolyP [x]; rewrite sub_kermxpoly_conjmx//.
move=> xV_le_fa x_neq0; apply/eigenpolyP.
by exists (x *m V); rewrite ?mulmx_free_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_conjmx
| |
eigenvalue_conjmxV f : stablemx V f -> row_free V ->
{subset eigenvalue (conjmx V f) <= eigenvalue f}.
Proof.
by move=> fV rfV a; rewrite ![_ \in _]eigenvalue_poly; apply: eigenpoly_conjmx.
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_conjmx
| |
conjmx_eigenvaluea V f : (V <= eigenspace f a)%MS -> row_free V ->
conjmx V f = a%:M.
Proof.
by move=> /eigenspaceP Vfa rfV; rewrite /conjmx Vfa -mul_scalar_mx 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_eigenvalue
| |
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
| |
simmx_to_for{F : fieldType} {m n}
(P : 'M_(m, n)) A (S : {pred 'M[F]_m}) := S (conjmx P A).
|
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
|
simmx_to_for
| |
simmx_forP A B := (A ~_P {in PredOfSimpl.coerce (pred1 B)}).
|
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
|
simmx_for
| |
simmx_inS A B := (exists2 P, P \in S & A ~_P B).
|
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
|
simmx_in
| |
simmx_in_toS A S' := (exists2 P, P \in S & A ~_P {in S'}).
|
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
|
simmx_in_to
| |
all_simmx_inS As S' :=
(exists2 P, P \in S & all [pred A | A ~_P {in S'}] As).
|
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
|
all_simmx_in
| |
diagonalizable_forP A := (A ~_P {in is_diag_mx}).
|
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
|
diagonalizable_for
| |
diagonalizable_inS A := (A ~_{in S} {in is_diag_mx}).
|
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
|
diagonalizable_in
| |
diagonalizableA := (diagonalizable_in unitmx A).
|
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
|
diagonalizable
| |
codiagonalizable_inS As := (all_simmx_in S As is_diag_mx).
|
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
|
codiagonalizable_in
| |
codiagonalizableAs := (codiagonalizable_in unitmx As).
|
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
|
codiagonalizable
| |
simmxPpm n {P : 'M[F]_(m, n)} {A B} :
stablemx P A -> A ~_P B -> P *m A = B *m P.
Proof. by move=> stablemxPA /eqP <-; rewrite mulmxKpV. 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
|
simmxPp
| |
simmxWm n {P : 'M[F]_(m, n)} {A B} : row_free P ->
P *m A = B *m P -> A ~_P B.
Proof. by rewrite /(_ ~__ _)/= /conjmx => fP ->; rewrite 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
|
simmxW
| |
simmxP{P A B} : P \in unitmx ->
reflect (P *m A = B *m P) (A ~_P B).
Proof.
move=> p_unit; apply: (iffP idP); first exact/simmxPp/stablemx_unit.
by apply: simmxW; rewrite 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
|
simmxP
| |
simmxRL{P A B} : P \in unitmx ->
reflect (B = P *m A *m invmx P) (A ~_P B).
Proof. by move=> ?; apply: (iffP eqP); rewrite conjumx. 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
|
simmxRL
| |
simmxLR{P A B} : P \in unitmx ->
reflect (A = conjmx (invmx P) B) (A ~_P B).
Proof.
by move=> Pu; rewrite conjVmx//; apply: (iffP (simmxRL Pu)) => ->;
rewrite !mulmxA ?(mulmxK, mulmxKV, mulVmx, mulmxV, mul1mx, mulmx1).
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
|
simmxLR
| |
simmx_minpoly{n} {P A B : 'M[F]_n.+1} : P \in unitmx ->
A ~_P B -> mxminpoly A = mxminpoly B.
Proof. by move=> Pu /eqP<-; rewrite mxminpoly_uconj. 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
|
simmx_minpoly
| |
diagonalizable_for_row_basem n (P : 'M[F]_(m, n)) (A : 'M_n) :
diagonalizable_for (row_base P) A = is_diag_mx (restrictmx P A).
Proof. by []. 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
|
diagonalizable_for_row_base
| |
diagonalizable_forPpm n (P : 'M[F]_(m, n)) A :
reflect (forall i j : 'I__, i != j :> nat -> conjmx P A i j = 0)
(diagonalizable_for P A).
Proof. exact: @is_diag_mxP. 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
|
diagonalizable_forPp
| |
diagonalizable_forPn (P : 'M[F]_n) A : P \in unitmx ->
reflect (forall i j : 'I__, i != j :> nat -> (P *m A *m invmx P) i j = 0)
(diagonalizable_for P A).
Proof. by move=> Pu; rewrite -conjumx//; exact: is_diag_mxP. 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
|
diagonalizable_forP
| |
diagonalizable_forPex{m} {n} {P : 'M[F]_(m, n)} {A} :
reflect (exists D, A ~_P (diag_mx D)) (diagonalizable_for P A).
Proof. by apply: (iffP (diag_mxP _)) => -[D]/eqP; exists D. 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
|
diagonalizable_forPex
| |
diagonalizable_forLRn {P : 'M[F]_n} {A} : P \in unitmx ->
reflect (exists D, A = conjmx (invmx P) (diag_mx D)) (diagonalizable_for P A).
Proof.
by move=> Punit; apply: (iffP diagonalizable_forPex) => -[D /(simmxLR Punit)]; exists D.
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
|
diagonalizable_forLR
| |
diagonalizable_for_mxminpoly{n} {P A : 'M[F]_n.+1}
(rs := undup [seq conjmx P A i i | i <- enum 'I_n.+1]) :
P \in unitmx -> diagonalizable_for P A ->
mxminpoly A = \prod_(r <- rs) ('X - r%:P).
Proof.
rewrite /rs => pu /(diagonalizable_forLR pu)[d {A rs}->].
rewrite mxminpoly_uconj ?unitmx_inv// mxminpoly_diag.
by rewrite [in X in _ = X](@eq_map _ _ _ (d 0))// => i; rewrite conjmxVK// mxE eqxx.
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
|
diagonalizable_for_mxminpoly
| |
diagonalizable_for_sum(F : fieldType) (m n : nat) (p_ : 'I_n -> nat)
(V_ : forall i, 'M[F]_(p_ i, m)) (A : 'M[F]_m) :
mxdirect (\sum_i <<V_ i>>) ->
(forall i, stablemx (V_ i) A) ->
(forall i, row_free (V_ i)) ->
diagonalizable_for (\mxcol_i V_ i) A = [forall i, diagonalizable_for (V_ i) A].
Proof.
move=> Vd VA rAV; have aVA : stablemx (\mxcol_i V_ i) A.
rewrite (eqmx_stable _ (eqmx_col _)) stablemx_sums//.
by move=> i; rewrite (eqmx_stable _ (genmxE _)).
apply/diagonalizable_forPex/'forall_diagonalizable_forPex => /=
[[D /(simmxPp aVA) +] i|/(_ _)/sigW DoA].
rewrite mxcol_mul -[D]submxrowK diag_mxrow mul_mxdiag_mxcol.
move=> /eq_mxcolP/(_ i); set D0 := (submxrow _ _) => VMeq.
by exists D0; apply/simmxW.
exists (\mxrow_i tag (DoA i)); apply/simmxW.
rewrite -row_leq_rank eqmx_col (mxdirectP Vd)/=.
by under [leqRHS]eq_bigr do rewrite genmxE (eqP (rAV _)).
rewrite mxcol_mul diag_mxrow mul_mxdiag_mxcol; apply: eq_mxcol => i.
by case: DoA => /= k /(simmxPp); rewrite VA => /(_ isT) ->.
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
|
diagonalizable_for_sum
| |
codiagonalizable1n (A : 'M[F]_n) :
codiagonalizable [:: A] <-> diagonalizable A.
Proof. by split=> -[P Punit PA]; exists P; move: PA; rewrite //= andbT. 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
|
codiagonalizable1
| |
codiagonalizablePfulln (As : seq 'M[F]_n) :
codiagonalizable As
<-> exists m, exists2 P : 'M_(m, n), row_full P &
all [pred A | diagonalizable_for P A] As.
Proof.
split => [[P Punit SPA]|[m [P Pfull SPA]]].
by exists n => //; exists P; rewrite ?row_full_unit.
have Qfull := fullrowsub_unit Pfull.
exists (rowsub (fullrankfun Pfull) P) => //; apply/allP => A AAs/=.
have /allP /(_ _ AAs)/= /diagonalizable_forPex[d /simmxPp] := SPA.
rewrite submx_full// => /(_ isT) PA_eq.
apply/diagonalizable_forPex; exists (colsub (fullrankfun Pfull) d).
apply/simmxP => //; apply/row_matrixP => i.
rewrite !row_mul row_diag_mx -scalemxAl -rowE !row_rowsub !mxE.
have /(congr1 (row (fullrankfun Pfull i))) := PA_eq.
by rewrite !row_mul row_diag_mx -scalemxAl -rowE => ->.
Qed.
|
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
|
codiagonalizablePfull
| |
codiagonalizable_onm n (V_ : 'I_n -> 'M[F]_m) (As : seq 'M[F]_m) :
(\sum_i V_ i :=: 1%:M)%MS -> mxdirect (\sum_i V_ i) ->
(forall i, all (fun A => stablemx (V_ i) A) As) ->
(forall i, codiagonalizable (map (restrictmx (V_ i)) As)) ->
codiagonalizable As.
Proof.
move=> V1 Vdirect /(_ _)/allP AV /(_ _) /sig2W/= Pof.
pose P_ i := tag (Pof i).
have P_unit i : P_ i \in unitmx by rewrite /P_; case: {+}Pof.
have P_diag i A : A \in As -> diagonalizable_for (P_ i *m row_base (V_ i)) A.
move=> AAs; rewrite /P_; case: {+}Pof => /= P Punit.
rewrite all_map => /allP/(_ A AAs); rewrite /= !/(diagonalizable_for _ _).
by rewrite conjuMmx ?row_base_free ?stablemx_row_base ?AV.
pose P := \mxcol_i (P_ i *m row_base (V_ i)).
have P_full i : row_full (P_ i) by rewrite row_full_unit.
have PrV i : (P_ i *m row_base (V_ i) :=: V_ i)%MS.
exact/(eqmx_trans _ (eq_row_base _))/eqmxMfull.
apply/codiagonalizablePfull; eexists _; last exists P; rewrite /=.
- rewrite -sub1mx eqmx_col.
by under eq_bigr do rewrite (eq_genmx (PrV _)); rewrite -genmx_sums genmxE V1.
apply/allP => A AAs /=; rewrite diagonalizable_for_sum.
- by apply/forallP => i; apply: P_diag.
- rewrite mxdirectE/=.
under eq_bigr do rewrite (eq_genmx (PrV _)); rewrite -genmx_sums genmxE V1.
by under eq_bigr do rewrite genmxE PrV; rewrite -(mxdirectP Vdirect)//= V1.
- by move=> i; rewrite (eqmx_stable _ (PrV _)) ?AV.
- by move=> i; rewrite /row_free eqmxMfull ?eq_row_base ?row_full_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
|
codiagonalizable_on
| |
diagonalizable_diag{n} (d : 'rV[F]_n) : diagonalizable (diag_mx d).
Proof.
exists 1%:M; rewrite ?unitmx1// /(diagonalizable_for _ _).
by rewrite conj1mx diag_mx_is_diag.
Qed.
Hint Resolve diagonalizable_diag : core.
|
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
|
diagonalizable_diag
| |
diagonalizable_scalar{n} (a : F) : diagonalizable (a%:M : 'M_n).
Proof. by rewrite -diag_const_mx. Qed.
Hint Resolve diagonalizable_scalar : core.
|
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
|
diagonalizable_scalar
| |
diagonalizable0{n} : diagonalizable (0 : 'M[F]_n).
Proof.
by rewrite (_ : 0 = 0%:M)//; apply/matrixP => i j; rewrite !mxE// mul0rn.
Qed.
Hint Resolve diagonalizable0 : core.
|
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
|
diagonalizable0
| |
diagonalizablePeigen{n} {A : 'M[F]_n} :
diagonalizable A <->
exists2 rs, uniq rs & (\sum_(r <- rs) eigenspace A r :=: 1%:M)%MS.
Proof.
split=> [df|[rs urs rsP]].
suff [rs rsP] : exists rs, (\sum_(r <- rs) eigenspace A r :=: 1%:M)%MS.
exists (undup rs); rewrite ?undup_uniq//; apply: eqmx_trans rsP.
elim: rs => //= r rs IHrs; rewrite big_cons.
case: ifPn => in_rs; rewrite ?big_cons; last exact: adds_eqmx.
apply/(eqmx_trans IHrs)/eqmx_sym/addsmx_idPr.
have rrs : (index r rs < size rs)%N by rewrite index_mem.
rewrite (big_nth 0) big_mkord (sumsmx_sup (Ordinal rrs)) ?nth_index//.
move: df => [P Punit /(diagonalizable_forLR Punit)[d ->]].
exists [seq d 0 i | i <- enum 'I_n]; rewrite big_image/=.
apply: (@eqmx_trans _ _ _ _ _ _ P); apply/eqmxP;
rewrite ?sub1mx ?submx1 ?row_full_unit//.
rewrite submx_full ?row_full_unit//=.
apply/row_subP => i; rewrite rowE (sumsmx_sup i)//.
apply/eigenspaceP; rewrite conjVmx// !mulmxA mulmxK//.
by rewrite -rowE row_diag_mx scalemxAl.
have mxdirect_eigenspaces : mxdirect (\sum_(i < size rs) eigenspace A rs`_i).
apply: mxdirect_sum_eigenspace => i j _ _ rsij; apply/val_inj.
by apply: uniqP rsij; rewrite ?inE.
rewrite (big_nth 0) big_mkord in rsP; apply/codiagonalizable1.
apply/(codiagonalizable_on _ mxdirect_eigenspaces) => // i/=.
case: n => [|n] in A {mxdirect_eigenspaces} rsP *.
by rewrite thinmx0 sub0mx.
by rewrite comm_mx_stable_eigenspace.
apply/codiagonalizable1.
rewrite (@conjmx_eigenvalue _ _ _ rs`_i);
...
|
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
|
diagonalizablePeigen
| |
diagonalizablePn' (n := n'.+1) (A : 'M[F]_n) :
diagonalizable A <->
exists2 rs, uniq rs & mxminpoly A %| \prod_(x <- rs) ('X - x%:P).
Proof.
split=> [[P Punit /diagonalizable_forPex[d /(simmxLR Punit)->]]|].
rewrite mxminpoly_uconj ?unitmx_inv// mxminpoly_diag.
by eexists; [|by []]; rewrite undup_uniq.
move=> + /ltac:(apply/diagonalizablePeigen) => -[rs rsu rsP]; exists rs => //.
rewrite (big_nth 0) [X in (X :=: _)%MS](big_nth 0) !big_mkord in rsP *.
rewrite (eq_bigr _ (fun _ _ => eigenspace_poly _ _)).
apply: (eqmx_trans (eqmx_sym (kermxpoly_prod _ _)) (kermxpoly_min _)) => //.
by move=> i j _ _; rewrite coprimep_XsubC root_XsubC nth_uniq.
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
|
diagonalizableP
| |
diagonalizable_conj_diagm n (V : 'M[F]_(m, n)) (d : 'rV[F]_n) :
stablemx V (diag_mx d) -> row_free V -> diagonalizable (conjmx V (diag_mx d)).
Proof.
case: m n => [|m] [|n] in V d * => Vd rdV; rewrite ?thinmx0.
- by [].
- by [].
- by exfalso; move: rdV; rewrite /row_free mxrank.unlock eqxx orbT.
apply/diagonalizableP; pose u := undup [seq d 0 i | i <- enum 'I_n.+1].
exists u; first by rewrite undup_uniq.
by rewrite (dvdp_trans (mxminpoly_conj (f:=diag_mx d) _ _))// mxminpoly_diag.
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
|
diagonalizable_conj_diag
| |
codiagonalizablePn (As : seq 'M[F]_n) :
{in As &, forall A B, comm_mx A B} /\ {in As, forall A, diagonalizable A}
<-> codiagonalizable As.
Proof.
split => [cdAs|[P Punit /allP/= AsD]]/=; last first.
split; last by exists P; rewrite // AsD.
move=> A B AAs BAs; move=> /(_ _ _)/diagonalizable_forPex/sigW in AsD.
have [[dA /simmxLR->//] [dB /simmxLR->//]] := (AsD _ AAs, AsD _ BAs).
by rewrite /comm_mx -!conjmxM 1?diag_mxC// inE stablemx_unit ?unitmx_inv.
move: cdAs => -[]; move/(rwP (all_comm_mxP _)) => cdAs cdAs'.
have [k] := ubnP (size As); elim: k => [|k IHk]//= in n As cdAs cdAs' *.
case: As cdAs cdAs' => [|A As]//=; first by exists 1%:M; rewrite ?unitmx1.
rewrite ltnS all_comm_mx_cons => /andP[/allP/(_ _ _)/eqP AAsC AsC dAAs] Ask.
have /diagonalizablePeigen [rs urs rs1] := dAAs _ (mem_head _ _).
rewrite (big_nth 0) big_mkord in rs1.
have eAB (i : 'I_(size rs)) B : B \in A :: As -> stablemx (eigenspace A rs`_i) B.
case: n => [|n'] in B A As AAsC AsC {dAAs rs1 Ask} * => B_AAs.
by rewrite thinmx0 sub0mx.
rewrite comm_mx_stable_eigenspace//.
by move: B_AAs; rewrite !inE => /predU1P [->//|/AAsC].
apply/(@codiagonalizable_on _ _ _ (_ :: _) rs1) => [|i|i /=].
- apply: mxdirect_sum_eigenspace => i j _ _ rsij; apply/val_inj.
by apply: uniqP rsij; rewrite ?inE.
- by apply/allP => B B_AAs; rewrite eAB.
rewrite (@conjmx_eigenvalue _ _ _ rs`_i) ?eq_row_base ?row_base_free//.
set Bs := map _ _; suff [P Punit /= PBs] : codiagonalizable Bs.
exists P; rewrite /= ?PBs ?andbT// /(d
...
|
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
|
codiagonalizableP
| |
conjmx(m n : nat)
(V : 'M_(m, n)) (f : 'M[F]_n) : 'M_m := V *m f *m pinvmx V.
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjmx
| |
restrictmxV := (conjmx (row_base V)).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.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 mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conj0mx
| |
conjmx0(m n : nat) (V : 'M[F]_(m, n)) : conjmx V 0 = 0.
Proof. by rewrite /conjmx mulmx0 mul0mx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjmx0
| |
conjumx(n : nat) (V : 'M_n) (f : 'M[F]_n) : V \in unitmx ->
conjmx V f = V *m f *m invmx V.
Proof. by move=> uV; rewrite /conjmx pinvmxE. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjumx
| |
conj1mx(n : nat) (f : 'M[F]_n) : conjmx 1%:M f = f.
Proof. by rewrite conjumx ?unitmx1// invmx1 mulmx1 mul1mx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conj1mx
| |
conjVmx(n : nat) (V : 'M_n) (f : 'M[F]_n) : V \in unitmx ->
conjmx (invmx V) f = invmx V *m f *m V.
Proof. by move=> Vunit; rewrite conjumx ?invmxK ?unitmx_inv. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjVmx
| |
conjmxK(n : nat) (V f : 'M[F]_n) :
V \in unitmx -> conjmx (invmx V) (conjmx V f) = f.
Proof. by move=> Vu; rewrite -conjuMumx ?unitmx_inv// mulVmx ?conj1mx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjmxK
| |
conjmxVK(n : nat) (V f : 'M[F]_n) :
V \in unitmx -> conjmx V (conjmx (invmx V) f) = f.
Proof. by move=> Vu; rewrite -conjuMumx ?unitmx_inv// mulmxV ?conj1mx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjmxVK
| |
horner_mx_conjm n p (B : 'M[F]_(n.+1, m.+1)) (f : 'M_m.+1) :
row_free B -> stablemx B f ->
horner_mx (conjmx B f) p = conjmx B (horner_mx f p).
Proof.
move=> B_free B_stab; rewrite/conjmx; elim/poly_ind: p => [|p c].
by rewrite !rmorph0 mulmx0 mul0mx.
rewrite !(rmorphD, rmorphM)/= !(horner_mx_X, horner_mx_C) => ->.
rewrite [_ * _]mulmxA [_ *m (B *m _)]mulmxA mulmxKpV ?horner_mx_stable//.
apply: (row_free_inj B_free); rewrite [_ *m B]mulmxDl.
pose stablemxE := (stablemxD, stablemxM, stablemxC, horner_mx_stable).
by rewrite !mulmxKpV -?[B *m _ *m _]mulmxA ?stablemxE// mulmxDr -scalar_mxC.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
horner_mx_conj
| |
horner_mx_uconjn p (B : 'M[F]_(n.+1)) (f : 'M_n.+1) :
B \is a GRing.unit ->
horner_mx (B *m f *m invmx B) p = B *m horner_mx f p *m invmx B.
Proof.
move=> B_unit; rewrite -!conjumx//.
by rewrite horner_mx_conj ?row_free_unit ?stablemx_unit.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
horner_mx_uconj
| |
horner_mx_uconjCn p (B : 'M[F]_(n.+1)) (f : 'M_n.+1) :
B \is a GRing.unit ->
horner_mx (invmx B *m f *m B) p = invmx B *m horner_mx f p *m B.
Proof.
move=> B_unit; rewrite -[X in _ *m X](invmxK B).
by rewrite horner_mx_uconj ?invmxK ?unitmx_inv.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
horner_mx_uconjC
| |
mxminpoly_conjm n (V : 'M[F]_(m.+1, n.+1)) (f : 'M_n.+1) :
row_free V -> stablemx V f -> mxminpoly (conjmx V f) %| mxminpoly f.
Proof.
by move=> *; rewrite mxminpoly_min// horner_mx_conj// mx_root_minpoly conjmx0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
mxminpoly_conj
| |
mxminpoly_uconjn (V : 'M[F]_(n.+1)) (f : 'M_n.+1) :
V \in unitmx -> mxminpoly (conjmx V f) = mxminpoly f.
Proof.
have simp := (row_free_unit, stablemx_unit, unitmx_inv, unitmx1).
move=> Vu; apply/eqP; rewrite -eqp_monic ?mxminpoly_monic// /eqp.
apply/andP; split; first by rewrite mxminpoly_conj ?simp.
by rewrite -[f in X in X %| _](conjmxK _ Vu) mxminpoly_conj ?simp.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
mxminpoly_uconj
| |
sub_kermxpoly_conjmxV f p W : stablemx V f -> row_free V ->
(W <= kermxpoly (conjmx V f) p)%MS = (W *m V <= kermxpoly f p)%MS.
Proof.
move: n m => [|n'] [|m']// in V f W *; rewrite ?thinmx0// => fV rfV.
- by rewrite /row_free mxrank0 in rfV.
- by rewrite mul0mx !sub0mx.
- apply/sub_kermxP/sub_kermxP; rewrite horner_mx_conj//; last first.
by move=> /(congr1 (mulmxr (pinvmx V)))/=; rewrite mul0mx !mulmxA.
move=> /(congr1 (mulmxr V))/=; rewrite ![W *m _]mulmxA ?mul0mx mulmxKpV//.
by rewrite -mulmxA mulmx_sub// horner_mx_stable//.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
sub_kermxpoly_conjmx
| |
sub_eigenspace_conjmxV f a W : stablemx V f -> row_free V ->
(W <= eigenspace (conjmx V f) a)%MS = (W *m V <= eigenspace f a)%MS.
Proof. by move=> fV rfV; rewrite !eigenspace_poly sub_kermxpoly_conjmx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
sub_eigenspace_conjmx
| |
eigenpoly_conjmxV f : stablemx V f -> row_free V ->
{subset eigenpoly (conjmx V f) <= eigenpoly f}.
Proof.
move=> fV rfV a /eigenpolyP [x]; rewrite sub_kermxpoly_conjmx//.
move=> xV_le_fa x_neq0; apply/eigenpolyP.
by exists (x *m V); rewrite ?mulmx_free_eq0.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
eigenpoly_conjmx
| |
eigenvalue_conjmxV f : stablemx V f -> row_free V ->
{subset eigenvalue (conjmx V f) <= eigenvalue f}.
Proof.
by move=> fV rfV a; rewrite ![_ \in _]eigenvalue_poly; apply: eigenpoly_conjmx.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
eigenvalue_conjmx
| |
conjmx_eigenvaluea V f : (V <= eigenspace f a)%MS -> row_free V ->
conjmx V f = a%:M.
Proof.
by move=> /eigenspaceP Vfa rfV; rewrite /conjmx Vfa -mul_scalar_mx mulmxKp.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
conjmx_eigenvalue
| |
restrictmxV := (conjmx (row_base V)).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
restrictmx
| |
similar_to{F : fieldType} {m n} (P : 'M_(m, n)) A
(C : {pred 'M[F]_m}) := C (conjmx P A).
|
Definition
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_to
| |
similarP A B := (similar_to P A (PredOfSimpl.coerce (pred1 B))).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar
| |
similar_inD A B := (exists2 P, P \in D & similar P A B).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_in
| |
similar_in_toD A C := (exists2 P, P \in D & similar_to P A C).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_in_to
| |
all_similar_toD As C := (exists2 P, P \in D & all [pred A | similar_to P A C] As).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
all_similar_to
| |
similar_diagP A := (similar_to P A is_diag_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_diag
| |
diagonalizable_inD A := (similar_in_to D A is_diag_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
diagonalizable_in
| |
diagonalizableA := (diagonalizable_in unitmx A).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
diagonalizable
| |
codiagonalizable_inD As := (all_similar_to D As is_diag_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
codiagonalizable_in
| |
codiagonalizableAs := (codiagonalizable_in unitmx As).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
codiagonalizable
| |
similar_trigP A := (similar_to P A is_trig_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_trig
| |
trigonalizable_inD A := (similar_in_to D A is_trig_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
trigonalizable_in
| |
trigonalizableA := (trigonalizable_in unitmx A).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
trigonalizable
| |
cotrigonalizable_inD As := (all_similar_to D As is_trig_mx).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
cotrigonalizable_in
| |
cotrigonalizableAs := (cotrigonalizable_in unitmx As).
|
Notation
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
cotrigonalizable
| |
similarPpm n {P : 'M[F]_(m, n)} {A B} :
stablemx P A -> similar P A B -> P *m A = B *m P.
Proof. by move=> stablemxPA /eqP <-; rewrite mulmxKpV. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similarPp
| |
similarWm n {P : 'M[F]_(m, n)} {A B} : row_free P ->
P *m A = B *m P -> similar P A B.
Proof. by rewrite /similar_to/= /conjmx => fP ->; rewrite mulmxKp. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similarW
| |
similarP{p f g} : p \in unitmx ->
reflect (p *m f = g *m p) (similar p f g).
Proof.
move=> p_unit; apply: (iffP idP); first exact/similarPp/stablemx_unit.
by apply: similarW; rewrite row_free_unit.
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similarP
| |
similarRL{p f g} : p \in unitmx ->
reflect (g = p *m f *m invmx p) (similar p f g).
Proof. by move=> ?; apply: (iffP eqP); rewrite conjumx. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similarRL
| |
similarLR{p f g} : p \in unitmx ->
reflect (f = conjmx (invmx p) g) (similar p f g).
Proof.
by move=> pu; rewrite conjVmx//; apply: (iffP (similarRL pu)) => ->;
rewrite !mulmxA ?(mulmxK, mulmxKV, mulVmx, mulmxV, mul1mx, mulmx1).
Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similarLR
| |
similar_mxminpoly{n} {p f g : 'M[F]_n.+1} : p \in unitmx ->
similar p f g -> mxminpoly f = mxminpoly g.
Proof. by move=> pu /eqP<-; rewrite mxminpoly_uconj. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_mxminpoly
| |
similar_diag_row_basem n (P : 'M[F]_(m, n)) (A : 'M_n) :
similar_diag (row_base P) A = is_diag_mx (restrictmx P A).
Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype finfun bigop fingroup perm order",
"From mathcomp Require Import ssralg zmodp matrix mxalgebra poly polydiv mxpoly"
] |
algebra/mxred.v
|
similar_diag_row_base
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.