← Back to branch summary

~dinko-metalac/calculus-app2/trunk

« back to all changes in this revision

Viewing changes to lib/py/sympy/physics/hep/tests/test_gamma_matrices.py

  • Committer: dinko.metalac at gmail
  • Date: 2015-04-14 13:28:14 UTC
  • Revision ID: dinko.metalac@gmail.com-20150414132814-j25k3qd7sq3warup
new sympy

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/py/sympy/physics/hep/tests/test_gamma_matrices.py
 
1
from sympy.tensor.tensor import tensor_indices, TensorIndexType, tensorhead, TensorManager, TensMul, TensAdd, get_lines, TensExpr
 
2
from sympy import simplify, trace
 
3
from sympy.physics.hep.gamma_matrices import GammaMatrix as G, GammaMatrixHead, DiracSpinorIndex
 
4
from sympy.utilities.pytest import XFAIL, raises
 
5
 
 
6
def _is_tensor_eq(arg1, arg2):
 
7
    if isinstance(arg1, TensExpr):
 
8
        return arg1.equals(arg2)
 
9
    elif isinstance(arg2, TensExpr):
 
10
        return arg2.equals(arg1)
 
11
    return arg1 == arg2
 
12
 
 
13
def execute_gamma_simplify_tests_for_function(tfunc, D):
 
14
    """
 
15
    Perform tests to check if sfunc is able to simplify gamma matrix expressions.
 
16
 
 
17
    Parameters
 
18
    ==========
 
19
 
 
20
    `sfunc`     a function to simplify a `TIDS`, shall return the simplified `TIDS`.
 
21
    `D`         the number of dimension (in most cases `D=4`).
 
22
 
 
23
    """
 
24
 
 
25
    mu, nu, rho, sigma = tensor_indices("mu, nu, rho, sigma", G.LorentzIndex)
 
26
    a1, a2, a3, a4, a5, a6 = tensor_indices("a1:7", G.LorentzIndex)
 
27
    mu11, mu12, mu21, mu31, mu32, mu41, mu51, mu52 = tensor_indices("mu11, mu12, mu21, mu31, mu32, mu41, mu51, mu52", G.LorentzIndex)
 
28
    mu61, mu71, mu72 = tensor_indices("mu61, mu71, mu72", G.LorentzIndex)
 
29
    m0, m1, m2, m3, m4, m5, m6 = tensor_indices("m0:7", G.LorentzIndex)
 
30
 
 
31
    def g(xx, yy):
 
32
        return (G(xx)*G(yy) + G(yy)*G(xx))/2
 
33
 
 
34
    # Some examples taken from Kahane's paper, 4 dim only:
 
35
    if D == 4:
 
36
        t = (G(a1)*G(mu11)*G(a2)*G(mu21)*G(-a1)*G(mu31)*G(-a2))
 
37
        assert _is_tensor_eq(tfunc(t), -4*G(mu11)*G(mu31)*G(mu21) - 4*G(mu31)*G(mu11)*G(mu21))
 
38
 
 
39
        t = (G(a1)*G(mu11)*G(mu12)*\
 
40
                              G(a2)*G(mu21)*\
 
41
                              G(a3)*G(mu31)*G(mu32)*\
 
42
                              G(a4)*G(mu41)*\
 
43
                              G(-a2)*G(mu51)*G(mu52)*\
 
44
                              G(-a1)*G(mu61)*\
 
45
                              G(-a3)*G(mu71)*G(mu72)*\
 
46
                              G(-a4))
 
47
        assert _is_tensor_eq(tfunc(t), \
 
48
            16*G(mu31)*G(mu32)*G(mu72)*G(mu71)*G(mu11)*G(mu52)*G(mu51)*G(mu12)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu31)*G(mu32)*G(mu72)*G(mu71)*G(mu12)*G(mu51)*G(mu52)*G(mu11)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu71)*G(mu72)*G(mu32)*G(mu31)*G(mu11)*G(mu52)*G(mu51)*G(mu12)*G(mu61)*G(mu21)*G(mu41) + 16*G(mu71)*G(mu72)*G(mu32)*G(mu31)*G(mu12)*G(mu51)*G(mu52)*G(mu11)*G(mu61)*G(mu21)*G(mu41))
 
49
 
 
50
    # Fully G.Lorentz-contracted expressions, these return scalars:
 
51
 
 
52
    def add_delta(ne):
 
