I am done

rl/Lib/site-packages/sympy/concrete/tests/test_delta.py

@@ -0,0 +1,499 @@
+from sympy.concrete import Sum
+from sympy.concrete.delta import deltaproduct as dp, deltasummation as ds, _extract_delta
+from sympy.core import Eq, S, symbols, oo
+from sympy.functions import KroneckerDelta as KD, Piecewise, piecewise_fold
+from sympy.logic import And
+from sympy.testing.pytest import raises
+
+i, j, k, l, m = symbols("i j k l m", integer=True, finite=True)
+x, y = symbols("x y", commutative=False)
+
+
+def test_deltaproduct_trivial():
+    assert dp(x, (j, 1, 0)) == 1
+    assert dp(x, (j, 1, 3)) == x**3
+    assert dp(x + y, (j, 1, 3)) == (x + y)**3
+    assert dp(x*y, (j, 1, 3)) == (x*y)**3
+    assert dp(KD(i, j), (k, 1, 3)) == KD(i, j)
+    assert dp(x*KD(i, j), (k, 1, 3)) == x**3*KD(i, j)
+    assert dp(x*y*KD(i, j), (k, 1, 3)) == (x*y)**3*KD(i, j)
+
+
+def test_deltaproduct_basic():
+    assert dp(KD(i, j), (j, 1, 3)) == 0
+    assert dp(KD(i, j), (j, 1, 1)) == KD(i, 1)
+    assert dp(KD(i, j), (j, 2, 2)) == KD(i, 2)
+    assert dp(KD(i, j), (j, 3, 3)) == KD(i, 3)
+    assert dp(KD(i, j), (j, 1, k)) == KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(KD(i, j), (j, k, 3)) == KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(KD(i, j), (j, k, l)) == KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_x_kd():
+    assert dp(x*KD(i, j), (j, 1, 3)) == 0
+    assert dp(x*KD(i, j), (j, 1, 1)) == x*KD(i, 1)
+    assert dp(x*KD(i, j), (j, 2, 2)) == x*KD(i, 2)
+    assert dp(x*KD(i, j), (j, 3, 3)) == x*KD(i, 3)
+    assert dp(x*KD(i, j), (j, 1, k)) == x*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(x*KD(i, j), (j, k, 3)) == x*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(x*KD(i, j), (j, k, l)) == x*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_add_x_y_kd():
+    assert dp((x + y)*KD(i, j), (j, 1, 3)) == 0
+    assert dp((x + y)*KD(i, j), (j, 1, 1)) == (x + y)*KD(i, 1)
+    assert dp((x + y)*KD(i, j), (j, 2, 2)) == (x + y)*KD(i, 2)
+    assert dp((x + y)*KD(i, j), (j, 3, 3)) == (x + y)*KD(i, 3)
+    assert dp((x + y)*KD(i, j), (j, 1, k)) == \
+        (x + y)*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp((x + y)*KD(i, j), (j, k, 3)) == \
+        (x + y)*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp((x + y)*KD(i, j), (j, k, l)) == \
+        (x + y)*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_add_kd_kd():
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 3)) == 0
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 1)) == KD(i, 1) + KD(j, 1)
+    assert dp(KD(i, k) + KD(j, k), (k, 2, 2)) == KD(i, 2) + KD(j, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, 3, 3)) == KD(i, 3) + KD(j, 3)
+    assert dp(KD(i, k) + KD(j, k), (k, 1, l)) == KD(l, 0) + \
+        KD(i, 1)*KD(l, 1) + KD(j, 1)*KD(l, 1) + \
+        KD(i, 1)*KD(j, 2)*KD(l, 2) + KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, 3)) == KD(l, 4) + \
+        KD(i, 3)*KD(l, 3) + KD(j, 3)*KD(l, 3) + \
+        KD(i, 2)*KD(j, 3)*KD(l, 2) + KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, m)) == KD(l, m + 1) + \
+        KD(i, m)*KD(l, m) + KD(j, m)*KD(l, m) + \
+        KD(i, m)*KD(j, m - 1)*KD(l, m - 1) + KD(i, m - 1)*KD(j, m)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_x_add_kd_kd():
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == x*(KD(i, 1) + KD(j, 1))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == x*(KD(i, 2) + KD(j, 2))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == x*(KD(i, 3) + KD(j, 3))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        x*KD(i, 1)*KD(l, 1) + x*KD(j, 1)*KD(l, 1) + \
+        x**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + x**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        x*KD(i, 3)*KD(l, 3) + x*KD(j, 3)*KD(l, 3) + \
+        x**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + x**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        x*KD(i, m)*KD(l, m) + x*KD(j, m)*KD(l, m) + \
+        x**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        x**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_add_x_y_add_kd_kd():
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == \
+        (x + y)*(KD(i, 1) + KD(j, 1))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == \
+        (x + y)*(KD(i, 2) + KD(j, 2))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == \
+        (x + y)*(KD(i, 3) + KD(j, 3))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        (x + y)*KD(i, 1)*KD(l, 1) + (x + y)*KD(j, 1)*KD(l, 1) + \
+        (x + y)**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + \
+        (x + y)**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        (x + y)*KD(i, 3)*KD(l, 3) + (x + y)*KD(j, 3)*KD(l, 3) + \
+        (x + y)**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + \
+        (x + y)**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        (x + y)*KD(i, m)*KD(l, m) + (x + y)*KD(j, m)*KD(l, m) + \
+        (x + y)**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        (x + y)**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_add_mul_x_y_mul_x_kd():
+    assert dp(x*y + x*KD(i, j), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, 1)) == x*y + x*KD(i, 1)
+    assert dp(x*y + x*KD(i, j), (j, 2, 2)) == x*y + x*KD(i, 2)
+    assert dp(x*y + x*KD(i, j), (j, 3, 3)) == x*y + x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, 3)) == \
+        (x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, l)) == \
+        (x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )
+
+
+def test_deltaproduct_mul_x_add_y_kd():
+    assert dp(x*(y + KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + KD(i, j)), (j, 1, 1)) == x*(y + KD(i, 1))
+    assert dp(x*(y + KD(i, j)), (j, 2, 2)) == x*(y + KD(i, 2))
+    assert dp(x*(y + KD(i, j)), (j, 3, 3)) == x*(y + KD(i, 3))
+    assert dp(x*(y + KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_x_add_y_twokd():
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        2*x*(x*y)**2*KD(i, 1) + 2*x*y*x*x*y*KD(i, 2) + 2*(x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 1)) == x*(y + 2*KD(i, 1))
+    assert dp(x*(y + 2*KD(i, j)), (j, 2, 2)) == x*(y + 2*KD(i, 2))
+    assert dp(x*(y + 2*KD(i, j)), (j, 3, 3)) == x*(y + 2*KD(i, 3))
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            (2*(x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_add_x_y_add_y_kd():
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 3)) == ((x + y)*y)**3 + \
+        (x + y)*((x + y)*y)**2*KD(i, 1) + \
+        (x + y)*y*(x + y)**2*y*KD(i, 2) + \
+        ((x + y)*y)**2*(x + y)*KD(i, 3)
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 1)) == (x + y)*(y + KD(i, 1))
+    assert dp((x + y)*(y + KD(i, j)), (j, 2, 2)) == (x + y)*(y + KD(i, 2))
+    assert dp((x + y)*(y + KD(i, j)), (j, 3, 3)) == (x + y)*(y + KD(i, 3))
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, k)) == \
+        ((x + y)*y)**k + Piecewise(
+            (((x + y)*y)**(-1)*((x + y)*y)**i*(x + y)*((x + y)*y
+            )**k*((x + y)*y)**(-i), (i >= 1) & (i <= k)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, 3)) == (
+        (x + y)*y)**4*((x + y)*y)**(-k) + Piecewise((((x + y)*y)**i*(
+        (x + y)*y)**(-k)*(x + y)*((x + y)*y)**3*((x + y)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, l)) == \
+        (x + y)*y*((x + y)*y)**l*((x + y)*y)**(-k) + Piecewise(
+        (((x + y)*y)**i*((x + y)*y)**(-k)*(x + y)*((x + y)*y
+        )**l*((x + y)*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltaproduct_mul_add_x_kd_add_y_kd():
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == \
+        KD(i, 1)*(KD(i, k) + x)*((KD(i, k) + x)*y)**2 + \
+        KD(i, 2)*(KD(i, k) + x)*y*(KD(i, k) + x)**2*y + \
+        KD(i, 3)*((KD(i, k) + x)*y)**2*(KD(i, k) + x) + \
+        ((KD(i, k) + x)*y)**3
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == \
+        (x + KD(i, k))*(y + KD(i, 1))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == \
+        (x + KD(i, k))*(y + KD(i, 2))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == \
+        (x + KD(i, k))*(y + KD(i, 3))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == \
+        ((KD(i, k) + x)*y)**k + Piecewise(
+        (((KD(i, k) + x)*y)**(-1)*((KD(i, k) + x)*y)**i*(KD(i, k) + x
+        )*((KD(i, k) + x)*y)**k*((KD(i, k) + x)*y)**(-i), (i >= 1
+        ) & (i <= k)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == (
+        (KD(i, k) + x)*y)**4*((KD(i, k) + x)*y)**(-k) + Piecewise(
+        (((KD(i, k) + x)*y)**i*((KD(i, k) + x)*y)**(-k)*(KD(i, k)
+        + x)*((KD(i, k) + x)*y)**3*((KD(i, k) + x)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == (
+        KD(i, k) + x)*y*((KD(i, k) + x)*y)**l*((KD(i, k) + x)*y
+        )**(-k) + Piecewise((((KD(i, k) + x)*y)**i*((KD(i, k) + x
+        )*y)**(-k)*(KD(i, k) + x)*((KD(i, k) + x)*y)**l*((KD(i, k) + x
+        )*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltasummation_trivial():
+    assert ds(x, (j, 1, 0)) == 0
+    assert ds(x, (j, 1, 3)) == 3*x
+    assert ds(x + y, (j, 1, 3)) == 3*(x + y)
+    assert ds(x*y, (j, 1, 3)) == 3*x*y
+    assert ds(KD(i, j), (k, 1, 3)) == 3*KD(i, j)
+    assert ds(x*KD(i, j), (k, 1, 3)) == 3*x*KD(i, j)
+    assert ds(x*y*KD(i, j), (k, 1, 3)) == 3*x*y*KD(i, j)
+
+
+def test_deltasummation_basic_numerical():
+    n = symbols('n', integer=True, nonzero=True)
+    assert ds(KD(n, 0), (n, 1, 3)) == 0
+
+    # return unevaluated, until it gets implemented
+    assert ds(KD(i**2, j**2), (j, -oo, oo)) == \
+        Sum(KD(i**2, j**2), (j, -oo, oo))
+
+    assert Piecewise((KD(i, k), And(1 <= i, i <= 3)), (0, True)) == \
+        ds(KD(i, j)*KD(j, k), (j, 1, 3)) == \
+        ds(KD(j, k)*KD(i, j), (j, 1, 3))
+
+    assert ds(KD(i, k), (k, -oo, oo)) == 1
+    assert ds(KD(i, k), (k, 0, oo)) == Piecewise((1, S.Zero <= i), (0, True))
+    assert ds(KD(i, k), (k, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(k*KD(i, j)*KD(j, k), (k, -oo, oo)) == j*KD(i, j)
+    assert ds(j*KD(i, j), (j, -oo, oo)) == i
+    assert ds(i*KD(i, j), (i, -oo, oo)) == j
+    assert ds(x, (i, 1, 3)) == 3*x
+    assert ds((i + j)*KD(i, j), (j, -oo, oo)) == 2*i
+
+
+def test_deltasummation_basic_symbolic():
+    assert ds(KD(i, j), (j, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, 1)) == Piecewise((1, Eq(i, 1)), (0, True))
+    assert ds(KD(i, j), (j, 2, 2)) == Piecewise((1, Eq(i, 2)), (0, True))
+    assert ds(KD(i, j), (j, 3, 3)) == Piecewise((1, Eq(i, 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, k)) == \
+        Piecewise((1, And(1 <= i, i <= k)), (0, True))
+    assert ds(KD(i, j), (j, k, 3)) == \
+        Piecewise((1, And(k <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, k, l)) == \
+        Piecewise((1, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_x_kd():
+    assert ds(x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, 1)) == Piecewise((x, Eq(i, 1)), (0, True))
+    assert ds(x*KD(i, j), (j, 2, 2)) == Piecewise((x, Eq(i, 2)), (0, True))
+    assert ds(x*KD(i, j), (j, 3, 3)) == Piecewise((x, Eq(i, 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, k)) == \
+        Piecewise((x, And(1 <= i, i <= k)), (0, True))
+    assert ds(x*KD(i, j), (j, k, 3)) == \
+        Piecewise((x, And(k <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, k, l)) == \
+        Piecewise((x, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_add_x_y_kd():
+    assert ds((x + y)*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x + y, Eq(i, 1)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x + y, Eq(i, 2)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x + y, Eq(i, 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, k)) == \
+        Piecewise((x + y, And(1 <= i, i <= k)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, 3)) == \
+        Piecewise((x + y, And(k <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, l)) == \
+        Piecewise((x + y, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_add_kd_kd():
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((1, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((1, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((1, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_kd_kd():
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_x_add_kd_kd():
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((x, Eq(j, 1)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((x, Eq(j, 2)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((x, Eq(j, 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_add_x_y_add_kd_kd():
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 1)), (0, True)) +
+        Piecewise((x + y, Eq(j, 1)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 2)), (0, True)) +
+        Piecewise((x + y, Eq(j, 2)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 3)), (0, True)) +
+        Piecewise((x + y, Eq(j, 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= l)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_y_mul_x_kd():
+    assert ds(x*y + x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_kd():
+    assert ds(x*(y + KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_twokd():
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + 2*x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + 2*x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + 2*x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + 2*x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + 2*x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*x*y + 2*x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + 2*x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_add_x_y_add_y_kd():
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 3)) == Piecewise(
+        (3*(x + y)*y + x + y, And(1 <= i, i <= 3)), (3*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 1)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 2)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 3)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, k)) == Piecewise(
+        (k*(x + y)*y + x + y, And(1 <= i, i <= k)), (k*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*(x + y)*y + x + y, And(k <= i, i <= 3)),
+        ((4 - k)*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*(x + y)*y + x + y, And(k <= i, i <= l)),
+        ((l - k + 1)*(x + y)*y, True))
+
+
+def test_deltasummation_mul_add_x_kd_add_y_kd():
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= 3)), (0, True)) +
+        3*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 1)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 2)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 3)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= k)), (0, True)) +
+        k*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= 3)), (0, True)) +
+        (4 - k)*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= l)), (0, True)) +
+        (l - k + 1)*(KD(i, k) + x)*y)
+
+
+def test_extract_delta():
+    raises(ValueError, lambda: _extract_delta(KD(i, j) + KD(k, l), i))

rl/Lib/site-packages/sympy/concrete/tests/test_gosper.py

@@ -0,0 +1,204 @@
+"""Tests for Gosper's algorithm for hypergeometric summation. """
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.gamma_functions import gamma
+from sympy.polys.polytools import Poly
+from sympy.simplify.simplify import simplify
+from sympy.concrete.gosper import gosper_normal, gosper_sum, gosper_term
+from sympy.abc import a, b, j, k, m, n, r, x
+
+
+def test_gosper_normal():
+    eq = 4*n + 5, 2*(4*n + 1)*(2*n + 3), n
+    assert gosper_normal(*eq) == \
+        (Poly(Rational(1, 4), n), Poly(n + Rational(3, 2)), Poly(n + Rational(1, 4)))
+    assert gosper_normal(*eq, polys=False) == \
+        (Rational(1, 4), n + Rational(3, 2), n + Rational(1, 4))
+
+
+def test_gosper_term():
+    assert gosper_term((4*k + 1)*factorial(
+        k)/factorial(2*k + 1), k) == (-k - S.Half)/(k + Rational(1, 4))
+
+
+def test_gosper_sum():
+    assert gosper_sum(1, (k, 0, n)) == 1 + n
+    assert gosper_sum(k, (k, 0, n)) == n*(1 + n)/2
+    assert gosper_sum(k**2, (k, 0, n)) == n*(1 + n)*(1 + 2*n)/6
+    assert gosper_sum(k**3, (k, 0, n)) == n**2*(1 + n)**2/4
+
+    assert gosper_sum(2**k, (k, 0, n)) == 2*2**n - 1
+
+    assert gosper_sum(factorial(k), (k, 0, n)) is None
+    assert gosper_sum(binomial(n, k), (k, 0, n)) is None
+
+    assert gosper_sum(factorial(k)/k**2, (k, 0, n)) is None
+    assert gosper_sum((k - 3)*factorial(k), (k, 0, n)) is None
+
+    assert gosper_sum(k*factorial(k), k) == factorial(k)
+    assert gosper_sum(
+        k*factorial(k), (k, 0, n)) == n*factorial(n) + factorial(n) - 1
+
+    assert gosper_sum((-1)**k*binomial(n, k), (k, 0, n)) == 0
+    assert gosper_sum((
+        -1)**k*binomial(n, k), (k, 0, m)) == -(-1)**m*(m - n)*binomial(n, m)/n
+
+    assert gosper_sum((4*k + 1)*factorial(k)/factorial(2*k + 1), (k, 0, n)) == \
+        (2*factorial(2*n + 1) - factorial(n))/factorial(2*n + 1)
+
+    # issue 6033:
+    assert gosper_sum(
+        n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b)), \
+        (n, 0, m)).simplify() == -exp(m*log(a) + m*log(b))*gamma(a + 1) \
+        *gamma(b + 1)/(gamma(a)*gamma(b)*gamma(a + m + 1)*gamma(b + m + 1)) \
+        + 1/(gamma(a)*gamma(b))
+
+
+def test_gosper_sum_indefinite():
+    assert gosper_sum(k, k) == k*(k - 1)/2
+    assert gosper_sum(k**2, k) == k*(k - 1)*(2*k - 1)/6
+
+    assert gosper_sum(1/(k*(k + 1)), k) == -1/k
+    assert gosper_sum(-(27*k**4 + 158*k**3 + 430*k**2 + 678*k + 445)*gamma(2*k
+                      + 4)/(3*(3*k + 7)*gamma(3*k + 6)), k) == \
+        (3*k + 5)*(k**2 + 2*k + 5)*gamma(2*k + 4)/gamma(3*k + 6)
+
+
+def test_gosper_sum_parametric():
+    assert gosper_sum(binomial(S.Half, m - j + 1)*binomial(S.Half, m + j), (j, 1, n)) == \
+        n*(1 + m - n)*(-1 + 2*m + 2*n)*binomial(S.Half, 1 + m - n)* \
+        binomial(S.Half, m + n)/(m*(1 + 2*m))
+
+
+def test_gosper_sum_algebraic():
+    assert gosper_sum(
+        n**2 + sqrt(2), (n, 0, m)) == (m + 1)*(2*m**2 + m + 6*sqrt(2))/6
+
+
+def test_gosper_sum_iterated():
+    f1 = binomial(2*k, k)/4**k
+    f2 = (1 + 2*n)*binomial(2*n, n)/4**n
+    f3 = (1 + 2*n)*(3 + 2*n)*binomial(2*n, n)/(3*4**n)
+    f4 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*binomial(2*n, n)/(15*4**n)
+    f5 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*(7 + 2*n)*binomial(2*n, n)/(105*4**n)
+
+    assert gosper_sum(f1, (k, 0, n)) == f2
+    assert gosper_sum(f2, (n, 0, n)) == f3
+    assert gosper_sum(f3, (n, 0, n)) == f4
+    assert gosper_sum(f4, (n, 0, n)) == f5
+
+# the AeqB tests test expressions given in
+# www.math.upenn.edu/~wilf/AeqB.pdf
+
+
+def test_gosper_sum_AeqB_part1():
+    f1a = n**4
+    f1b = n**3*2**n
+    f1c = 1/(n**2 + sqrt(5)*n - 1)
+    f1d = n**4*4**n/binomial(2*n, n)
+    f1e = factorial(3*n)/(factorial(n)*factorial(n + 1)*factorial(n + 2)*27**n)
+    f1f = binomial(2*n, n)**2/((n + 1)*4**(2*n))
+    f1g = (4*n - 1)*binomial(2*n, n)**2/((2*n - 1)**2*4**(2*n))
+    f1h = n*factorial(n - S.Half)**2/factorial(n + 1)**2
+
+    g1a = m*(m + 1)*(2*m + 1)*(3*m**2 + 3*m - 1)/30
+    g1b = 26 + 2**(m + 1)*(m**3 - 3*m**2 + 9*m - 13)
+    g1c = (m + 1)*(m*(m**2 - 7*m + 3)*sqrt(5) - (
+        3*m**3 - 7*m**2 + 19*m - 6))/(2*m**3*sqrt(5) + m**4 + 5*m**2 - 1)/6
+    g1d = Rational(-2, 231) + 2*4**m*(m + 1)*(63*m**4 + 112*m**3 + 18*m**2 -
+             22*m + 3)/(693*binomial(2*m, m))
+    g1e = Rational(-9, 2) + (81*m**2 + 261*m + 200)*factorial(
+        3*m + 2)/(40*27**m*factorial(m)*factorial(m + 1)*factorial(m + 2))
+    g1f = (2*m + 1)**2*binomial(2*m, m)**2/(4**(2*m)*(m + 1))
+    g1g = -binomial(2*m, m)**2/4**(2*m)
+    g1h = 4*pi -(2*m + 1)**2*(3*m + 4)*factorial(m - S.Half)**2/factorial(m + 1)**2
+
+    g = gosper_sum(f1a, (n, 0, m))
+    assert g is not None and simplify(g - g1a) == 0
+    g = gosper_sum(f1b, (n, 0, m))
+    assert g is not None and simplify(g - g1b) == 0
+    g = gosper_sum(f1c, (n, 0, m))
+    assert g is not None and simplify(g - g1c) == 0
+    g = gosper_sum(f1d, (n, 0, m))
+    assert g is not None and simplify(g - g1d) == 0
+    g = gosper_sum(f1e, (n, 0, m))
+    assert g is not None and simplify(g - g1e) == 0
+    g = gosper_sum(f1f, (n, 0, m))
+    assert g is not None and simplify(g - g1f) == 0
+    g = gosper_sum(f1g, (n, 0, m))
+    assert g is not None and simplify(g - g1g) == 0
+    g = gosper_sum(f1h, (n, 0, m))
+    # need to call rewrite(gamma) here because we have terms involving
+    # factorial(1/2)
+    assert g is not None and simplify(g - g1h).rewrite(gamma) == 0
+
+
+def test_gosper_sum_AeqB_part2():
+    f2a = n**2*a**n
+    f2b = (n - r/2)*binomial(r, n)
+    f2c = factorial(n - 1)**2/(factorial(n - x)*factorial(n + x))
+
+    g2a = -a*(a + 1)/(a - 1)**3 + a**(
+        m + 1)*(a**2*m**2 - 2*a*m**2 + m**2 - 2*a*m + 2*m + a + 1)/(a - 1)**3
+    g2b = (m - r)*binomial(r, m)/2
+    ff = factorial(1 - x)*factorial(1 + x)
+    g2c = 1/ff*(
+        1 - 1/x**2) + factorial(m)**2/(x**2*factorial(m - x)*factorial(m + x))
+
+    g = gosper_sum(f2a, (n, 0, m))
+    assert g is not None and simplify(g - g2a) == 0
+    g = gosper_sum(f2b, (n, 0, m))
+    assert g is not None and simplify(g - g2b) == 0
+    g = gosper_sum(f2c, (n, 1, m))
+    assert g is not None and simplify(g - g2c) == 0
+
+
+def test_gosper_nan():
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=True)
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True)
+    f2d = n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b))
+    g2d = 1/(factorial(a - 1)*factorial(
+        b - 1)) - a**(m + 1)*b**(m + 1)/(factorial(a + m)*factorial(b + m))
+    g = gosper_sum(f2d, (n, 0, m))
+    assert simplify(g - g2d) == 0
+
+
+def test_gosper_sum_AeqB_part3():
+    f3a = 1/n**4
+    f3b = (6*n + 3)/(4*n**4 + 8*n**3 + 8*n**2 + 4*n + 3)
+    f3c = 2**n*(n**2 - 2*n - 1)/(n**2*(n + 1)**2)
+    f3d = n**2*4**n/((n + 1)*(n + 2))
+    f3e = 2**n/(n + 1)
+    f3f = 4*(n - 1)*(n**2 - 2*n - 1)/(n**2*(n + 1)**2*(n - 2)**2*(n - 3)**2)
+    f3g = (n**4 - 14*n**2 - 24*n - 9)*2**n/(n**2*(n + 1)**2*(n + 2)**2*
+           (n + 3)**2)
+
+    # g3a -> no closed form
+    g3b = m*(m + 2)/(2*m**2 + 4*m + 3)
+    g3c = 2**m/m**2 - 2
+    g3d = Rational(2, 3) + 4**(m + 1)*(m - 1)/(m + 2)/3
+    # g3e -> no closed form
+    g3f = -(Rational(-1, 16) + 1/((m - 2)**2*(m + 1)**2))  # the AeqB key is wrong
+    g3g = Rational(-2, 9) + 2**(m + 1)/((m + 1)**2*(m + 3)**2)
+
+    g = gosper_sum(f3a, (n, 1, m))
+    assert g is None
+    g = gosper_sum(f3b, (n, 1, m))
+    assert g is not None and simplify(g - g3b) == 0
+    g = gosper_sum(f3c, (n, 1, m - 1))
+    assert g is not None and simplify(g - g3c) == 0
+    g = gosper_sum(f3d, (n, 1, m))
+    assert g is not None and simplify(g - g3d) == 0
+    g = gosper_sum(f3e, (n, 0, m - 1))
+    assert g is None
+    g = gosper_sum(f3f, (n, 4, m))
+    assert g is not None and simplify(g - g3f) == 0
+    g = gosper_sum(f3g, (n, 1, m))
+    assert g is not None and simplify(g - g3g) == 0

rl/Lib/site-packages/sympy/concrete/tests/test_guess.py

@@ -0,0 +1,82 @@
+from sympy.concrete.guess import (
+            find_simple_recurrence_vector,
+            find_simple_recurrence,
+            rationalize,
+            guess_generating_function_rational,
+            guess_generating_function,
+            guess
+        )
+from sympy.concrete.products import Product
+from sympy.core.function import Function
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.exponential import exp
+
+
+def test_find_simple_recurrence_vector():
+    assert find_simple_recurrence_vector(
+            [fibonacci(k) for k in range(12)]) == [1, -1, -1]
+
+
+def test_find_simple_recurrence():
+    a = Function('a')
+    n = Symbol('n')
+    assert find_simple_recurrence([fibonacci(k) for k in range(12)]) == (
+        -a(n) - a(n + 1) + a(n + 2))
+
+    f = Function('a')
+    i = Symbol('n')
+    a = [1, 1, 1]
+    for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
+    assert find_simple_recurrence(a, A=f, N=i) == (
+        -8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3))
+    assert find_simple_recurrence([0, 2, 15, 74, 12, 3, 0,
+                                    1, 2, 85, 4, 5, 63]) == 0
+
+
+def test_rationalize():
+    from mpmath import cos, pi, mpf
+    assert rationalize(cos(pi/3)) == S.Half
+    assert rationalize(mpf("0.333333333333333")) == Rational(1, 3)
+    assert rationalize(mpf("-0.333333333333333")) == Rational(-1, 3)
+    assert rationalize(pi, maxcoeff = 250) == Rational(355, 113)
+
+
+def test_guess_generating_function_rational():
+    x = Symbol('x')
+    assert guess_generating_function_rational([fibonacci(k)
+        for k in range(5, 15)]) == ((3*x + 5)/(-x**2 - x + 1))
+
+
+def test_guess_generating_function():
+    x = Symbol('x')
+    assert guess_generating_function([fibonacci(k)
+        for k in range(5, 15)])['ogf'] == ((3*x + 5)/(-x**2 - x + 1))
+    assert guess_generating_function(
+        [1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf'] == (
+        (1/(x**4 + 2*x**2 - 4*x + 1))**S.Half)
+    assert guess_generating_function(sympify(
+       "[3/2, 11/2, 0, -121/2, -363/2, 121, 4719/2, 11495/2, -8712, -178717/2]")
+       )['ogf'] == (x + Rational(3, 2))/(11*x**2 - 3*x + 1)
+    assert guess_generating_function([factorial(k) for k in range(12)],
+       types=['egf'])['egf'] == 1/(-x + 1)
+    assert guess_generating_function([k+1 for k in range(12)],
+       types=['egf']) == {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
+
+
+def test_guess():
+    i0, i1 = symbols('i0 i1')
+    assert guess([1, 2, 6, 24, 120], evaluate=False) == [Product(i1 + 1, (i1, 1, i0 - 1))]
+    assert guess([1, 2, 6, 24, 120]) == [RisingFactorial(2, i0 - 1)]
+    assert guess([1, 2, 7, 42, 429, 7436, 218348, 10850216], niter=4) == [
+        2**(i0 - 1)*(Rational(27, 16))**(i0**2/2 - 3*i0/2 +
+        1)*Product(RisingFactorial(Rational(5, 3), i1 - 1)*RisingFactorial(Rational(7, 3), i1
+        - 1)/(RisingFactorial(Rational(3, 2), i1 - 1)*RisingFactorial(Rational(5, 2), i1 -
+        1)), (i1, 1, i0 - 1))]
+    assert guess([1, 0, 2]) == []
+    x, y = symbols('x y')
+    assert guess([1, 2, 6, 24, 120], variables=[x, y]) == [RisingFactorial(2, x - 1)]

rl/Lib/site-packages/sympy/concrete/tests/test_products.py

@@ -0,0 +1,410 @@
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (rf, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.simplify import simplify
+from sympy.testing.pytest import raises
+
+a, k, n, m, x = symbols('a,k,n,m,x', integer=True)
+f = Function('f')
+
+
+def test_karr_convention():
+    # Test the Karr product convention that we want to hold.
+    # See his paper "Summation in Finite Terms" for a detailed
+    # reasoning why we really want exactly this definition.
+    # The convention is described for sums on page 309 and
+    # essentially in section 1.4, definition 3. For products
+    # we can find in analogy:
+    #
+    # \prod_{m <= i < n} f(i) 'has the obvious meaning'      for m < n
+    # \prod_{m <= i < n} f(i) = 0                            for m = n
+    # \prod_{m <= i < n} f(i) = 1 / \prod_{n <= i < m} f(i)  for m > n
+    #
+    # It is important to note that he defines all products with
+    # the upper limit being *exclusive*.
+    # In contrast, SymPy and the usual mathematical notation has:
+    #
+    # prod_{i = a}^b f(i) = f(a) * f(a+1) * ... * f(b-1) * f(b)
+    #
+    # with the upper limit *inclusive*. So translating between
+    # the two we find that:
+    #
+    # \prod_{m <= i < n} f(i) = \prod_{i = m}^{n-1} f(i)
+    #
+    # where we intentionally used two different ways to typeset the
+    # products and its limits.
+
+    i = Symbol("i", integer=True)
+    k = Symbol("k", integer=True)
+    j = Symbol("j", integer=True, positive=True)
+
+    # A simple example with a concrete factors and symbolic limits.
+
+    # The normal product: m = k and n = k + j and therefore m < n:
+    m = k
+    n = k + j
+
+    a = m
+    b = n - 1
+    S1 = Product(i**2, (i, a, b)).doit()
+
+    # The reversed product: m = k + j and n = k and therefore m > n:
+    m = k + j
+    n = k
+
+    a = m
+    b = n - 1
+    S2 = Product(i**2, (i, a, b)).doit()
+
+    assert S1 * S2 == 1
+
+    # Test the empty product: m = k and n = k and therefore m = n:
+    m = k
+    n = k
+
+    a = m
+    b = n - 1
+    Sz = Product(i**2, (i, a, b)).doit()
+
+    assert Sz == 1
+
+    # Another example this time with an unspecified factor and
+    # numeric limits. (We can not do both tests in the same example.)
+    f = Function("f")
+
+    # The normal product with m < n:
+    m = 2
+    n = 11
+
+    a = m
+    b = n - 1
+    S1 = Product(f(i), (i, a, b)).doit()
+
+    # The reversed product with m > n:
+    m = 11
+    n = 2
+
+    a = m
+    b = n - 1
+    S2 = Product(f(i), (i, a, b)).doit()
+
+    assert simplify(S1 * S2) == 1
+
+    # Test the empty product with m = n:
+    m = 5
+    n = 5
+
+    a = m
+    b = n - 1
+    Sz = Product(f(i), (i, a, b)).doit()
+
+    assert Sz == 1
+
+
+def test_karr_proposition_2a():
+    # Test Karr, page 309, proposition 2, part a
+    i, u, v = symbols('i u v', integer=True)
+
+    def test_the_product(m, n):
+        # g
+        g = i**3 + 2*i**2 - 3*i
+        # f = Delta g
+        f = simplify(g.subs(i, i+1) / g)
+        # The product
+        a = m
+        b = n - 1
+        P = Product(f, (i, a, b)).doit()
+        # Test if Product_{m <= i < n} f(i) = g(n) / g(m)
+        assert combsimp(P / (g.subs(i, n) / g.subs(i, m))) == 1
+
+    # m < n
+    test_the_product(u, u + v)
+    # m = n
+    test_the_product(u, u)
+    # m > n
+    test_the_product(u + v, u)
+
+
+def test_karr_proposition_2b():
+    # Test Karr, page 309, proposition 2, part b
+    i, u, v, w = symbols('i u v w', integer=True)
+
+    def test_the_product(l, n, m):
+        # Productmand
+        s = i**3
+        # First product
+        a = l
+        b = n - 1
+        S1 = Product(s, (i, a, b)).doit()
+        # Second product
+        a = l
+        b = m - 1
+        S2 = Product(s, (i, a, b)).doit()
+        # Third product
+        a = m
+        b = n - 1
+        S3 = Product(s, (i, a, b)).doit()
+        # Test if S1 = S2 * S3 as required
+        assert combsimp(S1 / (S2 * S3)) == 1
+
+    # l < m < n
+    test_the_product(u, u + v, u + v + w)
+    # l < m = n
+    test_the_product(u, u + v, u + v)
+    # l < m > n
+    test_the_product(u, u + v + w, v)
+    # l = m < n
+    test_the_product(u, u, u + v)
+    # l = m = n
+    test_the_product(u, u, u)
+    # l = m > n
+    test_the_product(u + v, u + v, u)
+    # l > m < n
+    test_the_product(u + v, u, u + w)
+    # l > m = n
+    test_the_product(u + v, u, u)
+    # l > m > n
+    test_the_product(u + v + w, u + v, u)
+
+
+def test_simple_products():
+    assert product(2, (k, a, n)) == 2**(n - a + 1)
+    assert product(k, (k, 1, n)) == factorial(n)
+    assert product(k**3, (k, 1, n)) == factorial(n)**3
+
+    assert product(k + 1, (k, 0, n - 1)) == factorial(n)
+    assert product(k + 1, (k, a, n - 1)) == rf(1 + a, n - a)
+
+    assert product(cos(k), (k, 0, 5)) == cos(1)*cos(2)*cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 3, 5)) == cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 1, Rational(5, 2))) != cos(1)*cos(2)
+
+    assert isinstance(product(k**k, (k, 1, n)), Product)
+
+    assert Product(x**k, (k, 1, n)).variables == [k]
+
+    raises(ValueError, lambda: Product(n))
+    raises(ValueError, lambda: Product(n, k))
+    raises(ValueError, lambda: Product(n, k, 1))
+    raises(ValueError, lambda: Product(n, k, 1, 10))
+    raises(ValueError, lambda: Product(n, (k, 1)))
+
+    assert product(1, (n, 1, oo)) == 1  # issue 8301
+    assert product(2, (n, 1, oo)) is oo
+    assert product(-1, (n, 1, oo)).func is Product
+
+
+def test_multiple_products():
+    assert product(x, (n, 1, k), (k, 1, m)) == x**(m**2/2 + m/2)
+    assert product(f(n), (
+        n, 1, m), (m, 1, k)) == Product(f(n), (n, 1, m), (m, 1, k)).doit()
+    assert Product(f(n), (m, 1, k), (n, 1, k)).doit() == \
+        Product(Product(f(n), (m, 1, k)), (n, 1, k)).doit() == \
+        product(f(n), (m, 1, k), (n, 1, k)) == \
+        product(product(f(n), (m, 1, k)), (n, 1, k)) == \
+        Product(f(n)**k, (n, 1, k))
+    assert Product(
+        x, (x, 1, k), (k, 1, n)).doit() == Product(factorial(k), (k, 1, n))
+
+    assert Product(x**k, (n, 1, k), (k, 1, m)).variables == [n, k]
+
+
+def test_rational_products():
+    assert product(1 + 1/k, (k, 1, n)) == rf(2, n)/factorial(n)
+
+
+def test_special_products():
+    # Wallis product
+    assert product((4*k)**2 / (4*k**2 - 1), (k, 1, n)) == \
+        4**n*factorial(n)**2/rf(S.Half, n)/rf(Rational(3, 2), n)
+
+    # Euler's product formula for sin
+    assert product(1 + a/k**2, (k, 1, n)) == \
+        rf(1 - sqrt(-a), n)*rf(1 + sqrt(-a), n)/factorial(n)**2
+
+
+def test__eval_product():
+    from sympy.abc import i, n
+    # issue 4809
+    a = Function('a')
+    assert product(2*a(i), (i, 1, n)) == 2**n * Product(a(i), (i, 1, n))
+    # issue 4810
+    assert product(2**i, (i, 1, n)) == 2**(n*(n + 1)/2)
+    k, m = symbols('k m', integer=True)
+    assert product(2**i, (i, k, m)) == 2**(-k**2/2 + k/2 + m**2/2 + m/2)
+    n = Symbol('n', negative=True, integer=True)
+    p = Symbol('p', positive=True, integer=True)
+    assert product(2**i, (i, n, p)) == 2**(-n**2/2 + n/2 + p**2/2 + p/2)
+    assert product(2**i, (i, p, n)) == 2**(n**2/2 + n/2 - p**2/2 + p/2)
+
+
+def test_product_pow():
+    # issue 4817
+    assert product(2**f(k), (k, 1, n)) == 2**Sum(f(k), (k, 1, n))
+    assert product(2**(2*f(k)), (k, 1, n)) == 2**Sum(2*f(k), (k, 1, n))
+
+
+def test_infinite_product():
+    # issue 5737
+    assert isinstance(Product(2**(1/factorial(n)), (n, 0, oo)), Product)
+
+
+def test_conjugate_transpose():
+    p = Product(x**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    A, B = symbols("A B", commutative=False)
+    p = Product(A*B**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    p = Product(B**k*A, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+
+def test_simplify_prod():
+    y, t, b, c, v, d = symbols('y, t, b, c, v, d', integer = True)
+
+    _simplify = lambda e: simplify(e, doit=False)
+    assert _simplify(Product(x*y, (x, n, m), (y, a, k)) * \
+        Product(y, (x, n, m), (y, a, k))) == \
+            Product(x*y**2, (x, n, m), (y, a, k))
+    assert _simplify(3 * y* Product(x, (x, n, m)) * Product(x, (x, m + 1, a))) \
+        == 3 * y * Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x, (x, n, k))) == \
+        Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))) == \
+        Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))
+    assert _simplify(Product(x, (t, a, b)) * Product(y, (t, a, b)) * \
+        Product(x, (t, b+1, c))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(x, (t, a, b)) * Product(x, (t, b+1, c)) * \
+        Product(y, (t, a, b))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
+        Product(2, (t, a, b))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 - 1, (t, a, b))) == \
+           Product(0, (t, a, b))
+    assert _simplify(Product(v*Product(sin(t)**2 + cos(t)**2, (t, a, b)),
+                             (v, c, d))) == Product(v*Product(1, (t, a, b)), (v, c, d))
+
+
+def test_change_index():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x, (x, a, b)).change_index(x, x + 1, y) == \
+        Product(y - 1, (y, a + 1, b + 1))
+    assert Product(x**2, (x, a, b)).change_index(x, x - 1) == \
+        Product((x + 1)**2, (x, a - 1, b - 1))
+    assert Product(x**2, (x, a, b)).change_index(x, -x, y) == \
+        Product((-y)**2, (y, -b, -a))
+    assert Product(x, (x, a, b)).change_index(x, -x - 1) == \
+        Product(-x - 1, (x, - b - 1, -a - 1))
+    assert Product(x*y, (x, a, b), (y, c, d)).change_index(x, x - 1, z) == \
+        Product((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
+
+
+def test_reorder():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
+        Product(x, (x, c, d), (x, a, b))
+    assert Product(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
+        (2, 0), (0, 1)) == Product(x*y + z, (z, m, n), (y, c, d), (x, a, b))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (0, 1), (1, 2), (0, 2)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (x, y), (y, z), (x, z)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+
+
+def test_Product_is_convergent():
+    assert Product(1/n**2, (n, 1, oo)).is_convergent() is S.false
+    assert Product(exp(1/n**2), (n, 1, oo)).is_convergent() is S.true
+    assert Product(1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n**2, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_reverse_order():
+    x, y, a, b, c, d= symbols('x, y, a, b, c, d', integer = True)
+
+    assert Product(x, (x, 0, 3)).reverse_order(0) == Product(1/x, (x, 4, -1))
+    assert Product(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
+           Product(x*y, (x, 6, 0), (y, 7, -1))
+    assert Product(x, (x, 1, 2)).reverse_order(0) == Product(1/x, (x, 3, 0))
+    assert Product(x, (x, 1, 3)).reverse_order(0) == Product(1/x, (x, 4, 0))
+    assert Product(x, (x, 1, a)).reverse_order(0) == Product(1/x, (x, a + 1, 0))
+    assert Product(x, (x, a, 5)).reverse_order(0) == Product(1/x, (x, 6, a - 1))
+    assert Product(x, (x, a + 1, a + 5)).reverse_order(0) == \
+           Product(1/x, (x, a + 6, a))
+    assert Product(x, (x, a + 1, a + 2)).reverse_order(0) == \
+           Product(1/x, (x, a + 3, a))
+    assert Product(x, (x, a + 1, a + 1)).reverse_order(0) == \
+           Product(1/x, (x, a + 2, a))
+    assert Product(x, (x, a, b)).reverse_order(0) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x, (x, a, b)).reverse_order(x) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+
+def test_issue_9983():
+    n = Symbol('n', integer=True, positive=True)
+    p = Product(1 + 1/n**Rational(2, 3), (n, 1, oo))
+    assert p.is_convergent() is S.false
+    assert product(1 + 1/n**Rational(2, 3), (n, 1, oo)) == p.doit()
+
+
+def test_issue_13546():
+    n = Symbol('n')
+    k = Symbol('k')
+    p = Product(n + 1 / 2**k, (k, 0, n-1)).doit()
+    assert p.subs(n, 2).doit() == Rational(15, 2)
+
+
+def test_issue_14036():
+    a, n = symbols('a n')
+    assert product(1 - a**2 / (n*pi)**2, [n, 1, oo]) != 0
+
+
+def test_rewrite_Sum():
+    assert Product(1 - S.Half**2/k**2, (k, 1, oo)).rewrite(Sum) == \
+        exp(Sum(log(1 - 1/(4*k**2)), (k, 1, oo)))
+
+
+def test_KroneckerDelta_Product():
+    y = Symbol('y')
+    assert Product(x*KroneckerDelta(x, y), (x, 0, 1)).doit() == 0
+
+
+def test_issue_20848():
+    _i = Dummy('i')
+    t, y, z = symbols('t y z')
+    assert diff(Product(x, (y, 1, z)), x).as_dummy() == Sum(Product(x, (y, 1, _i - 1))*Product(x, (y, _i + 1, z)), (_i, 1, z)).as_dummy()
+    assert diff(Product(x, (y, 1, z)), x).doit() == x**(z - 1)*z
+    assert diff(Product(x, (y, x, z)), x) == Derivative(Product(x, (y, x, z)), x)
+    assert diff(Product(t, (x, 1, z)), x) == S(0)
+    assert Product(sin(n*x), (n, -1, 1)).diff(x).doit() == S(0)