def prove(Eq): p = Symbol.p(complex=True) n = Symbol.n(domain=Interval(1, oo, integer=True)) x = Symbol.x(shape=(n,), given=True, complex=True) y = Symbol.y(shape=(n,), given=True, complex=True) k = Symbol.k(domain=Interval(1, oo, integer=True)) given = Equality(x @ LAMBDA[k:n](p ** k), y @ LAMBDA[k:n](p ** k)) Eq << apply(given) Eq << algebre.vector.cosine_similarity.apply(*given.lhs.args) Eq << algebre.vector.cosine_similarity.apply(*given.rhs.args) Eq << given.subs(Eq[-1], Eq[-2]) Eq << matmul_equality.apply(Eq[-1])
def apply(given): assert given.is_Equality lhs, rhs = given.args assert lhs.is_MatMul x, p_polynomial = lhs.args assert rhs.is_MatMul y, _p_polynomial = rhs.args assert p_polynomial == _p_polynomial assert p_polynomial.is_LAMBDA assert p_polynomial.shape == x.shape == y.shape assert len(p_polynomial.shape) == 1 # n = p_polynomial.shape[0] k = p_polynomial.variable polynomial = p_polynomial.function assert polynomial.is_Power b, e = polynomial.as_base_exp() assert not b.has(k) assert e.as_poly(k).degree() == 1 return Equality(x, y, given=given)
def apply(given, i=None, j=None, w=None): assert given.is_Equality x_set_comprehension, interval = given.args n = interval.max() + 1 assert interval.min() == 0 assert len(x_set_comprehension.limits) == 1 k, a, b = x_set_comprehension.limits[0] assert b - a == n - 1 x = LAMBDA(x_set_comprehension.function.arg, *x_set_comprehension.limits).simplify() if j is None: j = Symbol.j(domain=[0, n - 1], integer=True, given=True) if i is None: i = Symbol.i(domain=[0, n - 1], integer=True, given=True) assert j >= 0 and j < n assert i >= 0 and i < n index = index_function(n) if w is None: _i = Symbol.i(integer=True) _j = Symbol.j(integer=True) w = Symbol.w(definition=LAMBDA[_j:n, _i:n](Swap(n, _i, _j))) return Equality(index[i](w[index[i](x[:n]), index[j](x[:n])] @ x[:n]), index[j](x[:n]), given=given)
def apply(given): assert given.is_Equality assert given.lhs.is_Intersection and given.rhs.is_Union or given.lhs.is_Union and given.rhs.is_Intersection A, B = given.lhs.args _A, _B = given.rhs.args assert A == _A and B == _B return Equality(A, B, given=given)
def test_core_relational(): x = Symbol("x") y = Symbol("y") for c in (Equality, Equality(x,y), Inequality, Inequality(x,y), Relational, Relational(x,y), StrictInequality, StrictInequality(x,y), Unequality, Unequality(x,y)): check(c)
def apply(m, n=1): m = sympify(m) n = sympify(n) x = Symbol.x(real=True) return Equality(Integral[x:0:S.Pi / 2](cos(x)**(m - 1) * sin(x)**(n - 1)), beta(m / 2, n / 2) / 2)
def apply(given, excludes=None): assert given.is_Equality x_union_abs, x_abs_sum = given.args if not x_union_abs.is_Abs: tmp = x_union_abs x_union_abs = x_abs_sum x_abs_sum = tmp assert x_union_abs.is_Abs x_union = x_union_abs.arg assert x_union.is_UNION if x_abs_sum.is_Sum: assert x_abs_sum.function.is_Abs assert x_abs_sum.function.arg == x_union.function else: assert x_abs_sum == summation(abs(x_union.function), *x_union.limits) limits_dict = x_union.limits_dict i, *_ = limits_dict.keys() xi = x_union.function kwargs = i._assumptions.copy() if 'domain' in kwargs: del kwargs['domain'] j = xi.generate_free_symbol(excludes=excludes, **kwargs) xj = xi.subs(i, j) i_domain = limits_dict[i] or i.domain limits = [(j, i_domain - {i})] + [*x_union.limits] return ForAll(Equality(xi & xj, S.EmptySet).simplify(), *limits, given=given)
def test_jl_matrixsymbol_slice3(): A = MatrixSymbol('A', 8, 7) B = MatrixSymbol('B', 2, 2) C = MatrixSymbol('C', 4, 2) name_expr = ("test", [Equality(B, A[6:, 1::3]), Equality(C, A[::2, ::3])]) result, = codegen(name_expr, "Julia", header=False, empty=False) source = result[1] expected = ( "function test(A)\n" " B = A[7:end,2:3:end]\n" " C = A[1:2:end,1:3:end]\n" " return B, C\n" "end\n" ) assert source == expected
def _common_new(cls, function, *symbols, **assumptions): """Return either a special return value or the tuple, (function, limits, orientation). This code is common to both ExprWithLimits and AddWithLimits.""" function = sympify(function) if isinstance(function, Equality): # This transforms e.g. Integral(Eq(x, y)) to Eq(Integral(x), Integral(y)) # but that is only valid for definite integrals. limits, orientation = _process_limits(*symbols) if not (limits and all(len(limit) == 3 for limit in limits)): SymPyDeprecationWarning( feature='Integral(Eq(x, y))', useinstead='Eq(Integral(x, z), Integral(y, z))', issue=18053, deprecated_since_version=1.6, ).warn() lhs = function.lhs rhs = function.rhs return Equality(cls(lhs, *symbols, **assumptions), \ cls(rhs, *symbols, **assumptions)) if function is S.NaN: return S.NaN if symbols: limits, orientation = _process_limits(*symbols) for i, li in enumerate(limits): if len(li) == 4: function = function.subs(li[0], li[-1]) limits[i] = Tuple(*li[:-1]) else: # symbol not provided -- we can still try to compute a general form free = function.free_symbols if len(free) != 1: raise ValueError("specify dummy variables for %s" % function) limits, orientation = [Tuple(s) for s in free], 1 # denest any nested calls while cls == type(function): limits = list(function.limits) + limits function = function.function # Any embedded piecewise functions need to be brought out to the # top level. We only fold Piecewise that contain the integration # variable. reps = {} symbols_of_integration = {i[0] for i in limits} for p in function.atoms(Piecewise): if not p.has(*symbols_of_integration): reps[p] = Dummy() # mask off those that don't function = function.xreplace(reps) # do the fold function = piecewise_fold(function) # remove the masking function = function.xreplace({v: k for k, v in reps.items()}) return function, limits, orientation
def apply(given, i=None, j=None): assert given.is_Equality x_set_comprehension, interval = given.args n = interval.max() + 1 assert interval.min() == 0 assert len(x_set_comprehension.limits) == 1 k, a, b = x_set_comprehension.limits[0] assert b - a == n - 1 x = LAMBDA(x_set_comprehension.function.arg, *x_set_comprehension.limits).simplify() if j is None: j = Symbol.j(domain=[0, n - 1], integer=True, given=True) if i is None: i = Symbol.i(domain=[0, n - 1], integer=True, given=True) assert j >= 0 and j < n assert i >= 0 and i < n index = index_function(n) di = index[i](x[:n]) dj = index[j](x[:n]) return Equality(KroneckerDelta(di, dj), KroneckerDelta(i, j), given=given)
def apply(n, u, v): Q, w, x = predefined_symbols(n) X, index = X_definition(n, w, x) return ForAll[x[:n + 1]:Q[u]](Contains(X[v], Q[v]) & Equality(x[:n + 1], w[n, index[u](X[v])] @ X[v]))
def apply(given): assert given.is_Unequality A_det, zero = given.args assert A_det.is_Determinant assert zero.is_zero A = A_det.arg return Equality(Cofactors(A).T / Determinant(A), Inverse(A), given=given)
def subs(self, *args, **kwargs): if len(args) == 1: eq, *_ = args if isinstance(eq, Equality): args = eq.args return self.func(self.lhs._subs(*args, **kwargs), self.rhs._subs(*args, **kwargs), equivalent=[self, eq]) if isinstance(eq, Subset): A, B = self.args _A, _B = eq.args if A == _A and _B == B: return Equality(A, B, equivalent=[self, eq]) if isinstance(eq, Supset): A, B = self.args _B, _A = eq.args if A == _A and _B == B: return Equality(A, B, equivalent=[self, eq]) return self old, new = args new = _sympify(new) if self.plausible: lhs, rhs = self.lhs._subs(old, new), self.rhs._subs(old, new) if hasattr(new, 'has') and new.has(old): eq = self.func(lhs, rhs, substituent=self) else: eq = self.func(lhs, rhs, given=self) derivative = self.derivative if derivative is None: derivative = {} self.derivative = derivative if old not in derivative: derivative[old] = {} derivative[old][new] = eq return eq if old.is_symbol and new in old.domain: lhs = self.lhs._subs(old, new) rhs = self.rhs._subs(old, new) return self.func(lhs, rhs, given=self) return self
def prove(Eq): n = Symbol.n(domain=Interval(2, oo, integer=True)) S = Symbol.S(dtype=dtype.integer * n) x = Symbol.x(**S.element_symbol().dtype.dict) i = Symbol.i(integer=True) j = Symbol.j(integer=True) given = ForAll( Contains( LAMBDA[i:n](Piecewise((x[0], Equality(i, j)), (x[j], Equality(i, 0)), (x[i], True))), S), (j, 1, n - 1), (x, S)) Eq << apply(given) w = Eq[0].lhs.base Eq << swap1.utility.apply(x, w[0]) Eq << Eq[-1].reference(*Eq[-1].limits) Eq.given = Eq[1].subs(Eq[-1].reversed) Eq << axiom.algebre.matrix.elementary.swap.identity.apply(x, w) Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[0], 0) Eq << Eq[-1].this.lhs.limits_subs(Eq[-1].lhs.variable, i) Eq << Eq[-1].this.lhs.function.indices[0].args[1].limits_subs( Eq[-1].lhs.function.indices[0].args[1].variable, i) Eq << Eq[-1].subs(Eq[-1].rhs.args[0].indices[1], j) Eq.given = Eq.given.subs(Eq[-1]) Eq << Eq.given.limits_swap() Eq << ForAll[x:S](Eq[-1].function.subs(j, 0), plausible=True) Eq << Eq[-1].subs(w[0, 0].this.definition) Eq <<= Eq[-1] & Eq[-2] Eq << combinatorics.permutation.adjacent.swap2.contains.apply(Eq[-1])
def apply(n, m, b): i = Symbol.i(integer=True) return Equality( Concatenate( Concatenate(MatProduct[i:m](Swap(n, i, b[i])), ZeroMatrix(n)).T, Concatenate(ZeroMatrix(n), 1)).T, MatProduct[i:m](Swap(n + 1, i, b[i])))
def apply(n, d): Q = Symbol.Q(shape=(n, d), real=True) K = Symbol.K(shape=(n, d), real=True) V = Symbol.V(shape=(n, d), real=True) S = Symbol.S(shape=(n, d), definition=softmax(Q @ K.T / sympy.sqrt(d)) @ V) return Equality(S[0], softmax(Q[0] @ K.T / sympy.sqrt(d)) @ V)
def apply(x): n = x.shape[0] i = Symbol.i(domain=Interval(0, n - 1, integer=True)) j = Symbol.j(domain=Interval(0, n - 1, integer=True)) w = Symbol.w(integer=True, shape=(n, n, n, n), definition=LAMBDA[j, i](Swap(n, i, j))) return Equality(x @ w[i, j] @ w[i, j], x)
def test_core_relational(): x = Symbol("x") y = Symbol("y") for c in (Equality, Equality(x, y), GreaterThan, GreaterThan(x, y), LessThan, LessThan(x, y), Relational, Relational(x, y), StrictGreaterThan, StrictGreaterThan(x, y), StrictLessThan, StrictLessThan(x, y), Unequality, Unequality(x, y)): check(c)
def apply(given): assert given.is_Equality S_abs, one = given.args assert S_abs.is_Abs and one == 1 S = S_abs.arg x = S.element_symbol() return Exists(Equality(x.set, S), (x, ), given=given)
def apply(n): i = Symbol.i(integer=True) j = Symbol.j(integer=True) return Equality( Concatenate( Concatenate(Swap(n, i, j), ZeroMatrix(n)).T, Concatenate(ZeroMatrix(n), 1)), Swap(n + 1, i, j))
def prove(Eq): x = Symbol.x(real=True) a = Symbol.a(real=True) b = Symbol.b(real=True) Eq << apply(Unequal(x, 0), Equality(x * a, b)) Eq << Eq[1] / x Eq << (Eq[-1] & Eq[0]).split()
def test_Equivalent(): assert Equivalent(A, B) == Equivalent(B, A) == Equivalent(A, B, A) assert Equivalent() is true assert Equivalent(A, A) == Equivalent(A) is true assert Equivalent(True, True) == Equivalent(False, False) is true assert Equivalent(True, False) == Equivalent(False, True) is false assert Equivalent(A, True) == A assert Equivalent(A, False) == Not(A) assert Equivalent(A, B, True) == A & B assert Equivalent(A, B, False) == ~A & ~B assert Equivalent(1, A) == A assert Equivalent(0, A) == Not(A) assert Equivalent(A, Equivalent(B, C)) != Equivalent(Equivalent(A, B), C) assert Equivalent(A < 1, A >= 1) is false assert Equivalent(A < 1, A >= 1, 0) is false assert Equivalent(A < 1, A >= 1, 1) is false assert Equivalent(A < 1, S(1) > A) == Equivalent(1, 1) == Equivalent(0, 0) assert Equivalent(Equality(A, B), Equality(B, A)) is true
def prove(Eq): n = Symbol.n(integer=True) S = Symbol.A(dtype=dtype.integer * n) Eq << apply(Equality(Abs(S), 1)) Eq << sets.equality.imply.exists_equality.apply(Eq[0]).reversed Eq << Eq[1].subs(Eq[-1])
def prove(Eq): A = Symbol.A(dtype=dtype.integer, given=True) B = Symbol.B(dtype=dtype.integer, given=True) Eq << apply(Equality(B - A, EmptySet())) Eq << Eq[0].union(A).reversed Eq << Eq[1].subs(Eq[-1])
def apply(w): n = w.shape[0] i = w.generate_free_symbol(integer=True) j = w.generate_free_symbol({i}, integer=True) assert len(w.shape) == 4 and all(s == n for s in w.shape) assert w[i, j].is_Swap or w[i, j].definition.is_Swap return Equality(w[i, j], w[j, i])
def test_m_matrixsymbol_slice(): A = MatrixSymbol('A', 2, 3) B = MatrixSymbol('B', 1, 3) C = MatrixSymbol('C', 1, 3) D = MatrixSymbol('D', 2, 1) name_expr = ("test", [ Equality(B, A[0, :]), Equality(C, A[1, :]), Equality(D, A[:, 2]) ]) result, = codegen(name_expr, "Octave", header=False, empty=False) source = result[1] expected = ("function [B, C, D] = test(A)\n" " B = A(1, :);\n" " C = A(2, :);\n" " D = A(:, 3);\n" "end\n") assert source == expected
def test_results_named_unordered(): # Here output order is based on name_expr A, B, C = symbols('A,B,C') expr1 = Equality(C, (x + y)*z) expr2 = Equality(A, (x - y)*z) expr3 = Equality(B, 2*x) name_expr = ("test", [expr1, expr2, expr3]) result, = codegen(name_expr, "Julia", header=False, empty=False) source = result[1] expected = ( "function test(x, y, z)\n" " C = z.*(x + y)\n" " A = z.*(x - y)\n" " B = 2*x\n" " return C, A, B\n" "end\n" ) assert source == expected
def apply(given): assert given.is_Equality A, B = given.args if B != 0: A = B assert A.is_Abs A = A.arg return Equality(A, S.EmptySet, given=given)
def test_jl_output_arg_mixed_unordered(): # named outputs are alphabetical, unnamed output appear in the given order from sympy.functions.elementary.trigonometric import (cos, sin) a = symbols("a") name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))]) result, = codegen(name_expr, "Julia", header=False, empty=False) assert result[0] == "foo.jl" source = result[1]; expected = ( 'function foo(x)\n' ' out1 = cos(2*x)\n' ' y = sin(x)\n' ' out3 = cos(x)\n' ' a = sin(2*x)\n' ' return out1, y, out3, a\n' 'end\n' ) assert source == expected
def apply(a, b): n = a.shape[0] i = Symbol.i(integer=True) j = Symbol.j(integer=True) return Equality( Det(LAMBDA[j:n, i:n](a[Min(i, j)] * b[Max(i, j)])), a[0] * b[n - 1] * Product(a[i] * b[i - 1] - a[i - 1] * b[i], (i, 1, n - 1)))