53
        return ne * DiracSpinorIndex.delta(DiracSpinorIndex.auto_left, -DiracSpinorIndex.auto_right)
 
54
 
 
55
    t = (G(mu)*G(-mu))
 
56
    ts = add_delta(D)
 
57
    assert _is_tensor_eq(tfunc(t), ts)
 
58
 
 
59
    t = (G(mu)*G(nu)*G(-mu)*G(-nu))
 
60
    ts = add_delta(2*D - D**2)  # -8
 
61
    assert _is_tensor_eq(tfunc(t), ts)
 
62
 
 
63
    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
 
64
    ts = add_delta(D**2)  # 16
 
65
    assert _is_tensor_eq(tfunc(t), ts)
 
66
 
 
67
    t = (G(mu)*G(nu)*G(-rho)*G(-nu)*G(-mu)*G(rho))
 
68
    ts = add_delta(4*D - 4*D**2 + D**3)  # 16
 
69
    assert _is_tensor_eq(tfunc(t), ts)
 
70
 
 
71
    t = (G(mu)*G(nu)*G(rho)*G(-rho)*G(-nu)*G(-mu))
 
72
    ts = add_delta(D**3)  # 64
 
73
    assert _is_tensor_eq(tfunc(t), ts)
 
74
 
 
75
    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(-a3)*G(-a1)*G(-a2)*G(-a4))
 
76
    ts = add_delta(-8*D + 16*D**2 - 8*D**3 + D**4)  # -32
 
77
    assert _is_tensor_eq(tfunc(t), ts)
 
78
 
 
79
    t = (G(-mu)*G(-nu)*G(-rho)*G(-sigma)*G(nu)*G(mu)*G(sigma)*G(rho))
 
80
    ts = add_delta(-16*D + 24*D**2 - 8*D**3 + D**4)  # 64
 
81
    assert _is_tensor_eq(tfunc(t), ts)
 
82
 
 
83
    t = (G(-mu)*G(nu)*G(-rho)*G(sigma)*G(rho)*G(-nu)*G(mu)*G(-sigma))
 
84
    ts = add_delta(8*D - 12*D**2 + 6*D**3 - D**4)  # -32
 
85
    assert _is_tensor_eq(tfunc(t), ts)
 
86
 
 
87
    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(-a3)*G(-a2)*G(-a1)*G(-a5)*G(-a4))
 
88
    ts = add_delta(64*D - 112*D**2 + 60*D**3 - 12*D**4 + D**5)  # 256
 
89
    assert _is_tensor_eq(tfunc(t), ts)
 
90
 
 
91
    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(-a3)*G(-a1)*G(-a2)*G(-a4)*G(-a5))
 
92
    ts = add_delta(64*D - 120*D**2 + 72*D**3 - 16*D**4 + D**5)  # -128
 
93
    assert _is_tensor_eq(tfunc(t), ts)
 
94
 
 
95
    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(a6)*G(-a3)*G(-a2)*G(-a1)*G(-a6)*G(-a5)*G(-a4))
 
96
    ts = add_delta(416*D - 816*D**2 + 528*D**3 - 144*D**4 + 18*D**5 - D**6)  # -128
 
97
    assert _is_tensor_eq(tfunc(t), ts)
 
98
 
 
99
    t = (G(a1)*G(a2)*G(a3)*G(a4)*G(a5)*G(a6)*G(-a2)*G(-a3)*G(-a1)*G(-a6)*G(-a4)*G(-a5))
 
100
    ts = add_delta(416*D - 848*D**2 + 584*D**3 - 172*D**4 + 22*D**5 - D**6)  # -128
 
101
    assert _is_tensor_eq(tfunc(t), ts)
 
102
 
 
103
    # Expressions with free indices:
 
104
 
 
105
    t = (G(mu)*G(nu)*G(rho)*G(sigma)*G(-mu))
 
106
    assert _is_tensor_eq(tfunc(t), (-2*G(sigma)*G(rho)*G(nu) + (4-D)*G(nu)*G(rho)*G(sigma)))
 
107
 
 
108
    t = (G(mu)*G(nu)*G(-mu))
 
109
    assert _is_tensor_eq(tfunc(t), (2-D)*G(nu))
 
110
 
 
111
    t = (G(mu)*G(nu)*G(rho)*G(-mu))
 
