cmulwalsh This worksheet accompanies the following three-part paper:

Σχετικά έγγραφα
> `type/scalartype`:=proc(x) local st; return member(true,{seq(type(x,st),st=convert(_scalartypes,list))}); end proc: 3.

6.1. Dirac Equation. Hamiltonian. Dirac Eq.

2 Composition. Invertible Mappings

Section 8.3 Trigonometric Equations

EE512: Error Control Coding

Phys460.nb Solution for the t-dependent Schrodinger s equation How did we find the solution? (not required)

Example Sheet 3 Solutions

Lecture 2: Dirac notation and a review of linear algebra Read Sakurai chapter 1, Baym chatper 3

The Simply Typed Lambda Calculus

C.S. 430 Assignment 6, Sample Solutions

Finite Field Problems: Solutions

SCHOOL OF MATHEMATICAL SCIENCES G11LMA Linear Mathematics Examination Solutions

Other Test Constructions: Likelihood Ratio & Bayes Tests

CHAPTER 25 SOLVING EQUATIONS BY ITERATIVE METHODS

Εγκατάσταση λογισμικού και αναβάθμιση συσκευής Device software installation and software upgrade

DESIGN OF MACHINERY SOLUTION MANUAL h in h 4 0.

Nowhere-zero flows Let be a digraph, Abelian group. A Γ-circulation in is a mapping : such that, where, and : tail in X, head in

Homework 3 Solutions

HOMEWORK 4 = G. In order to plot the stress versus the stretch we define a normalized stretch:

Partial Trace and Partial Transpose

Math221: HW# 1 solutions

Εργαστήριο Ανάπτυξης Εφαρμογών Βάσεων Δεδομένων. Εξάμηνο 7 ο

department listing department name αχχουντσ ϕανε βαλικτ δδσϕηασδδη σδηφγ ασκϕηλκ τεχηνιχαλ αλαν ϕουν διξ τεχηνιχαλ ϕοην µαριανι

Srednicki Chapter 55

Approximation of distance between locations on earth given by latitude and longitude

3.4 SUM AND DIFFERENCE FORMULAS. NOTE: cos(α+β) cos α + cos β cos(α-β) cos α -cos β

Congruence Classes of Invertible Matrices of Order 3 over F 2

Every set of first-order formulas is equivalent to an independent set

Fourier Series. MATH 211, Calculus II. J. Robert Buchanan. Spring Department of Mathematics

Concrete Mathematics Exercises from 30 September 2016

Instruction Execution Times

ΚΥΠΡΙΑΚΗ ΕΤΑΙΡΕΙΑ ΠΛΗΡΟΦΟΡΙΚΗΣ CYPRUS COMPUTER SOCIETY ΠΑΓΚΥΠΡΙΟΣ ΜΑΘΗΤΙΚΟΣ ΔΙΑΓΩΝΙΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ 6/5/2006

The challenges of non-stable predicates

Partial Differential Equations in Biology The boundary element method. March 26, 2013

2. THEORY OF EQUATIONS. PREVIOUS EAMCET Bits.

Μηχανική Μάθηση Hypothesis Testing

Matrices and Determinants

derivation of the Laplacian from rectangular to spherical coordinates

Chapter 6: Systems of Linear Differential. be continuous functions on the interval

Ordinal Arithmetic: Addition, Multiplication, Exponentiation and Limit

ST5224: Advanced Statistical Theory II

TMA4115 Matematikk 3

Συστήματα Διαχείρισης Βάσεων Δεδομένων

Section 7.6 Double and Half Angle Formulas

VBA ΣΤΟ WORD. 1. Συχνά, όταν ήθελα να δώσω ένα φυλλάδιο εργασίας με ασκήσεις στους μαθητές έκανα το εξής: Version ΗΜΙΤΕΛΗΣ!!!!

Second Order Partial Differential Equations

Practice Exam 2. Conceptual Questions. 1. State a Basic identity and then verify it. (a) Identity: Solution: One identity is csc(θ) = 1

Space-Time Symmetries

Lecture 2. Soundness and completeness of propositional logic

Section 9.2 Polar Equations and Graphs

ANSWERSHEET (TOPIC = DIFFERENTIAL CALCULUS) COLLECTION #2. h 0 h h 0 h h 0 ( ) g k = g 0 + g 1 + g g 2009 =?

Reminders: linear functions

Problem Set 3: Solutions

4.6 Autoregressive Moving Average Model ARMA(1,1)

ΚΥΠΡΙΑΚΗ ΕΤΑΙΡΕΙΑ ΠΛΗΡΟΦΟΡΙΚΗΣ CYPRUS COMPUTER SOCIETY ΠΑΓΚΥΠΡΙΟΣ ΜΑΘΗΤΙΚΟΣ ΔΙΑΓΩΝΙΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ 19/5/2007

Solutions to Exercise Sheet 5

Jesse Maassen and Mark Lundstrom Purdue University November 25, 2013

ΚΥΠΡΙΑΚΗ ΕΤΑΙΡΕΙΑ ΠΛΗΡΟΦΟΡΙΚΗΣ CYPRUS COMPUTER SOCIETY ΠΑΓΚΥΠΡΙΟΣ ΜΑΘΗΤΙΚΟΣ ΔΙΑΓΩΝΙΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ 24/3/2007

Tridiagonal matrices. Gérard MEURANT. October, 2008

1 String with massive end-points

Potential Dividers. 46 minutes. 46 marks. Page 1 of 11

Advanced Subsidiary Unit 1: Understanding and Written Response

Exercises 10. Find a fundamental matrix of the given system of equations. Also find the fundamental matrix Φ(t) satisfying Φ(0) = I. 1.

Bounding Nonsplitting Enumeration Degrees

the total number of electrons passing through the lamp.

k A = [k, k]( )[a 1, a 2 ] = [ka 1,ka 2 ] 4For the division of two intervals of confidence in R +

Fractional Colorings and Zykov Products of graphs

Right Rear Door. Let's now finish the door hinge saga with the right rear door

Second Order RLC Filters

Homework 8 Model Solution Section

Dynamic types, Lambda calculus machines Section and Practice Problems Apr 21 22, 2016

Numerical Analysis FMN011

PARTIAL NOTES for 6.1 Trigonometric Identities

ΚΥΠΡΙΑΚΟΣ ΣΥΝΔΕΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ CYPRUS COMPUTER SOCIETY 21 ος ΠΑΓΚΥΠΡΙΟΣ ΜΑΘΗΤΙΚΟΣ ΔΙΑΓΩΝΙΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ Δεύτερος Γύρος - 30 Μαρτίου 2011

( ) 2 and compare to M.

Statistical Inference I Locally most powerful tests

IIT JEE (2013) (Trigonomtery 1) Solutions

= {{D α, D α }, D α }. = [D α, 4iσ µ α α D α µ ] = 4iσ µ α α [Dα, D α ] µ.

Example of the Baum-Welch Algorithm

Econ 2110: Fall 2008 Suggested Solutions to Problem Set 8 questions or comments to Dan Fetter 1

Areas and Lengths in Polar Coordinates

UNIVERSITY OF CAMBRIDGE INTERNATIONAL EXAMINATIONS International General Certificate of Secondary Education

( y) Partial Differential Equations

Answers - Worksheet A ALGEBRA PMT. 1 a = 7 b = 11 c = 1 3. e = 0.1 f = 0.3 g = 2 h = 10 i = 3 j = d = k = 3 1. = 1 or 0.5 l =

ΚΥΠΡΙΑΚΗ ΕΤΑΙΡΕΙΑ ΠΛΗΡΟΦΟΡΙΚΗΣ CYPRUS COMPUTER SOCIETY ΠΑΓΚΥΠΡΙΟΣ ΜΑΘΗΤΙΚΟΣ ΔΙΑΓΩΝΙΣΜΟΣ ΠΛΗΡΟΦΟΡΙΚΗΣ 11/3/2006

