> `type/scalartype`:=proc(x) local st; return member(true,{seq(type(x,st),st=convert(_scalartypes,list))}); end proc: 3.

Transcript

1 restart:with(clifford):with(linalg): eval(makealiases(9,'ordered')): eval(makealiases(9,'ordered')): ##read "Walshpackage.m"; ##useproduct(cmulwalsh); _default_clifford_product; Clifford:-cmulRS This worksheet accompanies the following three-part paper: "On the Transposition Anti-Involution in Real Clifford Algebras I: The Transposition Map" by R. Ablamowicz and B. Fauser, 2010 (to appear in Linear and Multilinear Algebra) "On the Transposition Anti-Involution in Real Clifford Algebras II: Stabilizer Groups of Primitive Idempotents" by R. Ablamowicz and B. Fauser, 2010 (to appear in Linear and Multilinear Algebra) "On the Transposition Anti-Involution in Real Clifford Algebras III: The Automorphism Group of the Transposition Scalar Product on Spinor Spaces" by R. Ablamowicz and B. Fauser, 2011 (submitted to Linear and Multilinear Algebra) Rafal Ablamowicz Cookeville, June 17, Procedure "by_dimension" defines a Boolean-valued function which allows to sort a list L with signatures [p,q] according to a total dimension p+q. by_dimension:=proc(l1,l2) local p: options `Copyright (c) by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`; description `Last revised: June 6, 2011`; if L1[1]+L1[ <= L2[1]+L2[ then return else return false 2. New type needed by tp `type/scalartype`:=proc(x) local st; return member(,{seq(type(x,st),st=convert(_scalartypes,list))}); 3. Procedure tp tp:=proc(xx::{scalartype,clibasmon,climon,clipolynom}) local x,l,p,co,u: if type(xx,scalartype) then return xx x:=clifford:-displayid(xx): if type(x,clibasmon) then if x=id then return Id else p:=op(clifford:-cliterms(x)); L:=Clifford:-extract(p,'integers'): L:=[seq(L[nops(L)-i+1],i=1..nops(L))]; u:=clifford:-cmul(seq(b[l[i],l[i]]*cat(e,l[i]),i=1..nops(l))); return Clifford:-reorder(u) elif type(x,climon) then p:=op(clifford:-cliterms(x)): co:=coeff(x,p); return co*procname(p) elif type(x,clipolynom) then return Clifford:-clilinear(x,procname) matkrepr([2,0],'left'); Cliplus has been loaded. Definitions for type/climon and type/clipolynom now include &C and &C[K]. Type?clip 1