112
    assert _is_tensor_eq(tfunc(t), 2*G(nu)*G(rho) + 2*G(rho)*G(nu) - (4-D)*G(nu)*G(rho))
 
113
 
 
114
    t = 2*G(m2)*G(m0)*G(m1)*G(-m0)*G(-m1)
 
115
    st = tfunc(t)
 
116
    assert _is_tensor_eq(st, (D*(-2*D + 4))*G(m2))
 
117
 
 
118
    t = G(m2)*G(m0)*G(m1)*G(-m0)*G(-m2)
 
119
    st = tfunc(t)
 
120
    assert _is_tensor_eq(st, ((-D + 2)**2)*G(m1))
 
121
 
 
122
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(-m1)
 
123
    st = tfunc(t)
 
124
    assert _is_tensor_eq(st, (D - 4)*G(m0)*G(m2)*G(m3) + 4*G(m0)*g(m2, m3))
 
125
 
 
126
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(-m1)*G(-m0)
 
127
    st = tfunc(t)
 
128
    assert _is_tensor_eq(st, ((D - 4)**2)*G(m2)*G(m3) + (8*D - 16)*g(m2, m3))
 
129
 
 
130
    t = G(m2)*G(m0)*G(m1)*G(-m2)*G(-m0)
 
131
    st = tfunc(t)
 
132
    assert _is_tensor_eq(st, ((-D + 2)*(D - 4) + 4)*G(m1))
 
133
 
 
134
    t = G(m3)*G(m1)*G(m0)*G(m2)*G(-m3)*G(-m0)*G(-m2)
 
135
    st = tfunc(t)
 
136
    assert _is_tensor_eq(st, (-4*D + (-D + 2)**2*(D - 4) + 8)*G(m1))
 
137
 
 
138
    t = 2*G(m0)*G(m1)*G(m2)*G(m3)*G(-m0)
 
139
    st = tfunc(t)
 
140
    assert _is_tensor_eq(st, ((-2*D + 8)*G(m1)*G(m2)*G(m3) - 4*G(m3)*G(m2)*G(m1)))
 
141
 
 
142
    t = G(m5)*G(m0)*G(m1)*G(m4)*G(m2)*G(-m4)*G(m3)*G(-m0)
 
143
    st = tfunc(t)
 
144
    assert _is_tensor_eq(st, (((-D + 2)*(-D + 4))*G(m5)*G(m1)*G(m2)*G(m3) + (2*D - 4)*G(m5)*G(m3)*G(m2)*G(m1)))
 
145
 
 
146
    t = -G(m0)*G(m1)*G(m2)*G(m3)*G(-m0)*G(m4)
 
147
    st = tfunc(t)
 
148
    assert _is_tensor_eq(st, ((D - 4)*G(m1)*G(m2)*G(m3)*G(m4) + 2*G(m3)*G(m2)*G(m1)*G(m4)))
 
149
 
 
150
    t = G(-m5)*G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)*G(m5)
 
151
    st = tfunc(t)
 
152
 
 
153
    result1 = ((-D + 4)**2 + 4)*G(m1)*G(m2)*G(m3)*G(m4) +\
 
154
        (4*D - 16)*G(m3)*G(m2)*G(m1)*G(m4) + (4*D - 16)*G(m4)*G(m1)*G(m2)*G(m3)\
 
155
        + 4*G(m2)*G(m1)*G(m4)*G(m3) + 4*G(m3)*G(m4)*G(m1)*G(m2) +\
 
156
        4*G(m4)*G(m3)*G(m2)*G(m1)
 
157
 
 
158
    # Kahane's algorithm yields this result, which is equivalent to `result1`
 
159
    # in four dimensions, but is not automatically recognized as equal:
 
160
    result2 = 8*G(m1)*G(m2)*G(m3)*G(m4) + 8*G(m4)*G(m3)*G(m2)*G(m1)
 
161
 
 
162
    if D == 4:
 
163
        assert _is_tensor_eq(st, (result1)) or _is_tensor_eq(st, (result2))
 
164
    else:
 
165
        assert _is_tensor_eq(st, (result1))
 
166
 
 
167
    # and a few very simple cases, with no contracted indices:
 
168
 
 
169
    t = G(m0)
 
170
    st = tfunc(t)
 
171
    assert _is_tensor_eq(st, t)
 
172
 
 
173
    t = -7*G(m0)
 
174
    st = tfunc(t)
 
