 restart(1);maple_mode(1);cas_setup(0,0,0,1,0,1e-10,25,[1,50,0,25],0,0,0);#radians,pas de cmplx, pas de  Sqrt
 diag(seq(1,4)); diag(1$4);
diag(seq(i,i=1..4));
 A:=matrix(4,4)+1;v:=[seq(1,j=1..4)];
A*v;# Attention il retourne une ligne,pour xcas les vecteurs sont en ligne
purge(a);
 f:=(i,j)->if (i=j) then 0 else if (i<j) then a[i,j] else -a[j,i] fi;fi;
 matrix(4,4,f); d:=det(matrix(4,4,f)):
 factor(d);#c'est toujours un carre
 if (op(factor(d))[nops(factor(d))]) == 2 then print("OK c'est un  carre")  else print("PB ca doit etre un carre"); fi ;
 M:=matrix(8,8,f);
/* Methode type pivot, contre m\'ethode de Laplace,... mais ici la matrice£est antisymetrique.*/
 print("calcul du det 8x8 antisymetrique formel");
 d1:=det(M):
 // print("calcul du det 8x8 antisymetrique formel par det_minor");
 d2:=det_minor(M):
if normal(d1-d2) == 0 then print("OK c'est bien nul") else print("erreur") fi ; 
 FFFd2:=factor(d2);
 if (op(FFFd2)[nops(FFFd2)]) == 2 then print("OK pour le pfaffien 8x8")  else print("PB ca doit etre un carre"); fi ;
/* -------------------Illustration de la reduction de Jordan--------------------------------------------------------------------------------£ Construction de l'exemple: on veut une reponse de ce type:*/
 f:=(i,j)->if(i=j-1) then 1 else 0 fi;
 J:=matrix(8,8,f);#forme classique d'ordre 8.
 J[3,4]:=0:J[6,7]:=0:J;#2 blocs d'ordre 3 et un d'ordre 2.
/*  On veut faire un changement de base simple. Ex det=1 pour garder  des coeffs entiers.£ on cree une transvection:*/
 f:=(i,j)->if(i=j) then 1 else 0 fi;
 T:=proc(i,j,a)
 local A;
 A:=matrix(8,8,f):A[i,j]:=a;A;
 end proc;
 B:=matrix(8,8,b);
/*  faire Li<-Li+aLj c'est multiplier a gauche par T(i,j,a).£ Par exemple L3<- L3+aL2 c'est multiplier a GAUCHE par: T(3,2,a);*/
 T(3,2,a)*B;
/* En revanche: C2<-C2+aC3 c'est multplier a DROITE par T(3,2,a)*/
 B*T(3,2,a);
/* Remarquer que l'inverse de T(i,j,a) est T(i,j,-a)*/
 T(3,2,a)^(-1);
/* Donc conjuguer par T(i,j,a) c'est faire:£  Li <- Li+aLj et Cj <- Cj-aCi*/
 P:=T(6,7,2)*T(4,5,1)*T(3,2,2)*T(1,2,1):
 P,P^(-1);
/* Donc faire a l'ordinateur:*/
 N:=P*J*P^(-1):
/*   est identique a faire a la main a partir de J:£  L1 <- L1+L2 ; C2<-C2 - C1 puis£  L3 <- L3+2L2 ; C2 <- C2 -2C3£  L4 <- L4+L5 ; C5 <- C5 -C4£  L6 <- L6 +2 L7; C7 <- C7 -2 C6£  On a maintenant trouve un bel exercice: Trouver la forme de£  jordan de N et une matrice de passage pour l'obtenir.£  On calcule N^2 et son noyau.*/
 N,N^2;
 N2:=nullspace(N^2);
/*  on choisit a et b  independants modulo ker N^2 (qui est aussi im£  N). (attention a et b hors de ker N^2 est insuffisant).*/
  a:=[0,0,1,0,0,0,0,0]:b:=[0,0,0,0,0,1,0,0]:
 rank(matrix([op(N2),a,b]));# doit etre dim ker N^2 +2.
 N1:=nullspace(N);
/*  dim ker N^2 -dim ker N= 6-3=2+1 donc N.a,N.b doit etre complete par c£  tq N.a,N.b,c indep modulo ker N. Par exemple on prend celui la:*/
  c:=[0,0,0,0,0,0,0,1]:
/* On verifie qu'il convient:*/
 rank(matrix([op(N1),N*a,N*b,c]));
/* dim ker N - dim ker N^0=3 c'est donc engendr\'e par£N^2.a,N^2.b,N.c. Il n'y a plus rien a faire, et l'on prend £ la base suivante: (Attention pour xcas N*a... sont des lignes, on£ prend donc la transposee)*/
 Q:=transpose(matrix([(N^2)*a,N*a,a,(N^2)*b,N*b,b,N*c,c]));
/* On sait maintenant que Q^(-1)*N*Q doit donner J. verifification:*/
 if J==normal(Q^(-1)*N*Q) then print("La jordanisation est bonne") else print("on n'a pas retrouve J") fi;
/* --------------------------------------------------------------------------------------------------------------*/
/* Il s'agit donc de trouver les bases qui jordanisent l'endomorphisme.£On a N^3=0.£Il nous faut d'abord pour les 2 blocs de taille 3, une base de kerN^3/ker N^2£que l'on remonte ensuite dans  ker N^3 (Choix de a et b dans la question£precedente). Comme ker N^3/ker N^2 est de dimension £2, on a deja: card(GL2).(card ker N^2)^2. qui vaut: (p^2-1)*(p^2-p)*(p^6)^2.£reste le choix d'un vecteur non nul de ker N^2/(ker N +Im N) que l'on remonte.£ker N+im N est de dim 3+2. On a donc p-1 choix dans le quotient, soit (p-1)*p^5£choix pour le dernier vecteur a choisir (c dans la question precedente).*/
cardstab:=(p^2-1)*(p^2-p)*p^12*(p-1)*p^5;
/* Autre methode: On commence par choisir les  vecteurs de base qui sont dans le£noyau. On prend une base de Im N^2 qui est de dim 2, soit (p^2-1)*(p^2-p) puis£un vecteur du noyau hors de Im N^2. soit (p^3-p^2) choix. On cherche alors des£antecedants a ces vecteurs. (p^3 choix pour l'antecedant d'un vecteur) */
cardstab2:=(p^2-1)*(p^2-p)*(p^3-p^2)*(p^3)^3*(p^3)^2;
normal(cardstab-cardstab2);
cardGL8:=product((p^8-p^i),i=0..7);
cardorbite:=normal(cardGL8/cardstab);

/* -------------------------------------------Exercice---syntaxe et combinatoire£des matrice nilpotentes--------------------------------*/
 n:=5; purge(a);
 A:=matrix(n,n,(i,j)->a[n*(i-1)+j]);
 l:=[seq(a[i],i=1..n^2)];
/*  Pour convertir la liste l en une matrice a n colonne:*/
 A:=list2mat(l,n);
J:=matrix(n,n):J[1,2]:=1:J[3,4]:=1:J;
 L:=mat2list(A*J-J*A);
 C:=matrix(n^2,n^2,(i,j)->diff(L[i],a[j]));
 n^2-rank(C); #est la dim du commutateur de J.
 Nullspace(matrix([[2]])) mod 2; # est correct
 nullspace(matrix([[2]])) mod 2; # cherche d'abord le noyau sur Q puis le reduit mod2
 maple_mode(0); // en mode xcas il suffit d'utiliser %, on reste dans Z/2Z
 e2:=1 % 2; maple_mode(1);
 nullspace(matrix([[2*e2]]));
com:=Nullspace(C) mod 2;
COM:=[seq(list2mat(i,n),i=com)];
 v:=[1$13];
 v*COM;
 [1,2,3]*[a,b,c,d,e];
 convert(67,base,2);
convert(0,base,2);# Attention, il ne retoure pas 0 mais le vide.
 augment(convert(67,base,2),[0$10]); # pour ajouter des 0
 LCOM:=[];
/*
 print("Patienter SVP 2^13 tours");
 for i from 0 to 2^13-1 do
 ci:=convert(i,base,2);LCOM:=[op(LCOM),augment(ci,[0$(13-dim(ci))])*COM] od; 
 STAB:=select(x->(det(x) mod 2)<>0,LCOM);
if dim(STAB)==1536 then print("OK 1536") else print("Erreur") fi;
*/