Algebraic reduction in discrete light-cone quantized electrodynamics using Maple V

Computer Physics Communications 132 (2000) 21–29 www.elsevier.nl/locate/cpc

Algebraic reduction in discrete light-cone quantized electrodynamics using Maple V Frank E. Harris a,b a Department of Physics, University of Utah, Salt Lake City, UT 84112, USA b Quantum Theory Project, University of Florida, P.O. Box 118435, Gainesville, FL 32611, USA

Received 23 February 1999; received in revised form 16 February 2000

Abstract This paper describes a symbolic computation system within the Maple V environment for carrying out algebraic reductions useful in a discrete light-cone quantization formulation of quantum electrodynamics. Elements of the resulting program package are identified and some typical applications are presented.  2000 Published by Elsevier Science B.V.

1. Introduction Studies of discrete light-cone quantization (DLCQ) methods for quantum electrodynamics (QED), both in our laboratory [1] and in published work by others [2], have led to relatively complicated algebraic expressions whose eventual reduction to tractable forms has involved a large amount of tedious and error-prone manipulation. The standard facilities of packages such as Maple V [3] do not provide a ready solution to the problems associated with such reductions, in large part because of the variety of the algebraic objects and the diversity of their combination rules. An adequate package for this purpose must handle lepton spinors and spinor matrices, photon spinors (polarization vectors) and matrices in their space, differential and integral space-time operators, and also wavefunctions and creation/annihilation operators for photons and leptons. There is a package (HIP-Maple) designed for various high-energy physics computations [4], but the metric tensor hard-coded into that package precludes its easy use in the context of light-cone quantization. We introduce here a package designed to work within the Maple V environment for the reduction and manipulation of quantities arising in DLCQ-QED, with tools that will facilitate creation and visualization of the objects being manipulated and with enough simplification power to reach useful results without large amounts of “Maple expertise”. The definitions introduced make it natural for most repeated-index summations to be framed as matrix operations, and we follow the Maple philosophy of letting the user control the time of expression evaluation (here by use of the package function evalqed). One of the by-products of this philosophy is the ability to structure the package so that a single symbol for possibly non-commutative multiplication is used (the “traditional Maple E-mail address: [email protected] (F.E. Harris). 0010-4655/00/$ – see front matter  2000 Published by Elsevier Science B.V. PII: S 0 0 1 0 - 4 6 5 5 ( 0 0 ) 0 0 1 3 3 - 8

22

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

symbol” &*), together with ordinary + and - signs, and parentheses are required only when they would be needed in normal algebraic notation. While the present package is clearly restricted to Abelian gauge theories, it is not inconceivable that the methods it illustrates could suggest how an extension could be made to a non-Abelian regime such as would be needed for application to quantum chromodynamics (QCD). The package was originally developed under Maple V, Release 3. An attempt to revise it for compatibility with Release 5 revealed that a number of Maple language changes made the task impossible without major alterations to the implementation. Since the developers of Maple appear to be following a strategy that neither gives great weight to inter-release compatibility nor preserves maximum generality (particularly with respect to multi-type data structures), the package was redesigned to minimize its dependence on language features that might soon be changed. The software described in this communication (for Maple V, Release 5) is available without charge from a Web page maintained by the author [5]. Unfortunately there can be no guarantee of performance under future Maple releases. 2. Spinor types and operations Central to the package is a set of type definitions which identify various kinds of algebraic objects. The special characters # and @ are built into the spinor definitions to reduce the chance of collision with user-generated names. A procedure build has been introduced to avoid the awkwardness of explicit introduction of the special characters (in which case back-quotes would need to be used), and a procedure show is provided to aid in visualization. Lepton spinors have type row_spinor or column_spinor; photon spinors, which are vectors in the two components x 1 and x 2 , have type row_pol or column_pol. We illustrate (examples are presented as fragments of a Maple session, but with the output on the same line as the input when space can thereby be saved): > CS := build(column_spinor,1,0,1,0);

CS := c#(1, 0, 1, 0)

> RS := build(row_spinor,1,-1,1,-1);

RS := r#(1, -1, 1, -1)

> CP1 := build(column_pol,1,I);