175
    assert _is_tensor_eq(st, t)
 
176
 
 
177
    t = 224*G(m0)*G(m1)*G(-m2)*G(m3)
 
178
    st = tfunc(t)
 
179
    assert _is_tensor_eq(st, t)
 
180
 
 
181
 
 
182
def test_kahane_algorithm():
 
183
    # Wrap this function to convert to and from TIDS:
 
184
 
 
185
    def tfunc(e):
 
186
        return GammaMatrixHead._simplify_single_line(e)
 
187
 
 
188
    execute_gamma_simplify_tests_for_function(tfunc, D=4)
 
189
 
 
190
def test_kahane_simplify1():
 
191
    i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15 = tensor_indices('i0:16', G.LorentzIndex)
 
192
    mu, nu, rho, sigma = tensor_indices("mu, nu, rho, sigma", G.LorentzIndex)
 
193
    KD = DiracSpinorIndex.delta
 
194
    sl = DiracSpinorIndex.auto_left
 
195
    sr = DiracSpinorIndex.auto_right
 
196
    D = 4
 
197
    s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14,s15,s16 = \
 
198
                   tensor_indices('s0:17', DiracSpinorIndex)
 
199
    t = DiracSpinorIndex.delta(s0,s1)
 
200
    t = G(i0)*G(i1)
 
201
    r = G._kahane_simplify(t.coeff, t._tids)
 
202
    assert r.equals(t)
 
203
 
 
204
    t = G(i0)*G(i1)*G(-i0)
 
205
    r = G._kahane_simplify(t.coeff, t._tids)
 
206
    assert r.equals(-2*G(i1))
 
207
    t = G(i0,s0,-s1)*G(i1,s1,-s2)*G(-i0,s2,-s3)
 
208
    r = G._kahane_simplify(t.coeff, t._tids)
 
209
    assert r.equals(-2*G(i1, s0, -s3))
 
210
 
 
211
    t = G(i0, s0, -s1)*G(i1, s1, -s2)
 
212
    r = G._kahane_simplify(t.coeff, t._tids)
 
213
    assert r.equals(t)
 
214
    t = G(i0, s0, -s1)*G(i1, s1, -s0)
 
215
    r = G._kahane_simplify(t.coeff, t._tids)
 
216
    assert r.equals(t)
 
217
    t = G(i0)*G(-i0)
 
218
    r = G._kahane_simplify(t.coeff, t._tids)
 
219
    assert r.equals(4*KD(sl, -sr))
 
220
    t = G(i0,s0,-s1)*G(-i0,s1,-s2)
 
221
    r = G._kahane_simplify(t.coeff, t._tids)
 
222
    assert r.equals(4*KD(s0, -s2))
 
223
    t = G(i0,s0,-s1)*G(-i0,s1,-s0)
 
224
    r = G._kahane_simplify(t.coeff, t._tids)
 
225
    assert r.equals(16)
 
226
    t = G(i0)*G(i1)*G(-i0)
 
227
    r = G._kahane_simplify(t.coeff, t._tids)
 
228
    assert r.equals(-2*G(i1))
 
229
    t = G(i0)*G(i1)*G(-i0)*G(-i1)
 
230
    r = G._kahane_simplify(t.coeff, t._tids)
 
231
    assert r.equals((2*D - D**2)*KD(sl, -sr))
 
232
    t = G(i0,s0,-s1)*G(i1,s1,-s2)*G(-i0,s2,-s3)*G(-i1,s3,-s0)
 
233
    r = G._kahane_simplify(t.coeff, t._tids)
 
234
    assert r.equals(4*(2*D - D**2))
 
235
    t = G(i0,s0,-s1)*G(-i0,s2,-s3)*G(i1,s1,-s2)*G(-i1,s3,-s0)
 
236
    raises(ValueError, lambda: G._kahane_simplify(t.coeff, t._tids))
 
237
    t = (G(mu)*G(nu)*G(-nu)*G(-mu))
 
238
    r = G._kahane_simplify(t.coeff, t._tids)
 
239
    assert r.equals(D**2*KD(sl, -sr))
 
240
    t = (G(mu,s0,-s1)*G(nu,s1,-s2)*G(-nu,s2,-s3)*G(-mu,s3,-s4))
 
241
    r = G._kahane_simplify(t.coeff, t._tids)
 
242
    assert r.equals(D**2*KD(s0, -s4))
 
