def _eval_innerproduct_JzBra(self, bra, **hints):
result = KroneckerDelta(self.j, bra.j)
if not issubclass(bra.dual_class, self.__class__):
result *= self._represent_JzOp(None)[bra.j - bra.m]
else:
result *= KroneckerDelta(self.m, bra.m)
return result
def _eval_innerproduct_JyBra(self, bra, **hints):
result = KroneckerDelta(self.j, bra.j)
if not isinstance(bra, self.__class__):
result *= self._represent_JyOp(None)[bra.j - bra.m]
else:
result *= KroneckerDelta(self.m, bra.m)
return result
def _check_varsh_872_9(term_list):
# Sum( CG(a,alpha,b,beta,c,gamma)*CG(a,alpha',b,beta',c,gamma), (gamma, -c, c), (c, abs(a-b), a+b))
a, alpha, alphap, b, beta, betap, c, gamma, lt = map(
Wild,
('a', 'alpha', 'alphap', 'b', 'beta', 'betap', 'c', 'gamma', 'lt'))
# Case alpha==alphap, beta==betap
# For numerical alpha,beta
expr = lt * CG(a, alpha, b, beta, c, gamma)**2
simp = 1
sign = lt / abs(lt)
x = abs(a - b)
y = abs(alpha + beta)
build_expr = a + b + 1 - Piecewise((x, x > y), (0, Eq(x, y)), (y, y > x))
index_expr = a + b - c
term_list, other1 = _check_cg_simp(expr, simp, sign, lt, term_list,
(a, alpha, b, beta, c, gamma, lt),
(a, alpha, b, beta), build_expr,
index_expr)
# For symbolic alpha,beta
x = abs(a - b)
y = a + b
build_expr = (y + 1 - x) * (x + y + 1)
index_expr = (c - x) * (x + c) + c + gamma
term_list, other2 = _check_cg_simp(expr, simp, sign, lt, term_list,
(a, alpha, b, beta, c, gamma, lt),
(a, alpha, b, beta), build_expr,
index_expr)
# Case alpha!=alphap or beta!=betap
# Note: this only works with leading term of 1, pattern matching is unable to match when there is a Wild leading term
# For numerical alpha,alphap,beta,betap
expr = CG(a, alpha, b, beta, c, gamma) * CG(a, alphap, b, betap, c, gamma)
simp = KroneckerDelta(alpha, alphap) * KroneckerDelta(beta, betap)
sign = sympify(1)
x = abs(a - b)
y = abs(alpha + beta)
build_expr = a + b + 1 - Piecewise((x, x > y), (0, Eq(x, y)), (y, y > x))
index_expr = a + b - c
term_list, other3 = _check_cg_simp(
expr, simp, sign, sympify(1), term_list,
(a, alpha, alphap, b, beta, betap, c, gamma),
(a, alpha, alphap, b, beta, betap), build_expr, index_expr)
# For symbolic alpha,alphap,beta,betap
x = abs(a - b)
y = a + b
build_expr = (y + 1 - x) * (x + y + 1)
index_expr = (c - x) * (x + c) + c + gamma
term_list, other4 = _check_cg_simp(
expr, simp, sign, sympify(1), term_list,
(a, alpha, alphap, b, beta, betap, c, gamma),
(a, alpha, alphap, b, beta, betap), build_expr, index_expr)
return term_list, other1 + other2 + other4
def _check_varsh_sum_871_1(e):
a = Wild('a')
alpha = symbols('alpha')
b = Wild('b')
match = e.match(Sum(CG(a, alpha, b, 0, a, alpha), (alpha, -a, a)))
if not match is None and len(match) == 2:
return ((2 * a + 1) * KroneckerDelta(b, 0)).subs(match)
return e
def _check_varsh_sum_871_2(e):
a = Wild('a')
alpha = symbols('alpha')
c = Wild('c')
match = e.match(
Sum((-1)**(a - alpha) * CG(a, alpha, a, -alpha, c, 0), (alpha, -a, a)))
if not match is None and len(match) == 2:
return (sqrt(2 * a + 1) * KroneckerDelta(c, 0)).subs(match)
return e
def _check_varsh_871_1(term_list):
# Sum( CG(a,alpha,b,0,a,alpha), (alpha, -a, a)) == KroneckerDelta(b,0)
a, alpha, b, lt = map(Wild, ('a', 'alpha', 'b', 'lt'))
expr = lt * CG(a, alpha, b, 0, a, alpha)
simp = (2 * a + 1) * KroneckerDelta(b, 0)
sign = lt / abs(lt)
build_expr = 2 * a + 1
index_expr = a + alpha
return _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, b, lt),
(a, b), build_expr, index_expr)
def _check_varsh_871_2(term_list):
# Sum((-1)**(a-alpha)*CG(a,alpha,a,-alpha,c,0),(alpha,-a,a))
a, alpha, c, lt = map(Wild, ('a', 'alpha', 'c', 'lt'))
expr = lt * CG(a, alpha, a, -alpha, c, 0)
simp = sqrt(2 * a + 1) * KroneckerDelta(c, 0)
sign = (-1)**(a - alpha) * lt / abs(lt)
build_expr = 2 * a + 1
index_expr = a + alpha
return _check_cg_simp(expr, simp, sign, lt, term_list, (a, alpha, c, lt),
(a, c), build_expr, index_expr)
def _check_varsh_sum_872_4(e):
a = Wild('a')
alpha = Wild('alpha')
b = Wild('b')
beta = Wild('beta')
c = Wild('c')
cp = Wild('cp')
gamma = Wild('gamma')
gammap = Wild('gammap')
match1 = e.match(
Sum(
CG(a, alpha, b, beta, c, gamma) *
CG(a, alpha, b, beta, cp, gammap), (alpha, -a, a), (beta, -b, b)))
if not match1 is None and len(match1) == 8:
return (KroneckerDelta(c, cp) *
KroneckerDelta(gamma, gammap)).subs(match1)
match2 = e.match(
Sum(CG(a, alpha, b, beta, c, gamma)**2, (alpha, -a, a), (beta, -b, b)))
if not match2 is None and len(match2) == 6:
return 1
return e
def test_cg_simp_sum():
x, a, b, c, cp, alpha, beta, gamma, gammap = symbols(
'x a b c cp alpha beta gamma gammap')
# Varshalovich 8.7.1 Eq 1
assert cg_simp(
x * Sum(CG(a, alpha, b, 0, a, alpha),
(alpha, -a, a))) == x * (2 * a + 1) * KroneckerDelta(b, 0)
assert cg_simp(x * Sum(CG(a, alpha, b, 0, a, alpha), (alpha, -a, a)) +
CG(1, 0, 1, 0, 1, 0)) == x * (2 * a + 1) * KroneckerDelta(
b, 0) + CG(1, 0, 1, 0, 1, 0)
assert cg_simp(2 * Sum(CG(1, alpha, 0, 0, 1, alpha), (alpha, -1, 1))) == 6
# Varshalovich 8.7.1 Eq 2
assert cg_simp(x * Sum(
(-1)**(a - alpha) * CG(a, alpha, a, -alpha, c, 0),
(alpha, -a, a))) == x * sqrt(2 * a + 1) * KroneckerDelta(c, 0)
assert cg_simp(3 * Sum((-1)**(2 - alpha) * CG(2, alpha, 2, -alpha, 0, 0),
(alpha, -2, 2))) == 3 * sqrt(5)
# Varshalovich 8.7.2 Eq 4
assert cg_simp(
Sum(
CG(a, alpha, b, beta, c, gamma) *
CG(a, alpha, b, beta, cp, gammap), (alpha, -a, a),
(beta, -b,
b))) == KroneckerDelta(c, cp) * KroneckerDelta(gamma, gammap)
assert cg_simp(
Sum(
CG(a, alpha, b, beta, c, gamma) * CG(a, alpha, b, beta, c, gammap),
(alpha, -a, a), (beta, -b, b))) == KroneckerDelta(gamma, gammap)
assert cg_simp(
Sum(
CG(a, alpha, b, beta, c, gamma) * CG(a, alpha, b, beta, cp, gamma),
(alpha, -a, a), (beta, -b, b))) == KroneckerDelta(c, cp)
assert cg_simp(
Sum(CG(a, alpha, b, beta, c, gamma)**2, (alpha, -a, a),
(beta, -b, b))) == 1
assert cg_simp(
Sum(
CG(2, alpha, 1, beta, 2, gamma) * CG(2, alpha, 1, beta, 2, gammap),
(alpha, -2, 2), (beta, -1, 1))) == KroneckerDelta(gamma, gammap)
def _eval_innerproduct_JxBra(self, bra, **hints):
d1 = KroneckerDelta(self.j, bra.j)
d2 = KroneckerDelta(self.m, bra.m)
return d1 * d2
def _eval_innerproduct_PIABBra(self, bra):
return KroneckerDelta(bra.label[0], self.label[0])
def test_cg_simp_add():
j, m1, m1p, m2, m2p = symbols('j m1 m1p m2 m2p')
# Test Varshalovich 8.7.1 Eq 1
a = CG(S(1) / 2, S(1) / 2, 0, 0, S(1) / 2, S(1) / 2)
b = CG(S(1) / 2, -S(1) / 2, 0, 0, S(1) / 2, -S(1) / 2)
c = CG(1, 1, 0, 0, 1, 1)
d = CG(1, 0, 0, 0, 1, 0)
e = CG(1, -1, 0, 0, 1, -1)
assert cg_simp(a + b) == 2
assert cg_simp(c + d + e) == 3
assert cg_simp(a + b + c + d + e) == 5
assert cg_simp(a + b + c) == 2 + c
assert cg_simp(2 * a + b) == 2 + a
assert cg_simp(2 * c + d + e) == 3 + c
assert cg_simp(5 * a + 5 * b) == 10
assert cg_simp(5 * c + 5 * d + 5 * e) == 15
assert cg_simp(-a - b) == -2
assert cg_simp(-c - d - e) == -3
assert cg_simp(-6 * a - 6 * b) == -12
assert cg_simp(-4 * c - 4 * d - 4 * e) == -12
a = CG(S(1) / 2, S(1) / 2, j, 0, S(1) / 2, S(1) / 2)
b = CG(S(1) / 2, -S(1) / 2, j, 0, S(1) / 2, -S(1) / 2)
c = CG(1, 1, j, 0, 1, 1)
d = CG(1, 0, j, 0, 1, 0)
e = CG(1, -1, j, 0, 1, -1)
assert cg_simp(a + b) == 2 * KroneckerDelta(j, 0)
assert cg_simp(c + d + e) == 3 * KroneckerDelta(j, 0)
assert cg_simp(a + b + c + d + e) == 5 * KroneckerDelta(j, 0)
assert cg_simp(a + b + c) == 2 * KroneckerDelta(j, 0) + c
assert cg_simp(2 * a + b) == 2 * KroneckerDelta(j, 0) + a
assert cg_simp(2 * c + d + e) == 3 * KroneckerDelta(j, 0) + c
assert cg_simp(5 * a + 5 * b) == 10 * KroneckerDelta(j, 0)
assert cg_simp(5 * c + 5 * d + 5 * e) == 15 * KroneckerDelta(j, 0)
assert cg_simp(-a - b) == -2 * KroneckerDelta(j, 0)
assert cg_simp(-c - d - e) == -3 * KroneckerDelta(j, 0)
assert cg_simp(-6 * a - 6 * b) == -12 * KroneckerDelta(j, 0)
assert cg_simp(-4 * c - 4 * d - 4 * e) == -12 * KroneckerDelta(j, 0)
# Test Varshalovich 8.7.1 Eq 2
a = CG(S(1) / 2, S(1) / 2, S(1) / 2, -S(1) / 2, 0, 0)
b = CG(S(1) / 2, -S(1) / 2, S(1) / 2, S(1) / 2, 0, 0)
c = CG(1, 1, 1, -1, 0, 0)
d = CG(1, 0, 1, 0, 0, 0)
e = CG(1, -1, 1, 1, 0, 0)
assert cg_simp(a - b) == sqrt(2)
assert cg_simp(c - d + e) == sqrt(3)
assert cg_simp(a - b + c - d + e) == sqrt(2) + sqrt(3)
assert cg_simp(a - b + c) == sqrt(2) + c
assert cg_simp(2 * a - b) == sqrt(2) + a
assert cg_simp(2 * c - d + e) == sqrt(3) + c
assert cg_simp(5 * a - 5 * b) == 5 * sqrt(2)
assert cg_simp(5 * c - 5 * d + 5 * e) == 5 * sqrt(3)
assert cg_simp(-a + b) == -sqrt(2)
assert cg_simp(-c + d - e) == -sqrt(3)
assert cg_simp(-6 * a + 6 * b) == -6 * sqrt(2)
assert cg_simp(-4 * c + 4 * d - 4 * e) == -4 * sqrt(3)
a = CG(S(1) / 2, S(1) / 2, S(1) / 2, -S(1) / 2, j, 0)
b = CG(S(1) / 2, -S(1) / 2, S(1) / 2, S(1) / 2, j, 0)
c = CG(1, 1, 1, -1, j, 0)
d = CG(1, 0, 1, 0, j, 0)
e = CG(1, -1, 1, 1, j, 0)
assert cg_simp(a - b) == sqrt(2) * KroneckerDelta(j, 0)
assert cg_simp(c - d + e) == sqrt(3) * KroneckerDelta(j, 0)
assert cg_simp(
a - b + c - d +
e) == sqrt(2) * KroneckerDelta(j, 0) + sqrt(3) * KroneckerDelta(j, 0)
assert cg_simp(a - b + c) == sqrt(2) * KroneckerDelta(j, 0) + c
assert cg_simp(2 * a - b) == sqrt(2) * KroneckerDelta(j, 0) + a
assert cg_simp(2 * c - d + e) == sqrt(3) * KroneckerDelta(j, 0) + c
assert cg_simp(5 * a - 5 * b) == 5 * sqrt(2) * KroneckerDelta(j, 0)
assert cg_simp(5 * c - 5 * d + 5 * e) == 5 * sqrt(3) * KroneckerDelta(j, 0)
assert cg_simp(-a + b) == -sqrt(2) * KroneckerDelta(j, 0)
assert cg_simp(-c + d - e) == -sqrt(3) * KroneckerDelta(j, 0)
assert cg_simp(-6 * a + 6 * b) == -6 * sqrt(2) * KroneckerDelta(j, 0)
assert cg_simp(-4 * c + 4 * d -
4 * e) == -4 * sqrt(3) * KroneckerDelta(j, 0)
# Test Varshalovich 8.7.2 Eq 9
# alpha=alphap,beta=betap case
# numerical
a = CG(S(1) / 2, S(1) / 2, S(1) / 2, -S(1) / 2, 1, 0)**2
b = CG(S(1) / 2, S(1) / 2, S(1) / 2, -S(1) / 2, 0, 0)**2
c = CG(1, 0, 1, 1, 1, 1)**2
d = CG(1, 0, 1, 1, 2, 1)**2
assert cg_simp(a + b) == 1
assert cg_simp(c + d) == 1
assert cg_simp(a + b + c + d) == 2
assert cg_simp(4 * a + 4 * b) == 4
assert cg_simp(4 * c + 4 * d) == 4
assert cg_simp(5 * a + 3 * b) == 3 + 2 * a
assert cg_simp(5 * c + 3 * d) == 3 + 2 * c
assert cg_simp(-a - b) == -1
assert cg_simp(-c - d) == -1
# symbolic
a = CG(S(1) / 2, m1, S(1) / 2, m2, 1, 1)**2
b = CG(S(1) / 2, m1, S(1) / 2, m2, 1, 0)**2
c = CG(S(1) / 2, m1, S(1) / 2, m2, 1, -1)**2
d = CG(S(1) / 2, m1, S(1) / 2, m2, 0, 0)**2
assert cg_simp(a + b + c + d) == 1
assert cg_simp(4 * a + 4 * b + 4 * c + 4 * d) == 4
assert cg_simp(3 * a + 5 * b + 3 * c + 4 * d) == 3 + 2 * b + d
assert cg_simp(-a - b - c - d) == -1
a = CG(1, m1, 1, m2, 2, 2)**2
b = CG(1, m1, 1, m2, 2, 1)**2
c = CG(1, m1, 1, m2, 2, 0)**2
d = CG(1, m1, 1, m2, 2, -1)**2
e = CG(1, m1, 1, m2, 2, -2)**2
f = CG(1, m1, 1, m2, 1, 1)**2
g = CG(1, m1, 1, m2, 1, 0)**2
h = CG(1, m1, 1, m2, 1, -1)**2
i = CG(1, m1, 1, m2, 0, 0)**2
assert cg_simp(a + b + c + d + e + f + g + h + i) == 1
assert cg_simp(4 * (a + b + c + d + e + f + g + h + i)) == 4
assert cg_simp(a + b + 2 * c + d + 4 * e + f + g + h + i) == 1 + c + 3 * e
assert cg_simp(-a - b - c - d - e - f - g - h - i) == -1
# alpha!=alphap or beta!=betap case
# numerical
a = CG(S(1) / 2,
S(1) / 2,
S(1) / 2, -S(1) / 2, 1, 0) * CG(
S(1) / 2, -S(1) / 2,
S(1) / 2,
S(1) / 2, 1, 0)
b = CG(S(1) / 2,
S(1) / 2,
S(1) / 2, -S(1) / 2, 0, 0) * CG(
S(1) / 2, -S(1) / 2,
S(1) / 2,
S(1) / 2, 0, 0)
c = CG(1, 1, 1, 0, 2, 1) * CG(1, 0, 1, 1, 2, 1)
d = CG(1, 1, 1, 0, 1, 1) * CG(1, 0, 1, 1, 1, 1)
assert cg_simp(a + b) == 0
assert cg_simp(c + d) == 0
# symbolic
a = CG(S(1) / 2, m1,
S(1) / 2, m2, 1, 1) * CG(S(1) / 2, m1p,
S(1) / 2, m2p, 1, 1)
b = CG(S(1) / 2, m1,
S(1) / 2, m2, 1, 0) * CG(S(1) / 2, m1p,
S(1) / 2, m2p, 1, 0)
c = CG(S(1) / 2, m1,
S(1) / 2, m2, 1, -1) * CG(S(1) / 2, m1p,
S(1) / 2, m2p, 1, -1)
d = CG(S(1) / 2, m1,
S(1) / 2, m2, 0, 0) * CG(S(1) / 2, m1p,
S(1) / 2, m2p, 0, 0)
assert cg_simp(a + b + c +
d) == KroneckerDelta(m1, m1p) * KroneckerDelta(m2, m2p)
a = CG(1, m1, 1, m2, 2, 2) * CG(1, m1p, 1, m2p, 2, 2)
b = CG(1, m1, 1, m2, 2, 1) * CG(1, m1p, 1, m2p, 2, 1)
c = CG(1, m1, 1, m2, 2, 0) * CG(1, m1p, 1, m2p, 2, 0)
d = CG(1, m1, 1, m2, 2, -1) * CG(1, m1p, 1, m2p, 2, -1)
e = CG(1, m1, 1, m2, 2, -2) * CG(1, m1p, 1, m2p, 2, -2)
f = CG(1, m1, 1, m2, 1, 1) * CG(1, m1p, 1, m2p, 1, 1)
g = CG(1, m1, 1, m2, 1, 0) * CG(1, m1p, 1, m2p, 1, 0)
h = CG(1, m1, 1, m2, 1, -1) * CG(1, m1p, 1, m2p, 1, -1)
i = CG(1, m1, 1, m2, 0, 0) * CG(1, m1p, 1, m2p, 0, 0)
assert cg_simp(a + b + c + d + e + f + g + h +
i) == KroneckerDelta(m1, m1p) * KroneckerDelta(m2, m2p)
def matrix_element(self, j, m, jp, mp):
result = hbar * mp
result *= KroneckerDelta(m, mp)
result *= KroneckerDelta(j, jp)
return result
def matrix_element(self, j, m, jp, mp):
result = (hbar**2) * j * (j + 1)
result *= KroneckerDelta(m, mp)
result *= KroneckerDelta(j, jp)
return result
def matrix_element(self, j, m, jp, mp):
result = hbar * sqrt(j * (j + S.One) - mp * (mp + S.One))
result *= KroneckerDelta(m, mp + 1)
result *= KroneckerDelta(j, jp)
return result
def matrix_element(self, j, m, jp, mp):
result = self.__class__.D(jp, m, mp, self.alpha, self.beta, self.gamma)
result *= KroneckerDelta(j, jp)
return result
def _eval_innerproduct_JyBar(self, bra, **hints):
d1 = KroneckerDelta(self.s, bra.s)
d2 = KroneckerDelta(self.ms, bra.ms)
return d1 * d2