CP1 := c@(1, I)

> CP2 := build(column_pol,1,-I);

CP2 := c@(1, - I)

> RP1 := build(row_pol,1,I);

RP1 := r@(1, I)

> RPZ := build(row_pol,0,0);

RPZ := r@(0, 0)

Each spinor is internally represented as a function whose name is also defined to be its type; more experienced users may replace, e.g., row_pol with ‘r@‘ in the build command, or explicitly construct a quantity such as ‘r@‘(1,-I). Visualization can be achieved by use of show: > show(RS);

[ 1 -1

> show(CP1);

[ 1 ] [ ] [ I ]

1 -1]

Note, however, that the output of show cannot be used as input for further operations of the package.

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

23

Matrices of either lepton spinor or photon spinor type can be formed by build from individual elements (using type names spinor_matrix or pol_matrix), from a column of rows, or from a row of columns. No matter how formed using build, a matrix is stored in a standard form, namely as a function whose arguments are its successive rows, prefaced by the function name m# or m@. Matrices explicitly constructed by the user must be in standard form; this requirement applies also to the compound types to be introduced below. Examples of matrix construction: > T := build(pol_matrix,1,2,3,4);

T := m@(r@(1, 2), r@(3, 4))

> show(T);

[ 1 [ [ 3

> build(row_pol,CP1,CP2);

2 ] ] 4 ]

m@(r@(1, 1),r@(I, - I))

Matrix operations can be set up using the operators &*, +, and -. It is only necessary to use &* where needed to control the ordering of factors; other multiplications (as, for example, to introduce constant factors) can be constructed using the usual * sign. The operations involving noncommutative multiplications are not carried out until the function evalqed is applied. If all elements of a spinor quantity evaluate to zero, it is replaced by a simple zero. For example, > T := 3 &* CP1 + CP2;

T := (3 &* c@(1, I)) + c@(1, - I)

> show(T);

> evalqed(T); > show(evalqed(T));

> show(evalqed(CP1 &* RP1));

> evalqed(RPZ);

/ [ 1 ]\ [ 1 ] |3 &* [ ]| + [ ] \ [ I ]/ [ - I ] c@(4, 2 I) [ 4 ] [ ] [ 2 I ] [ 1 [ [ I

I ] ] -1 ] 0

The package permits the construction and manipulation of compound types in which each element of, say, a lepton spinor matrix is itself a photon spinor or photon spinor matrix, and may contain operators of other types to be introduced in later sections of this paper. Such compound types are, whether created by build or as the result of multiplication, brought to a standard form. When any of the types here introduced are involved in multiplications, the function evalqed adjusts the associative grouping of the operations so as to obtain a reduction whenever possible, irrespective of the groupings explicitly or implicitly provided by the input. Before simplification, Maple assumes left associativity for the operator &* unless overridden by input parentheses; if expressions involving &* are simplified, they are written in a wholly associative form. Thus,

24

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

> T1 := evalqed(RP1 &* RS); T1 := r#r@(r@(1, I), r@(-1, - I), r@(1, I), r@(-1, - I)) > T2 := evalqed(CP2 &* CS); T2 := c#c@(c@(1, - I), 0, c@(1, - I), 0) > evalqed(T1 &* T2);

4

> evalqed(RP1 &* (RS &* CP2) &* CS);

4

> show(evalqed(RS &* CP2));

[ [ 1 ] [ [ ] [ [ - I ]

> show(RP1&*RS&*CP2&*CS); / |([ 1 \

I ] &* [ 1

-1

1

[ -1 ] [ ] [ I ]

[ 1 ] [ ] [ - I ]

[ [ [ 1 ]\ [ -1 ]) &* [ ]| &* [ [ - I ]/ [ [ [

> evalqed(RP1 &* RS &* CP2 &* CS);

[ -1 ] ] [ ] ] [ I ] ]

1 ] ] 0 ] ] 1 ] ] 0 ]

4

In addition to multiplication, the matrix operations adjunct and conjugate are available via the procedures adj and conj. These operations are evaluated immediately (i.e. they do not wait for an application of evalqed).