243
    t = (G(mu,s0,-s1)*G(nu,s1,-s2)*G(-nu,s2,-s3)*G(-mu,s3,-s0))
 
244
    r = G._kahane_simplify(t.coeff, t._tids)
 
245
    assert r.equals(4*D**2)
 
246
    t = (G(mu)*G(nu)*G(-rho)*G(-nu)*G(-mu)*G(rho))
 
247
    r = G._kahane_simplify(t.coeff, t._tids)
 
248
    assert r.equals((4*D - 4*D**2 + D**3)*KD(sl, -sr))
 
249
    t = (G(-mu)*G(-nu)*G(-rho)*G(-sigma)*G(nu)*G(mu)*G(sigma)*G(rho))
 
250
    r = G._kahane_simplify(t.coeff, t._tids)
 
251
    assert r.equals((-16*D + 24*D**2 - 8*D**3 + D**4)*KD(sl, -sr))
 
252
    t = (G(-mu)*G(nu)*G(-rho)*G(sigma)*G(rho)*G(-nu)*G(mu)*G(-sigma))
 
253
    r = G._kahane_simplify(t.coeff, t._tids)
 
254
    assert r.equals((8*D - 12*D**2 + 6*D**3 - D**4)*KD(sl, -sr))
 
255
 
 
256
    # Expressions with free indices:
 
257
    t = (G(mu)*G(nu)*G(rho)*G(sigma)*G(-mu))
 
258
    r = G._kahane_simplify(t.coeff, t._tids)
 
259
    assert r.equals(-2*G(sigma)*G(rho)*G(nu))
 
260
    t = (G(mu,s0,-s1)*G(nu,s1,-s2)*G(rho,s2,-s3)*G(sigma,s3,-s4)*G(-mu,s4,-s5))
 
261
    r = G._kahane_simplify(t.coeff, t._tids)
 
262
    assert r.equals(-2*G(sigma,s0,-s1)*G(rho,s1,-s2)*G(nu,s2,-s5))
 
263
 
 
264
 
 
265
def test_gamma_matrix_class():
 
266
    i, j, k = tensor_indices('i,j,k', G.LorentzIndex)
 
267
 
 
268
    # define another type of TensorHead to see if exprs are correctly handled:
 
269
    A = tensorhead('A', [G.LorentzIndex], [[1]])
 
270
 
 
271
    t = A(k)*G(i)*G(-i)
 
272
    ts = simplify(t)
 
273
    assert _is_tensor_eq(ts, 4*A(k)*DiracSpinorIndex.delta(DiracSpinorIndex.auto_left, -DiracSpinorIndex.auto_right))
 
274
 
 
275
    t = G(i)*A(k)*G(j)
 
276
    ts = simplify(t)
 
277
    assert _is_tensor_eq(ts, A(k)*G(i)*G(j))
 
278
 
 
279
    execute_gamma_simplify_tests_for_function(simplify, D=4)
 
280
 
 
281
def test_gamma_matrix_trace():
 
282
    gamma_trace = G.gamma_trace
 
283
    g = G.LorentzIndex.metric
 
284
 
 
285
    m0, m1, m2, m3, m4, m5, m6 = tensor_indices('m0:7', G.LorentzIndex)
 
286
    n0, n1, n2, n3, n4, n5 = tensor_indices('n0:6', G.LorentzIndex)
 
287
 
 
288
    # working in D=4 dimensions
 
289
    D = 4
 
290
 
 
291
    # traces of odd number of gamma matrices are zero:
 
292
    t = G(m0)
 
293
    t1 = gamma_trace(t)
 
294
    assert t1.equals(0)
 
295
 
 
296
    t = G(m0)*G(m1)*G(m2)
 
297
    t1 = gamma_trace(t)
 
298
    assert t1.equals(0)
 
299
 
 
300
    t = G(m0)*G(m1)*G(-m0)
 
301
    t1 = gamma_trace(t)
 
302
    assert t1.equals(0)
 
303
 
 
304
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)
 
305
    t1 = gamma_trace(t)
 
306
    assert t1.equals(0)
 
307
 
 
308
    # traces without internal contractions:
 
309
    t = G(m0)*G(m1)
 
310
    t1 = gamma_trace(t)
 
311
    assert _is_tensor_eq(t1, 4*g(m0, m1))
 
312
 
 
313
    t = G(m0)*G(m1)*G(m2)*G(m3)
 
