def test_mul():
from sympy.abc import x
Lorentz = TensorIndexType('Lorentz', dummy_fmt='L')
a, b, c, d = tensor_indices('a,b,c,d', Lorentz)
sym = tensorsymmetry([1]*2)
t = TensMul.from_data(S.One, [], [], [])
assert str(t) == '1'
A, B = tensorhead('A B', [Lorentz]*2, [[1]*2])
t = (1 + x)*A(a, b)
assert str(t) == '(x + 1)*A(a, b)'
assert t.types == [Lorentz]
assert t.rank == 2
assert t.dum == []
assert t.coeff == 1 + x
assert sorted(t.free) == [(a, 0, 0), (b, 1, 0)]
assert t.components == [A]
t = A(-b, a)*B(-a, c)*A(-c, d)
t1 = tensor_mul(*t.split())
assert t == t(-b, d)
assert t == t1
assert tensor_mul(*[]) == TensMul.from_data(S.One, [], [], [])
t = TensMul.from_data(1, [], [], [])
zsym = tensorsymmetry()
typ = TensorType([], zsym)
C = typ('C')
assert str(C()) == 'C'
assert str(t) == '1'
assert t.split()[0] == t
raises(ValueError, lambda: TIDS.free_dum_from_indices(a, a))
raises(ValueError, lambda: TIDS.free_dum_from_indices(-a, -a))
raises(ValueError, lambda: A(a, b)*A(a, c))
t = A(a, b)*A(-a, c)
raises(ValueError, lambda: t(a, b, c))
def test_mul():
from sympy.abc import x
Lorentz = TensorIndexType('Lorentz', dummy_fmt='L')
a, b, c, d = tensor_indices('a,b,c,d', Lorentz)
sym = tensorsymmetry([1] * 2)
t = TensMul.from_data(S.One, [], [], [])
assert str(t) == '1'
A, B = tensorhead('A B', [Lorentz] * 2, [[1] * 2])
t = (1 + x) * A(a, b)
assert str(t) == '(x + 1)*A(a, b)'
assert t.types == [Lorentz]
assert t.rank == 2
assert t.dum == []
assert t.coeff == 1 + x
assert sorted(t.free) == [(a, 0, 0), (b, 1, 0)]
assert t.components == [A]
t = A(-b, a) * B(-a, c) * A(-c, d)
t1 = tensor_mul(*t.split())
assert t == t(-b, d)
assert t == t1
assert tensor_mul(*[]) == TensMul.from_data(S.One, [], [], [])
t = TensMul.from_data(1, [], [], [])
zsym = tensorsymmetry()
typ = TensorType([], zsym)
C = typ('C')
assert str(C()) == 'C'
assert str(t) == '1'
assert t.split()[0] == t
raises(ValueError, lambda: TIDS.free_dum_from_indices(a, a))
raises(ValueError, lambda: TIDS.free_dum_from_indices(-a, -a))
raises(ValueError, lambda: A(a, b) * A(a, c))
t = A(a, b) * A(-a, c)
raises(ValueError, lambda: t(a, b, c))
def doit(self):
args, indices, free, dum = TensMul._tensMul_contract_indices(self.args)
obj = self.func(*args)
obj._indices = indices
obj._free = free
obj._dum = dum
return obj
def doit(self):
args, indices, free, dum = TensMul._tensMul_contract_indices(self.args)
obj = self.func(*args)
obj._indices = indices
obj._free = free
obj._dum = dum
return obj
def _trace_single_line1(t):
t = t.sorted_components()
components = t.components
ncomps = len(components)
g = LorentzIndex.metric
# gamma matirices are in a[i:j]
hit = 0
for i in range(ncomps):
if components[i] == GammaMatrix:
hit = 1
break
for j in range(i + hit, ncomps):
if components[j] != GammaMatrix:
break
else:
j = ncomps
numG = j - i
if numG == 0:
tcoeff = t.coeff
return t.nocoeff if tcoeff else t
if numG % 2 == 1:
return TensMul.from_data(S.Zero, [], [], [])
elif numG > 4:
# find the open matrix indices and connect them:
a = t.split()
ind1 = a[i].get_indices()[0]
ind2 = a[i + 1].get_indices()[0]
aa = a[:i] + a[i + 2:]
t1 = tensor_mul(*aa)*g(ind1, ind2)
t1 = t1.contract_metric(g)
args = [t1]
sign = 1
for k in range(i + 2, j):
sign = -sign
ind2 = a[k].get_indices()[0]
aa = a[:i] + a[i + 1:k] + a[k + 1:]
t2 = sign*tensor_mul(*aa)*g(ind1, ind2)
t2 = t2.contract_metric(g)
t2 = simplify_gpgp(t2, False)
args.append(t2)
t3 = TensAdd(*args)
t3 = _trace_single_line(t3)
return t3
else:
a = t.split()
t1 = _gamma_trace1(*a[i:j])
a2 = a[:i] + a[j:]
t2 = tensor_mul(*a2)
t3 = t1*t2
if not t3:
return t3
t3 = t3.contract_metric(g)
return t3
def _trace_single_line1(t):
t = t.sorted_components()
components = t.components
ncomps = len(components)
g = LorentzIndex.metric
# gamma matirices are in a[i:j]
hit = 0
for i in range(ncomps):
if components[i] == GammaMatrix:
hit = 1
break
for j in range(i + hit, ncomps):
if components[j] != GammaMatrix:
break
else:
j = ncomps
numG = j - i
if numG == 0:
tcoeff = t.coeff
return t.nocoeff if tcoeff else t
if numG % 2 == 1:
return TensMul.from_data(S.Zero, [], [], [])
elif numG > 4:
# find the open matrix indices and connect them:
a = t.split()
ind1 = a[i].get_indices()[0]
ind2 = a[i + 1].get_indices()[0]
aa = a[:i] + a[i + 2:]
t1 = tensor_mul(*aa) * g(ind1, ind2)
t1 = t1.contract_metric(g)
args = [t1]
sign = 1
for k in range(i + 2, j):
sign = -sign
ind2 = a[k].get_indices()[0]
aa = a[:i] + a[i + 1:k] + a[k + 1:]
t2 = sign * tensor_mul(*aa) * g(ind1, ind2)
t2 = t2.contract_metric(g)
t2 = simplify_gpgp(t2, False)
args.append(t2)
t3 = TensAdd(*args)
t3 = _trace_single_line(t3)
return t3
else:
a = t.split()
t1 = _gamma_trace1(*a[i:j])
a2 = a[:i] + a[j:]
t2 = tensor_mul(*a2)
t3 = t1 * t2
if not t3:
return t3
t3 = t3.contract_metric(g)
return t3
def expand_tensor(expr, idxs=None):
"""
Evaluate a tensor expression and return the resulting array.
Parameters
----------
expr : TensExpr
Symbolic expression of tensors.
idxs : TensorIndex
Indices that encode the covariance and contravariance of the result.
"""
if idxs is None:
idxs = TensMul(expr).get_free_indices()
return expr.replace_with_arrays(ReplacementManager, idxs)
def _contract_indices_for_derivative(cls, expr, variables):
variables_opposite_valence = []
for i in variables:
i_free_indices = i.get_free_indices()
variables_opposite_valence.append(
i.xreplace({k: -k
for k in i_free_indices}))
args, indices, free, dum = TensMul._tensMul_contract_indices(
[expr] + variables_opposite_valence, replace_indices=True)
for i in range(1, len(args)):
i_indices = args[i].get_free_indices()
args[i] = args[i].xreplace({k: -k for k in i_indices})
return args, indices, free, dum
def _expand_partial_derivative(self):
args, indices, free, dum = self._contract_indices_for_derivative(
self.expr, self.variables)
obj = self.func(*args)
obj._indices = indices
obj._free = free
obj._dum = dum
result = obj
if not args[0].free_symbols:
return S.Zero
elif isinstance(obj.expr, TensAdd):
# take care of sums of multi PDs
result = obj.expr.func(*[
self.func(a, *obj.variables)._expand_partial_derivative()
for a in result.expr.args
])
elif isinstance(obj.expr, TensMul):
# take care of products of multi PDs
if len(obj.variables) == 1:
# derivative with respect to single variable
terms = []
mulargs = list(obj.expr.args)
for ind in range(len(mulargs)):
if not isinstance(sympify(mulargs[ind]), Number):
# a number coefficient is not considered for
# expansion of PartialDerivative
d = self.func(
mulargs[ind],
*obj.variables)._expand_partial_derivative()
terms.append(
TensMul(*(mulargs[:ind] + [d] +
mulargs[(ind + 1):])))
result = TensAdd.fromiter(terms)
else:
# derivative with respect to multiple variables
# decompose:
# partial(expr, (u, v))
# = partial(partial(expr, u).doit(), v).doit()
result = obj.expr # init with expr
for v in obj.variables:
result = self.func(result, v)._expand_partial_derivative()
# then throw PD on it
return result
def __new__(cls, expr, *variables):
# Flatten:
if isinstance(expr, PartialDerivative):
variables = expr.variables + variables
expr = expr.expr
# TODO: check that all variables have rank 1.
args, indices, free, dum = TensMul._tensMul_contract_indices([expr] +
list(variables), replace_indices=True)
obj = TensExpr.__new__(cls, *args)
obj._indices = indices
obj._free = free
obj._dum = dum
return obj
def __new__(cls, expr, *variables):
# Flatten:
if isinstance(expr, PartialDerivative):
variables = expr.variables + variables
expr = expr.expr
# TODO: check that all variables have rank 1.
args, indices, free, dum = TensMul._tensMul_contract_indices(
[expr] + list(variables), replace_indices=True)
obj = TensExpr.__new__(cls, *args)
obj._indices = indices
obj._free = free
obj._dum = dum
return obj
def tfunc(e):
coeff, list_new_tids = GammaMatrixHead.kahane_simplify(e.coeff, e._tids)
return TensAdd(*[TensMul.from_TIDS(coeff, ti) for ti in list_new_tids])
def test_add1():
assert TensAdd() == 0
# simple example of algebraic expression
Lorentz = TensorIndexType('Lorentz', dummy_fmt='L')
a,b,d0,d1,i,j,k = tensor_indices('a,b,d0,d1,i,j,k', Lorentz)
# A, B symmetric
A, B = tensorhead('A,B', [Lorentz]*2, [[1]*2])
t1 = A(b,-d0)*B(d0,a)
assert TensAdd(t1).equals(t1)
t2a = B(d0,a) + A(d0, a)
t2 = A(b,-d0)*t2a
assert str(t2) == 'A(a, L_0)*A(b, -L_0) + A(b, L_0)*B(a, -L_0)'
t2b = t2 + t1
assert str(t2b) == '2*A(b, L_0)*B(a, -L_0) + A(a, L_0)*A(b, -L_0)'
p, q, r = tensorhead('p,q,r', [Lorentz], [[1]])
t = q(d0)*2
assert str(t) == '2*q(d0)'
t = 2*q(d0)
assert str(t) == '2*q(d0)'
t1 = p(d0) + 2*q(d0)
assert str(t1) == '2*q(d0) + p(d0)'
t2 = p(-d0) + 2*q(-d0)
assert str(t2) == '2*q(-d0) + p(-d0)'
t1 = p(d0)
t3 = t1*t2
assert str(t3) == '2*p(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t3 = t2*t1
assert str(t3) == '2*p(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t1 = p(d0) + 2*q(d0)
t3 = t1*t2
assert str(t3) == '4*p(L_0)*q(-L_0) + 4*q(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t1 = p(d0) - 2*q(d0)
assert str(t1) == '-2*q(d0) + p(d0)'
t2 = p(-d0) + 2*q(-d0)
t3 = t1*t2
assert t3 == p(d0)*p(-d0) - 4*q(d0)*q(-d0)
t = p(i)*p(j)*(p(k) + q(k)) + p(i)*(p(j) + q(j))*(p(k) - 3*q(k))
assert t == 2*p(i)*p(j)*p(k) - 2*p(i)*p(j)*q(k) + p(i)*p(k)*q(j) - 3*p(i)*q(j)*q(k)
t1 = (p(i) + q(i) + 2*r(i))*(p(j) - q(j))
t2 = (p(j) + q(j) + 2*r(j))*(p(i) - q(i))
t = t1 + t2
assert t == 2*p(i)*p(j) + 2*p(i)*r(j) + 2*p(j)*r(i) - 2*q(i)*q(j) - 2*q(i)*r(j) - 2*q(j)*r(i)
t = p(i)*q(j)/2
assert 2*t == p(i)*q(j)
t = (p(i) + q(i))/2
assert 2*t == p(i) + q(i)
t = S.One - p(i)*p(-i)
assert (t + p(-j)*p(j)).equals(1)
t = S.One + p(i)*p(-i)
assert (t - p(-j)*p(j)).equals(1)
t = A(a, b) + B(a, b)
assert t.rank == 2
t1 = t - A(a, b) - B(a, b)
assert t1 == 0
t = 1 - (A(a, -a) + B(a, -a))
t1 = 1 + (A(a, -a) + B(a, -a))
assert (t + t1).equals(2)
t2 = 1 + A(a, -a)
assert t1 != t2
assert t2 != TensMul.from_data(0, [], [], [])
t = p(i) + q(i)
raises(ValueError, lambda: t(i, j))
def tfunc(e):
coeff, list_new_tids = GammaMatrixHead.kahane_simplify(
e.coeff, e._tids)
return TensAdd(*[TensMul.from_TIDS(coeff, ti) for ti in list_new_tids])
def _kahane_simplify(coeff, tids):
r"""
This function cancels contracted elements in a product of four
dimensional gamma matrices, resulting in an expression equal to the given
one, without the contracted gamma matrices.
Parameters
==========
`coeff` the coefficient of the tensor expression.
`tids` TIDS object representing the gamma matrix expression to simplify.
Notes
=====
If spinor indices are given, the matrices must be given in
the order given in the product.
Algorithm
=========
The idea behind the algorithm is to use some well-known identities,
i.e., for contractions enclosing an even number of `\gamma` matrices
`\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N}} \gamma_\mu = 2 (\gamma_{a_{2N}} \gamma_{a_1} \cdots \gamma_{a_{2N-1}} + \gamma_{a_{2N-1}} \cdots \gamma_{a_1} \gamma_{a_{2N}} )`
for an odd number of `\gamma` matrices
`\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N+1}} \gamma_\mu = -2 \gamma_{a_{2N+1}} \gamma_{a_{2N}} \cdots \gamma_{a_{1}}`
Instead of repeatedly applying these identities to cancel out all contracted indices,
it is possible to recognize the links that would result from such an operation,
the problem is thus reduced to a simple rearrangement of free gamma matrices.
Examples
========
When using, always remember that the original expression coefficient
has to be handled separately
>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, DiracSpinorIndex as DS
>>> from sympy.tensor.tensor import tensor_indices, tensorhead, TensMul, TensAdd
>>> i0, i1, i2 = tensor_indices('i0:3', G.LorentzIndex)
>>> s0,s1,s2,s3,s4,s5 = tensor_indices('s0:6', DS)
>>> ta = G(i0)*G(-i0)
>>> G._kahane_simplify(ta.coeff, ta._tids) - 4*DS.delta(DS.auto_left, -DS.auto_right)
0
>>> tb = G(i0)*G(i1)*G(-i0)
>>> G._kahane_simplify(tb.coeff, tb._tids)
-2*gamma(i1, auto_left, -auto_right)
>>> t = G(i0, s0, -s1)*G(-i0,s1,-s2)
>>> G._kahane_simplify(t.coeff, t._tids) - 4*DS.delta(s0, -s2)
0
>>> t = G(i0, s0, -s1)*G(-i0,s1,-s0)
>>> G._kahane_simplify(t.coeff, t._tids)
16
If there are no contractions, the same expression is returned
>>> tc = 3*G(i0)*G(i1)
>>> G._kahane_simplify(tc.coeff, tc._tids)
3*gamma(i0, auto_left, S_0)*gamma(i1, -S_0, -auto_right)
References
==========
[1] Algorithm for Reducing Contracted Products of gamma Matrices, Joseph Kahane, Journal of Mathematical Physics, Vol. 9, No. 10, October 1968.
"""
for c in tids.components:
if not(isinstance(tids.components[0], GammaMatrixHead)):
raise ValueError('use only gamma matrices')
n = len(tids.components)
for p0, p1, c0, c1 in tids.dum:
if p0 == 0:
continue
dc = abs(c0 - c1)
if dc not in (1, n - 1):
raise ValueError('wrong gamma matrix ordering')
free = [_ for _ in tids.free if _[1] == 0]
spinor_free = [_ for _ in tids.free if _[1] != 0]
if len(spinor_free) == 2:
spinor_free.sort(key=lambda x: x[2])
assert spinor_free[0][1] == 1 and spinor_free[-1][1] == 2
assert spinor_free[0][2] == 0
elif spinor_free:
raise ValueError('spinor indices do not match')
dum = sorted([_ for _ in tids.dum if _[0] == 0 and _[1] == 0])
if len(dum) == 0: # or GammaMatrixHead:
# no contractions in `expression`, just return it.
return TensMul.from_TIDS(coeff, tids)
# find the `first_dum_pos`, i.e. the position of the first contracted
# gamma matrix, Kahane's algorithm as described in his paper requires the
# gamma matrix expression to start with a contracted gamma matrix, this is
# a workaround which ignores possible initial free indices, and re-adds
# them later.
dum_zip = list(zip(*dum))[2:]
first_dum_pos = min(min(dum_zip[0]), min(dum_zip[1]))
total_number = len(free) + len(dum)*2
number_of_contractions = len(dum)
free_pos = [None]*total_number
for i in free:
free_pos[i[2]] = i[0]
# `index_is_free` is a list of booleans, to identify index position
# and whether that index is free or dummy.
index_is_free = [False]*total_number
for i, indx in enumerate(free):
if indx[1] != 0:
raise ValueError("indx[1] should be equal to 0")
index_is_free[indx[2]] = True
# `links` is a dictionary containing the graph described in Kahane's paper,
# to every key correspond one or two values, representing the linked indices.
# All values in `links` are integers, negative numbers are used in the case
# where it is necessary to insert gamma matrices between free indices, in
# order to make Kahane's algorithm work (see paper).
links = dict()
for i in range(first_dum_pos, total_number):
links[i] = []
# `cum_sign` is a step variable to mark the sign of every index, see paper.
cum_sign = -1
# `cum_sign_list` keeps storage for all `cum_sign` (every index).
cum_sign_list = [None]*total_number
block_free_count = 0
# multiply `resulting_coeff` by the coefficient parameter, the rest
# of the algorithm ignores a scalar coefficient.
resulting_coeff = S.One * coeff
# initialize a lisf of lists of indices. The outer list will contain all
# additive tensor expressions, while the inner list will contain the
# free indices (rearranged according to the algorithm).
resulting_indices = [[]]
# start to count the `connected_components`, which together with the number
# of contractions, determines a -1 or +1 factor to be multiplied.
connected_components = 1
# First loop: here we fill `cum_sign_list`, and draw the links
# among consecutive indices (they are stored in `links`). Links among
# non-consecutive indices will be drawn later.
for i, is_free in enumerate(index_is_free):
# if `expression` starts with free indices, they are ignored here;
# they are later added as they are to the beginning of all
# `resulting_indices` list of lists of indices.
if i < first_dum_pos:
continue
if is_free:
block_free_count += 1
# if previous index was free as well, draw an arch in `links`.
if block_free_count > 1:
links[i - 1].append(i)
links[i].append(i - 1)
else:
# Change the sign of the index (`cum_sign`) if the number of free
# indices preceding it is even.
cum_sign *= 1 if (block_free_count % 2) else -1
if block_free_count == 0 and i != first_dum_pos:
# check if there are two consecutive dummy indices:
# in this case create virtual indices with negative position,
# these "virtual" indices represent the insertion of two
# gamma^0 matrices to separate consecutive dummy indices, as
# Kahane's algorithm requires dummy indices to be separated by
# free indices. The product of two gamma^0 matrices is unity,
# so the new expression being examined is the same as the
# original one.
if cum_sign == -1:
links[-1-i] = [-1-i+1]
links[-1-i+1] = [-1-i]
if (i - cum_sign) in links:
if i != first_dum_pos:
links[i].append(i - cum_sign)
if block_free_count != 0:
if i - cum_sign < len(index_is_free):
if index_is_free[i - cum_sign]:
links[i - cum_sign].append(i)
block_free_count = 0
cum_sign_list[i] = cum_sign
# The previous loop has only created links between consecutive free indices,
# it is necessary to properly create links among dummy (contracted) indices,
# according to the rules described in Kahane's paper. There is only one exception
# to Kahane's rules: the negative indices, which handle the case of some
# consecutive free indices (Kahane's paper just describes dummy indices
# separated by free indices, hinting that free indices can be added without
# altering the expression result).
for i in dum:
if i[0] != 0:
raise ValueError("i[0] should be 0")
if i[1] != 0:
raise ValueError("i[1] should be 0")
# get the positions of the two contracted indices:
pos1 = i[2]
pos2 = i[3]
# create Kahane's upper links, i.e. the upper arcs between dummy
# (i.e. contracted) indices:
links[pos1].append(pos2)
links[pos2].append(pos1)
# create Kahane's lower links, this corresponds to the arcs below
# the line described in the paper:
# first we move `pos1` and `pos2` according to the sign of the indices:
linkpos1 = pos1 + cum_sign_list[pos1]
linkpos2 = pos2 + cum_sign_list[pos2]
# otherwise, perform some checks before creating the lower arcs:
# make sure we are not exceeding the total number of indices:
if linkpos1 >= total_number:
continue
if linkpos2 >= total_number:
continue
# make sure we are not below the first dummy index in `expression`:
if linkpos1 < first_dum_pos:
continue
if linkpos2 < first_dum_pos:
continue
# check if the previous loop created "virtual" indices between dummy
# indices, in such a case relink `linkpos1` and `linkpos2`:
if (-1-linkpos1) in links:
linkpos1 = -1-linkpos1
if (-1-linkpos2) in links:
linkpos2 = -1-linkpos2
# move only if not next to free index:
if linkpos1 >= 0 and not index_is_free[linkpos1]:
linkpos1 = pos1
if linkpos2 >=0 and not index_is_free[linkpos2]:
linkpos2 = pos2
# create the lower arcs:
if linkpos2 not in links[linkpos1]:
links[linkpos1].append(linkpos2)
if linkpos1 not in links[linkpos2]:
links[linkpos2].append(linkpos1)
# This loop starts from the `first_dum_pos` index (first dummy index)
# walks through the graph deleting the visited indices from `links`,
# it adds a gamma matrix for every free index in encounters, while it
# completely ignores dummy indices and virtual indices.
pointer = first_dum_pos
previous_pointer = 0
while True:
if pointer in links:
next_ones = links.pop(pointer)
else:
break
if previous_pointer in next_ones:
next_ones.remove(previous_pointer)
previous_pointer = pointer
if next_ones:
pointer = next_ones[0]
else:
break
if pointer == previous_pointer:
break
if pointer >=0 and free_pos[pointer] is not None:
for ri in resulting_indices:
ri.append(free_pos[pointer])
# The following loop removes the remaining connected components in `links`.
# If there are free indices inside a connected component, it gives a
# contribution to the resulting expression given by the factor
# `gamma_a gamma_b ... gamma_z + gamma_z ... gamma_b gamma_a`, in Kahanes's
# paper represented as {gamma_a, gamma_b, ... , gamma_z},
# virtual indices are ignored. The variable `connected_components` is
# increased by one for every connected component this loop encounters.
# If the connected component has virtual and dummy indices only
# (no free indices), it contributes to `resulting_indices` by a factor of two.
# The multiplication by two is a result of the
# factor {gamma^0, gamma^0} = 2 I, as it appears in Kahane's paper.
# Note: curly brackets are meant as in the paper, as a generalized
# multi-element anticommutator!
while links:
connected_components += 1
pointer = min(links.keys())
previous_pointer = pointer
# the inner loop erases the visited indices from `links`, and it adds
# all free indices to `prepend_indices` list, virtual indices are
# ignored.
prepend_indices = []
while True:
if pointer in links:
next_ones = links.pop(pointer)
else:
break
if previous_pointer in next_ones:
if len(next_ones) > 1:
next_ones.remove(previous_pointer)
previous_pointer = pointer
if next_ones:
pointer = next_ones[0]
if pointer >= first_dum_pos and free_pos[pointer] is not None:
prepend_indices.insert(0, free_pos[pointer])
# if `prepend_indices` is void, it means there are no free indices
# in the loop (and it can be shown that there must be a virtual index),
# loops of virtual indices only contribute by a factor of two:
if len(prepend_indices) == 0:
resulting_coeff *= 2
# otherwise, add the free indices in `prepend_indices` to
# the `resulting_indices`:
else:
expr1 = prepend_indices
expr2 = list(reversed(prepend_indices))
resulting_indices = [expri + ri for ri in resulting_indices for expri in (expr1, expr2)]
# sign correction, as described in Kahane's paper:
resulting_coeff *= -1 if (number_of_contractions - connected_components + 1) % 2 else 1
# power of two factor, as described in Kahane's paper:
resulting_coeff *= 2**(number_of_contractions)
# If `first_dum_pos` is not zero, it means that there are trailing free gamma
# matrices in front of `expression`, so multiply by them:
for i in range(0, first_dum_pos):
[ri.insert(0, free_pos[i]) for ri in resulting_indices]
resulting_expr = S.Zero
for i in resulting_indices:
temp_expr = S.One
for j in i:
temp_expr *= GammaMatrix(j)
resulting_expr += temp_expr
t = resulting_coeff * resulting_expr
t1 = None
if isinstance(t, TensAdd):
t1 = t.args[0]
elif isinstance(t, TensMul):
t1 = t
if t1:
spinor_free1 = [_ for _ in t1._tids.free if _[1] != 0]
if spinor_free1:
if spinor_free:
t = t.substitute_indices((DiracSpinorIndex.auto_left, spinor_free[0][0]), (-DiracSpinorIndex.auto_right, spinor_free[-1][0]))
else:
# FIXME trace
t = t*DiracSpinorIndex.delta(DiracSpinorIndex.auto_right, -DiracSpinorIndex.auto_left)
t = GammaMatrix.simplify_lines(t)
else:
if spinor_free:
t = t*DiracSpinorIndex.delta(spinor_free[0][0], spinor_free[-1][0])
else:
t = t*4
else:
if spinor_free:
t = t*DiracSpinorIndex.delta(spinor_free[0][0], spinor_free[-1][0])
else:
t = t*4
return t
def _trace_single_line1(t):
t = t.sorted_components()
components = t.components
ncomps = len(components)
g = self.LorentzIndex.metric
sg = DiracSpinorIndex.delta
# gamma matirices are in a[i:j]
hit = 0
for i in range(ncomps):
if isinstance(components[i], GammaMatrixHead):
hit = 1
break
for j in range(i + hit, ncomps):
if not isinstance(components[j], GammaMatrixHead):
break
else:
j = ncomps
numG = j - i
if numG == 0:
spinor_free = [_[0] for _ in t._tids.free if _[0].tensortype is DiracSpinorIndex]
tcoeff = t.coeff
if spinor_free == [DiracSpinorIndex.auto_left, -DiracSpinorIndex.auto_right]:
t = t*DiracSpinorIndex.delta(-DiracSpinorIndex.auto_left, DiracSpinorIndex.auto_right)
t = t.contract_metric(sg)
return t/tcoeff if tcoeff else t
else:
return t/tcoeff if tcoeff else t
if numG % 2 == 1:
return TensMul.from_data(S.Zero, [], [], [])
elif numG > 4:
t = t.substitute_indices((-DiracSpinorIndex.auto_right, -DiracSpinorIndex.auto_index), (DiracSpinorIndex.auto_left, DiracSpinorIndex.auto_index))
a = t.split()
ind1, lind1, rind1 = a[i].args[-1]
ind2, lind2, rind2 = a[i + 1].args[-1]
aa = a[:i] + a[i + 2:]
t1 = tensor_mul(*aa)*g(ind1, ind2)*sg(lind1, rind1)*sg(lind2, rind2)
t1 = t1.contract_metric(g)
t1 = t1.contract_metric(sg)
args = [t1]
sign = 1
for k in range(i + 2, j):
sign = -sign
ind2, lind2, rind2 = a[k].args[-1]
aa = a[:i] + a[i + 1:k] + a[k + 1:]
t2 = sign*tensor_mul(*aa)*g(ind1, ind2)*sg(lind1, rind1)*sg(lind2, rind2)
t2 = t2.contract_metric(g)
t2 = t2.contract_metric(sg)
t2 = GammaMatrixHead.simplify_gpgp(t2, False)
args.append(t2)
t3 = TensAdd(*args)
#aa = _tensorlist_contract_metric(aa, g(ind1, ind2))
#t3 = t3.canon_bp()
t3 = self._trace_single_line(t3)
return t3
else:
a = t.split()
if len(t.components) == 1:
if t.components[0] is DiracSpinorIndex.delta:
return 4 # FIXME only for D=4
t1 = self._gamma_trace1(*a[i:j])
a2 = a[:i] + a[j:]
t2 = tensor_mul(*a2)
t3 = t1*t2
if not t3:
return t3
t3 = t3.contract_metric(g)
return t3
def test_add1():
assert TensAdd() == 0
# simple example of algebraic expression
Lorentz = TensorIndexType('Lorentz', dummy_fmt='L')
a, b, d0, d1, i, j, k = tensor_indices('a,b,d0,d1,i,j,k', Lorentz)
# A, B symmetric
A, B = tensorhead('A,B', [Lorentz] * 2, [[1] * 2])
t1 = A(b, -d0) * B(d0, a)
assert TensAdd(t1).equals(t1)
t2a = B(d0, a) + A(d0, a)
t2 = A(b, -d0) * t2a
assert str(t2) == 'A(a, L_0)*A(b, -L_0) + A(b, L_0)*B(a, -L_0)'
t2b = t2 + t1
assert str(t2b) == '2*A(b, L_0)*B(a, -L_0) + A(a, L_0)*A(b, -L_0)'
p, q, r = tensorhead('p,q,r', [Lorentz], [[1]])
t = q(d0) * 2
assert str(t) == '2*q(d0)'
t = 2 * q(d0)
assert str(t) == '2*q(d0)'
t1 = p(d0) + 2 * q(d0)
assert str(t1) == '2*q(d0) + p(d0)'
t2 = p(-d0) + 2 * q(-d0)
assert str(t2) == '2*q(-d0) + p(-d0)'
t1 = p(d0)
t3 = t1 * t2
assert str(t3) == '2*p(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t3 = t2 * t1
assert str(t3) == '2*p(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t1 = p(d0) + 2 * q(d0)
t3 = t1 * t2
assert str(t3) == '4*p(L_0)*q(-L_0) + 4*q(L_0)*q(-L_0) + p(L_0)*p(-L_0)'
t1 = p(d0) - 2 * q(d0)
assert str(t1) == '-2*q(d0) + p(d0)'
t2 = p(-d0) + 2 * q(-d0)
t3 = t1 * t2
assert t3 == p(d0) * p(-d0) - 4 * q(d0) * q(-d0)
t = p(i) * p(j) * (p(k) + q(k)) + p(i) * (p(j) + q(j)) * (p(k) - 3 * q(k))
assert t == 2 * p(i) * p(j) * p(k) - 2 * p(i) * p(j) * q(k) + p(i) * p(
k) * q(j) - 3 * p(i) * q(j) * q(k)
t1 = (p(i) + q(i) + 2 * r(i)) * (p(j) - q(j))
t2 = (p(j) + q(j) + 2 * r(j)) * (p(i) - q(i))
t = t1 + t2
assert t == 2 * p(i) * p(j) + 2 * p(i) * r(j) + 2 * p(j) * r(i) - 2 * q(
i) * q(j) - 2 * q(i) * r(j) - 2 * q(j) * r(i)
t = p(i) * q(j) / 2
assert 2 * t == p(i) * q(j)
t = (p(i) + q(i)) / 2
assert 2 * t == p(i) + q(i)
t = S.One - p(i) * p(-i)
assert (t + p(-j) * p(j)).equals(1)
t = S.One + p(i) * p(-i)
assert (t - p(-j) * p(j)).equals(1)
t = A(a, b) + B(a, b)
assert t.rank == 2
t1 = t - A(a, b) - B(a, b)
assert t1 == 0
t = 1 - (A(a, -a) + B(a, -a))
t1 = 1 + (A(a, -a) + B(a, -a))
assert (t + t1).equals(2)
t2 = 1 + A(a, -a)
assert t1 != t2
assert t2 != TensMul.from_data(0, [], [], [])
t = p(i) + q(i)
raises(ValueError, lambda: t(i, j))