3. Dynamical operators and wavefunctions Dynamical operators are represented by appropriate names to which values must not be assigned. We use a_(s,n), b_(s,n), and d_(s,n) respectively for photon, electron, and positron annihilation operators for a particle in spin state s and in a “spatial” state corresponding to a plane wave of base index n, where the index is an “underscore vector”, usually written in ordinary text as n. No user assignment may be attached to any quantity used in this package as a plane-wave index. For the photon, s must evaluate to ±1; for electrons or positrons, to ±1/2. Underscore vectors are with respect to the metric defined in the papers of Ref. [2]. The dot product of n with a vector x is n · x = (1/2)n+ x − − n1 x 1 − n2 x 2 , and integrals over light-cone position are with respect to the variables x − , x 1 , x 2 . Creation operators are represented as a*(s,n), b*(s,n), and d*(s,n) – the ASCII character set has no dagger. When processed via evalqed, the package interprets f(x,n) (which must not be assigned a value by the user) as f (x, n) = exp(in · x) and appropriately processes the application thereto of differential and integral operators as described in a later section. Operations leading to individual components of n result in output suffixes that are to be interpreted as superscripts. The procedure conj works on wavefunctions, and adj converts between creation and annihilation operators. The functionality described in this and the preceding section enables the description of quantities central to DLCQ-QED, such as the unnormalized column-spinor lepton field operator

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

25

> psi := proc(s,n); > f_spin[s] &* (b_(s,n)&*conj(f(x,n)) + ‘d*‘(-s,n)&*f(x,n)) end: with f_spin[1/2] := c#(rhalf, 0, rhalf, 0), f_spin[−1/2] := c#(0, rhalf, 0, −rhalf),

and rhalf := 1/sqrt(2).

The electromagnetic field operator can take the row-vector form, unnormalized and omitting a factor (n+ )−1/2 : > A := proc(s,n); > a_(s,n)&*b_spin[s]&*conj(f(x,n)) + ‘a*‘(s,n)&*conj(b_spin[s])&*f(x,n) > end: with b_spin[1] := r@(−rhalf, −I ∗ rhalf), b_spin[−1] := r@(rhalf, −I ∗ rhalf). Upon application of evalqed, dynamical operators are permuted to the right through other quantities and then, using their commutation relations, brought to normal order (generically, a*a_b*d*b_d_). The Kronecker symbols that in principle arise when the indices of a product coincide are ignored. Expressions involving wavefunctions f(x,n) are deemed integrated over x. The Jacobian connecting x with (x 1 , x 2 , x 3 ) (actually equal to 1/2) is ignored, as is the volume of the x space. Because the n component n+ is restricted to positive values, expressions that contain a f(x,n) will vanish upon integration unless the expression also contains a conj(f(x,m)) (and vice versa); the combination of these wavefunctions will then, upon integration, lead to a three-dimensional Kronecker delta in the underscore vector components. In output from the package, these delta functions will take forms such as delta(n − m). Because of the limitation of f(x,n) to index values with positive n+ , the package makes no provision for the user to represent products such as f(x,n)*f(x,m) as f(x,n+m). Simplifications for which the latter representation might be a logical first step will be carried out directly from the former representation. 4. Differentiation and integration operators The symbols [D1], [D2], and [‘D+‘] (the list indicators [ ] are part of the symbol and back-quotes are needed to shield the + sign) stand for i∂1 , i∂2 , and i∂ + (which are respectively i∂/∂x 1 , i∂/∂x 2 , and 2i∂/∂x − ). [‘I+‘] is the operation inverse to [‘D+‘], and [‘I++‘] denotes two successive applications of [‘I+‘]. These operators are deemed to act on all factors to their right in a &* product irrespective of parentheses controlling associativity. The operator [‘I+‘] is defined in a way that eliminates homogeneous solutions to the inversion problem (see Ref. [2]); when applied to a single f (x, n) it yields −f (x, n)/n+ : > evalqed(conj(f(x,m)) &* [‘I+‘] &* f(x,n));

Delta(- m + n) - -------------n+

A frequent use of [D1] and [D2] is in repeated-index sums; it is convenient to define a quantity such as > D12 := build(row_pol,[D1],[D2]);

D12 := r@([D1], [D2])