314
    t1 = gamma_trace(t)
 
315
    t2 = -4*g(m0, m2)*g(m1, m3) + 4*g(m0, m1)*g(m2, m3) + 4*g(m0, m3)*g(m1, m2)
 
316
    st2 = str(t2)
 
317
    assert _is_tensor_eq(t1, t2)
 
318
 
 
319
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(m5)
 
320
    t1 = gamma_trace(t)
 
321
    t2 = t1*g(-m0, -m5)
 
322
    t2 = t2.contract_metric(g)
 
323
    assert _is_tensor_eq(t2, D*gamma_trace(G(m1)*G(m2)*G(m3)*G(m4)))
 
324
 
 
325
    # traces of expressions with internal contractions:
 
326
    t = G(m0)*G(-m0)
 
327
    t1 = gamma_trace(t)
 
328
    assert t1.equals(4*D)
 
329
 
 
330
    t = G(m0)*G(m1)*G(-m0)*G(-m1)
 
331
    t1 = gamma_trace(t)
 
332
    assert t1.equals(8*D - 4*D**2)
 
333
 
 
334
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)
 
335
    t1 = gamma_trace(t)
 
336
    t2 = (-4*D)*g(m1, m3)*g(m2, m4) + (4*D)*g(m1, m2)*g(m3, m4) + \
 
337
                 (4*D)*g(m1, m4)*g(m2, m3)
 
338
    assert t1.equals(t2)
 
339
 
 
340
    t = G(-m5)*G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(-m0)*G(m5)
 
341
    t1 = gamma_trace(t)
 
342
    t2 = (32*D + 4*(-D + 4)**2 - 64)*(g(m1, m2)*g(m3, m4) - \
 
343
            g(m1, m3)*g(m2, m4) + g(m1, m4)*g(m2, m3))
 
344
    assert t1.equals(t2)
 
345
 
 
346
    t = G(m0)*G(m1)*G(-m0)*G(m3)
 
347
    t1 = gamma_trace(t)
 
348
    assert t1.equals((-4*D + 8)*g(m1, m3))
 
349
 
 
350
#    p, q = S1('p,q')
 
351
#    ps = p(m0)*G(-m0)
 
352
#    qs = q(m0)*G(-m0)
 
353
#    t = ps*qs*ps*qs
 
354
#    t1 = gamma_trace(t)
 
355
#    assert t1 == 8*p(m0)*q(-m0)*p(m1)*q(-m1) - 4*p(m0)*p(-m0)*q(m1)*q(-m1)
 
356
 
 
357
    t = G(m0)*G(m1)*G(m2)*G(m3)*G(m4)*G(m5)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)*G(-m5)
 
358
    t1 = gamma_trace(t)
 
359
    assert t1.equals(-4*D**6 + 120*D**5 - 1040*D**4 + 3360*D**3 - 4480*D**2 + 2048*D)
 
360
 
 
361
    t = G(m0)*G(m1)*G(n1)*G(m2)*G(n2)*G(m3)*G(m4)*G(-n2)*G(-n1)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)
 
362
    t1 = gamma_trace(t)
 
363
    tresu = -7168*D + 16768*D**2 - 14400*D**3 + 5920*D**4 - 1232*D**5 + 120*D**6 - 4*D**7
 
364
    assert t1.equals(tresu)
 
365
 
 
366
    # checked with Mathematica
 
367
    # In[1]:= <<Tracer.m
 
368
    # In[2]:= Spur[l];
 
369
    # In[3]:= GammaTrace[l, {m0},{m1},{n1},{m2},{n2},{m3},{m4},{n3},{n4},{m0},{m1},{m2},{m3},{m4}]
 
370
    t = G(m0)*G(m1)*G(n1)*G(m2)*G(n2)*G(m3)*G(m4)*G(n3)*G(n4)*G(-m0)*G(-m1)*G(-m2)*G(-m3)*G(-m4)
 
371
    t1 = gamma_trace(t)
 
372
#    t1 = t1.expand_coeff()
 
373
    c1 = -4*D**5 + 120*D**4 - 1200*D**3 + 5280*D**2 - 10560*D + 7808
 
374
    c2 = -4*D**5 + 88*D**4 - 560*D**3 + 1440*D**2 - 1600*D + 640
 
