def test_hash(): D = Symbol('D') Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') a,b,c,d,e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric p, q = tensorhead('p q', [Lorentz], [[1]]) p_type = p.args[1] t1 = p(a)*q(b) t2 = p(a)*p(b) assert hash(t1) != hash(t2) t3 = p(a)*p(b) + g(a,b) t4 = p(a)*p(b) - g(a,b) assert hash(t3) != hash(t4) assert a.func(*a.args) == a assert Lorentz.func(*Lorentz.args) == Lorentz assert g.func(*g.args) == g assert p.func(*p.args) == p assert p_type.func(*p_type.args) == p_type assert p(a).func(*(p(a)).args) == p(a) assert t1.func(*t1.args) == t1 assert t2.func(*t2.args) == t2 assert t3.func(*t3.args) == t3 assert t4.func(*t4.args) == t4 assert hash(a.func(*a.args)) == hash(a) assert hash(Lorentz.func(*Lorentz.args)) == hash(Lorentz) assert hash(g.func(*g.args)) == hash(g) assert hash(p.func(*p.args)) == hash(p) assert hash(p_type.func(*p_type.args)) == hash(p_type) assert hash(p(a).func(*(p(a)).args)) == hash(p(a)) assert hash(t1.func(*t1.args)) == hash(t1) assert hash(t2.func(*t2.args)) == hash(t2) assert hash(t3.func(*t3.args)) == hash(t3) assert hash(t4.func(*t4.args)) == hash(t4) def check_all(obj): return all([isinstance(_, Basic) for _ in obj.args]) assert check_all(a) assert check_all(Lorentz) assert check_all(g) assert check_all(p) assert check_all(p_type) assert check_all(p(a)) assert check_all(t1) assert check_all(t2) assert check_all(t3) assert check_all(t4) tsymmetry = tensorsymmetry([2], [1], [1, 1, 1]) assert tsymmetry.func(*tsymmetry.args) == tsymmetry assert hash(tsymmetry.func(*tsymmetry.args)) == hash(tsymmetry) assert check_all(tsymmetry)
def test_hash(): D = Symbol('D') Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric p, q = tensorhead('p q', [Lorentz], [[1]]) p_type = p.args[1] t1 = p(a) * q(b) t2 = p(a) * p(b) assert hash(t1) != hash(t2) t3 = p(a) * p(b) + g(a, b) t4 = p(a) * p(b) - g(a, b) assert hash(t3) != hash(t4) assert a.func(*a.args) == a assert Lorentz.func(*Lorentz.args) == Lorentz assert g.func(*g.args) == g assert p.func(*p.args) == p assert p_type.func(*p_type.args) == p_type assert p(a).func(*(p(a)).args) == p(a) assert t1.func(*t1.args) == t1 assert t2.func(*t2.args) == t2 assert t3.func(*t3.args) == t3 assert t4.func(*t4.args) == t4 assert hash(a.func(*a.args)) == hash(a) assert hash(Lorentz.func(*Lorentz.args)) == hash(Lorentz) assert hash(g.func(*g.args)) == hash(g) assert hash(p.func(*p.args)) == hash(p) assert hash(p_type.func(*p_type.args)) == hash(p_type) assert hash(p(a).func(*(p(a)).args)) == hash(p(a)) assert hash(t1.func(*t1.args)) == hash(t1) assert hash(t2.func(*t2.args)) == hash(t2) assert hash(t3.func(*t3.args)) == hash(t3) assert hash(t4.func(*t4.args)) == hash(t4) def check_all(obj): return all([isinstance(_, Basic) for _ in obj.args]) assert check_all(a) assert check_all(Lorentz) assert check_all(g) assert check_all(p) assert check_all(p_type) assert check_all(p(a)) assert check_all(t1) assert check_all(t2) assert check_all(t3) assert check_all(t4) tsymmetry = tensorsymmetry([2], [1], [1, 1, 1]) assert tsymmetry.func(*tsymmetry.args) == tsymmetry assert hash(tsymmetry.func(*tsymmetry.args)) == hash(tsymmetry) assert check_all(tsymmetry)
def test_special_eq_ne(): # test special equality cases: 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]) p, q, r = tensorhead('p,q,r', [Lorentz], [[1]]) t = 0 * A(a, b) assert t == 0 assert t == S.Zero assert p(i) != A(a, b) assert A(a, -a) != A(a, b) assert 0 * (A(a, b) + B(a, b)) == 0 assert 0 * (A(a, b) + B(a, b)) == S.Zero assert 3 * (A(a, b) - A(a, b)) == S.Zero assert p(i) + q(i) != A(a, b) assert p(i) + q(i) != A(a, b) + B(a, b) assert p(i) - p(i) == 0 assert p(i) - p(i) == S.Zero assert A(a, b) == A(b, a)
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_riemann_invariants(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11 = \ tensor_indices('d0:12', Lorentz) # R^{d0 d1}_{d1 d0}; ord = [d0,-d0,d1,-d1] # T_c = -R^{d0 d1}_{d0 d1} R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) t = R(d0, d1, -d1, -d0) tc = t.canon_bp() assert str(tc) == '-R(L_0, L_1, -L_0, -L_1)' # R_d11^d1_d0^d5 * R^{d6 d4 d0}_d5 * R_{d7 d2 d8 d9} * # R_{d10 d3 d6 d4} * R^{d2 d7 d11}_d1 * R^{d8 d9 d3 d10} # can = [0,2,4,6, 1,3,8,10, 5,7,12,14, 9,11,16,18, 13,15,20,22, # 17,19,21<F10,23, 24,25] # T_c = R^{d0 d1 d2 d3} * R_{d0 d1}^{d4 d5} * R_{d2 d3}^{d6 d7} * # R_{d4 d5}^{d8 d9} * R_{d6 d7}^{d10 d11} * R_{d8 d9 d10 d11} t = R(-d11,d1,-d0,d5)*R(d6,d4,d0,-d5)*R(-d7,-d2,-d8,-d9)* \ R(-d10,-d3,-d6,-d4)*R(d2,d7,d11,-d1)*R(d8,d9,d3,d10) tc = t.canon_bp() assert str( tc ) == 'R(L_0, L_1, L_2, L_3)*R(-L_0, -L_1, L_4, L_5)*R(-L_2, -L_3, L_6, L_7)*R(-L_4, -L_5, L_8, L_9)*R(-L_6, -L_7, L_10, L_11)*R(-L_8, -L_9, -L_10, -L_11)'
def test_fun(): D = Symbol('D') Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric p, q = tensorhead('p q', [Lorentz], [[1]]) t = q(c) * p(a) * q(b) + g(a, b) * g(c, d) * q(-d) assert t(a, b, c) == t assert t - t(b, a, c) == q(c) * p(a) * q(b) - q(c) * p(b) * q(a) assert t(b, c, d) == q(d) * p(b) * q(c) + g(b, c) * g(d, e) * q(-e) t1 = t.fun_eval((a, b), (b, a)) assert t1 == q(c) * p(b) * q(a) + g(a, b) * g(c, d) * q(-d) # check that g_{a b; c} = 0 # example taken from L. Brewin # "A brief introduction to Cadabra" arxiv:0903.2085 # dg_{a b c} = \partial_{a} g_{b c} is symmetric in b, c dg = tensorhead('dg', [Lorentz] * 3, [[1], [1] * 2]) # gamma^a_{b c} is the Christoffel symbol gamma = S.Half * g(a, d) * (dg(-b, -d, -c) + dg(-c, -b, -d) - dg(-d, -b, -c)) # t = g_{a b; c} t = dg(-c, -a, -b) - g(-a, -d) * gamma(d, -b, -c) - g(-b, -d) * gamma(d, -a, -c) t = t.contract_metric(g, True) assert t == 0 t = q(c) * p(a) * q(b) assert t(b, c, d) == q(d) * p(b) * q(c)
def __new__(cls, dim=4, eps_dim=None, dummy_fmt="L"): if (dim, eps_dim) in _LorentzContainer.lorentz_types: return _LorentzContainer.lorentz_types[(dim, eps_dim)] new_L = TensorIndexType("Lorentz", dim=dim, eps_dim=eps_dim, dummy_fmt=dummy_fmt) _LorentzContainer.lorentz_types[(dim, eps_dim)] = new_L return new_L
def test_tensor_element(): L = TensorIndexType("L") i, j, k, l, m, n = tensor_indices("i j k l m n", L) A = TensorHead("A", [L, L], TensorSymmetry.no_symmetry(2)) a = A(i, j) assert isinstance(TensorElement(a, {}), Tensor) assert isinstance(TensorElement(a, {k: 1}), Tensor) te1 = TensorElement(a, {Symbol("i"): 1}) assert te1.free == [(j, 0)] assert te1.get_free_indices() == [j] assert te1.dum == [] te2 = TensorElement(a, {i: 1}) assert te2.free == [(j, 0)] assert te2.get_free_indices() == [j] assert te2.dum == [] assert te1 == te2 array = Array([[1, 2], [3, 4]]) assert te1.replace_with_arrays({A(i, j): array}, [j]) == array[1, :]
def test_TensorIndexType(): D = Symbol('D') G = Metric('g', False) Lorentz = TensorIndexType('Lorentz', metric=G, dim=D, dummy_fmt='L') m0, m1, m2, m3, m4 = tensor_indices('m0:5', Lorentz) sym2 = tensorsymmetry([1] * 2) sym2n = tensorsymmetry(*get_symmetric_group_sgs(2)) assert sym2 == sym2n g = Lorentz.metric assert str(g) == 'g(Lorentz,Lorentz)' assert Lorentz.eps_dim == Lorentz.dim TSpace = TensorIndexType('TSpace') i0, i1 = tensor_indices('i0 i1', TSpace) g = TSpace.metric A = tensorhead('A', [TSpace] * 2, [[1] * 2]) assert str(A(i0, -i0).canon_bp()) == 'A(TSpace_0, -TSpace_0)'
def test_bug_correction_tensor_indices(): # to make sure that tensor_indices does not return a list if creating # only one index: from sympy.tensor.tensor import tensor_indices, TensorIndexType, TensorIndex A = TensorIndexType("A") i = tensor_indices('i', A) assert not isinstance(i, (tuple, list)) assert isinstance(i, TensorIndex)
def test_TensorManager(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') LorentzH = TensorIndexType('LorentzH', dummy_fmt='LH') i, j = tensor_indices('i,j', Lorentz) ih, jh = tensor_indices('ih,jh', LorentzH) p, q = tensorhead('p q', [Lorentz], [[1]]) ph, qh = tensorhead('ph qh', [LorentzH], [[1]]) Gsymbol = Symbol('Gsymbol') GHsymbol = Symbol('GHsymbol') TensorManager.set_comm(Gsymbol, GHsymbol, 0) G = tensorhead('G', [Lorentz], [[1]], Gsymbol) assert TensorManager._comm_i2symbol[G.comm] == Gsymbol GH = tensorhead('GH', [LorentzH], [[1]], GHsymbol) ps = G(i) * p(-i) psh = GH(ih) * ph(-ih) t = ps + psh t1 = t * t assert t1 == ps * ps + 2 * ps * psh + psh * psh qs = G(i) * q(-i) qsh = GH(ih) * qh(-ih) assert ps * qsh == qsh * ps assert ps * qs != qs * ps n = TensorManager.comm_symbols2i(Gsymbol) assert TensorManager.comm_i2symbol(n) == Gsymbol assert GHsymbol in TensorManager._comm_symbols2i raises(ValueError, lambda: TensorManager.set_comm(GHsymbol, 1, 2)) TensorManager.set_comms((Gsymbol, GHsymbol, 0), (Gsymbol, 1, 1)) assert TensorManager.get_comm(n, 1) == TensorManager.get_comm(1, n) == 1 TensorManager.clear() assert TensorManager.comm == [{ 0: 0, 1: 0, 2: 0 }, { 0: 0, 1: 1, 2: None }, { 0: 0, 1: None }] assert GHsymbol not in TensorManager._comm_symbols2i nh = TensorManager.comm_symbols2i(GHsymbol) assert GHsymbol in TensorManager._comm_symbols2i
def test_contract_automatrix_and_data(): numpy = import_module('numpy') if numpy is None: return L = TensorIndexType('L') S = TensorIndexType('S') G = tensorhead('G', [L, S, S], [[1] * 3], matrix_behavior=True) def G_data(): G.data = [[[1]]] raises(ValueError, G_data) L.data = [1, -1] raises(ValueError, G_data) S.data = [[1, 0], [0, 2]] G.data = [ [[1, 2], [3, 4]], [[5, 6], [7, 8]] ] m0, m1, m2 = tensor_indices('m0:3', L) s0, s1, s2 = tensor_indices('s0:3', S) assert (G(-m0).data == numpy.array([ [[1, 4], [3, 8]], [[-5, -12], [-7, -16]] ])).all() (G(m0) * G(-m0)).data G(m0, s0, -s1).data c1 = G(m0, s0, -s1)*G(-m0, s1, -s2) c2 = G(m0) * G(-m0) assert (c1.data == c2.data).all() del L.data del S.data del G.data assert L.data is None assert S.data is None assert G.data is None
def test_TensorHead(): assert TensAdd() == 0 # simple example of algebraic expression Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') a, b = tensor_indices('a,b', Lorentz) # A, B symmetric A = tensorhead('A', [Lorentz] * 2, [[1] * 2]) assert A.rank == 2 assert A.symmetry == tensorsymmetry([1] * 2)
def test_TensorType(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') sym = tensorsymmetry([1] * 2) A = tensorhead('A', [Lorentz] * 2, [[1] * 2]) assert A.typ == TensorType([Lorentz] * 2, sym) assert A.types == [Lorentz] typ = TensorType([Lorentz] * 2, sym) assert str(typ) == "TensorType(['Lorentz', 'Lorentz'])" raises(ValueError, lambda: typ(2))
def test_contract_metric1(): D = Symbol('D') Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric p = tensorhead('p', [Lorentz], [[1]]) t = g(a, b) * p(-b) t1 = t.contract_metric(g) assert t1 == p(a) A, B = tensorhead('A,B', [Lorentz] * 2, [[1] * 2]) # case with g with all free indices t1 = A(a, b) * B(-b, c) * g(d, e) t2 = t1.contract_metric(g) assert t1 == t2 # case of g(d, -d) t1 = A(a, b) * B(-b, c) * g(-d, d) t2 = t1.contract_metric(g) assert t2 == D * A(a, d) * B(-d, c) # g with one free index t1 = A(a, b) * B(-b, -c) * g(c, d) t2 = t1.contract_metric(g) assert t2 == A(a, c) * B(-c, d) # g with both indices contracted with another tensor t1 = A(a, b) * B(-b, -c) * g(c, -a) t2 = t1.contract_metric(g) assert t2 == A(a, b) * B(-b, -a) t1 = A(a, b) * B(-b, -c) * g(c, d) * g(-a, -d) t2 = t1.contract_metric(g) t2 = t2.contract_metric(g) assert t2 == A(a, b) * B(-b, -a) t1 = A(a, b) * g(-a, -b) t2 = t1.contract_metric(g) assert t2 == A(a, -a) assert not t2.free Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') a, b = tensor_indices('a,b', Lorentz) g = Lorentz.metric raises(ValueError, lambda: g(a, -a).contract_metric(g)) # no dim
def test_riemann_cyclic_replace(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') m0, m1, m2, m3 = tensor_indices('m:4', Lorentz) symr = tensorsymmetry([2, 2]) R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) t = R(m0, m2, m1, m3) t1 = riemann_cyclic_replace(t) t1a = -S.One / 3 * R(m0, m3, m2, m1) + S.One / 3 * R( m0, m1, m2, m3) + Rational(2, 3) * R(m0, m2, m1, m3) assert t1 == t1a
def test_tensorsymmetry(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') sym = tensorsymmetry([1] * 2) sym1 = TensorSymmetry(get_symmetric_group_sgs(2)) assert sym == sym1 sym = tensorsymmetry([2]) sym1 = TensorSymmetry(get_symmetric_group_sgs(2, 1)) assert sym == sym1 sym2 = tensorsymmetry() assert sym2.base == Tuple() and sym2.generators == Tuple(Permutation(1)) raises(NotImplementedError, lambda: tensorsymmetry([2, 1]))
def test_indices(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') a, b, c, d = tensor_indices('a,b,c,d', Lorentz) assert a.tensortype == Lorentz assert a != -a A, B = tensorhead('A B', [Lorentz] * 2, [[1] * 2]) t = A(a, b) * B(-b, c) indices = t.get_indices() L_0 = TensorIndex('L_0', Lorentz) assert indices == [a, L_0, -L_0, c] raises(ValueError, lambda: tensor_indices(3, Lorentz)) raises(ValueError, lambda: A(a, b, c))
def test_hash(): D = Symbol('D') Lorentz = TensorIndexType('Lorentz', dim=D, dummy_fmt='L') a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric p, q = tensorhead('p q', [Lorentz], [[1]]) t1 = p(a) * q(b) t2 = p(a) * p(b) assert hash(t1) != hash(t2) t3 = p(a) * p(b) + g(a, b) t4 = p(a) * p(b) - g(a, b) assert hash(t3) != hash(t4)
def test_div(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') m0, m1, m2, m3 = tensor_indices('m0:4', Lorentz) R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) t = R(m0, m1, -m1, m3) t1 = t / S(4) assert str(t1) == '1/4*R(m0, L_0, -L_0, m3)' t = t.canon_bp() assert not t1._is_canon_bp t1 = t * 4 assert t1._is_canon_bp t1 = t1 / 4 assert t1._is_canon_bp
def test_noncommuting_components(): numpy = import_module("numpy") if numpy is None: skip("numpy not installed.") euclid = TensorIndexType('Euclidean') euclid.data = [1, 1] i1, i2, i3 = tensor_indices('i1:4', euclid) a, b, c, d = symbols('a b c d', commutative=False) V1 = tensorhead('V1', [euclid] * 2, [[1]] * 2) V1.data = [[a, b], (c, d)] V2 = tensorhead('V2', [euclid] * 2, [[1]] * 2) V2.data = [[a, c], [b, d]] vtp = V1(i1, i2) * V2(-i2, -i1) assert vtp == a**2 + b * c + c * b + d**2 assert vtp != a**2 + 2 * b * c + d**2 Vc = b * V1(i1, -i1) assert Vc.expand() == b * a + b * d
def test_noncommuting_components(): numpy = import_module("numpy") if numpy is None: skip("numpy not installed.") euclid = TensorIndexType('Euclidean') euclid.data = [1, 1] i1, i2, i3 = tensor_indices('i1:4', euclid) a, b, c, d = symbols('a b c d', commutative=False) V1 = tensorhead('V1', [euclid] * 2, [[1]]*2) V1.data = [[a, b], (c, d)] V2 = tensorhead('V2', [euclid] * 2, [[1]]*2) V2.data = [[a, c], [b, d]] vtp = V1(i1, i2) * V2(-i2, -i1) assert vtp == a ** 2 + b * c + c * b + d ** 2 assert vtp != a**2 + 2*b*c + d**2 Vc = b * V1(i1, -i1) assert Vc.expand() == b * a + b * d
def test_add2(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') m, n, p, q = tensor_indices('m,n,p,q', Lorentz) R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) A = tensorhead('A', [Lorentz] * 3, [[3]]) t1 = 2 * R(m, n, p, q) - R(m, q, n, p) + R(m, p, n, q) t2 = t1 * A(-n, -p, -q) assert t2 == 0 t1 = S(2) / 3 * R(m, n, p, q) - S(1) / 3 * R(m, q, n, p) + S(1) / 3 * R( m, p, n, q) t2 = t1 * A(-n, -p, -q) assert t2 == 0 t = A(m, -m, n) + A(n, p, -p) assert t == 0
def test_canonicalize3(): D = Symbol('D') Spinor = TensorIndexType('Spinor', dim=D, metric=True, dummy_fmt='S') a0, a1, a2, a3, a4 = tensor_indices('a0:5', Spinor) C = Spinor.metric chi, psi = tensorhead('chi,psi', [Spinor], [[1]], 1) t = chi(a1) * psi(a0) t1 = t.canon_bp() assert t1 == t t = psi(a1) * chi(a0) t1 = t.canon_bp() assert t1 == -chi(a0) * psi(a1)
def __new__(cls, symbol, coords, matrix, **kwargs): """ Create a new Metric object. Parameters ---------- symbol : str Name of the tensor and the symbol to denote it by when printed. coords : iterable List of ~sympy.Symbol objects to denote the coordinates by which derivatives are taken with respect to. matrix : (list, tuple, ~sympy.Matrix, ~sympy.Array) Matrix representation of the tensor to be used in substitution. Can be of any type that is acceptable by ~sympy.Array. Examples -------- >>> from sympy import diag, symbols >>> from einsteinpy.symbolic.tensor import indices, expand_tensor >>> from einsteinpy.symbolic.metric import Metric >>> t, x, y, z = symbols('t x y z') >>> eta = Metric('eta', [t, x, y, z], diag(1, -1, -1, -1)) >>> mu, nu = indices('mu nu', eta) >>> expr = eta(mu, nu) * eta(-mu, -nu) >>> expand_tensor(expr) 4 """ array = Array(matrix) if array.rank() != 2 or array.shape[0] != array.shape[1]: raise ValueError( "matrix must be square, received matrix of shape {}".format( array.shape)) obj = TensorIndexType.__new__( cls, symbol, metric=cls._MetricId(symbol, False), dim=array.shape[0], dummy_fmt=symbol, **kwargs, ) obj = AbstractTensor.__new__(cls, obj, array) obj.metric = Tensor(obj.name, array, obj, covar=(-1, -1)) obj.coords = tuple(coords) ReplacementManager[obj] = array return obj
def test_canonicalize_no_dummies(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') a, b, c, d = tensor_indices('a, b, c, d', Lorentz) sym1 = tensorsymmetry([1]) sym2 = tensorsymmetry([1] * 2) sym2a = tensorsymmetry([2]) # A commuting # A^c A^b A^a # T_c = A^a A^b A^c S1 = TensorType([Lorentz], sym1) A = S1('A') t = A(c) * A(b) * A(a) tc = t.canon_bp() assert str(tc) == 'A(a)*A(b)*A(c)' # A anticommuting # A^c A^b A^a # T_c = -A^a A^b A^c A = S1('A', 1) t = A(c) * A(b) * A(a) tc = t.canon_bp() assert str(tc) == '-A(a)*A(b)*A(c)' # A commuting and symmetric # A^{b,d}*A^{c,a} # T_c = A^{a c}*A^{b d} S2 = TensorType([Lorentz] * 2, sym2) A = S2('A') t = A(b, d) * A(c, a) tc = t.canon_bp() assert str(tc) == 'A(a, c)*A(b, d)' # A anticommuting and symmetric # A^{b,d}*A^{c,a} # T_c = -A^{a c}*A^{b d} A = S2('A', 1) t = A(b, d) * A(c, a) tc = t.canon_bp() assert str(tc) == '-A(a, c)*A(b, d)' # A^{c,a}*A^{b,d} # T_c = A^{a c}*A^{b d} t = A(c, a) * A(b, d) tc = t.canon_bp() assert str(tc) == 'A(a, c)*A(b, d)'
def test_riemann_products(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') d0, d1, d2, d3, d4, d5, d6 = tensor_indices('d0:7', Lorentz) a0, a1, a2, a3, a4, a5 = tensor_indices('a0:6', Lorentz) a, b = tensor_indices('a,b', Lorentz) R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) # R^{a b d0}_d0 = 0 t = R(a, b, d0, -d0) tc = t.canon_bp() assert tc == 0 # R^{d0 b a}_d0 # T_c = -R^{a d0 b}_d0 t = R(d0, b, a, -d0) tc = t.canon_bp() assert str(tc) == '-R(a, L_0, b, -L_0)' # R^d1_d2^b_d0 * R^{d0 a}_d1^d2; ord=[a,b,d0,-d0,d1,-d1,d2,-d2] # T_c = -R^{a d0 d1 d2}* R^b_{d0 d1 d2} t = R(d1, -d2, b, -d0) * R(d0, a, -d1, d2) tc = t.canon_bp() assert str(tc) == '-R(a, L_0, L_1, L_2)*R(b, -L_0, -L_1, -L_2)' # A symmetric commuting # R^{d6 d5}_d2^d1 * R^{d4 d0 d2 d3} * A_{d6 d0} A_{d3 d1} * A_{d4 d5} # g = [12,10,5,2, 8,0,4,6, 13,1, 7,3, 9,11,14,15] # T_c = -R^{d0 d1 d2 d3} * R_d0^{d4 d5 d6} * A_{d1 d4}*A_{d2 d5}*A_{d3 d6} V = tensorhead('V', [Lorentz] * 2, [[1] * 2]) t = R(d6, d5, -d2, d1) * R(d4, d0, d2, d3) * V(-d6, -d0) * V(-d3, -d1) * V( -d4, -d5) tc = t.canon_bp() assert str( tc ) == '-R(L_0, L_1, L_2, L_3)*R(-L_0, L_4, L_5, L_6)*V(-L_1, -L_4)*V(-L_2, -L_5)*V(-L_3, -L_6)' # R^{d2 a0 a2 d0} * R^d1_d2^{a1 a3} * R^{a4 a5}_{d0 d1} # T_c = R^{a0 d0 a2 d1}*R^{a1 a3}_d0^d2*R^{a4 a5}_{d1 d2} t = R(d2, a0, a2, d0) * R(d1, -d2, a1, a3) * R(a4, a5, -d0, -d1) tc = t.canon_bp() assert str( tc) == 'R(a0, L_0, a2, L_1)*R(a1, a3, -L_0, L_2)*R(a4, a5, -L_1, -L_2)'
def test_substitute_indices(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') i, j, k, l, m, n, p, q = tensor_indices('i,j,k,l,m,n,p,q', Lorentz) A, B = tensorhead('A,B', [Lorentz] * 2, [[1] * 2]) t = A(i, k) * B(-k, -j) t1 = t.substitute_indices((i, j), (j, k)) t1a = A(j, l) * B(-l, -k) assert t1 == t1a p = tensorhead('p', [Lorentz], [[1]]) t = p(i) t1 = t.substitute_indices((j, k)) assert t1 == t t1 = t.substitute_indices((i, j)) assert t1 == p(j) t1 = t.substitute_indices((i, -j)) assert t1 == p(-j) t1 = t.substitute_indices((-i, j)) assert t1 == p(-j) t1 = t.substitute_indices((-i, -j)) assert t1 == p(j)
def test_TensExpr(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') a, b, c, d = tensor_indices('a,b,c,d', Lorentz) g = Lorentz.metric A, B = tensorhead('A B', [Lorentz] * 2, [[1] * 2]) raises(ValueError, lambda: g(c, d) / g(a, b)) raises(ValueError, lambda: S.One / g(a, b)) raises(ValueError, lambda: (A(c, d) + g(c, d)) / g(a, b)) raises(ValueError, lambda: S.One / (A(c, d) + g(c, d))) raises(ValueError, lambda: A(a, b) + A(a, c)) t = A(a, b) + B(a, b) raises(NotImplementedError, lambda: TensExpr.__mul__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__add__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__radd__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__sub__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__rsub__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__div__(t, 'a')) raises(NotImplementedError, lambda: TensExpr.__rdiv__(t, 'a')) raises(NotImplementedError, lambda: A(a, b)**2) raises(NotImplementedError, lambda: 2**A(a, b)) raises(NotImplementedError, lambda: abs(A(a, b)))
def test_riemann_cyclic(): Lorentz = TensorIndexType('Lorentz', dummy_fmt='L') i, j, k, l, m, n, p, q = tensor_indices('i,j,k,l,m,n,p,q', Lorentz) R = tensorhead('R', [Lorentz] * 4, [[2, 2]]) t = R(i,j,k,l) + R(i,l,j,k) + R(i,k,l,j) - \ R(i,j,l,k) - R(i,l,k,j) - R(i,k,j,l) t2 = t * R(-i, -j, -k, -l) t3 = riemann_cyclic(t2) assert t3 == 0 t = R(i, j, k, l) * (R(-i, -j, -k, -l) - 2 * R(-i, -k, -j, -l)) t1 = riemann_cyclic(t) assert t1 == 0 t = R(i, j, k, l) t1 = riemann_cyclic(t) assert t1 == -S(1) / 3 * R(i, l, j, k) + S(1) / 3 * R( i, k, j, l) + S(2) / 3 * R(i, j, k, l) t = R(i, j, k, l) * R(-k, -l, m, n) * (R(-m, -n, -i, -j) + 2 * R(-m, -j, -n, -i)) t1 = riemann_cyclic(t) assert t1 == 0
def test_canonicalize2(): D = Symbol('D') Eucl = TensorIndexType('Eucl', metric=0, dim=D, dummy_fmt='E') i0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14 = \ tensor_indices('i0:15', Eucl) A = tensorhead('A', [Eucl] * 3, [[3]]) # two examples from Cvitanovic, Group Theory page 59 # of identities for antisymmetric tensors of rank 3 # contracted according to the Kuratowski graph eq.(6.59) t = A(i0, i1, i2) * A(-i1, i3, i4) * A(-i3, i7, i5) * A(-i2, -i5, i6) * A( -i4, -i6, i8) t1 = t.canon_bp() assert t1 == 0 # eq.(6.60) #t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i2,i5,i6)*A(-i3,i7,i8)*A(-i6,-i7,i9)* # A(-i8,i10,i13)*A(-i5,-i10,i11)*A(-i4,-i11,i12)*A(-i3,-i12,i14) t = A(i0,i1,i2)*A(-i1,i3,i4)*A(-i2,i5,i6)*A(-i3,i7,i8)*A(-i6,-i7,i9)*\ A(-i8,i10,i13)*A(-i5,-i10,i11)*A(-i4,-i11,i12)*A(-i9,-i12,i14) t1 = t.canon_bp() assert t1 == 0
def test_epsilon(): Lorentz = TensorIndexType('Lorentz', dim=4, dummy_fmt='L') a, b, c, d, e = tensor_indices('a,b,c,d,e', Lorentz) g = Lorentz.metric epsilon = Lorentz.epsilon p, q, r, s = tensorhead('p,q,r,s', [Lorentz], [[1]]) t = epsilon(b, a, c, d) t1 = t.canon_bp() assert t1 == -epsilon(a, b, c, d) t = epsilon(c, b, d, a) t1 = t.canon_bp() assert t1 == epsilon(a, b, c, d) t = epsilon(c, a, d, b) t1 = t.canon_bp() assert t1 == -epsilon(a, b, c, d) t = epsilon(a, b, c, d) * p(-a) * q(-b) t1 = t.canon_bp() assert t1 == epsilon(c, d, a, b) * p(-a) * q(-b) t = epsilon(c, b, d, a) * p(-a) * q(-b) t1 = t.canon_bp() assert t1 == epsilon(c, d, a, b) * p(-a) * q(-b) t = epsilon(c, a, d, b) * p(-a) * q(-b) t1 = t.canon_bp() assert t1 == -epsilon(c, d, a, b) * p(-a) * q(-b) t = epsilon(c, a, d, b) * p(-a) * p(-b) t1 = t.canon_bp() assert t1 == 0 t = epsilon(c, a, d, b) * p(-a) * q(-b) + epsilon(a, b, c, d) * p(-b) * q(-a) t1 = t.canon_bp() assert t1 == -2 * epsilon(c, d, a, b) * p(-a) * q(-b)
def test_no_metric_symmetry(): # no metric symmetry; A no symmetry # A^d1_d0 * A^d0_d1 # T_c = A^d0_d1 * A^d1_d0 Lorentz = TensorIndexType('Lorentz', metric=None, dummy_fmt='L') d0, d1, d2, d3 = tensor_indices('d:4', Lorentz) A = tensorhead('A', [Lorentz] * 2, [[1], [1]]) t = A(d1, -d0) * A(d0, -d1) tc = t.canon_bp() assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_0)' # A^d1_d2 * A^d0_d3 * A^d2_d1 * A^d3_d0 # T_c = A^d0_d1 * A^d1_d0 * A^d2_d3 * A^d3_d2 t = A(d1, -d2) * A(d0, -d3) * A(d2, -d1) * A(d3, -d0) tc = t.canon_bp() assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_0)*A(L_2, -L_3)*A(L_3, -L_2)' # A^d0_d2 * A^d1_d3 * A^d3_d0 * A^d2_d1 # T_c = A^d0_d1 * A^d1_d2 * A^d2_d3 * A^d3_d0 t = A(d0, -d1) * A(d1, -d2) * A(d2, -d3) * A(d3, -d0) tc = t.canon_bp() assert str(tc) == 'A(L_0, -L_1)*A(L_1, -L_2)*A(L_2, -L_3)*A(L_3, -L_0)'
def test_hidden_indices_for_matrix_multiplication(): L = TensorIndexType('Lorentz') S = TensorIndexType('Matind') m0, m1, m2, m3, m4, m5 = tensor_indices('m0:6', L) s0, s1, s2 = tensor_indices('s0:3', S) A = tensorhead('A', [L, S, S], [[1], [1], [1]], matrix_behavior=True) B = tensorhead('B', [L, S], [[1], [1]], matrix_behavior=True) D = tensorhead('D', [L, L, S, S], [[1, 1], [1, 1]], matrix_behavior=True) E = tensorhead('E', [L, L, L, L], [[1], [1], [1], [1]], matrix_behavior=True) F = tensorhead('F', [L], [[1]], matrix_behavior=True) assert (A(m0)) == A(m0, S.auto_left, -S.auto_right) assert (B(-m1)) == B(-m1, S.auto_left) A0 = A(m0) B0 = B(-m0) B1 = B(m1) assert (B1*A0*B0) == B(m1, s0)*A(m0, -s0, s1)*B(-m0, -s1) assert (B0*A0) == B(-m0, s0)*A(m0, -s0, -S.auto_right) assert (A0*B0) == A(m0, S.auto_left, s0)*B(-m0, -s0) C = tensorhead('C', [L, L], [[1]*2]) assert (C(True, True)) == C(L.auto_left, -L.auto_right) assert (A(m0)*C(m1, -m0)) == A(m2, S.auto_left, -S.auto_right)*C(m1, -m2) assert (C(True, True)*C(True, True)) == C(L.auto_left, m0)*C(-m0, -L.auto_right) assert A(m0) == A(m0) assert B(-m1) == B(-m1) assert A(m0) - A(m0) == 0 ts1 = A(m0)*A(m1) + A(m1)*A(m0) ts2 = A(m1)*A(m0) + A(m0)*A(m1) assert ts1 == ts2 assert A(m0)*A(m1) + A(m1)*A(m0) == A(m1)*A(m0) + A(m0)*A(m1) assert A(m0) == (2*A(m0))/2 assert A(m0) == -(-A(m0)) assert 2*A(m0) - 3*A(m0) == -A(m0) assert 2*D(m0, m1) - 5*D(m1, m0) == -3*D(m0, m1) D0 = D(True, True, True, True) Aa = A(True, True, True) assert D0 * Aa == D(L.auto_left, m0, S.auto_left, s0)*A(-m0, -s0, -S.auto_right) assert D(m0, m1) == D(m0, m1, S.auto_left, -S.auto_right) raises(ValueError, lambda: C(True)) raises(ValueError, lambda: C()) raises(ValueError, lambda: E(True, True, True, True)) # test that a delta is automatically added on missing auto-matrix indices in TensAdd assert F(m2)*F(m3)*F(m4)*A(m1) + E(m1, m2, m3, m4) == \ E(m1, m2, m3, m4)*S.delta(S.auto_left, -S.auto_right) +\ F(m2)*F(m3)*F(m4)*A(m1, S.auto_left, -S.auto_right) assert E(m1, m2) + F(m1)*F(m2) == E(m1, m2) + F(m1)*F(m2)*L.delta(L.auto_left, -L.auto_right) assert E(m1, m2)*A(m3) + F(m1)*F(m2)*F(m3) == \ E(m1, m2, L.auto_left, -L.auto_right)*A(m3, S.auto_left, -S.auto_right) +\ F(m1)*F(m2)*F(m3)*L.delta(L.auto_left, -L.auto_right)*S.delta(S.auto_left, -S.auto_right) assert L.delta() == L.delta(L.auto_left, -L.auto_right) assert S.delta() == S.delta(S.auto_left, -S.auto_right) assert L.metric() == L.metric(L.auto_left, -L.auto_right) assert S.metric() == S.metric(S.auto_left, -S.auto_right)
assert hash(tsymmetry.func(*tsymmetry.args)) == hash(tsymmetry) assert check_all(tsymmetry) ### TEST VALUED TENSORS ### numpy = import_module('numpy') if numpy: minkowski = Matrix(( (1, 0, 0, 0), (0, -1, 0, 0), (0, 0, -1, 0), (0, 0, 0, -1), )) Lorentz = TensorIndexType('Lorentz', dim=4) Lorentz.data = minkowski i0, i1, i2, i3, i4 = tensor_indices('i0:5', Lorentz) E, px, py, pz = symbols('E px py pz') A = tensorhead('A', [Lorentz], [[1]]) A.data = [E, px, py, pz] B = tensorhead('B', [Lorentz], [[1]], 'Gcomm') B.data = range(4) AB = tensorhead("AB", [Lorentz] * 2, [[1]]*2) AB.data = minkowski ba_matrix = Matrix(( (1, 2, 3, 4), (5, 6, 7, 8),