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 |
|---|---|---|---|---|---|---|
orthogonal_freeS : pairwise_orthogonal form S -> free S.
Proof.
case/pairwise_orthogonalP=> [/=/andP[notS0 uniqS] oSS].
rewrite -(in_tupleE S); apply/freeP => a aS0 i.
have S_i: S`_i \in S by apply: mem_nth.
have /eqP: '[S`_i, 0] = 0 := linear0r _ _.
rewrite -{2}aS0 raddf_sum /= (bigD1 i) //= big1 => [|j neq_ji]; last 1 first.
by rewrite linearZ /= oSS ?mulr0 ?mem_nth // eq_sym nth_uniq.
rewrite addr0 linearZ mulf_eq0 conjC_eq0 dnorm_eq0.
by case/pred2P=> // Si0; rewrite -Si0 S_i in notS0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_free
| |
filter_pairwise_orthogonalS p :
pairwise_orthogonal form S -> pairwise_orthogonal form (filter p S).
Proof.
move=> orthoS; apply: sub_pairwise_orthogonal (orthoS).
exact: mem_subseq (filter_subseq p S).
exact/filter_uniq/free_uniq/orthogonal_free.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
filter_pairwise_orthogonal
| |
orthonormal_freeS : orthonormal form S -> free S.
Proof. by move/orthonormal_orthogonal/orthogonal_free. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthonormal_free
| |
CauchySchwarz(u v : U) :
`|'[u, v]| ^+ 2 <= '[u] * '[v] ?= iff ~~ free [:: u; v].
Proof.
rewrite free_cons span_seq1 seq1_free -negb_or negbK orbC.
have [-> | nz_v] /= := altP (v =P 0).
by apply/leifP; rewrite /= !linear0r normCK mul0r mulr0.
without loss ou: u / '[u, v] = 0.
move=> IHo; pose a := '[u, v] / '[v]; pose u1 := u - a *: v.
have ou: '[u1, v] = 0.
rewrite linearBl/=.
rewrite linearZl_LR.
by rewrite divfK ?dnorm_eq0 ?subrr.
rewrite (canRL (subrK _) (erefl u1)) rpredDr ?rpredZ ?memv_line //.
rewrite linearDl /= ou add0r.
rewrite linearZl_LR/= normrM (ger0_norm (dnorm_ge0 _ _)).
rewrite exprMn mulrA -dnormZ hnormDd/=; last by rewrite linearZr_LR/= ou mulr0.
have:= IHo _ ou.
by rewrite mulrDl -leifBLR subrr ou normCK mul0r.
rewrite ou normCK mul0r; split; first by rewrite mulr_ge0.
rewrite eq_sym mulf_eq0 orbC dnorm_eq0 (negPf nz_v) /=.
apply/idP/idP=> [|/vlineP[a {2}->]]; last by rewrite linearZr_LR/= ou mulr0.
by rewrite dnorm_eq0 => /eqP->; apply: rpred0.
Qed.
|
Theorem
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
CauchySchwarz
| |
CauchySchwarz_sqrtu v :
`|'[u, v]| <= sqrtC '[u] * sqrtC '[v] ?= iff ~~ free [:: u; v].
Proof.
rewrite -(sqrCK (normr_ge0 _)) -sqrtCM ?nnegrE//.
rewrite (mono_in_leif (@ler_sqrtC _)) 1?rpredM//= ?nnegrE//=.
exact: CauchySchwarz.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
CauchySchwarz_sqrt
| |
orthoPphi psi : reflect ('[phi, psi] = 0) (orthogonal form [:: phi] [:: psi]).
Proof. by rewrite /orthogonal /= !andbT; apply: eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoP
| |
orthoPlphi S :
reflect {in S, forall psi, '[phi, psi] = 0} (orthogonal form [:: phi] S).
Proof.
by rewrite [orthogonal form _ S]andbT /=; apply: (iffP allP) => ophiS ? /ophiS/eqP.
Qed.
Arguments orthoPl {phi S}.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoPl
| |
orthogonal_sym: symmetric (orthogonal form).
Proof.
apply: symmetric_from_pre => R S /orthogonalP oRS.
by apply/orthogonalP=> phi psi Rpsi Sphi; rewrite hermC /= oRS ?rmorph0 ?mulr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_sym
| |
orthoPrS psi :
reflect {in S, forall phi, '[phi, psi] = 0} (orthogonal form S [:: psi]).
Proof.
rewrite orthogonal_sym.
by apply: (iffP orthoPl) => oSpsi phi Sphi; rewrite hermC /= oSpsi //= conjC0 mulr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoPr
| |
orthogonal_catlR1 R2 S :
orthogonal form (R1 ++ R2) S = orthogonal form R1 S && orthogonal form R2 S.
Proof. exact: all_cat. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_catl
| |
orthogonal_catrR S1 S2 :
orthogonal form R (S1 ++ S2) = orthogonal form R S1 && orthogonal form R S2.
Proof. by rewrite !(orthogonal_sym R) orthogonal_catl. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_catr
| |
eq_pairwise_orthogonalR S :
perm_eq R S -> pairwise_orthogonal form R = pairwise_orthogonal form S.
Proof.
apply: catCA_perm_subst R S => R S S'.
rewrite !pairwise_orthogonal_cat !orthogonal_catr (orthogonal_sym R S) -!andbA.
by do !bool_congr.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
eq_pairwise_orthogonal
| |
eq_orthonormalS0 S : perm_eq S0 S -> orthonormal form S0 = orthonormal form S.
Proof.
move=> eqRS; rewrite !orthonormalE (eq_all_r (perm_mem eqRS)).
by rewrite (eq_pairwise_orthogonal eqRS).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
eq_orthonormal
| |
orthogonal_opplS R : orthogonal form (map -%R S) R = orthogonal form S R.
Proof. by rewrite -!(orthogonal_sym R) orthogonal_oppr. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_oppl
| |
triangle_lerifu v :
sqrtC '[u + v] <= sqrtC '[u] + sqrtC '[v]
?= iff ~~ free [:: u; v] && (0 <= coord [tuple v] 0 u).
Proof.
rewrite -(mono_in_leif ler_sqr) ?rpredD ?nnegrE ?sqrtC_ge0//.
rewrite andbC sqrrD !sqrtCK addrAC dnormD (mono_leif (lerD2l _))/=.
rewrite -mulr_natr -[_ + _](divfK (negbT (pnatr_eq0 C 2))) -/('Re _).
rewrite (mono_leif (ler_pM2r _)) ?ltr0n//.
have := leif_trans (leif_Re_Creal '[u, v]) (CauchySchwarz_sqrt u v).
rewrite ReE; congr (_ <= _ ?= iff _); apply: andb_id2r.
rewrite free_cons span_seq1 seq1_free -negb_or negbK orbC.
have [-> | nz_v] := altP (v =P 0); first by rewrite linear0 coord0.
case/vlineP=> [x ->]; rewrite linearZl linearZ/= pmulr_lge0 ?dnorm_gt0 //=.
by rewrite (coord_free 0) ?seq1_free // eqxx mulr1.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
triangle_lerif
| |
span_orthogonalS1 S2 phi1 phi2 :
orthogonal form S1 S2 -> phi1 \in <<S1>>%VS -> phi2 \in <<S2>>%VS ->
'[phi1, phi2] = 0.
Proof.
move/orthogonalP=> oS12; do 2!move/(@coord_span _ _ _ (in_tuple _))->.
rewrite linear_sumlz big1 // => i _; rewrite linear_sumr big1 // => j _.
by rewrite linearZlr/= oS12 ?mem_nth ?mulr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
span_orthogonal
| |
orthogonal_splitS beta :
{X : U & X \in <<S>>%VS &
{Y :U | [/\ beta = X + Y, '[X, Y] = 0 & orthogonal form [:: Y] S]}}.
Proof.
suffices [X S_X [Y -> oYS]]:
{X : _ & X \in <<S>>%VS & {Y | beta = X + Y & orthogonal form [:: Y] S}}.
- exists X => //; exists Y.
by rewrite hermC /= (span_orthogonal oYS) ?memv_span1 ?conjC0 // mulr0.
elim: S beta => [|phi S IHS] beta.
by exists 0; last exists beta; rewrite ?mem0v ?add0r.
have [[UU S_U [V -> oVS]] [X S_X [Y -> oYS]]] := (IHS phi, IHS beta).
pose Z := '[Y, V] / '[V] *: V; exists (X + Z).
rewrite /Z -{4}(addKr UU V) scalerDr scalerN addrA addrC span_cons.
by rewrite memv_add ?memvB ?memvZ ?memv_line.
exists (Y - Z); first by rewrite addrCA !addrA addrK addrC.
apply/orthoPl=> psi; rewrite !inE => /predU1P[-> | Spsi]; last first.
by rewrite linearBl linearZl_LR /= (orthoPl oVS _ Spsi) mulr0 subr0 (orthoPl oYS).
rewrite linearBl !linearDr /= (span_orthogonal oYS) // ?memv_span ?mem_head //.
rewrite !linearZl_LR /= (span_orthogonal oVS _ S_U) ?mulr0 ?memv_span ?mem_head //.
have [-> | nzV] := eqVneq V 0; first by rewrite linear0r !mul0r subrr.
by rewrite divfK ?dnorm_eq0 ?subrr.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthogonal_split
| |
normf1:= fun u => form1 u u.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
normf1
| |
normf2:= fun u => form2 u u.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
normf2
| |
isometry_of_dnormS tauS :
pairwise_orthogonal form1 S -> pairwise_orthogonal form2 tauS ->
map normf2 tauS = map normf1 S ->
{tau : {linear U1 -> U2} | map tau S = tauS
& {in <<S>>%VS &, isometry form2 form1 tau}}.
Proof.
move=> oS oT eq_nST; have freeS := orthogonal_free oS.
have eq_sz: size tauS = size S by have:= congr1 size eq_nST; rewrite !size_map.
have [tau defT] := linear_of_free S tauS; rewrite -[S]/(tval (in_tuple S)).
exists tau => [|u v /coord_span-> /coord_span->]; rewrite ?raddf_sum ?defT //=.
apply: eq_bigr => i _ /=; rewrite !linearZ/= !linear_sumlz; congr (_ * _).
apply: eq_bigr => j _ /=; rewrite linearZ !linearZl; congr (_ * _).
rewrite -!(nth_map 0 0 tau) ?{}defT //; have [-> | neq_ji] := eqVneq j i.
by rewrite /= -[RHS](nth_map 0 0 normf1) -?[LHS](nth_map 0 0 normf2) ?eq_sz // eq_nST.
have{oS} [/=/andP[_ uS] oS] := pairwise_orthogonalP oS.
have{oT} [/=/andP[_ uT] oT] := pairwise_orthogonalP oT.
by rewrite oS ?oT ?mem_nth ?nth_uniq ?eq_sz.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
isometry_of_dnorm
| |
isometry_of_freeS f :
free S -> {in S &, isometry form2 form1 f} ->
{tau : {linear U1 -> U2} |
{in S, tau =1 f} & {in <<S>>%VS &, isometry form2 form1 tau}}.
Proof.
move=> freeS If; have defS := free_span freeS.
have [tau /(_ freeS (size_map f S))Dtau] := linear_of_free S (map f S).
have {}Dtau: {in S, tau =1 f}.
by move=> _ /(nthP 0)[i ltiS <-]; rewrite -!(nth_map 0 0) ?Dtau.
exists tau => // _ _ /defS[a -> _] /defS[b -> _] /=.
rewrite 2!{1}linear_sum /= !{1}linear_sumlz /=; apply/eq_big_seq=> xi1 Sxi1.
rewrite !{1}linear_sumr; apply/eq_big_seq=> xi2 Sxi2 /=.
by rewrite !linearZ /= !linearZl !Dtau //= If.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
isometry_of_free
| |
isometry_raddf_inj(tau : {additive U1 -> U2}) :
{in U1 &, isometry form2 form1 tau} ->
{in U1 &, forall u v, u - v \in U1} ->
{in U1 &, injective tau}.
Proof.
move=> Itau linU phi psi Uphi Upsi /eqP; rewrite -subr_eq0 -raddfB.
by rewrite -(dnorm_eq0 form2) Itau ?linU // dnorm_eq0 subr_eq0 => /eqP.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
isometry_raddf_inj
| |
form_of_matrixm M (U V : 'M_(m, n)) := \tr (U *m M *m (V ^t theta)).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrix
| |
matrix_of_form(form : 'rV[R]_n -> 'rV[R]_n -> R) : 'M[R]_n :=
\matrix_(i, j) form 'e_i 'e_j.
Implicit Type form : {bilinear 'rV[R]_n -> 'rV[R]_n -> R | *%R & theta \; *%R}.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
matrix_of_form
| |
matrix_of_formEform i j : matrix_of_form form i j = form 'e_i 'e_j.
Proof. by rewrite mxE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
matrix_of_formE
| |
Definition_ U := @GRing.isLinear.Build _ _ _ _
(form_of_matrix theta M U) (form_of_matrix_is_linear U).
|
HB.instance
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
Definition
| |
form_of_matrixrU := (form_of_matrix theta M)^~U.
Let form_of_matrixr_is_linear U : linear_for *%R (form_of_matrixr U).
Proof.
rewrite /form_of_matrixr /form_of_matrix => k v w.
by rewrite -linearP /= !mulmxDl -!scalemxAl.
Qed.
HB.instance Definition _ U := @GRing.isLinear.Build _ _ _ _
(form_of_matrixr U) (form_of_matrixr_is_linear U).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrixr
| |
form_of_matrixr_rev:=
[revop form_of_matrixr of form_of_matrix theta M].
*)
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrixr_rev
| |
form_of_matrix_is_bilinear:
bilinear_for
(GRing.Scale.Law.clone _ _ ( *%R ) _) (GRing.Scale.Law.clone _ _ (theta \; *%R ) _)
(@form_of_matrix theta m M).
Proof.
split=> [u'|u] a x y /=.
- by rewrite /form_of_matrix !mulmxDl linearD/= -!scalemxAl linearZ.
- rewrite /form_of_matrix -linearZ/= -linearD/= [in LHS]linearD/= map_mxD.
rewrite mulmxDr; congr (\tr (_ + _)).
rewrite scalemxAr; congr (_ *m _).
by rewrite linearZ/= map_mxZ.
Qed.
HB.instance Definition _ :=
bilinear_isBilinear.Build R _ _ _
(GRing.Scale.Law.clone _ _ ( *%R ) _)
(GRing.Scale.Law.clone _ _ (theta \; *%R ) _)
(@form_of_matrix theta m M)
form_of_matrix_is_bilinear.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrix_is_bilinear
| |
rV_formeei j : '['e_i :'rV__, 'e_j] = M i j.
Proof.
rewrite /form_of_matrix -rowE -map_trmx map_delta_mx -[M in LHS]trmxK.
by rewrite -tr_col -trmx_mul -rowE trace_mx11 !mxE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
rV_formee
| |
form_of_matrixK: matrix_of_form (form_of_matrix theta M) = M.
Proof. by apply/matrixP => i j; rewrite !mxE rV_formee. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrixK
| |
rV_form0_eq0: M = 0 -> forall u v, '[u, v] = 0.
Proof.
by rewrite /form_of_matrix => -> u v; rewrite mulmx0 mul0mx trace_mx11 mxE.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
rV_form0_eq0
| |
matrix_of_formK: form_of_matrix theta (matrix_of_form form) =2 form.
Proof.
set f := (X in X =2 _); have f_eq i j : f 'e_i 'e_j = form 'e_i 'e_j.
by rewrite /f rV_formee mxE.
move=> u v; rewrite [u]row_sum_delta [v]row_sum_delta /f.
rewrite !linear_sum/=; apply: eq_bigr => j _.
rewrite !linear_sumlz/=; apply: eq_bigr => i _.
by rewrite !linearZlr/= -f_eq.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
matrix_of_formK
| |
hermitianmx:=
[qualify M : 'M_n | M == ((-1) ^+ eps) *: M ^t theta].
Fact hermitianmx_key : pred_key hermitianmx. Proof. by []. Qed.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitianmx
| |
hermitianmx_keyed:= KeyedQualifier hermitianmx_key.
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitianmx_keyed
| |
hermitian_matrix:= HermitianMx {
mx_of_hermitian :> 'M[R]_n;
_ : mx_of_hermitian \is hermitianmx }.
|
Structure
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitian_matrix
| |
is_hermitianmxEM :
(M \is hermitianmx) = (M == (-1) ^+ eps *: M ^t theta).
Proof. by rewrite qualifE. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
is_hermitianmxE
| |
is_hermitianmxPM :
reflect (M = (-1) ^+ eps *: M ^t theta) (M \is hermitianmx).
Proof. by rewrite is_hermitianmxE; apply/eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
is_hermitianmxP
| |
hermitianmxE(M : hermitian_matrix) :
M = ((-1) ^+ eps) *: M ^t theta :> 'M__.
Proof. by apply/eqP; case: M. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitianmxE
| |
trmx_hermitian(M : hermitian_matrix) :
M^T = ((-1) ^+ eps) *: M ^ theta :> 'M__.
Proof. by rewrite {1}hermitianmxE linearZ /= map_trmx trmxK. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
trmx_hermitian
| |
maptrmx_hermitian: M^t theta = (-1) ^+ eps *: (M : 'M__).
Proof.
rewrite trmx_hermitian map_mxZ rmorph_sign -map_mx_comp.
by rewrite (map_mx_id (rmorphK _)).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
maptrmx_hermitian
| |
form_of_matrix_is_hermitianm x y :
(@form_of_matrix theta m M) x y =
(-1) ^+ eps * theta ((@form_of_matrix theta m M) y x).
Proof.
rewrite {1}hermitianmxE /form_of_matrix.
rewrite -!(scalemxAr, scalemxAl) linearZ/=; congr (_ * _).
rewrite -mxtrace_tr -trace_map_mx !(trmx_mul, map_mxM, map_trmx, trmxK).
by rewrite -mulmxA -!map_mx_comp !(map_mx_id (rmorphK _)).
Qed.
HB.instance Definition _ m := @isHermitianSesquilinear.Build _ _ _ _ _
(@form_of_matrix_is_hermitian m).
Local Notation "''[' u , v ]" := (form_of_matrix theta M u%R v%R) : ring_scope.
Local Notation "''[' u ]" := '[u, u]%R : ring_scope.
Local Notation "B ^!" := (orthomx theta M B) : matrix_set_scope.
Local Notation "A '_|_ B" := (A%MS <= B%MS^!)%MS : matrix_set_scope.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
form_of_matrix_is_hermitian
| |
orthomxEu v : (u '_|_ v)%MS = ('[u, v] == 0).
Proof.
rewrite (sameP sub_kermxP eqP) mulmxA.
by rewrite [_ *m _^t _]mx11_scalar -trace_mx11 fmorph_eq0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomxE
| |
hermmx_eq0P{u v} : reflect ('[u, v] = 0) (u '_|_ v)%MS.
Proof. by rewrite orthomxE; apply/eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermmx_eq0P
| |
orthomxPp q (A : 'M_(p, n)) (B :'M_(q, n)) :
reflect (forall (u v : 'rV_n), u <= A -> v <= B -> u '_|_ v)%MS
(A '_|_ B)%MS.
Proof.
apply: (iffP idP) => AnB.
move=> u v uA vB; rewrite (submx_trans uA) // (submx_trans AnB) //.
apply/sub_kermxP; have /submxP [w ->] := vB.
rewrite trmx_mul map_mxM !mulmxA -[kermx _ *m _ *m _]mulmxA.
by rewrite [kermx _ *m _](sub_kermxP _) // mul0mx.
apply/rV_subP => u /AnB /(_ _) /sub_kermxP uMv; apply/sub_kermxP.
suff: forall m (v : 'rV[R]_m),
(forall i, v *m 'e_i ^t theta = 0 :> 'M_1) -> v = 0.
apply => i; rewrite !mulmxA -!mulmxA -map_mxM -trmx_mul uMv //.
by apply/submxP; exists 'e_i.
move=> /= m v Hv; apply: (can_inj (@trmxK _ _ _)).
rewrite trmx0; apply/row_matrixP=> i; rewrite row0 rowE.
apply: (can_inj (@trmxK _ _ _)); rewrite trmx0 trmx_mul trmxK.
by rewrite -(map_delta_mx theta) map_trmx Hv.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomxP
| |
orthomx_symp q (A : 'M_(p, n)) (B :'M_(q, n)) :
(A '_|_ B)%MS = (B '_|_ A)%MS.
Proof.
gen have nC : p q A B / (A '_|_ B -> B '_|_ A)%MS; last by apply/idP/idP; apply/nC.
move=> AnB; apply/orthomxP => u v ? ?; rewrite orthomxE.
rewrite hermC mulf_eq0 ?fmorph_eq0 ?signr_eq0 /=.
by rewrite -orthomxE (orthomxP _ _ AnB).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomx_sym
| |
ortho_ortho_mxp (A : 'M_(p, n)) : (A^! '_|_ A)%MS. Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
ortho_ortho_mx
| |
ortho_mx_orthop (A : 'M_(p, n)) : (A '_|_ A^!)%MS.
Proof. by rewrite orthomx_sym. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
ortho_mx_ortho
| |
rank_orthomxu : (\rank (u ^!) >= n.-1)%N.
Proof.
rewrite mxrank_ker -subn1 leq_sub2l //.
by rewrite (leq_trans (mxrankM_maxr _ _)) // rank_leq_col.
Qed.
Local Notation radmx := (1%:M^!)%MS.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
rank_orthomx
| |
radmxE: radmx = kermx M.
Proof. by rewrite /orthomx /orthomx trmx1 map_mx1 mulmx1. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
radmxE
| |
orthoNmxk m (A : 'M[R]_(k, n)) (B : 'M[R]_(m, n)) :
((- A) '_|_ B)%MS = (A '_|_ B)%MS.
Proof. by rewrite eqmx_opp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoNmx
| |
orthomxNk m (A : 'M[R]_(k, n)) (B : 'M[R]_(m, n)) :
(A '_|_ (- B))%MS = (A '_|_ B)%MS.
Proof. by rewrite ![(A '_|_ _)%MS]orthomx_sym orthoNmx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomxN
| |
orthoDmxk m p (A : 'M[R]_(k, n)) (B : 'M[R]_(m, n)) (C : 'M[R]_(p, n)) :
(A + B '_|_ C)%MS = (A '_|_ C)%MS && (B '_|_ C)%MS.
Proof. by rewrite addsmxE !(sameP sub_kermxP eqP) mul_col_mx col_mx_eq0. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoDmx
| |
orthomxDk m p (A : 'M[R]_(k, n)) (B : 'M[R]_(m, n)) (C : 'M[R]_(p, n)) :
(A '_|_ B + C)%MS = (A '_|_ B)%MS && (A '_|_ C)%MS.
Proof. by rewrite ![(A '_|_ _)%MS]orthomx_sym orthoDmx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomxD
| |
orthoZmxp m a (A : 'M[R]_(p, n)) (B : 'M[R]_(m, n)) : a != 0 ->
(a *: A '_|_ B)%MS = (A '_|_ B)%MS.
Proof. by move=> a_neq0; rewrite eqmx_scale. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthoZmx
| |
orthomxZp m a (A : 'M[R]_(p, n)) (B : 'M[R]_(m, n)) : a != 0 ->
(A '_|_ (a *: B))%MS = (A '_|_ B)%MS.
Proof. by move=> a_neq0; rewrite ![(A '_|_ _)%MS]orthomx_sym orthoZmx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
orthomxZ
| |
eqmx_orthop m (A : 'M[R]_(p, n)) (B : 'M[R]_(m, n)) :
(A :=: B)%MS -> (A^! :=: B^!)%MS.
Proof.
move=> eqAB; apply/eqmxP.
by rewrite orthomx_sym -eqAB ortho_mx_ortho orthomx_sym eqAB ortho_mx_ortho.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
eqmx_ortho
| |
genmx_orthop (A : 'M[R]_(p, n)) : (<<A>>^! :=: A^!)%MS.
Proof. exact: (eqmx_ortho (genmxE _)). Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
genmx_ortho
| |
symmetricmx:= (hermitianmx _ false idfun).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
symmetricmx
| |
skewmx:= (hermitianmx _ true idfun).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
skewmx
| |
hermsymmx:= (hermitianmx _ false conjC).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermsymmx
| |
hermitian1mx_subproof{C : numClosedFieldType} n : (1%:M : 'M[C]_n) \is hermsymmx.
Proof.
by rewrite qualifE /= expr0 scale1r tr_scalar_mx map_scalar_mx/= conjC1.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitian1mx_subproof
| |
hermitian1mx{C : numClosedFieldType} n :=
HermitianMx (@hermitian1mx_subproof C n).
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq div",
"From mathcomp Require Import choice fintype tuple bigop ssralg finset fingroup",
"From mathcomp Require Import zmodp poly order ssrnum matrix mxalgebra vector"
] |
algebra/sesquilinear.v
|
hermitian1mx
| |
eigenvalue_closed{C : numClosedFieldType} n (A : 'M[C]_n) : (n > 0)%N ->
exists a, eigenvalue A a.
Proof.
move=> n_gt0; have /closed_rootP [a rAa] : size (char_poly A) != 1%N.
by rewrite size_char_poly; case: (n) n_gt0.
by exists a; rewrite eigenvalue_root_char.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
eigenvalue_closed
| |
common_eigenvector{C : numClosedFieldType} n (As : seq 'M[C]_n) :
(n > 0)%N -> {in As &, forall A B, comm_mx A B} ->
exists2 v : 'rV_n, v != 0 & all (fun A => stablemx v A) As.
Proof.
move=> n_gt0 /all_comm_mxP; have [k sAsk] := ubnP (size As).
elim: k n n_gt0 As sAsk => [//|k IHk] n n_gt0 [|A As].
exists (const_mx 1) => //; apply/negP => /eqP/rowP/(_ (Ordinal n_gt0)).
by rewrite !mxE => /eqP; rewrite oner_eq0.
rewrite ltnS all_comm_mx_cons => sAsk /andP[].
move=> /allP/(_ _ _)/eqP/= A_comm /all_comm_mxP As_comm.
have [a a_eigen] := eigenvalue_closed A n_gt0.
have [] := IHk _ _ [seq restrictmx (eigenspace A a) B | B <- As].
- by rewrite lt0n mxrank_eq0.
- by rewrite size_map.
- apply/all_comm_mxP; move=> _ _ /= /mapP /= [B B_in ->] /mapP /= [B' B'_in ->].
rewrite -?conjmxM ?inE ?stablemx_row_base ?comm_mx_stable_eigenspace//;
by [rewrite As_comm | apply: As_comm | apply: A_comm].
move=> v vN0 /allP /= vP; exists (v *m (row_base (eigenspace A a))).
by rewrite mulmx_free_eq0 ?row_base_free.
apply/andP; split.
by apply/eigenvectorP; exists a; rewrite mulmx_sub // eq_row_base.
apply/allP => B B_in; rewrite -stablemx_restrict ?vP //.
by apply/mapP; exists B.
by rewrite comm_mx_stable_eigenspace //; exact: A_comm.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
common_eigenvector
| |
common_eigenvector2{C : numClosedFieldType}n (A B : 'M[C]_n) :
(n > 0)%N -> A *m B = B *m A ->
exists2 v : 'rV_n, v != 0 & (stablemx v A) && (stablemx v B).
Proof.
move=> n_gt0 AB_comm; have [] := @common_eigenvector _ _ [:: A; B] n_gt0.
by move=> A' B'; rewrite !inE => /orP [] /eqP-> /orP [] /eqP->.
by move=> v v_neq0 /allP vP; exists v; rewrite ?vP ?(mem_head, in_cons, orbT).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
common_eigenvector2
| |
realmx:= (mxOver Num.real).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
realmx
| |
trmxCK{C : numClosedFieldType} m n (A : 'M[C]_(m, n)) : A ^t* ^t* = A.
Proof. by apply/matrixP=> i j; rewrite !mxE conjCK. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
trmxCK
| |
realmxCA : A \is a realmx -> A ^ conjC = A.
Proof.
by move=> ?; apply/matrixP => x y; rewrite mxE; exact/CrealP/mxOverP.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
realmxC
| |
realmxDA B : A \is a realmx -> B \is a realmx -> A + B \is a realmx.
Proof.
rewrite !qualifE/= => /'forall_forallP realA /'forall_forallP realB.
by apply/'forall_forallP => i j; rewrite mxE realD.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
realmxD
| |
Remx_rect: {in realmx &, forall A B, (A + 'i *: B) ^ (@Re _) = A}.
Proof.
move=> A B Areal Breal; apply/matrixP=> i j; rewrite !mxE.
by rewrite Re_rect // (mxOverP _ _).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
Remx_rect
| |
Immx_rect: {in realmx &, forall A B, (A + 'i *: B) ^ (@Im _) = B}.
Proof.
move=> /= A B Areal Breal; apply/matrixP=> i j; rewrite !mxE.
by rewrite Im_rect // (mxOverP _ _).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
Immx_rect
| |
eqmx_ReiImA B A' B' :
A \is a realmx -> B \is a realmx -> A' \is a realmx -> B' \is a realmx ->
(A + 'i *: B) = (A' + 'i *: B') -> (A, B) = (A', B').
Proof.
move=> ARe BRe A'Im B'Im eqAB.
have /(congr1 (fun A => A ^ (@Im _))) := eqAB.
have /(congr1 (fun A => A ^ (@Re _))) := eqAB.
by rewrite !Remx_rect// !Immx_rect// => -> ->.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
eqmx_ReiIm
| |
realsym_hermsym{C : numClosedFieldType} {n} (A : 'M[C]_n) :
A \is symmetricmx -> A \is a realmx -> A \is hermsymmx.
Proof.
move=> Asym Areal; apply/is_hermitianmxP.
by rewrite (trmx_hermitian (HermitianMx Asym))/= !scale1r ?realmxC ?map_mx_id.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
realsym_hermsym
| |
real_similar{C : numClosedFieldType} {n} (A B : 'M[C]_n) :
similar_in unitmx A B ->
A \is a realmx -> B \is a realmx -> similar_in [predI realmx & unitmx] A B.
Proof.
case=> [P /=]; pose Pr := P ^ (@Re _); pose Pi := P ^ (@Im _).
have Pr_real : Pr \is a realmx by apply/mxOverP=> i j; rewrite !mxE Creal_Re.
have Pi_real : Pi \is a realmx by apply/mxOverP=> i j; rewrite !mxE Creal_Im.
pose Q x := P ^ (@Re _) + x *: P ^ (@Im _).
have -> : P = Q 'i by apply/matrixP=> i j; rewrite !mxE -Crect.
move=> Qi_unit eq_AP_PB Areal Breal.
pose p := \det (Pr ^ polyC + 'X *: Pi ^ polyC).
have horner_evaliC x : horner_eval (x : C) \o polyC =1 id := fun=> hornerC _ _.
have Qunit x : Q x \in unitmx = (p.[x] != 0).
rewrite /p -horner_evalE -det_map_mx map_mxD map_mxZ/= horner_evalE hornerX.
by rewrite -![(_ ^ polyC) ^ _]map_mx_comp !map_mx_id// unitmxE unitfE.
have p_neq0 : p != 0.
by move: Qi_unit; rewrite Qunit; apply: contra_neq => ->; rewrite hornerE.
have [a a_real rootNa] : exists2 a, a \is Num.real & ~~ root p a.
have rs_uniq : uniq [seq (i%:R : C) | i <- iota 0 (size p)].
by rewrite map_inj_uniq ?iota_uniq //; apply: mulrIn; rewrite oner_eq0.
have := contraNN (fun x => max_poly_roots p_neq0 x rs_uniq).
rewrite size_map size_iota ltnn => /(_ isT) /allPn[a a_in rootNpa].
by exists a => //; by move: a_in => /mapP [i _ ->]; rewrite realn.
exists (Q a).
rewrite inE Qunit rootNa andbT.
rewrite /Q/=.
by rewrite realmxD// mxOverZ.
apply/similarP; rewrite ?Qunit//; move: eq_AP_PB
...
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
real_similar
| |
unitarymx{m n} := [qualify X : 'M[C]_(m, n) | X *m X ^t* == 1%:M].
Fact unitarymx_key m n : pred_key (@unitarymx m n). Proof. by []. Qed.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
unitarymx
| |
unitarymx_keyedm n := KeyedQualifier (unitarymx_key m n).
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
unitarymx_keyed
| |
unitarymxPm n {M : 'M[C]_(m, n)} :
reflect (M *m M^t* = 1%:M) (M \is unitarymx).
Proof. by apply: (iffP eqP). Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
unitarymxP
| |
mulmxtVKm1 m2 n (A : 'M[C]_(m1, n)) (B : 'M[C]_(n, m2)) :
B \is unitarymx -> A *m B *m B^t* = A.
Proof. by move=> B_unitary; rewrite -mulmxA (unitarymxP _) ?mulmx1. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
mulmxtVK
| |
unitarymx_unitn (M : 'M[C]_n) : M \is unitarymx -> M \in unitmx.
Proof. by move=> /unitarymxP /mulmx1_unit []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
unitarymx_unit
| |
invmx_unitaryn (M : 'M[C]_n) : M \is unitarymx -> invmx M = M^t*.
Proof.
move=> Munitary; apply: (@row_full_inj _ _ _ _ M).
by rewrite row_full_unit unitarymx_unit.
by rewrite mulmxV ?unitarymx_unit ?(unitarymxP _).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
invmx_unitary
| |
mulmxKtVm1 m2 n (A : 'M[C]_(m1, n)) (B : 'M[C]_(m2, n)) :
B \is unitarymx -> m2 = n -> A *m B^t* *m B = A.
Proof.
move=> B_unitary m2E; case: _ / (esym m2E) in B B_unitary *.
by rewrite -invmx_unitary // mulmxKV //; exact: unitarymx_unit.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
mulmxKtV
| |
mxrank_unitarym n (M : 'M[C]_(m, n)) : M \is unitarymx -> \rank M = m.
Proof.
rewrite qualifE => /eqP /(congr1 mxrank); rewrite mxrank1 => rkM.
apply/eqP; rewrite eqn_leq rank_leq_row /= -[X in (X <= _)%N]rkM.
by rewrite mxrankM_maxl.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
mxrank_unitary
| |
mul_unitarymxm n p (A : 'M[C]_(m, n)) (B : 'M[C]_(n, p)) :
A \is unitarymx -> B \is unitarymx -> A *m B \is unitarymx.
Proof.
move=> Aunitary Bunitary; apply/unitarymxP; rewrite trmx_mul map_mxM.
by rewrite mulmxA -[A *m _ *m _]mulmxA !(unitarymxP _, mulmx1).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
mul_unitarymx
| |
pinvmx_unitaryn (M : 'M[C]_n) : M \is unitarymx -> pinvmx M = M^t*.
Proof. by move=> Munitary; rewrite pinvmxE ?unitarymx_unit// invmx_unitary. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
pinvmx_unitary
| |
conjymxn (P M : 'M[C]_n) : P \is unitarymx -> conjmx P M = P *m M *m P^t*.
Proof. by move=> Munitary; rewrite conjumx ?invmx_unitary ?unitarymx_unit. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
conjymx
| |
trmx_unitaryn (M : 'M[C]_n) : (M ^T \is unitarymx) = (M \is unitarymx).
Proof.
apply/unitarymxP/unitarymxP; rewrite -?map_trmx -trmx_mul.
by rewrite -trmx1 => /trmx_inj /mulmx1C->; rewrite trmx1.
by move=> /mulmx1C->; rewrite trmx1.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
trmx_unitary
| |
conjC_unitarym n (M : 'M[C]_(m, n)) :
(M ^ conjC \is unitarymx) = (M \is unitarymx).
Proof.
apply/unitarymxP/unitarymxP; rewrite -?map_mxM ?map_trmx; last first.
by move=> ->; rewrite map_mx1.
by rewrite -[1%:M](map_mx1 conjC) => /map_mx_inj ->; rewrite map_mx1.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
conjC_unitary
| |
trmxC_unitaryn (M : 'M[C]_n) : (M ^t* \is unitarymx) = (M \is unitarymx).
Proof. by rewrite conjC_unitary trmx_unitary. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
trmxC_unitary
| |
normalmx:= [qualify M : 'M[C]_n | M *m M ^t* == M ^t* *m M].
Fact normalmx_key : pred_key normalmx. Proof. by []. Qed.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
normalmx
| |
normalmx_keyed:= KeyedQualifier normalmx_key.
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
normalmx_keyed
| |
normalmxP{M : 'M[C]_n} :
reflect (M *m M ^t* = M ^t* *m M) (M \is normalmx).
Proof. exact: eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
normalmxP
| |
hermitian_normalmx(A : 'M[C]_n) : A \is hermsymmx -> A \is normalmx.
Proof.
move=> Ahermi; apply/normalmxP.
by rewrite (trmx_hermitian (HermitianMx Ahermi)) scale1r map_mxCK.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
hermitian_normalmx
| |
symmetric_normalmx(A : 'M[C]_n) : A \is symmetricmx ->
A \is a realmx -> A \is normalmx.
Proof. by move=> Asym Areal; rewrite hermitian_normalmx// realsym_hermsym. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
symmetric_normalmx
| |
dotmxn (u v : 'rV[C]_n) := dotmx_def u%R v%R.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
dotmx
| |
Definition_ n := Bilinear.on (@dotmx n).
to be sufficient to equip dotmx with the bilinear structure
but needed to use .copy in the end as in:
*)
HB.instance Definition _ n := Bilinear.copy (@dotmx n) dotmx_def.
Local Notation "''[' u , v ]" := (dotmx u v) : ring_scope.
Local Notation "''[' u ]" := '[u, u]%R : ring_scope.
HB.instance Definition _ n := Hermitian.copy (@dotmx n) dotmx_def.
|
HB.instance
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
Definition
| |
dotmxEn (u v : 'rV[C]_n) : '[u, v] = ( u *m v ^t* ) 0 0.
Proof. by rewrite /dotmx /form_of_matrix mulmx1 /= trace_mx11. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
dotmxE
| |
row_unitarymxPm n {M : 'M[C]_(m, n)} :
reflect (forall i j, '[row i M, row j M] = (i == j)%:R) (M \is unitarymx).
Proof.
apply: (iffP eqP) => [Mo i j|Mo].
have /matrixP/(_ i j) := Mo; rewrite !mxE => <-.
by rewrite dotmxE !mxE; apply: eq_bigr => /= k _; rewrite !mxE.
apply/matrixP=> i j; rewrite !mxE; have := Mo i j; rewrite dotmxE !mxE => <-.
by apply: eq_bigr => /= k _; rewrite !mxE.
Qed.
Fact dotmx_is_dotmx n (u : 'rV[C]_n) : u != 0 -> 0 < '[u].
Proof.
move=> u_neq0; rewrite dotmxE mxE.
suff /existsP[i ui_neq0] : [exists i, u 0 i != 0].
rewrite (bigD1 i) //= ltr_wpDr// ?sumr_ge0// ?mxE ?mul_conjC_gt0//.
by move=> j _; rewrite !mxE mul_conjC_ge0.
apply: contraNT u_neq0; rewrite negb_exists => /forallP uNN0.
by apply/eqP/rowP=> j; rewrite mxE; apply/eqP; rewrite -[_ == _]negbK uNN0.
Qed.
HB.instance Definition _ n := isDotProduct.Build _ _ (@dotmx n)
(@dotmx_is_dotmx n).
Local Notation "B ^!" :=
(orthomx conjC (mx_of_hermitian (hermitian1mx _)) B) :
matrix_set_scope.
Local Notation "A '_|_ B" := (A%MS <= B^!)%MS : bool_scope.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
row_unitarymxP
| |
orthomx1Em n p (A : 'M[C]_(m, n)) (B : 'M_(p, n)) :
(A '_|_ B)%MS = (A *m B^t* == 0).
Proof. by apply/sub_kermxP/eqP; rewrite !mul1mx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
orthomx1E
| |
orthomx1Pm n p {A : 'M[C]_(m, n)} {B : 'M_(p, n)} :
reflect (A *m B^t* = 0) (A '_|_ B).
Proof. by rewrite orthomx1E; exact/eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype choice ssrnat",
"From mathcomp Require Import seq div fintype bigop ssralg finset fingroup zmodp",
"From mathcomp Require Import poly polydiv order ssrnum matrix mxalgebra vector",
"From mathcomp Require Import mxpoly mxred sesquilinear"
] |
algebra/spectral.v
|
orthomx1P
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.