375
    assert _is_tensor_eq(t1, c1*g(n1, n4)*g(n2, n3) + c2*g(n1, n2)*g(n3, n4) + \
 
376
            (-c1)*g(n1, n3)*g(n2, n4))
 
377
 
 
378
    p, q = tensorhead('p,q', [G.LorentzIndex], [[1]])
 
379
    ps = p(m0)*G(-m0)
 
380
    qs = q(m0)*G(-m0)
 
381
    p2 = p(m0)*p(-m0)
 
382
    q2 = q(m0)*q(-m0)
 
383
    pq = p(m0)*q(-m0)
 
384
    t = ps*qs*ps*qs
 
385
    r = gamma_trace(t)
 
386
    assert _is_tensor_eq(r, 8*pq*pq - 4*p2*q2)
 
387
    t = ps*qs*ps*qs*ps*qs
 
388
    r = gamma_trace(t)
 
389
    assert r.equals(-12*p2*pq*q2 + 16*pq*pq*pq)
 
390
    t = ps*qs*ps*qs*ps*qs*ps*qs
 
391
    r = gamma_trace(t)
 
392
    assert r.equals(-32*pq*pq*p2*q2 + 32*pq*pq*pq*pq + 4*p2*p2*q2*q2)
 
393
 
 
394
    t = 4*p(m1)*p(m0)*p(-m0)*q(-m1)*q(m2)*q(-m2)
 
395
    assert _is_tensor_eq(gamma_trace(t), t)
 
396
    t = ps*ps*ps*ps*ps*ps*ps*ps
 
397
    r = gamma_trace(t)
 
398
    assert r.equals(4*p2*p2*p2*p2)
 
399
 
 
400
def test_simple_trace_cases_symbolic_dim():
 
401
    from sympy import symbols
 
402
    D = symbols('D')
 
403
    G = GammaMatrixHead(dim=D)
 
404
 
 
405
    m0, m1, m2, m3 = tensor_indices('m0:4', G.LorentzIndex)
 
406
    g = G.LorentzIndex.metric
 
407
 
 
408
    t = G(m0)*G(m1)
 
409
    t1 = G._trace_single_line(t)
 
410
    assert _is_tensor_eq(t1, 4 * G.LorentzIndex.metric(m0, m1))
 
411
 
 
412
    t = G(m0)*G(m1)*G(m2)*G(m3)
 
413
    t1 = G._trace_single_line(t)
 
414
    t2 = -4*g(m0, m2)*g(m1, m3) + 4*g(m0, m1)*g(m2, m3) + 4*g(m0, m3)*g(m1, m2)
 
415
    assert _is_tensor_eq(t1, t2)
 
416
 
 
417
def test_get_lines():
 
418
    i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13 = \
 
419
       tensor_indices('i0:14', G.LorentzIndex)
 
420
    s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14,s15,s16 = \
 
421
       tensor_indices('s0:17', DiracSpinorIndex)
 
422
    t = G(i1,s1,-s2)*G(i2,s3,-s4)*G(i4,s2,-s6)*G(i3,s4,-s3)
 
423
    r = get_lines(t, DiracSpinorIndex)
 
424
    assert r == ([[0, 2]], [[1, 3]], [])
 
425
    t = G(i1,s1,-s2)*G(i2,s2,-s3)*G(i3,s3,-s4)*G(i4,s4,-s5)*\
 
426
        G(i5,s6,-s7)*G(i6,s7,-s8)*G(i7,s8,-s9)*G(i8,s9,-s6)
 
427
    r = get_lines(t, DiracSpinorIndex)
 
428
    assert r == ([[0, 1, 2, 3]], [[4, 5, 6, 7]], [])
 
429
    t = G(i1,s1,-s2)*G(i0,s0,-s10)*G(i2,s2,-s3)*G(i3,s3,-s4)*\
 
430
    G(i4,s4,-s5)*G(i5,s6,-s7)*G(i6,s7,-s8)*G(i7,s8,-s9)*\
 
431
    G(i8,s9,-s6)*G(i9,s10,-s0)
 
432
    r = get_lines(t, DiracSpinorIndex)
 
433
    assert r == ([[0, 2, 3, 4]], [[5, 6, 7, 8], [1, 9]], [])
 
434
    t = G(i1,s1,-s2)*G(i11,s12,-s13)*G(i0,s0,-s10)*G(i2,s2,-s3)*G(i3,s3,-s4)*\
 