For example, if v is a column vector c@(v1,v2), then i∂j v j (where j is summed over 1 and 2) becomes D12 &* v.

26

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

5. Plane-wave and spin summations The procedure D_sum(expr,n,m,...,q) causes, upon application of evalqed, the summation of expr with respect to the underscore indices n, m, . . . , q. The summations are infinite in extent and, in Maple terminology, “inert”. Expressions containing the Kronecker delta will not be collapsed. The procedure S_sum(expr,s,t,...,v) causes, upon application of evalqed, the summation of expr with respect to the two values ±1/2 for each of s, t, . . . , v. Because it will often turn out that there is only one independent spin index, the package treats only the sum over the first index as “inert”; any remaining index sums are explicitly carried out. Because the summations are always over ±1/2, photon spins will need to be indicated as two times the summation index. When both underscore and spin indices are to be summed, S_sum must be placed inside D_sum. Examples: > T := S_sum(conj(f(x,n))&*‘b*‘(s,n)&*f(x,m)&*d_(t,m),s,t): > evalqed(T); ----\ ) ((b*(s, n) &* d_(s, m)) delta(-n + m) / ----s + (b*(s, n) &* d_(-s, m)) delta(-n + m)) > evalqed(D_sum(T,n,m)); ----\ ) / ----n,m

/----| \ | ) ((b*(s, n) &* d_(s, m)) delta(-n + m) | / |----\ s \ | + (b*(s, n) &* d_(-s, m)) delta(-n + m))| | | /

> evalqed(S_sum(a_(2*s,n)&*d_(-s,m),s)); ----\ ) (a_(2 s, n) &* d_(- s, m)) / ----s

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

27

The above examples show that multiple sums are written with a single summation sign, with the indices separated by commas. This notation is more compact and readable than standard Maple, but makes the output unsuitable as input to further Maple operations.

6. Applications To show the simplification power of the package, we look at an identity presented as the first of equations Eq. (4-23) in the unpublished report by Tang [2] and used in the reduction (by hand) leading to the formulas in the published paper of Ref. [2]. In a notation close to Tang’s, that equation is v j χ † (s) i (λ)α i α j χ(t) = 2δs,t δ2s,λ i (λ)v i , where the indices i and j are summed over 1 and 2, χ(s) is a lepton column spinor of spin s,  i (λ) is the i component of the photon row spinor of spin λ, α i is the Dirac spinor matrix associated with spatial component i, and v i is the i component of an arbitrary vector. In terms of quantities introduced in earlier sections of this paper, χ(s) is the column spinor f_spin[s],  i (λ) (for i = 1, 2) is the row spinor b_spin[λ]; we represent v i (for i = 1, 2) as v := ‘r@‘(v1,v2), and define > alpha1 := build(spinor_matrix,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0): > alpha2 := build(spinor_matrix,0,0,0,-I,0,0,I,0,0,-I,0,0,I,0,0,0): > alpha12 := build(‘c@‘,alpha1,alpha2): Incidentally, this definition of alpha12 illustrates the utility of the build command; the statement alpha12 := ‘c@‘(alpha1,alpha2) would produce alpha12 in a nonstandard form unsuitable for further use. An instance of the left side of Tang’s equation with s = t = 1/2 and λ = 1 now takes the form > L := v&*adj(f_spin[1/2])&*b_spin[1]&*alpha12&*alpha12&*f_spin[1/2]: > evalqed(L);

1/2 1/2 - 2 v1 - I 2 v2

The right side of that equation for the same input (but with v a column vector to yield a matrix multiplication) reduces to the same result. With the package of this paper, one would in fact not have to derive or verify identities such as that above; the simplifications which could result from their use would take place automatically when expressions containing such quantities are evaluated. We see this in a final, more robust example. Using quantities already defined, we write an expression which, when evaluated, yields a result equivalent to that presented as Eq. (2.7) of the published version of Ref. [2]. Readers using our computer program to confirm this result may wish first to enter > interface(screenwidth=96,labelling=false,quiet=true): and set the display window accordingly. > T := proc(s,t,u,v,m,p,q,n); > adj(psi(s,m))&*A(t,p)&*alpha12&*[‘I+‘]&*A(u,q)&*alpha12&*psi(v,n) > end:

28

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

> evalqed( D_sum(S_sum(T(s,2*t,2*u,v,m,p,q,n),s,t,u,v),m,p,q,n)); ----\ ) / ----m,p,q,n

/----| \ | ) | / |----\ s

/ &*(a*(-2 s, p),a_(-2 s, q),b*(s, m),d*(-s, n)) delta(m + p - q + n) |2 ------------------------------------------------------------------\ q+ - n+ &*(a*(2 s, q),a_(2 s, p),d*(-s, n),d_(-s, m)) delta(-m - p + q + n) - 2 -------------------------------------------------------------------q+ - n+ &*(a*(-2 s, p),a*(2 s, q),d*(-s, n),d_(-s, m)) delta(-m + p + q + n) + 2 --------------------------------------------------------------------q+ - n+ &*(a_(2 s, p),a_(-2 s, q),b*(s, m),d*(-s, n)) delta(m - p - q + n) - 2 -----------------------------------------------------------------q+ - n+ &*(a*(-2 s, p),a_(-2 s, q),d*(-s, n),d_(-s, m)) delta(-m + p - q + n) - 2 --------------------------------------------------------------------q+ - n+ &*(a*(2 s, q),a_(2 s, p),b_(s, n),d_(-s, m)) delta(-m - p + q - n) - 2 ------------------------------------------------------------------q+ + n+ &*(a*(2 s, q),a_(2 s, p),b*(s, m),d*(-s, n)) delta(m - p + q + n) + 2 -----------------------------------------------------------------q+ - n+ &*(a*(-2 s, p),a*(2 s, q),b*(s, m),b_(s, n)) delta(m + p + q - n) - 2 -----------------------------------------------------------------q+ + n+ &*(a_(2 s, p),a_(-2 s, q),d*(-s, n),d_(-s, m)) delta(-m - p - q + n) + 2 -------------------------------------------------------------------q+ - n+

F.E. Harris / Computer Physics Communications 132 (2000) 21–29

29

&*(a_(2 s, p),a_(-2 s, q),b*(s, m),b_(s, n)) delta(m - p - q - n) - 2 ----------------------------------------------------------------q+ + n+ &*(a*(2 s, q),a_(2 s, p),b*(s, m),b_(s, n)) delta(m - p + q - n) + 2 ----------------------------------------------------------------q+ + n+ &*(a*(-2 s, p),a_(-2 s, q),b_(s, n),d_(-s, m)) delta(-m + p - q - n) - 2 -------------------------------------------------------------------q+ + n+ &*(a*(-2 s, p),a_(-2 s, q),b*(s, m),b_(s, n)) delta(m + p - q - n) + 2 -----------------------------------------------------------------q+ + n+ \ &*(a*(-2 s, p),a*(2 s, q),b_(s, n),d_(-s, m)) delta(-m + p + q - n)\| + 2 -------------------------------------------------------------------|| -q+ + n+ /| | / This result also illustrates the fact that Maple simplifies &* to a wholly associative form; the notation &*(a,b,c,d) stands for a &* b &* c &* d.

Acknowledgement The author is pleased to acknowledge stimulating conversations with his former colleague Dr. V.G. Koures, whose encouragement and counsel played an important role in bringing this work to completion. References [1] V.G. Koures, Phys. Lett. B 348 (1995) 170; V.G. Koures, F.E. Harris, Int. J. Quantum Chem. S 29 (1995) 277. [2] A.C. Tang, S.J. Brodsky, H.-C. Pauli, Phys. Rev. D 44 (1991) 1842; A.C. Tang, Stanford Linear Accelerator Center Report No. SLAC-351 (1990), unpublished. [3] Maple V is a product of Waterloo Maple Inc. URL: http://www.maplesoft.com. [4] E. Yehudai, HIP-maple – Symbolic high-energy physics calculations, Fermi National Accelerator Laboratory (1991). [5] URL: http://www.chem.utah.edu; click on “faculty”, then “Frank E. Harris”, then under “Available Software” click on “Maple V program: Discrete Light-Cone Quantization of Quantum Electrodynamics”.