2 rod for help. 1. Transposition of a dfmatrix: e1 =, e2 = dtranspose:=proc(mm) local M1,M2; return cdfmatrix(map(linalg:-transpose,ddfmatrix(mm))); Procedure that multiplies a ddfmatrix by a scalar: scalarmultiply:=proc(lambda,mm) local r,c,l; r,c:=linalg:-rowdim(mm),linalg:-coldim(mm); L:=ddfmatrix(MM): L:=map(evalm,lambda*L); return cdfmatrix(l); Procedure which checks if two ddfmatrices are equal: dequal:=proc(mm,nn) local MM1,MM2,NN1,NN2: MM1,MM2:=op(ddfmatrix(MM)); NN1,NN2:=op(ddfmatrix(NN)); return evalb(linalg:-equal(mm1,nn1) and linalg:-equal(mm2,nn2)); This procedure displays Id in matrices of the type dfmatrix: ddisplayid:=proc(mm::dfmatrix) local M1,M2; M1,M2:=op(ddfmatrix(MM)): M1,M2:=displayid(M1),displayid(M2); return cdfmatrix(m1,m2); This procedure computes a trace of a double filed matrix of type dfmatrix: dtrace:=proc(m::dfmatrix) local M1,M2: M1,M2:=op(ddfmatrix(M)); return [linalg:-trace(m1),linalg:-trace(m2)]; Here we have additional procedures that define: 1. `type/quaternionic` `type/quaternionicentry`:=proc(p::{clipolynom,climon,clibasmon}) local p1,co1,co2,co3,co4,s: p1:=clifford:-displayid(p): match(p1=co1*kfield[1]+co2*kfield[+co3*kfield[3]+co4*kfield[4],kfieldset,'s'); 2. Quaternionic conjugation in a subring of Cl(p,q) isomorphic to quaternions that has been chosen to represent "quaternionic" matrices in the spinor representation of Cl(p,q). This procedure can also act on quaternionic matrices and on matrices of type `dfmatrix` with quaternionic entries. quatconjugation:=proc(p::{quaternionicentry,numeric,array,dfmatrix}) local p1,s,co1,co2,co3,co4:global kfield; if type(p,numeric) then return p if type(p,dfmatrix) then return(clifford:-cdfmatrix(map(procname,clifford:-ddfmatrix(p)))) if type(p,array) then return map(procname,p) end if; p1:=clifford:-displayid(p): 2

3 match(p1=co1*kfield[1]+co2*kfield[+co3*kfield[3]+co4*kfield[4],kfieldset,'s'); subs(s,co1*kfield[1]-co2*kfield[-co3*kfield[3]-co4*kfield[4]); 3. 'quathermitationconjugation' is an anti-involution which is defined as a composition of transpositon and quaternionic conjugation in H = fcl(p,q)f. quathermitianconjugation:=proc(p::{array}) local p1,s,co1,co2: return linalg:-transpose(quatconjugation(p)); 4. 'dquathermitationconjugation' is an anti-involution which is defined as a composition of dtranspositon and quaternionic conjugation in Cl(p,q)f + gradeinv(cl(p,q)f). dquathermitianconjugation:=proc(p::{array}) local M12: M12:=ddfmatrix(dtranspose(p)): cdfmatrix(map(quatconjugation,m12)); stabilizer:=proc(f::idempotent,monomials::list({clibasmon,climon})) local m,p: option remember; P:=[]: for m in monomials do if cmul(m,f,cinv(m))=f then P:=[op(P),m] end do: return P; stabilizer:=proc(f::idempotent,monomials::list({clibasmon,climon})) local m,p,k: option remember; P:=[]: k:=0: for m in monomials do k:=k+1: if cmul(m,f)=cmul(f,m) then P:=[op(P),m]: print(k,m); end do: return P; This way we can check whether 1. The StabilizerGroup[p,q] is NOT Abelian, and, 2. Look for generators of that group. FF:=proc(i,j) local n;global pq,stab; option remember; n:=nops(stab[pq]); if evalb(i<=n and j<=n) then return cmul(stab[pq][i],stab[pq][j]) elif evalb(in and jn) then return procname(i-n,j-n) elif evalb(in and j<=n) then return (-1)*procname(i-n,j) elif evalb(i<=n and jn) then return (-1)*procname(i,j-n) else return "X" This procedure computes order of a group element: order_of_element:=proc(g::{clibasmon,climon}) local flag,k: 3

4 if g=id then return 1 flag:=: k:=1: while flag do k:=k+1: flag:=not evalb(cmul(g$k)=id): end do: return k; ###forget(order_of_element[pq]); order_of_element2:=proc(g::{clibasmon,climon}) local flag1,flag2,flag,k,k,m,co,pq; #option remember; pq:=op(1,procname); if g=id then return 1 if g=-id then return 2 if type(g,climon) then m:=op(cliterms(g)): co:=coeff(g,m)*id; if co=-1 then return lcm(2,procname[pq](m)) flag:=false: k:=1: K:=g: while not flag do k:=k+1: K:=cmul(K,g): flag1:=evalb(k=id): flag2:=evalb(k=-id): flag:=flag1 or flag2: end do: if flag1 then return k end if; if flag2 then return 2*k end if; order_of_element:=proc(g::{clibasmon,climon}) local flag1,flag2,flag,k,k,m,co,pq,mpq;global MONCMUL; ##option remember; Mpq:=op(1,procname); if g=id then return 1 if g=-id then return 2 if type(g,climon) then m:=op(cliterms(g)): co:=coeff(g,m)*id; if co=-1 then return lcm(2,procname['mpq'](m)) ####################################################### MONCMUL:=proc(a::{climon,clibasmon},b::{climon,clibasmon}) local m1,co1,m2,co2,l,sgn,n,i,bpq:global B: Bpq:=op(1,procname): if not type(bpq,diagmatrix) then return Clifford:-cmul[Bpq](a,b) co1,co2:=1,1: if type(a,climon) then m1:=op(clifford:-cliterms(a)): co1:=coeff(a,m1); else m1:=a if type(b,climon) then m2:=op(clifford:-cliterms(b)): 4

5 co2:=coeff(b,m2); else m2:=b if m1<m2 then return co1*co2*clifford:-cmul[bpq](m1,m2) L:=Clifford:-extract(m1,'integer'); n:=nops(l): sgn:=(-1)^(n*(n-1)/2); return sgn*co1*co2*mul(bpq[i,i],i=l)*id; ####################################################### flag:=false: k:=1: K:=g: while not flag do k:=k+1: K:=MONCMUL[Mpq](K,g): flag1:=evalb(k=id): flag2:=evalb(k=-id): flag:=flag1 or flag2: end do: if flag1 then return k end if; if flag2 then return 2*k end if; generategroup:=proc(l::list({climon,clibasmon})) local G,m,i,B:global FLAG_commuting_gens; B:=op(1,procname); if not FLAG_commuting_gens then G:={Id,op(L),op(map(cmul[B]@op,[seq(op(combinat:-permute(L,i)),i=1..(nops(L)))]))}; else G:={Id,op(L),op(map(cmul[B]@op,[seq(op(combinat:-choose(L,i)),i=1..(nops(L)))]))}; end if; G:=[seq(m,m=G),seq(-m,m=G)]; generategroup:=proc(l::list({climon,clibasmon})) local G,m,i,B:global FLAG_commuting_gens; B:=op(1,procname); if not FLAG_commuting_gens then G:={Id,op(L),op(map(cmul[B]@op,[seq(op(combinat:-permute(L,i)),i=1..(nops(L)))]))}; else G:={Id,op(L),op(map(cmul[B]@op,[seq(op(combinat:-choose(L,i)),i=1..(nops(L)))]))}; end if; G:=convert({seq(m,m=G)},list): return convert({seq(m,m=g),seq(-m,m=g)},list); Here we check whether Stab[p,q] = generategroup(gen[pq]) ####<<<<--- NOTE: Stab[p,q] is not a group, it is a list Stab[p,q] = StabilizerGroup[p,q] \cap clibasis NOTE: If not, try to guess for now correct Gen[p,q] using mygens. NOTE: We may not need element -Id to generate Stab[p,q] and StabilizerGroup[p,q] if there is an element of order 4 in Gen[p,q] 5

6 Here we check whether StabilizerGroup[p,q] = generategroup(gen[pq]); NOTE: If not, try to guess for now correct Gen[p,q] using mygens. read "Stab.m"; ####Stab:=table(): ##initialization indices(stab,'nolist'); [ 6, 2 ], [ 2, 4 ], [ 0, 7 ], [ 4, 3 ], [ 2, 0 ], [ 3, 2 ], [ 6, 3 ], [ 5, 0 ], [ 2, 5 ], [ 7, 0 ], [ 2, 6 ], [ 0, 6 ], [ 1, 8 ], [ 7, 2 ], [ 1, 1 ], [ 2, 3 ], [ 0, 4 ], [ 3, 0], [ 1, 2 ], [ 0, 5 ], [ 4, 0 ], [ 4, 1 ], [ 5, 1 ], [ 1, 5 ], [ 3, 3 ], [ 6, 1 ], [ 1, 4 ], [ 3, 6 ], [ 3, 5 ], [ 0, 3 ], [ 5, 4 ], [ 7, 1 ], [ 8, 1 ], [ 0, 9 ], [ 5, 2 ], [ 0, 8], [ 1, 3 ], [ 4, 2 ], [ 3, 4 ], [ 3, 1 ], [ 1, 7 ], [ 5, 3 ], [ 2, 1 ], [ 2, 2 ], [ 9, 0 ], [ 4, 5 ], [ 2, 7 ], [ 4, 4 ], [ 6, 0 ], [ 1, 6 ], [ 8, 0] read "StabilizerGroup.m"; ####StabilizerGroup:=table(): ##initialization indices(stabilizergroup,'nolist'); [ 6, 2 ], [ 2, 4 ], [ 0, 7 ], [ 4, 3 ], [ 2, 0 ], [ 3, 2 ], [ 6, 3 ], [ 5, 0 ], [ 2, 5 ], [ 7, 0 ], [ 2, 6 ], [ 0, 6 ], [ 1, 8 ], [ 7, 2 ], [ 1, 1 ], [ 2, 3 ], [ 0, 4 ], [ 3, 0], [ 1, 2 ], [ 0, 5 ], [ 4, 0 ], [ 4, 1 ], [ 5, 1 ], [ 1, 5 ], [ 3, 3 ], [ 6, 1 ], [ 1, 4 ], [ 3, 6 ], [ 3, 5 ], [ 0, 3 ], [ 5, 4 ], [ 7, 1 ], [ 8, 1 ], [ 0, 9 ], [ 5, 2 ], [ 0, 8], [ 1, 3 ], [ 4, 2 ], [ 3, 4 ], [ 3, 1 ], [ 1, 7 ], [ 5, 3 ], [ 2, 1 ], [ 2, 2 ], [ 9, 0 ], [ 4, 5 ], [ 2, 7 ], [ 4, 4 ], [ 6, 0 ], [ 1, 6 ], [ 8, 0] if pq=[0,3] then F3:=[e1,e2,e3]; ### in [0,3] F3:=convert(convert(generateGroup(F3),set),list); nops(%); matrix(2,nops(f3),(i,j)-if i=1 then order_of_element[pq](f3[j]) else F3[j] end if); save pq,f3,"f3.m"; ### F3 is saved from [0,3] signature ################################################################# elif pq=[5,0] then H3:=[e23,e24,e45]; ### in [5,0] H3:=convert(convert(generateGroup(H3),set),list); nops(%); matrix(2,nops(h3),(i,j)-if i=1 then order_of_element[pq](h3[j]) else H3[j] end if); save pq,h3,"h3.m"; ### H3 is saved from [5,0] signature ################################################################# elif pq=[6,1] then G3:=[e23,e24,e25]; ### in [6,1] G3:=convert(convert(generateGroup(G3),set),list); nops(%); matrix(2,nops(g3),(i,j)-if i=1 then order_of_element[pq](g3[j]) else G3[j] end if); save pq,g3,"g3.m"; ### G3 is saved from [6,1] signature elif pq=[3,6] then I3:=[e67,e68,e89]; ### in [3,6] I3:=convert(convert(generateGroup(I3),set),list); nops(%); matrix(2,nops(i3),(i,j)-if i=1 then order_of_element[pq](i3[j]) else I3[j] end if); save pq,i3,"i3.m"; ### I3 is saved from [3,6] signature elif pq=[7, then J3:=[e45,e57,e67]; ### in [7, J3:=convert(convert(generateGroup(J3),set),list); nops(%); matrix(2,nops(j3),(i,j)-if i=1 then order_of_element[pq](j3[j]) else J3[j] end if); save pq,j3,"j3.m"; ### J3 is saved from [7, signature end if; F3 should be isomorphic to G3: pq03:=[0,3]; 6

7 B03:=diag(1$pq03[1],-1$pq03[): F3gens:=[e1,e2,e3]; ### in [0,3] F3M:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); FLAG_commuting_gens:=type(F3M,symmatrix); ###<<<--- If this is, generators commute F3:=generateGroup['B03'](F3gens); pq03 := [ 0, 3] F3gens := [ e1, e2, e3 ] F3M := F3 := [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123 ] pq61:=[6,1]; B61:=diag(1$pq61[1],-1$pq61[): G3gens:=[e25,e24,e23]; ### in [6,1] G3M:=matrix(nops(G3gens),nops(G3gens),(i,j)-cmul[B61](G3gens[i],G3gens[j])); FLAG_commuting_gens:=type(G3M,symmatrix); ###<<<--- If this is, generators commute G3:=generateGroup['B61'](G3gens); pq61 := [ 6, 1] G3gens := [ e25, e24, e23 ] Id e45 e35 G3M := e45 Id e34 e35 e34 Id G3 := [ Id, e23, e24, e25, e34, e35, e45, e2345, Id, e23, e24, e25, e34, e35, e45, phi:='phi': phi(e1):=e25;phi(e2):=e24;phi(e3):=e23;phi(id):=id;phi(e123):=cmul[b61](phi(e1),phi(e2),p hi(e3)); phi(-e1):=-phi(e1);phi(-e2):=-phi(e2);phi(-e3):=-phi(e3);phi(-id):=-id;phi(-e123):=-cmul[ B61](phi(e1),phi(e2),phi(e3)); φ( e1 ) := e25 φ( e2 ) := e24 φ( e3 ) := e23 φ( Id ) := Id φ( e123 ) := e2345 φ e1 ( ) := e25 φ e2 ( ) := e24 φ e3 ( ) := e23 φ Id ( ) := Id φ e123 ( ) := e2345 for g1 in F3gens do for g2 in F3gens do phi(cmul[b03](g1,g2)):=cmul[b61](phi(g1),phi(g2)); end do; end do; M03:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); M61:=matrix(nops(G3gens),nops(G3gens),(i,j)-cmul[B61](G3gens[i],G3gens[j])); M03 := 7

8 Id e45 e35 M61 := e45 Id e34 e35 e34 Id phim03:=map(phi,evalm(m03)); Id e45 e35 phim03 := e45 Id e34 e35 e34 Id equal(phim03,m61); 'F3'=F3; F3 = [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123] 'G3'=G3; G3 = [ Id, e23, e24, e25, e34, e35, e45, e2345, Id, e23, e24, e25, e34, e35, e45, G33:=map(phi,F3); G33 := [ Id, e25, e24, e23, e45, e35, e34, e2345, Id, e25, e24, e23, e45, e35, e34, evalb(convert(g3,set)=convert(g33,set)); G3:=G33; G3 := [ Id, e25, e24, e23, e45, e35, e34, e2345, Id, e25, e24, e23, e45, e35, e34, matrix(2,nops(f3),[op(f3),op(g3)]); Id e1 e2 e3 e12 e13 e23 e123 Id e1 e2 e3 e12 e13 e23 e123 Id e25 e24 e23 e45 e35 e34 e2345 Id e25 e24 e23 e45 e35 e34 e2345 M03:=matrix(nops(F3),nops(F3),(i,j)-cmul[B03](F3[i],F3[j])): M61:=matrix(nops(G3),nops(G3),(i,j)-cmul[B61](G3[i],G3[j])): equal(map(phi,m03),m61); Is F3 isomorphic to H3? Yes, because H3 can be generated by three anticommuting generators e23, e24, e25. pq03:=[0,3]; B03:=diag(1$pq03[1],-1$pq03[): F3gens:=[e1,e2,e3]; ### in [0,3] F3M:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); FLAG_commuting_gens:=type(F3M,symmatrix); ###<<<--- If this is, generators commute F3:=generateGroup['B03'](F3gens); map(order_of_element[b03],f3); pq03 := [ 0, 3] F3gens := [ e1, e2, e3 ] F3M := F3 := [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123 ] pq50:=[5,0]; B50:=diag(1$pq50[1],-1$pq50[): H3gens:=[e23,e24,e45]; ### in [5,0] H3M:=matrix(nops(H3gens),nops(H3gens),(i,j)-cmul[B50](H3gens[i],H3gens[j])); FLAG_commuting_gens:=type(H3M,symmatrix); ###<<<--- If this is, generators commute H3:=generateGroup['B50'](H3gens); map(order_of_element[b50], H3); pq50 := [ 5, 0] 8

9 H3gens := [ e23, e24, e45 ] Id e34 e2345 H3M := e34 Id e25 e2345 e25 Id H3 := [ Id, e23, e24, e25, e34, e35, e45, e2345, Id, e23, e24, e25, e34, e35, e45, H3gens:=[e25,e24,e23]; ### new generators in [5,0] H3M:=matrix(nops(H3gens),nops(H3gens),(i,j)-cmul[B50](H3gens[i],H3gens[j])); FLAG_commuting_gens:=type(H3M,symmatrix); ###<<<--- If this is, generators commute H33:=generateGroup['B50'](H3gens); map(order_of_element[b50], H33); evalb(convert(h3,set)=convert(h33,set)); H3gens := [ e25, e24, e23 ] Id e45 e35 H3M := e45 Id e34 e35 e34 Id H33 := [ Id, e23, e24, e25, e34, e35, e45, e2345, Id, e23, e24, e25, e34, e35, e45, phi:='phi': phi(e1):=e25;phi(e2):=e24;phi(e3):=e23;phi(id):=id;phi(e123):=cmul[b50](phi(e1),phi(e2),p hi(e3)); phi(-e1):=-e25;phi(-e2):=-e24;phi(-e3):=-e23;phi(-id):=-id;phi(-e123):=-cmul[b50](phi(e1),phi(e2),phi(e3)); φ( e1 ) := e25 φ( e2 ) := e24 φ( e3 ) := e23 φ( Id ) := Id φ( e123 ) := e2345 φ e1 ( ) := e25 φ e2 ( ) := e24 φ e3 ( ) := e23 φ Id ( ) := Id φ e123 ( ) := e2345 for g1 in F3gens do for g2 in F3gens do phi(cmul[b03](g1,g2)):=cmul[b50](phi(g1),phi(g2)); end do; end do; M03:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); M50:=matrix(nops(H3gens),nops(H3gens),(i,j)-cmul[B50](H3gens[i],H3gens[j])); phim03:=map(phi,evalm(m03)); M03 := M50 := Id e45 e35 e45 Id e34 e35 e34 Id 9

10 Id e45 e35 phim03 := e45 Id e34 e35 e34 Id equal(phim03,m50); 'F3'=F3; F3 = [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123] 'H3'=H3; H3 = [ Id, e23, e24, e25, e34, e35, e45, e2345, Id, e23, e24, e25, e34, e35, e45, H33:=map(phi,F3); H33 := [ Id, e25, e24, e23, e45, e35, e34, e2345, Id, e25, e24, e23, e45, e35, e34, evalb(convert(h3,set)=convert(h33,set)); H3:=H33; H3 := [ Id, e25, e24, e23, e45, e35, e34, e2345, Id, e25, e24, e23, e45, e35, e34, matrix(2,nops(f3),[op(f3),op(h3)]); Id e1 e2 e3 e12 e13 e23 e123 Id e1 e2 e3 e12 e13 e23 e123 Id e25 e24 e23 e45 e35 e34 e2345 Id e25 e24 e23 e45 e35 e34 e2345 M03:=matrix(nops(F3),nops(F3),(i,j)-cmul[B03](F3[i],F3[j])): M50:=matrix(nops(H3),nops(H3),(i,j)-cmul[B50](H3[i],H3[j])): equal(map(phi,m03),m50); Is F3 isomorphic to I3? Yes, because I3 can be generated by three anticommuting generators e67, e68, e69. pq03:=[0,3]; B03:=diag(1$pq03[1],-1$pq03[): F3gens:=[e1,e2,e3]; ### in [0,3] F3M:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); FLAG_commuting_gens:=type(F3M,symmatrix); ###<<<--- If this is, generators commute F3:=generateGroup['B03'](F3gens); map(order_of_element[b03],f3); pq03 := [ 0, 3] F3gens := [ e1, e2, e3 ] F3M := F3 := [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123 ] pq36:=[3,6]; B36:=diag(1$pq36[1],-1$pq36[): I3gens:=[e67,e68,e89]; ### in [3,6] I3M:=matrix(nops(I3gens),nops(I3gens),(i,j)-cmul[B36](I3gens[i],I3gens[j])); FLAG_commuting_gens:=type(I3M,symmatrix); ###<<<--- If this is, generators commute I3:=generateGroup['B36'](I3gens); map(order_of_element[b36],i3); pq36 := [ 3, 6] I3gens := [ e67, e68, e89 ] Id e78 e6789 I3M := e78 Id e69 e6789 e69 Id 10

11 I3 := [ Id, e67, e68, e69, e78, e79, e89, e6789, Id, e67, e68, e69, e78, e79, e89, e6789 ] I3gens:=[e67,e68,e69]; ### new generators in [3,6] I3M:=matrix(nops(I3gens),nops(I3gens),(i,j)-cmul[B36](I3gens[i],I3gens[j])); FLAG_commuting_gens:=type(I3M,symmatrix); ###<<<--- If this is, generators commute I33:=generateGroup['B36'](I3gens); map(order_of_element[b36], I33); evalb(convert(i3,set)=convert(i33,set)); 'F3M'=evalm(F3M); I3gens := [ e67, e68, e69 ] Id e78 e79 I3M := e78 Id e89 e79 e89 Id I33 := [ Id, e67, e68, e69, e78, e79, e89, e6789, Id, e67, e68, e69, e78, e79, e89, e6789 ] F3M = phi:='phi': phi(e1):=e67;phi(e2):=e68;phi(e3):=e69;phi(id):=id;phi(e123):=cmul[b36](phi(e1),phi(e2),p hi(e3)); phi(-e1):=-e67;phi(-e2):=-e68;phi(-e3):=-e69;phi(-id):=-id;phi(-e123):=-cmul[b36](phi(e1),phi(e2),phi(e3)); φ( e1 ) := e67 φ( e2 ) := e68 φ( e3 ) := e69 φ( Id ) := Id φ( e123 ) := e6789 φ e1 ( ) := e67 φ e2 ( ) := e68 φ e3 ( ) := e69 φ Id ( ) := Id φ e123 ( ) := e6789 for g1 in F3gens do for g2 in F3gens do phi(cmul[b03](g1,g2)):=cmul[b36](phi(g1),phi(g2)); end do; end do; M03:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); M36:=matrix(nops(I3gens),nops(I3gens),(i,j)-cmul[B36](I3gens[i],I3gens[j])); phim03:=map(phi,evalm(m03)); M03 := M36 := Id e78 e79 e78 Id e89 e79 e89 Id 11

12 Id e78 e79 phim03 := e78 Id e89 e79 e89 Id equal(phim03,m36); 'F3'=F3; F3 = [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123] 'I3'=I3; I3 = [ Id, e67, e68, e69, e78, e79, e89, e6789, Id, e67, e68, e69, e78, e79, e89, e6789 ] I33:=map(phi,F3); I33 := [ Id, e67, e68, e69, e78, e79, e89, e6789, Id, e67, e68, e69, e78, e79, e89, e6789 ] evalb(convert(i3,set)=convert(i33,set)); I3:=I33; I3 := [ Id, e67, e68, e69, e78, e79, e89, e6789, Id, e67, e68, e69, e78, e79, e89, e6789 ] matrix(2,nops(f3),[op(f3),op(i3)]); Id e1 e2 e3 e12 e13 e23 e123 Id e1 e2 e3 e12 e13 e23 e123 Id e67 e68 e69 e78 e79 e89 e6789 Id e67 e68 e69 e78 e79 e89 e6789 M03:=matrix(nops(F3),nops(F3),(i,j)-cmul[B03](F3[i],F3[j])): M36:=matrix(nops(I3),nops(I3),(i,j)-cmul[B36](I3[i],I3[j])): equal(map(phi,m03),m36); Is F3 isomorphic to J3? Yes, because J3 can be generated by three anticommuting generators. pq03:=[0,3]; B03:=diag(1$pq03[1],-1$pq03[): F3gens:=[e1,e2,e3]; ### in [0,3] F3M:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); FLAG_commuting_gens:=type(F3M,symmatrix); ###<<<--- If this is, generators commute F3:=generateGroup['B03'](F3gens); map(order_of_element[b03],f3); pq03 := [ 0, 3] F3gens := [ e1, e2, e3 ] F3M := F3 := [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123 ] pq72:=[7,; B72:=diag(1$pq72[1],-1$pq72[): J3gens:=[e45,e57,e67]; ### in [7, J3M:=matrix(nops(J3gens),nops(J3gens),(i,j)-cmul[B7(J3gens[i],J3gens[j])); FLAG_commuting_gens:=type(J3M,symmatrix); ###<<<--- If this is, generators commute J3:=generateGroup['B72'](J3gens); map(order_of_element[b7,j3); pq72 := [ 7, J3gens := [ e45, e57, e67 ] Id e47 e4567 J3M := e47 Id e56 e4567 e56 Id 12

13 J3 := [ Id, e45, e46, e47, e56, e57, e67, e4567, Id, e45, e46, e47, e56, e57, e67, e4567] J3gens:=[e45,e56,e57]; ### new generators in [7, J3M:=matrix(nops(J3gens),nops(J3gens),(i,j)-cmul[B7(J3gens[i],J3gens[j])); FLAG_commuting_gens:=type(J3M,symmatrix); ###<<<--- If this is, generators commute J33:=generateGroup['B72'](J3gens); map(order_of_element[b7, J33); evalb(convert(j3,set)=convert(j33,set)); 'F3M'=evalm(F3M); J3gens := [ e45, e56, e57 ] Id e46 e47 J3M := e46 Id e67 e47 e67 Id J33 := [ Id, e45, e46, e47, e56, e57, e67, e4567, Id, e45, e46, e47, e56, e57, e67, e4567 ] F3M = phi:='phi': phi(e1):=e45;phi(e2):=e56;phi(e3):=e57;phi(id):=id;phi(e123):=cmul[b7(phi(e1),phi(e2),p hi(e3)); phi(-e1):=-e45;phi(-e2):=-e56;phi(-e3):=-e57;phi(-id):=-id;phi(-e123):=-cmul[b7(phi(e1),phi(e2),phi(e3)); φ( e1 ) := e45 φ( e2 ) := e56 φ( e3 ) := e57 φ( Id ) := Id φ( e123 ) := e4567 φ e1 ( ) := e45 φ e2 ( ) := e56 φ e3 ( ) := e57 φ Id ( ) := Id φ e123 ( ) := e4567 for g1 in F3gens do for g2 in F3gens do phi(cmul[b03](g1,g2)):=cmul[b7(phi(g1),phi(g2)); end do; end do; M03:=matrix(nops(F3gens),nops(F3gens),(i,j)-cmul[B03](F3gens[i],F3gens[j])); M72:=matrix(nops(J3gens),nops(J3gens),(i,j)-cmul[B7(J3gens[i],J3gens[j])); phim03:=map(phi,evalm(m03)); M03 := M72 := Id e46 e47 e46 Id e67 e47 e67 Id 13

14 Id e46 e47 phim03 := e46 Id e67 e47 e67 Id equal(phim03,m72); 'F3'=F3; F3 = [ Id, e1, e2, e3, e12, e13, e23, e123, Id, e1, e2, e3, e12, e13, e23, e123] 'J3'=J3; J3 = [ Id, e45, e46, e47, e56, e57, e67, e4567, Id, e45, e46, e47, e56, e57, e67, e4567 ] J33:=map(phi,F3); J33 := [ Id, e45, e56, e57, e46, e47, e67, e4567, Id, e45, e56, e57, e46, e47, e67, e4567 ] evalb(convert(j3,set)=convert(j33,set)); J3:=J33; J3 := [ Id, e45, e56, e57, e46, e47, e67, e4567, Id, e45, e56, e57, e46, e47, e67, e4567] matrix(2,nops(f3),[op(f3),op(j3)]); Id e1 e2 e3 e12 e13 e23 e123 Id e1 e2 e3 e12 e13 e23 e123 Id e45 e56 e57 e46 e47 e67 e4567 Id e45 e56 e57 e46 e47 e67 e4567 M03:=matrix(nops(F3),nops(F3),(i,j)-cmul[B03](F3[i],F3[j])): M72:=matrix(nops(J3),nops(J3),(i,j)-cmul[B7(J3[i],J3[j])): equal(map(phi,m03),m72); QED 14