435
        G(i4,s4,-s5)*G(i5,s6,-s7)*G(i10,s11,-s12)*G(i6,s7,-s8)*G(i7,s8,-s9)*\
 
436
        G(i8,s9,-s6)*G(i9,s10,-s0)
 
437
    r = get_lines(t, DiracSpinorIndex)
 
438
    assert r == ([[0, 3, 4, 5], [7, 1]], [[6, 8, 9, 10], [2, 11]], [])
 
439
    t = G(i4,s4,-s5)*G(i5,s6,-s7)*G(i10,s11,-s12)*G(i6,s7,-s8)*G(i7,s8,-s9)*\
 
440
        G(i8,s9,-s6)*G(i9,s10,-s0)*\
 
441
        G(i1,s1,-s2)*G(i11,s12,-s13)*G(i0,s0,-s10)*G(i2,s2,-s3)*G(i3,s3,-s4)
 
442
    r = get_lines(t, DiracSpinorIndex)
 
443
    assert r == ([[2, 8], [7, 10, 11, 0]], [[1, 3, 4, 5], [6, 9]], [])
 
444
    t = G(i8,s9,-s6)*G(i9,s10,-s0)*G(i4,s4,-s5)*G(i13,s14,-s15)*\
 
445
        G(i10,s11,-s12)*G(i1,s1,-s2)*G(i11,s12,-s13)*\
 
446
        G(i0,s0,-s10)*G(i6,s7,-s8)*G(i7,s8,-s9)*\
 
447
        G(i2,s2,-s3)*G(i12,s13,-s14)*G(i3,s3,-s4)*G(i5,s6,-s7)
 
448
    r = get_lines(t, DiracSpinorIndex)
 
449
    assert r == ([[4, 6, 11, 3], [5, 10, 12, 2]], [[1, 7], [0, 13, 8, 9]], [])
 
450
 
 
451
def test_simplify_lines():
 
452
    i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12 = tensor_indices('i0:13', G.LorentzIndex)
 
453
    s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14,s15,s16 = \
 
454
       tensor_indices('s0:17', DiracSpinorIndex)
 
455
 
 
456
    g = G.LorentzIndex.metric
 
457
    Sdelta = DiracSpinorIndex.delta
 
458
    t = G(i1,s1,-s2)*G(i2,s2,-s1)*G(i3,s4,-s5)*G(i4,s5,-s6)*G(i5,s7,-s8)
 
459
    r = G.simplify_lines(t)
 
460
    assert r.equals(4*G(i5, s7, -s8)*G(i3, s4, -s0)*G(i4, s0, -s6)*g(i1, i2))
 
461
 
 
462
    t = G(i1,s1,-s2)*G(i2,s2,-s1)*G(i3,s4,-s5)*G(-i3,s5,-s6)*G(i5,s7,-s8)
 
463
    r = G.simplify_lines(t)
 
464
    assert r.equals(16*G(i5, s7, -s8)*Sdelta(s4, -s6)*g(i1, i2))
 
465
    t = G(i1,s1,-s2)*G(i2,s2,-s1)*G(i3,s4,-s5)*G(i4,s5,-s6)*G(i5,s7,-s8)
 
466
    r = G.simplify_lines(t)
 
467
    assert r.equals(4*G(i5, s7, -s8)*G(i3, s4, s0)*G(i4, -s0, -s6)*g(i1, i2))
 
468
    t = G(i5,s7,-s8)*G(i6,s9,-s10)*G(i1,s1,-s2)*G(i3,s4,-s5)*G(i2,s2,-s1)*G(i4,s5,-s6)*G(-i6,s10,-s9)
 
469
    r = G.simplify_lines(t)
 
470
    assert r.equals(64*G(i5, s7, -s8)*G(i3, s4, s0)*G(i4, -s0, -s6)*g(i1, i2))
 
471
    t = G(i5,s7,-s8)*G(i6,s9,-s10)*G(i1,s1,-s2)*G(i7,s12,-s11)*G(i3,s4,-s5)*\
 
472
        G(i2,s2,-s1)*G(i4,s5,-s6)*G(-i6,s10,-s9)*G(-i7,s11,-s13)
 
473
    r = G.simplify_lines(t)
 
474
    assert r.equals(256*G(i5, s7, -s8)*G(i3, s4, s0)*G(i4, -s0, -s6)*\
 
475
           g(i1, i2)*Sdelta(s12,-s13))