Overview. Transition Semantics. Configurations and the transition relation. Executions and computation

Notes on the Open Economy

LESSON 14 (ΜΑΘΗΜΑ ΔΕΚΑΤΕΣΣΕΡΑ) REF : 202/057/34-ADV. 18 February 2014

14 Lesson 2: The Omega Verb - Present Tense

Paper Reference. Paper Reference(s) 1776/04 Edexcel GCSE Modern Greek Paper 4 Writing. Thursday 21 May 2009 Afternoon Time: 1 hour 15 minutes

Solution Series 9. i=1 x i and i=1 x i.

D Alembert s Solution to the Wave Equation

SOLUTIONS TO MATH38181 EXTREME VALUES AND FINANCIAL RISK EXAM

Lecture 13 - Root Space Decomposition II

Orbital angular momentum and the spherical harmonics

forms This gives Remark 1. How to remember the above formulas: Substituting these into the equation we obtain with

9.09. # 1. Area inside the oval limaçon r = cos θ. To graph, start with θ = 0 so r = 6. Compute dr

Part III - Pricing A Down-And-Out Call Option

Cambridge International Examinations Cambridge International General Certificate of Secondary Education

Transcript:

restart:with(linalg):with(clifford):_prolevel:=true: read "Walshpackage.m": useproduct(cmulwalsh); _default_clifford_product; eval(makealiases(9'ordered')): Warning expecting one of the following Clifford products: cmulrs cmulnum cmulgen or cmul_user_defined Warning cmul will use cmulwalsh; for help see pages?cmul?clifford:-intro or?cmulwalsh This worksheet accompanies the following three-part paper: cmulwalsh "On the Transposition Anti-Involution in Real Clifford Algebras I: The Transposition Map" by R. Ablamowicz and B. Fauser 1 (to appear in Linear and Multilinear Algebra) "On the Transposition Anti-Involution in Real Clifford Algebras II: Stabilizer Groups of Primitive empotents" by R. Ablamowicz and B. Fauser 1 (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 11 (submitted to Linear and Multilinear Algebra) Rafal Ablamowicz rablamowicz@tntech.edu Cookeville June 1 11 New procedures: _shortcut_in_minimalideal:=false: _shortcut_in_kfield:=false: _shortcut_in_spinokbasis:=false: _shortcut_in_spinorkrepr:=false: _shortcut_in_minimalideal:=true: _shortcut_in_kfield:=true: _shortcut_in_spinokbasis:=true: _shortcut_in_spinorkrepr:=true: 1. Procedure "by_dimension" defines a Boolean-valued function which allows to sort a list L with signatures [pq according to a total dimension p+q. by_dimension:=proc(l1l) local p: options `Copyright (c) 1995-11 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`; description `Last revised: June 6 11`; if L1[+L1[ <= L[+L[ then return true else return false end if: end proc: read "LAMBDA.m": read "BETA_PLUS.m": read "BETA_MINUS.m":. New type needed by tp. `type/scalartype`:=proc(x) local st; return member(true{seq(type(xst)st=convert(_scalartypeslist))}); end proc: 3. Procedures beta_plus and beta_minus are expected to be faster versions of beta_plus and beta_minus which are built into CLIFFORD. ######################################################################################## beta_plus:= proc(psiphif) local locflocdataymflagmonsuueqlambdasyssolkbasvivarsflagftransversal; global B_prolevel; 1

options `Copyright (c) 1995-9 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`; description `Last revised: August 8 9`; ############################################# if not _prolevel then if not type(psi{cliscalarclibasmonclimonclipolynom}) then error "first argument must be of type 'cliscalar' 'clibasmon' 'climon' or 'clipolynom'" if not type(phi{cliscalarclibasmonclimonclipolynom}) then error "second argument must be of type 'cliscalar' 'clibasmon' 'climon' or 'clipolynom'" ###Load in pre-computed data and check if idempotents are the same locdata:=clifford:-clidata(b): locf:=eval(eval(locdata[4)); Kbas:=locdata[6; if nops(kbas)1 then flagf:=evalb(simplify(f-eval(locf))= or simplify(f-clifford:-gradeinv(locf))= or simplify(f+clifford:-gradeinv(locf))= or simplify(f+eval(locf))=); if not flagf then error "when K = C or K = H primitive idempotent f = plus/minus clidata(b)[4 or its grade involution" ######################################################################################## y:=cmul(reversion(expand(psi))expand(phi)); if y = then if nargs = 4 then if not type(args[4name) or type(args[4protected) then error "fourth optional argument when used must be of type unprotected name" else assign(args[4'') return ######################################################################################### m := 'm';i:='i': flag := false; #mons := cbasis(linalg[coldim(b)); transversal:=locdata[7: mons:=transversal: v := array(1.. nops(kbas)[); lambda := add(v[i*kbas[ii=1..nops(kbas)); for m in mons while not flag do uu := m; #eq := clicollect(cmul(my) - expand(cmul(lambdaf))); eq := clicollect(cmul(my) - expand(cmul(flambda))); sys := {coeffs(eq cliterms(eq))}; vars := {seq(v[i i = 1.. nops(kbas))}; sol := solve(sys vars); flag := not evalb(sol = NULL) end do: if nargs = 4 then if not type(args[4name) or type(args[4protected) then

error "fourth optional argument when used must be of type unprotected name" else assign(args[4uu) lambda:=subs(sollambda): if vectorpart(lambda)=lambda then return (scalarpart(lambda)) else return lambda end proc: ######################################################################################### save beta_plus"beta_plus.m": ######################################################################################### beta_minus:= proc(psiphif) local locflocdataymflagmonsuueqlambdasyssolkbasvivarsflagftransversal; global B_prolevel; options `Copyright (c) 1995-9 by Rafal Ablamowicz and Bertfried Fauser. All rights reserved.`; description `Last revised: August 8 9`; ############################################# if not _prolevel then if not type(psi{cliscalarclibasmonclimonclipolynom}) then error "first argument must be of type 'cliscalar' 'clibasmon' 'climon' or 'clipolynom'" if not type(phi{cliscalarclibasmonclimonclipolynom}) then error "second argument must be of type 'cliscalar' 'clibasmon' 'climon' or 'clipolynom'" ###Load in pre-computed data and check if idempotents are the same locdata := clidata(b): locf := eval(eval(locdata[4)); Kbas := locdata[6; if nops(kbas)1 then flagf:=evalb(simplify(f-eval(locf))= or simplify(f-clifford:-gradeinv(locf))= or simplify(f+clifford:-gradeinv(locf))= or simplify(f+eval(locf))=); if not flagf then error "when K = C or K = H primitive idempotent f = plus/minus clidata(b)[4 or its grade involution" ######################################################################################## y:=cmul(conjugation(expand(psi))expand(phi)); if y = then if nargs = 4 then if not type(args[4name) or type(args[4protected) then error "fourth optional argument when used must be of type unprotected name" else assign(args[4'') return ######################################################################################### m := 'm';i:='i': flag := false; ###mons := cbasis(linalg[coldim(b)); 3

transversal:=locdata[7: mons:=transversal: v := array(1.. nops(kbas)[); lambda := add(v[i*kbas[ii=1..nops(kbas)); for m in mons while not flag do uu := m; eq := clicollect(cmul(my) - expand(cmul(lambdaf))); sys := {coeffs(eq cliterms(eq))}; vars := {seq(v[i i = 1.. nops(kbas))}; sol := solve(sys vars); flag := not evalb(sol = NULL) end do: if nargs = 4 then if not type(args[4name) or type(args[4protected) then error "fourth optional argument when used must be of type unprotected name" else assign(args[4uu) lambda:=subs(sollambda): if vectorpart(lambda)=lambda then return scalarpart(lambda) else return lambda end proc: ##################################################################################### save beta_minus"beta_minus.m": ##################################################################################### 4. Procedure tp. ######################################################################### tp:=proc(xx::{scalartypeclibasmonclimonclipolynom}) local xlpcou: if type(xxscalartype) then return xx end if: x:=clifford:-displayid(xx): if type(xclibasmon) then if x= then return else p:=op(clifford:-cliterms(x)); L:=Clifford:-extract(p'integers'): L:=[seq(L[nops(L)-i+i=1..nops(L)); u:=clifford:-cmul(seq(b[l[il[i*cat(el[i)i=1..nops(l))); return Clifford:-reorder(u) end if: elif type(xclimon) then p:=op(clifford:-cliterms(x)): co:=coeff(xp); return co*procname(p) elif type(xclipolynom) then return Clifford:-clilinear(xprocname) end if: end proc: ######################################################################### ########################################################## #### CODE FOR SIMPLE ALGEBRAS (semisimple are below) ########################################################## L_real_simple:=sort(all_sigs(1..9'real''simple')by_dimension);nops(%); L_complex_simple:=sort(all_sigs(1..9'complex''simple')by_dimension);nops(%); L_quat_simple:=sort(all_sigs(1..9'quat''simple')by_dimension);nops(%); 4

L_real_simple := [ [ 1 1 [ [ [ 3 1 [ 6 [ 3 3 [ 4 [ 8 [ 1 7 [ 4 4 [ 5 3 [ 8 1 L_complex_simple := [ [ 1 [ 1 [ 3 [ 5 [ 3 [ 4 1 [ 1 6 [ 3 4 [ 5 [ 7 [ 9 [ 7 [ 4 5 [ 6 3 [ 8 15 L_quat_simple := [ [ [ 4 [ 1 3 [ 4 [ 1 5 [ 4 [ 5 1 [ 6 [ 6 [ 3 5 [ 6 [ 7 1 Adjustments if any: L_real_simple:=remove(memberL_real_simple[);nops(%); L_real_simple := [ [ 1 1 [ [ [ 3 1 [ 6 [ 3 3 [ 4 [ 8 [ 1 7 [ 4 4 [ 5 3 [ 8 1 L_complex_simple:=remove(memberL_complex_simple[[);nops(%); L_complex_simple := [ [ 1 [ 3 [ 5 [ 3 [ 4 1 [ 1 6 [ 3 4 [ 5 [ 7 [ 9 [ 7 [ 4 5 [ 6 3 [ 8 14 L_quat_simple:=remove(memberL_quat_simple[[);nops(%); L_quat_simple := [ [ 4 [ 1 3 [ 4 [ 1 5 [ 4 [ 5 1 [ 6 [ 6 [ 3 5 [ 6 [ 7 11 Execute code below for each signature in each list. For example j:=1: _prolevel:=true: pq:=op(l_real_simple[j); #pq:=op(l_complex_simple[j); ##pq:=op(l_quat_simple[j); B:=linalg[diag(1$p -1$q):#define form B for Cl(pq) eval(makealiases(p+q'ordered')): p q := 1 1 data:=clidata(b); #retrieve and display data about Cl(pq) data := real simple + [ [ [ e clibasis:=cbasis(p+q): f:=data[4:#assign pre-stored idempotent to f or use your own here K:=data[6; ##kfieldset:=convert(kfieldset); K := [ left_sbasis:=minimalideal(clibasisf'left'); Kbasis:=Kfield(left_sbasisf); SBgens:=left_sbasis[; FBgens:=Kbasis[; 'K'=K; left_sbasis := e + + [ left Kbasis := + SBgens := [ [ FBgens := [ K = [ K_basis:=spinorKbasis(SBgensfFBgens'left'); e K_basis := + + [ left for i from 1 to nops(k_basis[) do 5

ff i:=k_basis[[i; end do; Let's find matrices representing the basis vectors in S: k:=q-rhnumber(q-p); N:=^k; Thus spinors psi and phi have these components: ff1 := + e ff := + k := 1 N := for i from 1 to N do Psi i:=add(psi i j*fbgens[jj=1..nops(fbgens)); end do; Ψ1 := ψ11 Ψ := ψ1 for i from 1 to N do Phi i:=add(phi i j*fbgens[jj=1..nops(fbgens)); end do; Φ1 := φ11 Φ := φ1 Spinors Psispinor and Phispinor will then look as follows: Psispinor:= add(cmul(ff ipsi i) i=1..n); ψ11 ψ11 ψ1 ψ1 e Psispinor := + + + Phispinor:= add(cmul(ff iphi i) i=1..n); φ11 φ11 φ1 φ1 e Phispinor := + + + psimat:=matrix(n1[seq(psi ii=1..n)); phimat:=matrix(n1[seq(phi ii=1..n)); ψ11 psimat := ψ1 φ11 phimat := φ1 transversal:=data[7; transversal := [ e TO COMPUTE LAMBDA JUMP TO POINT 3 BELOW!!!!! ######################################################################################### ###################################################################### 1. We compute beta_plus using original definition in CLIFFORD and assign 'pure spinor' to s1: start:=time(): x:=beta_plus(psispinorphispinorf's1'); time()-start; 's1'=s1; x := ( ψ1 φ11 + ψ11 φ1) 6

.3 s1 =. We verify that s1 belongs to the transversal and that indeed cmul(s1reversion(psispinor)phispinor) belongs to K = f Cl(pq)f modulo f: member(s1transversal); true start:time(): xx:=cmul(s1reversion(psispinor)phispinor); time()-start; xx-cmul(xf); ## this should be zero if x = xx mod f ( ψ1 φ11 + ψ11 φ1) ( ψ1 φ11 + ψ11 φ1) xx := +.5 read "BETA_PLUS.m": assigned(beta_plus[[pq); ## checking if stored BETA_PLUS[[pq; ## displaying when stored [s1x; ## just computed true [ ( ψ1 φ11 + ψ11 φ1) [ ( ψ1 φ11 + ψ11 φ1) BETA_PLUS[[pq:=[s1x; save BETA_PLUS"BETA_PLUS.m"; BETA_PLUS [ 11 := [ ( ψ1 φ11 + ψ11 φ1) BP:=BETA_PLUS[[pq; ######################################################################################### ############### print(`##############`); print(`this SHOULD BE TRUE: `);flag5:=evalb(s1=bp[); ###<<<--- comparing pure spinors: EXPECTED TO BE TRUE print(`this SHOULD BE TRUE: `);flag6:=evalb(simplify(bp[-x)=); ###<<<--- comparing beta_plus stored and recomputed: EXPECTED TO BE TRUE print(`##############`); ######################################################################################### ############### flag56:=evalb(flag5 and flag6); BP := [ ( ψ1 φ11 + ψ11 φ1) ############## THIS SHOULD BE TRUE: flag5 := true THIS SHOULD BE TRUE: flag6 := true ############## flag56 := true ##BETA_PLUS[[pq:=[s1x; save BETA_PLUS"BETA_PLUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet ######################################################################################### ############### if not flag56 then BETA_PLUS[[pq:=[s1x; save BETA_PLUS"BETA_PLUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN BETA_PLUS for signature: `[pq); else 7

print(`entry IN BETA_PLUS for signature: `[pq`was OK.`); ENTRY IN BETA_PLUS for signature: [ 1 was OK. 'transversal'=transversal; transversal = [ 1. We compute beta_minus using original definition in CLIFFORD and assign 'pure spinor' to s: start:=time(): y:=beta_minus(psispinorphispinorf's'); time()-start; 's'=s; y := ( ψ1 φ11 + ψ11 φ1).15 s =. We verify that s belongs to the transversal and that indeed cmul(sconjugation(psispinor)phispinor) belongs to K = f Cl(pq)f modulo f: member(stransversal); true start:=time(): yy:=cmul(sconjugation(psispinor)phispinor); time()-start; yy-cmul(yf); ## this should be zero if y = yy mod f ( ψ1 φ11 ψ11 φ1) ( ψ1 φ11 ψ11 φ1) yy :=.47 read "BETA_MINUS.m"; assigned(beta_minus[[pq); BETA_MINUS[[pq; ## displaying when stored [sy; ## just computed true [ ( ψ1 φ11 + ψ11 φ1) [ ( ψ1 φ11 + ψ11 φ1) BETA_MINUS[[pq:=[sy; save BETA_MINUS"BETA_MINUS.m"; BM:=BETA_MINUS[[pq; ######################################################################################### ############### print(`##############`); print(`this SHOULD BE TRUE: `);flag7:=evalb(s=bm[); ###<<<--- comparing pure spinors print(`this SHOULD BE TRUE: `);flag8:=evalb(simplify(bm[-y)=); ###<<<--- comparing beta_minus stored and recomputed with new procedure print(`##############`); ######################################################################################### ############### flag78:=evalb(flag7 and flag8); BETA_MINUS [ 11 := [ ( ψ1 φ11 + ψ11 φ1) BM := [ ( ψ1 φ11 + ψ11 φ1) ############## THIS SHOULD BE TRUE: flag7 := true THIS SHOULD BE TRUE: flag8 := true 8

############## flag78 := true ##BETA_MINUS[[pq:=[sy; save BETA_MINUS"BETA_MINUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet if not flag78 then BETA_MINUS[[pq:=[sy; save BETA_MINUS"BETA_MINUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN BETA_MINUS for signature: `[pq); else print(`entry IN BETA_MINUS for signature: `[pq`was OK.`); ENTRY IN BETA_MINUS for signature: [ 1 was OK. The above has been checked for errors in these signatures: (a) real simple: (11) () () (31) (6) (33) (4) (8) (17) (44) (53) (8) (b) complex simple: (1) (3) (5) (3) (41) (16) (34) (5) (7) (9) (7) (45) (63) (81) (c) quaternionic simple: (4) (13) (4) (15) (4) (51) (6) (6) (35) (6) (71) ######################################################################################### ###################################################################### ######################################################################################### ###################################################################### 3. Here we compute lambda for simple algebras: ['p''q'=[pq; lambda:='lambda': Lambda:='Lambda': [ p q = [ 1 Lambda:=add(lambda[i*FBgens[ii=1..nops(FBgens)); vars:=[seq(lambda[ii=1..nops(fbgens)); ######################################################################################### ##### print(`###############`); start:=time(): out1:=cmul(tp(psispinor)phispinor); time()-start; print(`###############`); ######################################################################################### ##### sol:=op(clisolve(cmul(flambda)-out1vars)); Lambda1:=subs(sol Lambda); out1 - cmul(lambda1f); ###<<<--- This should be zero out1 - cmul(flambda1); ###<<<--- This is also zero because Lambda1 is in fcl(pq)f and f^=f cmul(lambda1f)-cmul(flambda1); ###<<<--- This should be zero Λ := λ 1 vars := [ λ 1 ############### ( ψ11 φ11 + ψ1 φ1) ( ψ11 φ11 + ψ1 φ1) out1 := +.3 9

############### sol := { λ 1 = ψ11 φ11 + ψ1 φ1} Λ1 := ( ψ11 φ11 + ψ1 φ1) LAMBDA[[pq:=Lambda1; save LAMBDA "LAMBDA.m"; LAMBDA [ 11 := ( ψ11 φ11 + ψ1 φ1) read "LAMBDA.m": LAM:=LAMBDA[[pq; LAM := ( ψ11 φ11 + ψ1 φ1) ######################################################################################### ############### print(`##############`); print(`this SHOULD BE TRUE: `);flaglambda1:=evalb(lam=lambda1); ###<<<--- comparing Lambda[pq saved with computed print(`##############`); ######################################################################################### ############### ############## THIS SHOULD BE TRUE: flaglambda1 := true ############## ##LAMBDA[[pq:=Lambda1; save LAMBDA "LAMBDA.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet ######################################################################################### ############### if not flaglambda1 then LAMBDA[[pq:=Lambda1; save LAMBDA "LAMBDA.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN LAMBDA for signature: `[pq); else print(`entry IN LAMBDA for signature: `[pq`was OK.`); ENTRY IN LAMBDA for signature: [ 1 was OK. The above has been checked for errors in these signatures: (a) real simple: (11) () () (31) (6) (33) (4) (8) (17) (44) (53) (8) (b) complex simple: (1) (3) (5) (3) (41) (16) (34) (5) (7) (9) (7) (45) (63) (81) (c) quaternionic simple: (4) (13) (4) (15) (4) (51) (6) (6) (35) (6) (71) LAM:=LAMBDA[[pq; x:=beta_plus[[pq[; xx:=beta_minus[[pq[; evalb(simplify(lam-lambda1)=); ###<<<--- comparing LAMBDA[[pq stored and recomputed with new procedure LAM := ( ψ11 φ11 + ψ1 φ1) x := ( ψ1 φ11 + ψ11 φ1) xx := ( ψ1 φ11 + ψ11 φ1) true if q= then evalb(simplify(lambda1-x)=) elif p= then evalb(simplify(lambda1-xx)=) 1

[pq; [ 1 'LAMBDA[[pq'=LAMBDA[[pq; LAMBDA [ pq = ( ψ11 φ11 + ψ1 φ1) 'BETA_PLUS[[pq'=BETA_PLUS[[pq; BETA_PLUS [ pq = [ ( ψ1 φ11 + ψ11 φ1) 'BETA_MINUS[[pq'=BETA_MINUS[[pq; BETA_MINUS [ pq = [ ( ψ1 φ11 + ψ11 φ1) assigned(beta_plus[[pq); assigned(beta_minus[[pq);assigned(lambda[[pq); true true true Repeat the above for all signatures in real complex and quaternionic simple Clifford algebras. ############################################################### Displaying signatures of all entries which have been computed: A. LAMBDA: L_indices_LAMBDA:=sort([indices(LAMBDA'nolist')by_dimension); L_indices_LAMBDA := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 ##LAMBDA[pq:=evaln(LAMBDA[pq); ###eliminating unneeded entry if needed ##save LAMBDA "LAMBDA.m"; B. BETA_PLUS: L_indices_BETA_PLUS:=sort([indices(BETA_PLUS'nolist')by_dimension); L_indices_BETA_PLUS := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 ##BETA_PLUS[pq:=evaln(BETA_PLUS[pq); ###eliminating unneeded entry if needed ##save BETA_PLUS "BETA_PLUS.m"; C. BETA_MINUS: L_indices_BETA_MINUS:=sort([indices(BETA_MINUS'nolist')by_dimension); L_indices_BETA_MINUS := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 ##BETA_MINUS[pq:=evaln(BETA_MINUS[pq); ###eliminating unneeded entry if needed ##save BETA_MINUS "BETA_MINUS.m"; Checking if there are any signatures [[pq left to compute LAMBDA[[pq BETA_PLUS[[pq or BETA_MINUS[[pq: A. For real simple first: L_real_simple:=sort(all_sigs(1..9'real''simple')by_dimension);nops(%); 11

L_real_simple := [ [ 1 1 [ [ [ 3 1 [ 6 [ 3 3 [ 4 [ 8 [ 1 7 [ 4 4 [ 5 3 [ 8 1 LAMBDA_to_do_real_simple:=[:for pq in L_real_simple do if not member(pql_indices_lambda) then LAMBDA_to_do_real_simple:=[op(LAMBDA_to_do_real_simple)pq end if end do; seq(pq=member(pql_indices_lambda)pq=l_real_simple); 'LAMBDA_to_do_real_simple'=LAMBDA_to_do_real_simple; ###<<<--- LAMBDA_to_do i real simple case LAMBDA_to_do_real_simple:=remove(memberLAMBDA_to_do_real_simple[); ###<<<--- adjusted LAMBDA_to_do in real simple case [ 1 = true [ = true [ = true [ 3 = true [ 6 = true [ 3 3 = true [ 4 = true [ 8 = true [ 1 7 = true [ 4 4 = true [ 5 3 = true [ 8 = true LAMBDA_to_do_real_simple = [ LAMBDA_to_do_real_simple := [ ########################################################## BETA_PLUS_to_do_real_simple:=[:for pq in L_real_simple do if not member(pql_indices_beta_plus) then BETA_PLUS_to_do_real_simple:=[op(BETA_PLUS_to_do_real_simple)pq end if end do; seq(pq=member(pql_indices_beta_plus)pq=l_real_simple); 'BETA_PLUS_to_do_real_simple'=BETA_PLUS_to_do_real_simple; ###<<<--- BETA_PLUS_to_do i real simple case BETA_PLUS_to_do_real_simple:=remove(memberBETA_PLUS_to_do_real_simple[); ###<<<--- adjusted BETA_PLUS_to_do_real_simple in real simple case [ 1 = true [ = true [ = true [ 3 = true [ 6 = true [ 3 3 = true [ 4 = true [ 8 = true [ 1 7 = true [ 4 4 = true [ 5 3 = true [ 8 = true BETA_PLUS_to_do_real_simple = [ BETA_PLUS_to_do_real_simple := [ ########################################################## BETA_MINUS_to_do_real_simple:=[:for pq in L_real_simple do if not member(pql_indices_beta_minus) then BETA_MINUS_to_do_real_simple:=[op(BETA_MINUS_to_do_real_simple)pq end if end do; seq(pq=member(pql_indices_beta_minus)pq=l_real_simple); 'BETA_MINUS_to_do_real_simple'=BETA_MINUS_to_do_real_simple; ###<<<--- BETA_MINUS_to_do i real simple case BETA_MINUS_to_do_real_simple:=remove(memberBETA_MINUS_to_do_real_simple[); ###<<<--- adjusted BETA_MINUS_to_do_real_simple in real simple case [ 1 = true [ = true [ = true [ 3 = true [ 6 = true [ 3 3 = true [ 4 = true [ 8 = true [ 1 7 = true [ 4 4 = true [ 5 3 = true [ 8 = true BETA_MINUS_to_do_real_simple = [ BETA_MINUS_to_do_real_simple := [ ########################################################## B. For complex simple next: L_complex_simple:=sort(all_sigs(1..9'complex''simple')by_dimension);nops(%); L_complex_simple := [ [ 1 [ 1 [ 3 [ 5 [ 3 [ 4 1 [ 1 6 [ 3 4 [ 5 [ 7 [ 9 [ 7 [ 4 5 [ 6 3 [ 8 15 LAMBDA_to_do_complex_simple:=[:for pq in L_complex_simple do if not member(pql_indices_lambda) then LAMBDA_to_do_complex_simple:=[op(LAMBDA_to_do_complex_simple)pq end if end do; seq(pq=member(pql_indices_lambda)pq=l_complex_simple); 'LAMBDA_to_do_complex_simple'=LAMBDA_to_do_complex_simple; ###<<<--- LAMBDA_to_do in complex simple case LAMBDA_to_do_complex_simple:=remove(memberLAMBDA_to_do_complex_simple[[); 1

###<<<--- adjusted LAMBDA_to_do in complex simple case [ = false [ 1 = true [ 3 = true [ 5 = true [ 3 = true [ 4 = true [ 1 6 = true [ 3 4 = true [ 5 = true [ 7 = true [ 9 = true [ 7 = true [ 4 5 = true [ 6 3 = true [ 8 = true LAMBDA_to_do_complex_simple = [[ LAMBDA_to_do_complex_simple := [ ########################################################## BETA_PLUS_to_do_complex_simple:=[:for pq in L_complex_simple do if not member(pql_indices_beta_plus) then BETA_PLUS_to_do_complex_simple:=[op(BETA_PLUS_to_do_complex_simple)pq end if end do; seq(pq=member(pql_indices_beta_plus)pq=l_complex_simple); 'BETA_PLUS_to_do_complex_simple'=BETA_PLUS_to_do_complex_simple; ###<<<--- BETA_PLUS_to_do in complex simple case BETA_PLUS_to_do_complex_simple:=remove(memberBETA_PLUS_to_do_complex_simple[[); ###<<<--- adjusted BETA_PLUS_to_do_complex_simple in complex simple case [ = false [ 1 = true [ 3 = true [ 5 = true [ 3 = true [ 4 = true [ 1 6 = true [ 3 4 = true [ 5 = true [ 7 = true [ 9 = true [ 7 = true [ 4 5 = true [ 6 3 = true [ 8 = true BETA_PLUS_to_do_complex_simple = [[ BETA_PLUS_to_do_complex_simple := [ ########################################################## BETA_MINUS_to_do_complex_simple:=[:for pq in L_complex_simple do if not member(pql_indices_beta_minus) then BETA_MINUS_to_do_complex_simple:=[op(BETA_MINUS_to_do_complex_simple)pq end if end do; seq(pq=member(pql_indices_beta_minus)pq=l_complex_simple); 'BETA_MINUS_to_do_complex_simple'=BETA_MINUS_to_do_complex_simple; ###<<<--- BETA_MINUS_to_do in complex simple case BETA_MINUS_to_do_complex_simple:=remove(memberBETA_MINUS_to_do_complex_simple[[); ###<<<--- adjusted BETA_MINUS_to_do_complex_simple in complex simple case [ = false [ 1 = true [ 3 = true [ 5 = true [ 3 = true [ 4 = true [ 1 6 = true [ 3 4 = true [ 5 = true [ 7 = true [ 9 = true [ 7 = true [ 4 5 = true [ 6 3 = true [ 8 = true BETA_MINUS_to_do_complex_simple = [[ BETA_MINUS_to_do_complex_simple := [ ########################################################## C. For quaternionic simple next: L_quat_simple:=sort(all_sigs(1..9'quat''simple')by_dimension);nops(%); L_quat_simple := [ [ [ 4 [ 1 3 [ 4 [ 1 5 [ 4 [ 5 1 [ 6 [ 6 [ 3 5 [ 6 [ 7 1 LAMBDA_to_do_quat_simple:=[:for pq in L_quat_simple do if not member(pql_indices_lambda) then LAMBDA_to_do_quat_simple:=[op(LAMBDA_to_do_quat_simple)pq end if end do; seq(pq=member(pql_indices_lambda)pq=l_quat_simple); 'LAMBDA_to_do_quat_simple'=LAMBDA_to_do_quat_simple; ###<<<--- LAMBDA_to_do in quat simple case LAMBDA_to_do_quat_simple:=remove(memberLAMBDA_to_do_quat_simple[[); ###<<<--- adjusted LAMBDA_to_do in quat simple case [ = false [ 4 = true [ 1 3 = true [ 4 = true [ 1 5 = true [ 4 = true [ 5 = true [ 6 = true [ 6 = true [ 3 5 = true [ 6 = true [ 7 = true LAMBDA_to_do_quat_simple = [[ LAMBDA_to_do_quat_simple := [ ########################################################## BETA_PLUS_to_do_quat_simple:=[:for pq in L_quat_simple do if not member(pql_indices_beta_plus) then BETA_PLUS_to_do_quat_simple:=[op(BETA_PLUS_to_do_quat_simple)pq end if end do; 13

seq(pq=member(pql_indices_beta_plus)pq=l_quat_simple); 'BETA_PLUS_to_do_quat_simple'=BETA_PLUS_to_do_quat_simple; ###<<<--- BETA_PLUS_to_do in quat simple case BETA_PLUS_to_do_quat_simple:=remove(memberBETA_PLUS_to_do_quat_simple[[); ###<<<--- adjusted BETA_PLUS_to_do_quat_simple in quat simple case [ = false [ 4 = true [ 1 3 = true [ 4 = true [ 1 5 = true [ 4 = true [ 5 = true [ 6 = true [ 6 = true [ 3 5 = true [ 6 = true [ 7 = true BETA_PLUS_to_do_quat_simple = [[ BETA_PLUS_to_do_quat_simple := [ ########################################################## BETA_MINUS_to_do_quat_simple:=[:for pq in L_quat_simple do if not member(pql_indices_beta_minus) then BETA_MINUS_to_do_quat_simple:=[op(BETA_MINUS_to_do_quat_simple)pq end if end do; seq(pq=member(pql_indices_beta_minus)pq=l_quat_simple); 'BETA_MINUS_to_do_quat_simple'=BETA_MINUS_to_do_quat_simple; ###<<<--- BETA_MINUS_to_do in quat simple case BETA_MINUS_to_do_quat_simple:=remove(memberBETA_MINUS_to_do_quat_simple[[); ###<<<--- adjusted BETA_MINUS_to_do_quat_simple in quat simple case [ = false [ 4 = true [ 1 3 = true [ 4 = true [ 1 5 = true [ 4 = true [ 5 = true [ 6 = true [ 6 = true [ 3 5 = true [ 6 = true [ 7 = true BETA_MINUS_to_do_quat_simple = [[ BETA_MINUS_to_do_quat_simple := [ ########################################################## ########################################################## #### CODE FOR SEMI-SIMPLE ALGEBRAS ########################################################## Now we compute Lambda beta_plus and beta_minus for semisimple algebras. L_real_semisimple:=sort(all_sigs(1..9'real''semisimple')by_dimension);nops(%); L_quat_semisimple:=sort(all_sigs(1..9'quat''semisimple')by_dimension);nops(%); L_real_semisimple := [[ 1 [ 1 [ 3 [ 7 [ 4 3 [ 1 8 [ 5 4 [ 9 8 L_quat_semisimple := [[ 3 [ 1 4 [ 5 [ 5 [ 6 1 [ 3 6 [ 7 7 Adjustments if any: L_real_semisimple:=remove(memberL_real_semisimple[[1);nops(%); L_real_semisimple := [[ 1 [ 3 [ 7 [ 4 3 [ 1 8 [ 5 4 [ 9 7 L_quat_semisimple:=remove(memberL_quat_semisimple[[);nops(%); L_quat_semisimple := [[ 3 [ 1 4 [ 5 [ 5 [ 6 1 [ 3 6 [ 7 7 Select signature and make initial assigmnents: L4:=L_real_semisimple; L5:=L_quat_semisimple; nops(l5); k:=1; L4 := [[ 1 [ 3 [ 7 [ 4 3 [ 1 8 [ 5 4 [ 9 L5 := [[ 3 [ 1 4 [ 5 [ 5 [ 6 1 [ 3 6 [ 7 14

7 k := 1 pq:=l5[k; pq:=op(pq); ppq:=p+q; pmq:=p-q; B:=diag(1$p-1$q); F:=LAMBDA[pq[;####<<<<--- here we take the first entry only as the second entry in LAMBDA[pq is the same kfield:=sort(convert(cliterms(f)list)bygrade); N:=^(q-RHnumber(q-p)-1); ###########################################NEW cdata:=clidata(pq); f:=eval(cdata[4); fg:=gradeinv(f); M:=cdata[7; ##transversal set transversal:=cdata[7; ##another name for M K:=cdata[6; ## basis for K 'kfield'=kfield: kfield:=k; ###########################################NEW pq := [ 3 p q := 3 ppq := 3 pmq := -3-1 B := -1-1 F := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) kfield := [ e N := 1 3 cdata := quaternionic 1 semisimple + [ e e3 [ e [ 3 f := + 3 fg := M := [ transversal := [ K := [ e kfield := [ e for i from 1 to N do Ps[i:=add((psi i j)*kfield[jj=1..nops(kfield)); Ph[i:=add((phi i j)*kfield[jj=1..nops(kfield)); end do: Psi_spinorPhi_spinor:=matrix(N1[seq(Ps[ii=1..N))matrix(N1[seq(Ph[ii=1..N)); Psi_spinor Phi_spinor := [ ψ11 + ψ1 + ψ13 e + ψ14 [ φ11 + φ1 + φ13 e + φ14 Psi_spinor:=add(cmul(transversal[ifPs[i)i=1..N); ### spinor psi in S = Cl(pq)f Phi_spinor:=add(cmul(transversal[ifPh[i)i=1..N); ### spinor phi in S = Cl(pq)f ψ11 ψ1 ψ13 e ψ14 e3 ψ14 ψ13 3 ψ1 e3 ψ11 3 Psi_spinor := + + + + + 15

φ11 φ1 φ13 e φ14 e3 φ14 φ13 3 φ1 e3 φ11 3 Phi_spinor := + + + + + Psi_spinorg:=add(cmul(transversal[ifgPs[i)i=1..N); ### spinor psi in Sg = Cl(pq)fg where fg = gradeinv(f) Phi_spinorg:=add(cmul(transversal[ifgPh[i)i=1..N); ### spinor phi in Sg = Cl(pq)fg where fg = gradeinv(f) ψ11 ψ1 ψ13 e ψ14 e3 ψ14 ψ13 3 ψ1 e3 ψ11 3 Psi_spinorg := + + + + + φ11 φ1 φ13 e φ14 e3 φ14 φ13 3 φ1 e3 φ11 3 Phi_spinorg := + + + + + 'signature'=[pq;'transversal'=transversal; signature = [ 3 transversal = [ TO COMPUTE LAMBDA[[pq = [Lambda1 Lambda1g in semisimple algebras jump to point 4 below. ######################################################################################### ######################################################## 1. We compute beta_plus in S and Sg using original definition in CLIFFORD and assign 'pure spinor' to s1 and s1g: x:='x':xx:='xx':xg:='xg':xxg:='xxg':s1:='s1':s1g:='s1g': start:=time(): x:=beta_plus(psi_spinorphi_spinorf's1'); 's1'=s1; time()-start; x := s1 =.15 N=^(q-RHnumber(q-p)-1);K;clidata(pq); 1 = 1 [ e 3 quaternionic 1 semisimple + [ e e3 [ e [ xg:=beta_plus(psi_spinorgphi_spinorgfg's1g'); 's1g'=s1g; xg := s1g =. We verify that s1 and s1g belong to the transversal and that indeed cmul(s1reversion(psi_spinor)phi_spinor) and cmul(s1greversion(psi_spinorg)phi_spinorg) belong to K = f Cl(pq)f modulo f: member(s1transversal); member(s1gtransversal); true true xx:=cmul(s1reversion(psi_spinor)phi_spinor); xx-cmul(xf); ## this should be zero if x = xx mod f xx := xxg:=cmul(s1greversion(psi_spinorg)phi_spinorg); xxg-cmul(xgfg); ## this should be zero if xg = xxg mod fg xxg := 16

3. We check what is assigned to BETA_PLUS[[pq: read "BETA_PLUS.m"; assigned(beta_plus[[pq); ## checking if stored BETA_PLUS[[pq; ## displaying when stored [[s1x[s1gxg; ## just computed true [[ [ [[ [ BETA_PLUS[[pq:=[[s1x[s1gxg; save BETA_PLUS"BETA_PLUS.m"; BETA_PLUS [ 3 := [[ [ BP:=BETA_PLUS[[pq; BP := [[ [ ######################################################################################### ############### print(`this SHOULD BE TRUE: `);flag1:=evalb(s1=bp[[); ###<<<--- comparing pure spinors: EXPECTED TO BE TRUE print(`this SHOULD BE TRUE: `);flag:=evalb(simplify(bp[[-x)=); ###<<<--- comparing beta_plus stored and recomputed: EXPECTED TO BE TRUE THIS SHOULD BE TRUE: flag1 := true THIS SHOULD BE TRUE: flag := true ######################################################################################### ############### print(`this SHOULD BE TRUE: `);flag3:=evalb(s1g=bp[[); ###<<<--- comparing pure spinors: EXPECTED TO BE TRUE print(`this SHOULD BE TRUE: `);flag4:=evalb(simplify(bp[[-xg)=); ###<<<--- comparing beta_plus stored and recomputed: EXPECTED TO BE TRUE THIS SHOULD BE TRUE: flag3 := true THIS SHOULD BE TRUE: flag4 := true ######################################################################################### ############### print(`###########`); flag134:=evalb(flag1 and flag and flag3 and flag4); ###if true then there is no need to save new data otherwise save print(`###########`); ########### flag134 := true ########### ######################################################################################### ############### if not flag134 then BETA_PLUS[[pq:=[[s1x[s1gxg; save BETA_PLUS"BETA_PLUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN BETA_PLUS for signature: `[pq); else print(`entry IN BETA_PLUS for signature: `[pq`was OK.`); 17

ENTRY IN BETA_PLUS for signature: [ 3 was OK. 1. We compute beta_minus in S and Sg using original definition in CLIFFORD and assign 'pure spinor' to s and sg: y:='y':yy:='yy':yg:='yg':yyg:='yyg':s:='s':sg:='sg': start:=time(): y:=beta_minus(psi_spinorphi_spinorf's'); 's'=s; time()-start; y := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) s =.38 start:=time(): yg:=beta_minus(psi_spinorgphi_spinorgfg'sg'); 'sg'=sg; time()-start; yg := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) sg =.3. We verify that s and sg belong to the transversal and that indeed cmul(sconjugation(psi_spinor)phi_spinor) and cmul(sgconjugation(psi_spinorg)phi_spinorg) belong to K = f Cl(pq)f modulo f: member(stransversal); member(sgtransversal); true true yy:=cmul(sconjugation(psi_spinor)phi_spinor); yy-cmul(yf); ## this should be zero if y = yy mod f yy := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) e + ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) e3 ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) 3 ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) 3 ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) e3 + + start:=time(): yyg:=cmul(sgconjugation(psi_spinorg)phi_spinorg); time()-start; yyg-cmul(ygfg); ## this should be zero if yg = yyg mod fg yyg := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) e ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) + ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) e3 ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) e3 ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) 3 ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) 3 18

3. We check what is assigned to BETA_MINUS[[pq:.188 read "BETA_MINUS.m"; assigned(beta_minus[[pq); ## checking if stored BETA_MINUS[[pq; ## displaying when stored [[sy[sgyg; ## just computed true [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) BETA_MINUS[[pq:=[[sy[sgyg; save BETA_MINUS"BETA_MINUS.m"; BETA_MINUS [ 3 := [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) BM:=BETA_MINUS[[pq; BM := [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ######################################################################################### ############### print(`this SHOULD BE TRUE: `);flag1:=evalb(s=bm[[); ###<<<--- comparing pure spinors: EXPECTED TO BE TRUE print(`this SHOULD BE TRUE: `);flag:=evalb(simplify(bm[[-y)=); ###<<<--- comparing beta_minus stored and recomputed: EXPECTED TO BE TRUE THIS SHOULD BE TRUE: flag1 := true THIS SHOULD BE TRUE: flag := true ######################################################################################### ############### print(`this SHOULD BE TRUE: `);flag3:=evalb(sg=bm[[); ###<<<--- comparing pure spinors: EXPECTED TO BE TRUE print(`this SHOULD BE TRUE: `);flag4:=evalb(simplify(bm[[-yg)=); ###<<<--- comparing beta_minus stored and recomputed: EXPECTED TO BE TRUE THIS SHOULD BE TRUE: flag3 := true THIS SHOULD BE TRUE: flag4 := true ######################################################################################### ############### 19

print(`###########`); flag134:=evalb(flag1 and flag and flag3 and flag4); ###if true then there is no need to save new data otherwise save print(`###########`); ########### flag134 := true ########### ######################################################################################### ############### if not flag134 then BETA_MINUS[[pq:=[[sy[sgyg; save BETA_MINUS"BETA_MINUS.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN BETA_MINUS for signature: `[pq); else print(`entry IN BETA_MINUS for signature: `[pq`was OK.`); [pq; L5; BETA_PLUS[pq; BETA_MINUS[pq; ENTRY IN BETA_MINUS for signature: [ 3 was OK. [ 3 [[ 3 [ 1 4 [ 5 [ 5 [ 6 1 [ 3 6 [ 7 [[ [ [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) The above has been checked for errors in these signatures: (a) real semisimple: (1) (3) (7) (43) (18) (54) (9) (b) quaternionic semisimple: (3) (14) (5) (5) (61) (36) (7) ######################################################################################### ###################################################################### ######################################################################################### ###################################################################### 4. Here we compute Lambda1 and Lambda1g for semi-simple algebras: ['p''q'=[pq; N:=^(q-RHnumber(q-p)-1); #number of K-components in 1/-spinor Psi_spinor in S and 1/-spinor Psi_spinorg in Sg K:=cdata[6; ## basis for K lambda:='lambda':lambda:='lambda': lambdag:='lambdag':lambdag:='lambdag': [ p q = [ 3 N := 1 K := [ e First we compute Lambda1 for Psi_spinor and Phi_spinor: Lambda:=add(lambda[i*K[ii=1..nops(K));

vars:=[seq(lambda[ii=1..nops(k)); ######################################################################################### ##### print(`###############`); start:=time(): out1:=cmul(tp(psi_spinor)phi_spinor); time()-start; print(`###############`); ######################################################################################### ##### sol1:=op(clisolve(cmul(flambda)-out1vars)); Lambda1:=subs(sol1 Lambda); out1 - cmul(lambda1f); ###<<<--- This should be zero out1 - cmul(flambda1); ###<<<--- This is also zero because Lambda1 is in fcl(pq)f and f^=f cmul(lambda1f)-cmul(flambda1); ###<<<--- This should be zero Λ := λ 1 + λ + λ 3 e + λ 4 vars := [ λ 1 λ λ 3 λ 4 ############### ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) out1 := ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) e ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) e3 + ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) 3 ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) e3 ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) 3 + +.79 ############### sol1 := { λ 1 = ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13 λ = ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14 λ 3 = ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14 λ 4 = ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1} Λ1 := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ##findquatmatrix33(lambda1nk"lambda"); Second we compute Lambda1g for Psi_spinorg and Phi_spinorg: Lambdag:=add(mu[i*K[ii=1..nops(K)); vars:=[seq(mu[ii=1..nops(k)); ######################################################################################### ##### print(`###############`); start:=time(): out:=cmul(tp(psi_spinorg)phi_spinorg); time()-start; print(`###############`); ######################################################################################### ##### sol:=op(clisolve(cmul(fglambdag)-outvars)); Lambda1g:=subs(sol Lambdag); out - cmul(lambda1gfg); ###<<<--- This should be zero 1

out - cmul(fglambda1g); ###<<<--- This is also zero because Lambda1g is in fgcl(pq)fg and fg^=fg cmul(lambda1gfg)-cmul(fglambda1g); ###<<<--- This should be zero Lambdag := µ 1 + µ + µ 3 e + µ 4 vars := [ µ 1 µ µ 3 µ 4 out := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) e ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) + ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) e3 ############### ( ψ14 φ13 ψ11 φ1 + ψ13 φ14 + ψ1 φ11) ( ψ11 φ14 + ψ14 φ11 + ψ1 φ13 ψ13 φ1) e3 ( ψ1 φ14 + ψ13 φ11 ψ11 φ13 + ψ14 φ1) 3 ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) 3.19 ############### sol := { µ 1 = ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13 µ = ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14 µ 3 = ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14 µ 4 = ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1} Lambda1g := ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ##findquatmatrix33(lambda1gnk"lambda"); Are these two forms the same? Yes but why? 'sol1'=sol1; 'sol'=sol; sol1 = { λ 1 = ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13 λ = ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14 λ 3 = ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14 λ 4 = ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1} sol = { µ 1 = ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13 µ = ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14 µ 3 = ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14 µ 4 = ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1} 'Lambda1'=Lambda1; Λ1 = ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) 'Lambda1g'=Lambda1g; Lambda1g = ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) evalb(lambda1-lambda1g=); Now we save if needed: LAMBDA[[pq:=[Lambda1Lambda1g; save LAMBDA "LAMBDA.m"; LAMBDA [ 3 := [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) true

+ ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) read "LAMBDA.m": read "BETA_PLUS.m": read "BETA_MINUS.m": LAM:=LAMBDA[[pq; LAM := [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) BETA_PLUS[[pq; BETA_MINUS[[pq; [[ [ [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ######################################################################################### ################################################## print(`##############`); print(`this SHOULD BE TRUE: `);flaglambda1:=evalb(simplify(lam[-lambda1)=); ###<<<--- comparing LAMBDA[pq[ saved with computed Lambda1 print(`##############`); print(`this SHOULD BE TRUE: `);flaglambda1g:=evalb(simplify(lam[-lambda1g)=); ###<<<--- comparing LAMBDA[pq[ saved with computed Lambda1g print(`##############`); print(`this SHOULD BE TRUE: `);flaglambda1lambda1g:=evalb(flaglambda1 and flaglambda1g); ######################################################################################### ################################################## ############## THIS SHOULD BE TRUE: flaglambda1 := true ############## THIS SHOULD BE TRUE: flaglambda1g := true ############## THIS SHOULD BE TRUE: flaglambda1lambda1g := true LAMBDA[[pq:=[Lambda1Lambda1g; save LAMBDA "LAMBDA.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet LAMBDA [ 3 := [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ######################################################################################### ################################################## if not flaglambda1lambda1g then LAMBDA[[pq:=[Lambda1Lambda1g; save LAMBDA "LAMBDA.m"; ### this may be needed if data stored is bad or it has not been computed and stored yet print(`saved NEW ENTRY IN LAMBDA for signature: `[pq); else print(`entry IN LAMBDA for signature: `[pq`was OK.`); ENTRY IN LAMBDA for signature: [ 3 was OK. 3

The above has been checked for errors in these signatures: (a) real semisimple: (1) (3) (7) (43) (18) (54) (9) (b) quaternionic semisimple:(3) (14) (5) (5) (61) (36) (7) LAM:=LAMBDA[[pq; beta_plus_no_pure:=[beta_plus[[pq[[beta_plus[[pq[[; beta_minus_no_pure:=[beta_minus[[pq[[beta_minus[[pq[[; LAM := [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) beta_plus_no_pure := [ beta_minus_no_pure := [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) if q= then evalb(simplify(lam-beta_plus_no_pure)=[) elif p= then evalb(simplify(lam-beta_minus_no_pure)=[) true [pq; [ 3 'LAMBDA[[pq'=LAMBDA[[pq; LAMBDA [ pq = [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) 'BETA_PLUS[[pq'=BETA_PLUS[[pq; BETA_PLUS [ pq = [[ [ 'BETA_MINUS[[pq'=BETA_MINUS[[pq; BETA_MINUS [ pq = [ [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) [ ( ψ11 φ11 + ψ1 φ1 + ψ14 φ14 + ψ13 φ13) + ( ψ1 φ11 + ψ14 φ13 + ψ11 φ1 ψ13 φ14) + ( ψ11 φ13 ψ14 φ1 ψ13 φ11 + ψ1 φ14) e + ( ψ11 φ14 ψ1 φ13 ψ14 φ11 + ψ13 φ1) assigned(beta_plus[[pq); assigned(beta_minus[[pq);assigned(lambda[[pq); true true true ######################################################################################### ######################## Displaying signatures of all entries which have been computed: A. LAMBDA: L_indices_LAMBDA:=sort([indices(LAMBDA'nolist')by_dimension); L_indices_LAMBDA := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 4

##LAMBDA[pq:=evaln(LAMBDA[pq); ###eliminating unneeded entry if needed ##save LAMBDA "LAMBDA.m"; B. BETA_PLUS: L_indices_BETA_PLUS:=sort([indices(BETA_PLUS'nolist')by_dimension); L_indices_BETA_PLUS := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 ##BETA_PLUS[pq:=evaln(BETA_PLUS[pq); ###eliminating unneeded entry if needed ##save BETA_PLUS "BETA_PLUS.m"; C. BETA_MINUS: L_indices_BETA_MINUS:=sort([indices(BETA_MINUS'nolist')by_dimension); L_indices_BETA_MINUS := [ [ 1 1 [ [ 1 [ 3 [ 3 [ 1 [ 1 3 [ 3 1 [ 4 [ 4 [ [ 1 4 [ 5 [ 5 [ 4 1 [ 3 [ 3 [ 5 1 [ 6 [ 4 [ 1 5 [ 6 [ 4 [ 3 3 [ 6 1 [ 3 4 [ 5 [ 1 6 [ 7 [ 4 3 [ 7 [ 5 [ 6 [ 3 5 [ 7 1 [ 4 4 [ 6 [ 8 [ 8 [ 1 7 [ 5 3 [ 6 3 [ 3 6 [ 8 1 [ 7 [ 9 [ 9 [ 5 4 [ 4 5 [ 1 8 [ 7 ##BETA_MINUS[pq:=evaln(BETA_MINUS[pq); ###eliminating unneeded entry if needed ##save BETA_MINUS "BETA_MINUS.m"; Checking if there are any signatures [[pq left to compute LAMBDA[[pq BETA_PLUS[[pq or BETA_MINUS[[pq: A. For real simple first: L_real_simple:=sort(all_sigs(1..9'real''simple')by_dimension);nops(%); L_real_simple := [ [ 1 1 [ [ [ 3 1 [ 6 [ 3 3 [ 4 [ 8 [ 1 7 [ 4 4 [ 5 3 [ 8 1 LAMBDA_to_do_real_simple:=[:for pq in L_real_simple do if not member(pql_indices_lambda) then LAMBDA_to_do_real_simple:=[op(LAMBDA_to_do_real_simple)pq end if end do; seq(pq=member(pql_indices_lambda)pq=l_real_simple); 'LAMBDA_to_do_real_simple'=LAMBDA_to_do_real_simple; ###<<<--- LAMBDA_to_do i real simple case LAMBDA_to_do_real_simple:=remove(memberLAMBDA_to_do_real_simple[); ###<<<--- adjusted LAMBDA_to_do in real simple case [ 1 = true [ = true [ = true [ 3 = true [ 6 = true [ 3 3 = true [ 4 = true [ 8 = true [ 1 7 = true [ 4 4 = true [ 5 3 = true [ 8 = true LAMBDA_to_do_real_simple = [ LAMBDA_to_do_real_simple := [ ########################################################## BETA_PLUS_to_do_real_simple:=[:for pq in L_real_simple do if not member(pql_indices_beta_plus) then BETA_PLUS_to_do_real_simple:=[op(BETA_PLUS_to_do_real_simple)pq end if end do; seq(pq=member(pql_indices_beta_plus)pq=l_real_simple); 'BETA_PLUS_to_do_real_simple'=BETA_PLUS_to_do_real_simple; ###<<<--- BETA_PLUS_to_do i real simple case BETA_PLUS_to_do_real_simple:=remove(memberBETA_PLUS_to_do_real_simple[); ###<<<--- adjusted BETA_PLUS_to_do_real_simple in real simple case [ 1 = true [ = true [ = true [ 3 = true [ 6 = true [ 3 3 = true [ 4 = true [ 8 = true [ 1 7 = true [ 4 4 = true [ 5 3 = true [ 8 = true BETA_PLUS_to_do_real_simple = [ 5

2025 © DocPlayer.gr Πολιτική Απορρήτου | Όροι Χρήσης | Σχόλια