def test_subs1(): e = Integral(exp(x - y), x) assert e.subs(y, 3) == Integral(exp(x - 3), x) e = Integral(exp(x - y), (x, 0, 1)) assert e.subs(y, 3) == Integral(exp(x - 3), (x, 0, 1)) f = Lambda(x, exp(-x**2)) conv = Integral(f(x - y) * f(y), (y, -oo, oo)) assert conv.subs({x: 0}) == Integral(exp(-2 * y**2), (y, -oo, oo))
def test_pickling_polys_rootoftools(): f = x**3 + x + 3 for c in (RootOf, RootOf(f, 0)): check(c) for c in (RootSum, RootSum(f, Lambda(x, exp(x)))): check(c)
def test_funcmatrix(): X = FunctionMatrix(3, 3, Lambda((i, j), i - j)) assert X[1, 1] == 0 assert X[1, 2] == -1 assert X.shape == (3, 3) assert X.rows == X.cols == 3 assert Matrix(X) == Matrix(3, 3, lambda i, j: i - j) assert isinstance(X * X + X, MatrixExpr)
def test_issue_922(): assert rsolve(-2 * n / 3 + f(n) - f(n - 1) + 2 * (n - 1)**3 / 3 + 2 * (n - 1)**2 / 3, init={f(0): 0}) == [{ f: Lambda(n, n * (-3 * n**3 + 2 * n**2 + 9 * n + 4) / 18) }]
def test_RootSum___eq__(): f = Lambda(x, exp(x)) assert (RootSum(x**3 + x + 1, f) == RootSum(x**3 + x + 1, f)) is True assert (RootSum(x**3 + x + 1, f) == RootSum(y**3 + y + 1, f)) is True assert (RootSum(x**3 + x + 1, f) == RootSum(x**3 + x + 2, f)) is False assert (RootSum(x**3 + x + 1, f) == RootSum(y**3 + y + 2, f)) is False
def test_Lambda_equality(): assert Lambda(x, 2 * x) == Lambda(y, 2 * y) # although variables are casts as Dummies, the expressions # should still compare equal assert Lambda((x, y), 2 * x) == Lambda((x, y), 2 * x) assert Lambda(x, 2 * x) != Lambda((x, y), 2 * x) assert Lambda(x, 2 * x) != 2 * x
def test_DifferentialExtension_misc(): # Odd ends assert DifferentialExtension(sin(y)*exp(x), x, dummy=False)._important_attrs == \ (Poly(sin(y)*t0, t0, domain='ZZ[sin(y)]'), Poly(1, t0, domain='ZZ'), [Poly(1, x, domain='ZZ'), Poly(t0, t0, domain='ZZ')], [x, t0], [Lambda(i, exp(i))], [], [1], [x], [], []) pytest.raises(NotImplementedError, lambda: DifferentialExtension(sin(x), x)) assert DifferentialExtension(10**x, x, dummy=False)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(log(10)*t0, t0)], [x, t0], [Lambda(i, exp(i*log(10)))], [(exp(x*log(10)), 10**x)], [1], [x*log(10)], [], []) assert DifferentialExtension(log(x) + log(x**2), x, dummy=False)._important_attrs in [ (Poly(3*t0, t0), Poly(2, t0), [Poly(1, x), Poly(2/x, t0)], [x, t0], [Lambda(i, log(i**2))], [], [], [], [1], [x**2]), (Poly(3*t0, t0), Poly(1, t0), [Poly(1, x), Poly(1/x, t0)], [x, t0], [Lambda(i, log(i))], [], [], [], [1], [x])] assert DifferentialExtension(Integer(0), x, dummy=False)._important_attrs == \ (Poly(0, x), Poly(1, x), [Poly(1, x)], [x], [], [], [], [], [], [])
def test_ImageSet(): squares = ImageSet(Lambda(x, x**2), S.Naturals) assert 4 in squares assert 5 not in squares assert FiniteSet(*range(10)).intersection(squares) == FiniteSet(1, 4, 9) assert 16 not in squares.intersection(Interval(0, 10)) si = iter(squares) a, b, c, d = next(si), next(si), next(si), next(si) assert (a, b, c, d) == (1, 4, 9, 16) harmonics = ImageSet(Lambda(x, 1 / x), S.Naturals) assert Rational(1, 5) in harmonics assert Rational(.25) in harmonics assert 0.25 not in harmonics assert Rational(.3) not in harmonics assert harmonics.is_iterable
def test_halfcircle(): r, th = symbols('r, theta', extended_real=True) L = Lambda((r, th), (r * cos(th), r * sin(th))) halfcircle = ImageSet(L, Interval(0, 1) * Interval(0, pi)) assert (1, 0) in halfcircle assert (0, -1) not in halfcircle assert (0, 0) in halfcircle assert not halfcircle.is_iterable
def test_infinitely_indexed_set_1(): assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(m, m), S.Integers) assert (imageset(Lambda(n, 2*n), S.Integers).intersect(imageset(Lambda(m, 2*m + 1), S.Integers)) == EmptySet()) assert (imageset(Lambda(n, 2*n), S.Integers).intersect(imageset(Lambda(n, 2*n + 1), S.Integers)) == EmptySet()) assert (imageset(Lambda(m, 2*m), S.Integers).intersect(imageset(Lambda(n, 3*n), S.Integers)) == ImageSet(Lambda(t, 6*t), S.Integers))
def test_integers(): Z = S.Integers assert 5 in Z assert -5 in Z assert 5.5 not in Z zi = iter(Z) a, b, c, d = next(zi), next(zi), next(zi), next(zi) assert (a, b, c, d) == (0, 1, -1, 2) assert isinstance(a, Basic) assert Z.intersection(Interval(-5, 5)) == Range(-5, 6) assert Z.intersection(Interval(-5, 5, True, True)) == Range(-4, 5) assert Z.intersection(Set(x)) == Intersection(Z, Set(x), evaluate=False) assert Z.inf == -oo assert Z.sup == oo assert Z.boundary == Z assert imageset(Lambda((x, y), x * y), Z) == ImageSet(Lambda((x, y), x * y), Z)
def test_DifferentialExtension_handle_first(): assert DifferentialExtension(exp(x)*log(x), x, handle_first='log', dummy=False)._important_attrs == \ (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(1/x, t0), Poly(t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(i))], [], [2], [x], [1], [x]) assert DifferentialExtension(exp(x)*log(x), x, handle_first='exp', dummy=False)._important_attrs == \ (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(1/x, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, log(i))], [], [1], [x], [2], [x]) # This one must have the log first, regardless of what we set it to # (because the log is inside of the exponential: x**x == exp(x*log(x))) assert DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x, handle_first='exp', dummy=False)._important_attrs == \ DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x, handle_first='log', dummy=False)._important_attrs == \ (Poly((-1 + x - x*t0**2)*t1, t1), Poly(x, t1), [Poly(1, x), Poly(1/x, t0), Poly((1 + t0)*t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(t0*i))], [(exp(x*log(x)), x**x)], [2], [t0*x], [1], [x])
def test_integrate_primitive(): DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(1 / x, t)], 'Tfuncs': [log] }) assert integrate_primitive(Poly(t, t), Poly(1, t), DE) == (x * log(x), -1, True) assert integrate_primitive(Poly(x, t), Poly(t, t), DE) == (0, NonElementaryIntegral(x / log(x), x), False) DE = DifferentialExtension( extension={ 'D': [Poly(1, x), Poly(1 / x, t1), Poly(1 / (x + 1), t2)], 'Tfuncs': [log, Lambda(i, log(i + 1))] }) assert integrate_primitive(Poly(t1, t2), Poly(t2, t2), DE) == \ (0, NonElementaryIntegral(log(x)/log(1 + x), x), False) DE = DifferentialExtension( extension={ 'D': [Poly(1, x), Poly(1 / x, t1), Poly(1 / (x * t1), t2)], 'Tfuncs': [log, Lambda(i, log(log(i)))] }) assert integrate_primitive(Poly(t2, t2), Poly(t1, t2), DE) == \ (0, NonElementaryIntegral(log(log(x))/log(x), x), False) DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(1 / x, t0)], 'Tfuncs': [log] }) assert integrate_primitive(Poly(x**2*t0**3 + (3*x**2 + x)*t0**2 + (3*x**2 + 2*x)*t0 + x**2 + x, t0), Poly(x**2*t0**4 + 4*x**2*t0**3 + 6*x**2*t0**2 + 4*x**2*t0 + x**2, t0), DE) == \ (-1/(log(x) + 1), NonElementaryIntegral(1/(log(x) + 1), x), False)
def test_halfcircle(): # This test sometimes works and sometimes doesn't. # It may be an issue with solve? Maybe with using Lambdas/dummys? # I believe the code within fancysets is correct r, th = symbols('r, theta', extended_real=True) L = Lambda((r, th), (r*cos(th), r*sin(th))) halfcircle = ImageSet(L, Interval(0, 1)*Interval(0, pi)) assert (1, 0) in halfcircle assert (0, -1) not in halfcircle assert (0, 0) in halfcircle assert not halfcircle.is_iterable
def test_apart_full(): f = 1 / (x**2 + 1) assert apart(f, full=False) == f assert apart(f, full=True) == \ -RootSum(x**2 + 1, Lambda(a, a/(x - a)), auto=False)/2 f = 1 / (x**3 + x + 1) assert apart(f, full=False) == f assert apart(f, full=True) == \ RootSum(x**3 + x + 1, Lambda(a, (6*a**2/31 - 9*a/31 + Rational(4, 31))/(x - a)), auto=False) f = 1 / (x**5 + 1) assert apart(f, full=False) == \ (-Rational(1, 5))*((x**3 - 2*x**2 + 3*x - 4)/(x**4 - x**3 + x**2 - x + 1)) + (Rational(1, 5))/(x + 1) assert apart(f, full=True) == \ -RootSum(x**4 - x**3 + x**2 - x + 1, Lambda(a, a/(x - a)), auto=False)/5 + (Rational(1, 5))/(x + 1)
def test_apart_list(): from diofant.utilities.iterables import numbered_symbols assert apart_list(1) == 1 w0, w1, w2 = Symbol("w0"), Symbol("w1"), Symbol("w2") _a = Dummy("a") f = (-2 * x - 2 * x**2) / (3 * x**2 - 6 * x) assert apart_list(f, x, dummies=numbered_symbols("w")) == (-1, Poly(Rational(2, 3), x, domain='QQ'), [(Poly(w0 - 2, w0, domain='ZZ'), Lambda(_a, 2), Lambda(_a, -_a + x), 1)]) assert apart_list( 2 / (x**2 - 2), x, dummies=numbered_symbols("w")) == (1, Poly(0, x, domain='ZZ'), [ (Poly(w0**2 - 2, w0, domain='ZZ'), Lambda(_a, _a / 2), Lambda(_a, -_a + x), 1) ]) f = 36 / (x**5 - 2 * x**4 - 2 * x**3 + 4 * x**2 + x - 2) assert apart_list( f, x, dummies=numbered_symbols("w")) == (1, Poly(0, x, domain='ZZ'), [ (Poly(w0 - 2, w0, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1), (Poly(w1**2 - 1, w1, domain='ZZ'), Lambda(_a, -3 * _a - 6), Lambda(_a, -_a + x), 2), (Poly(w2 + 1, w2, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1) ])
def test_sympyissue_18751(): r = symbols('r', real=True, positive=True) theta = symbols('theta', real=True) eq = f(n) - 2 * r * cos(theta) * f(n - 1) + r**2 * f(n - 2) res = [{ f: Lambda( n, r**n * (C0 * (cos(theta) - I * abs(sin(theta)))**n + C1 * (cos(theta) + I * abs(sin(theta)))**n)) }] assert rsolve(eq) == res
def compute_cdf(self, **kwargs): """ Compute the CDF from the PDF Returns a Lambda """ x, z = symbols('x, z', integer=True, finite=True, cls=Dummy) left_bound = self.set.inf # CDF is integral of PDF from left bound to z pdf = self.pdf(x) cdf = summation(pdf, (x, left_bound, z), **kwargs) # CDF Ensure that CDF left of left_bound is zero cdf = Piecewise((cdf, z >= left_bound), (0, True)) return Lambda(z, cdf)
def test_call(): # See the long history of this in issues sympy/sympy#5026 and sympy/sympy#5105. pytest.raises(TypeError, lambda: sin(x)({x: 1, sin(x): 2})) pytest.raises(TypeError, lambda: sin(x)(1)) # No effect as there are no callables assert sin(x).rcall(1) == sin(x) assert (1 + sin(x)).rcall(1) == 1 + sin(x) # Effect in the pressence of callables l = Lambda(x, 2 * x) assert (l + x).rcall(y) == 2 * y + x assert (x**l).rcall(2) == x**4
def _inverse_cdf_expression(self): """ Inverse of the CDF Used by sample """ x, z = symbols('x, z', extended_real=True, positive=True, cls=Dummy) # Invert CDF try: inverse_cdf = solve(self.cdf(x) - z, x) except NotImplementedError: inverse_cdf = None if not inverse_cdf or len(inverse_cdf) != 1: raise NotImplementedError("Could not invert CDF") return Lambda(z, inverse_cdf[0])
def test_ccode_Pow(): assert ccode(x**3) == 'pow(x, 3)' assert ccode(x**(y**3)) == 'pow(x, pow(y, 3))' g = implemented_function('g', Lambda(x, 2*x)) assert ccode(1/(g(x)*3.5)**(x - y**x)/(x**2 + y)) == \ 'pow(3.5*2*x, -x + pow(y, x))/(pow(x, 2) + y)' assert ccode(x**-1.0) == '1.0/x' assert ccode(x**Rational(2, 3)) == 'pow(x, 2.0L/3.0L)' _cond_cfunc = [(lambda base, exp: exp.is_integer, 'dpowi'), (lambda base, exp: not exp.is_integer, 'pow')] assert ccode(x**3, user_functions={'Pow': _cond_cfunc}) == 'dpowi(x, 3)' assert ccode(x**3.2, user_functions={'Pow': _cond_cfunc}) == 'pow(x, 3.2)' _cond_cfunc2 = [(lambda base, exp: base == 2, lambda base, exp: f'exp2({exp})'), (lambda base, exp: base != 2, 'pow')] # Related to sympy/sympy#11353 assert ccode(2**x, user_functions={'Pow': _cond_cfunc2}) == 'exp2(x)' assert ccode(x**2, user_functions={'Pow': _cond_cfunc2}) == 'pow(x, 2)'
def doit(self, **kwargs): evaluate = kwargs.pop('evaluate', True) expr, condition = self.expr, self.condition if condition is not None: # Recompute on new conditional expr expr = given(expr, condition, **kwargs) if not random_symbols(expr): return Lambda(x, DiracDelta(x - expr)) if (isinstance(expr, RandomSymbol) and hasattr(expr.pspace, 'distribution') and isinstance(pspace(expr), SinglePSpace)): return expr.pspace.distribution result = pspace(expr).compute_density(expr, **kwargs) if evaluate and hasattr(result, 'doit'): return result.doit() else: return result
def test_image_interval(): x = Symbol('x', extended_real=True) a = Symbol('a', extended_real=True) assert imageset(x, 2 * x, Interval(-2, 1)) == Interval(-4, 2) assert imageset(x, 2*x, Interval(-2, 1, True, False)) == \ Interval(-4, 2, True, False) assert imageset(x, x**2, Interval(-2, 1, True, False)) == \ Interval(0, 4, False, True) assert imageset(x, x**2, Interval(-2, 1)) == Interval(0, 4) assert imageset(x, x**2, Interval(-2, 1, True, False)) == \ Interval(0, 4, False, True) assert imageset(x, x**2, Interval(-2, 1, True, True)) == \ Interval(0, 4, False, True) assert imageset(x, (x - 2)**2, Interval(1, 3)) == Interval(0, 1) assert imageset(x, 3*x**4 - 26*x**3 + 78*x**2 - 90*x, Interval(0, 4)) == \ Interval(-35, 0) # Multiple Maxima assert imageset(x, x + 1/x, Interval(-oo, oo)) == Interval(-oo, -2) \ + Interval(2, oo) # Single Infinite discontinuity assert imageset(x, 1/x + 1/(x - 1)**2, Interval(0, 2, True, False)) == \ Interval(Rational(3, 2), oo, False, True) # Multiple Infinite discontinuities # issue sympy/sympy#10113 assert imageset(x, x**2 / (x**2 - 4), Interval(-2, 2)) == Interval(-oo, 0, True) # Test for Python lambda assert imageset(lambda x: 2 * x, Interval(-2, 1)) == Interval(-4, 2) assert (imageset(Lambda(x, a * x), Interval(0, 1)) == ImageSet(Lambda(x, a * x), Interval(0, 1))) assert (imageset(Lambda(x, sin(cos(x))), Interval(0, 1)) == ImageSet(Lambda(x, sin(cos(x))), Interval(0, 1))) assert imageset(x, -(x - 2) * (x + 2), Interval(-3, 4)) == Interval(-12, 4) assert (imageset(z, 2 * z, ImageSet(Lambda((x, y), x * y), Interval(0, 2))) == ImageSet( Lambda(z, 2 * z), ImageSet(Lambda((x, y), x * y), Interval(0, 2))))
def test_rsolve(): f = y(n + 2) - y(n + 1) - y(n) h = sqrt(5)*(Rational(1, 2) + sqrt(5)/2)**n \ - sqrt(5)*(Rational(1, 2) - sqrt(5)/2)**n assert rsolve(f, y(n)) in [ C0 * (Rational(1, 2) - sqrt(5) / 2)**n + C1 * (Rational(1, 2) + sqrt(5) / 2)**n, C1 * (Rational(1, 2) - sqrt(5) / 2)**n + C0 * (Rational(1, 2) + sqrt(5) / 2)**n, ] assert rsolve(f, y(n), [0, 5]) == h assert rsolve(f, y(n), {0: 0, 1: 5}) == h assert rsolve(f, y(n), {y(0): 0, y(1): 5}) == h assert rsolve(y(n) - y(n - 1) - y(n - 2), y(n), [0, 5]) == h assert rsolve(Eq(y(n), y(n - 1) + y(n - 2)), y(n), [0, 5]) == h assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = (n - 1) * y(n + 2) - (n**2 + 3 * n - 2) * y(n + 1) + 2 * n * (n + 1) * y(n) g = C1 * factorial(n) + C0 * 2**n h = -3 * factorial(n) + 3 * 2**n assert rsolve(f, y(n)) == g assert rsolve(f, y(n), []) == g assert rsolve(f, y(n), {}) == g assert rsolve(f, y(n), [0, 3]) == h assert rsolve(f, y(n), {0: 0, 1: 3}) == h assert rsolve(f, y(n), {y(0): 0, y(1): 3}) == h assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = y(n) - y(n - 1) - 2 assert rsolve(f, y(n), {y(0): 0}) == 2 * n assert rsolve(f, y(n), {y(0): 1}) == 2 * n + 1 assert rsolve(f, y(n), {y(0): 0, y(1): 1}) is None assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = 3 * y(n - 1) - y(n) - 1 assert rsolve(f, y(n), {y(0): 0}) == -3**n / 2 + Rational(1, 2) assert rsolve(f, y(n), {y(0): 1}) == 3**n / 2 + Rational(1, 2) assert rsolve(f, y(n), {y(0): 2}) == 3 * 3**n / 2 + Rational(1, 2) assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = y(n) - 1 / n * y(n - 1) assert rsolve(f, y(n)) == C0 / factorial(n) assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = y(n) - 1 / n * y(n - 1) - 1 assert rsolve(f, y(n)) is None f = 2 * y(n - 1) + (1 - n) * y(n) / n assert rsolve(f, y(n), {y(1): 1}) == 2**(n - 1) * n assert rsolve(f, y(n), {y(1): 2}) == 2**(n - 1) * n * 2 assert rsolve(f, y(n), {y(1): 3}) == 2**(n - 1) * n * 3 assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 f = (n - 1) * (n - 2) * y(n + 2) - (n + 1) * (n + 2) * y(n) assert rsolve(f, y(n), {y(3): 6, y(4): 24}) == n * (n - 1) * (n - 2) assert rsolve(f, y(n), { y(3): 6, y(4): -24 }) == -n * (n - 1) * (n - 2) * (-1)**(n) assert f.subs(y, Lambda(k, rsolve(f, y(n)).subs(n, k))).simplify() == 0 assert rsolve(Eq(y(n + 1), a * y(n)), y(n), {y(1): a}).simplify() == a**n assert rsolve(y(n) - a*y(n-2), y(n), {y(1): sqrt(a)*(a + b), y(2): a*(a - b)}).simplify() == \ a**(n/2)*(-(-1)**n*b + a) f = (-16 * n**2 + 32 * n - 12) * y(n - 1) + (4 * n**2 - 12 * n + 9) * y(n) assert expand_func(rsolve(f, y(n), {y(1): binomial(2*n + 1, 3)}).rewrite(gamma)).simplify() == \ 2**(2*n)*n*(2*n - 1)*(4*n**2 - 1)/12 assert (rsolve(y(n) + a * (y(n + 1) + y(n - 1)) / 2, y(n)) - (C0 * (-sqrt(-1 + a**(-2)) - 1 / a)**n + C1 * (sqrt(-1 + a**(-2)) - 1 / a)**n)).simplify() == 0
def test_sym_integral(): f = Lambda(x, exp(-x**2)) l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="diofant") assert l(y).doit() == sqrt(pi)
def test_integral(): f = Lambda(x, exp(-x**2)) l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="diofant") assert l(x) == Integral(exp(-x**2), (x, -oo, oo))
def test_ImageSet_simplification(): assert imageset(Lambda(n, n), S.Integers) == S.Integers assert (imageset(Lambda(n, sin(n)), imageset(Lambda(m, tan(m)), S.Integers)) == imageset(Lambda(m, sin(tan(m))), S.Integers))
def test_infinitely_indexed_set_3(): assert imageset(Lambda(n, 2 * n + 1), S.Integers) == imageset(Lambda(n, 2 * n - 1), S.Integers) assert imageset(Lambda(n, 3 * n + 2), S.Integers) == imageset(Lambda(n, 3 * n - 1), S.Integers)
def test_infinitely_indexed_diophantine(): assert (imageset(Lambda(m, 2 * pi * m), S.Integers).intersection( imageset(Lambda(n, 3 * pi * n), S.Integers)) == ImageSet(Lambda(t, 6 * pi * t), S.Integers))
def test_infinitely_indexed_set_2(): a = Symbol('a', integer=True) assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(n, n + a), S.Integers) assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(n, -n + a), S.Integers) assert imageset(Lambda(n, -6 * n), S.Integers) == ImageSet(Lambda(n, 6 * n), S.Integers) assert imageset(Lambda(n, 2 * n + pi), S.Integers) == ImageSet(Lambda(n, 2 * n + pi), S.Integers) assert imageset(Lambda(n, pi * n + pi), S.Integers) == ImageSet(Lambda(n, pi * n + pi), S.Integers) assert imageset(Lambda(n, exp(n)), S.Integers) != imageset( Lambda(n, n), S.Integers)