def test_issue_6194(): x = Symbol('x') assert unchanged(Contains, x, Interval(0, 1)) assert Interval(0, 1).contains(x) == (S.Zero <= x) & (x <= 1) assert Contains(x, FiniteSet(0)) != S.false assert Contains(x, Interval(1, 1)) != S.false assert Contains(x, S.Integers) != S.false
def prove(Eq): n = Symbol.n(integer=True, positive=True) x = Symbol.x(complex=True, shape=(n, )) f = Function.f(nargs=(n, ), integer=True, shape=()) g = Function.g(nargs=(n, ), integer=True, shape=()) A = Symbol.A(definition=conditionset(x, Equality(f(x), 1))) B = Symbol.B(definition=conditionset(x, Equality(g(x), 1))) assert f.is_integer and g.is_integer assert f.shape == g.shape == () Eq << apply(ForAll[x:A](Equality(g(x), 1)), ForAll[x:B](Equality(f(x), 1))) Eq << sets.imply.conditionset.apply(A) Eq << sets.imply.conditionset.apply(B) Eq << ForAll[x:A](Contains(x, B), plausible=True) Eq << Eq[-1].definition Eq << ForAll[x:B](Contains(x, A), plausible=True) Eq << Eq[-1].definition Eq << sets.forall_contains.forall_contains.imply.equality.apply( Eq[-2], Eq[-1])
def test_GammaProcess_symbolic(): t, d, x, y, g, l = symbols('t d x y g l', positive=True) X = GammaProcess("X", l, g) raises(NotImplementedError, lambda: X[t]) raises(IndexError, lambda: X(-1)) assert isinstance(X(t), RandomIndexedSymbol) assert X.state_space == Interval(0, oo) assert X.distribution(t) == GammaDistribution(g * t, 1 / l) assert X.joint_distribution(5, X(3)) == JointDistributionHandmade( Lambda( (X(5), X(3)), l**(8 * g) * exp(-l * X(3)) * exp(-l * X(5)) * X(3)**(3 * g - 1) * X(5)**(5 * g - 1) / (gamma(3 * g) * gamma(5 * g)))) # property of the gamma process at any given timestamp assert E(X(t)) == g * t / l assert variance(X(t)).simplify() == g * t / l**2 # Equivalent to E(2*X(1)) + E(X(1)**2) + E(X(1)**3), where E(X(1)) == g/l assert E(X(t)**2 + X(d)*2 + X(y)**3, Contains(t, Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2)) & Contains(y, Interval.Ropen(3, 4))) == \ 2*g/l + (g**2 + g)/l**2 + (g**3 + 3*g**2 + 2*g)/l**3 assert P(X(t) > 3, Contains(t, Interval.Lopen(3, 4))).simplify() == \ 1 - lowergamma(g, 3*l)/gamma(g) # equivalent to P(X(1)>3) #test issue 20078 assert (2 * X(t) + 3 * X(t)).simplify() == 5 * X(t) assert (2 * X(t) - 3 * X(t)).simplify() == -X(t) assert (2 * (0.25 * X(t))).simplify() == 0.5 * X(t) assert (2 * X(t) * 0.25 * X(t)).simplify() == 0.5 * X(t)**2 assert (X(t)**2 + X(t)**3).simplify() == (X(t) + 1) * X(t)**2
def test_contains_basic(): raises(TypeError, lambda: Contains(S.Integers, 1)) assert Contains(2, S.Integers) is S.true assert Contains(-2, S.Naturals) is S.false i = Symbol('i', integer=True) assert Contains(i, S.Naturals) == Contains(i, S.Naturals, evaluate=False)
def prove(Eq): n = Symbol.n(integer=True, positive=True) m = Symbol.m(integer=True, positive=True) A = Symbol.A(dtype=dtype.integer * n) a = Symbol.a(integer=True, shape=(n, )) B = Symbol.B(dtype=dtype.integer * m) b = Symbol.b(integer=True, shape=(m, )) f = Function.f(nargs=(n, ), integer=True, shape=(m, )) g = Function.g(nargs=(m, ), integer=True, shape=(n, )) assert f.is_integer assert g.is_integer assert f.shape == (m, ) assert g.shape == (n, ) Eq << apply(ForAll[a:A](Contains(f(a), B)), ForAll[b:B](Contains(g(b), A)), ForAll[a:A](Equality(a, g(f(a)))), ForAll[b:B](Equality( b, f(g(b))))) Eq << sets.forall_contains.forall_contains.forall_equality.imply.equality.apply( Eq[0], Eq[1], Eq[2]) Eq << sets.forall_contains.forall_contains.forall_equality.imply.equality.apply( Eq[1], Eq[0], Eq[3]) Eq << sets.equality.equality.imply.equality.abs.apply(Eq[-1], Eq[-2]).reversed
def test_powerset_contains(): A = PowerSet(FiniteSet(1), evaluate=False) assert A.contains(2) == Contains(2, A) x = Symbol('x') A = PowerSet(FiniteSet(x), evaluate=False) assert A.contains(FiniteSet(1)) == Contains(FiniteSet(1), A)
def prove(Eq): e = Symbol.e(integer=True) A = Symbol.A(dtype=dtype.integer) B = Symbol.B(dtype=dtype.integer) Eq << apply(Contains(e, A), Contains(e, B)) Eq << Eq[-1].split()
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[j:1:n - 1, x:S](Contains( LAMBDA[i:n](Piecewise((x[0], Equality(i, j)), (x[j], Equality(i, 0)), (x[i], True))), S)), ForAll[x:S](Equality(abs(x.set_comprehension()), n)) ] Eq << apply(given) Eq << discrete.combinatorics.permutation.adjacent.swap2.general.apply( Eq[0]) Eq.permutation = discrete.combinatorics.permutation.adjacent.swapn.permutation.apply( Eq[-1]) Eq << Eq.permutation.limits[0][1].this.definition Eq << discrete.combinatorics.permutation.factorial.definition.apply(n) Eq << Eq[-1].this.lhs.arg.limits_subs(Eq[-1].lhs.arg.variable, Eq[-2].rhs.variable) Eq <<= Eq[-1] & Eq[-2].abs() F = Function.F(nargs=(), dtype=dtype.integer * n) F.eval = lambda e: conditionset(x, Equality(x.set_comprehension(), e), S) e = Symbol.e(dtype=dtype.integer) Eq << Subset(F(e), S, plausible=True) Eq << Eq[-1].this.lhs.definition Eq << sets.subset.forall.imply.forall.apply(Eq[-1], Eq.permutation) Eq.forall_x = ForAll(Contains(Eq[-1].lhs, F(e)), *Eq[-1].limits, plausible=True) Eq << Eq.forall_x.definition.split() P = Eq[-1].limits[0][1] Eq << sets.imply.conditionset.apply(P) Eq << Eq[-1].apply(sets.equality.imply.equality.permutation, x) Eq.equality_e = Eq[-3] & Eq[-1] Eq << sets.imply.conditionset.apply(F(e)).reversed
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) w = Symbol.w(integer=True, shape=(n, n, n, n), definition=LAMBDA[j:n, i:n](Swap(n, i, j))) given = ForAll[x:S](Contains(w[0, j] @ x, S)) Eq << apply(given) Eq.given_i = given.subs(j, i) Eq << given.subs(x, Eq.given_i.function.lhs) Eq << (Eq.given_i & Eq[-1]).split()[-1] Eq << Eq.given_i.subs(x, Eq[-1].function.lhs) Eq.final_statement = (Eq[-2] & Eq[-1]).split()[0] Eq << swap2.equality.apply(n, w) Eq << Eq[-1] @ x Eq << Eq[-1].forall((Eq[-1].limits[0].args[1].args[1].arg,)) Eq.i_complement = Eq.final_statement.subs(Eq[-1]) Eq.plausible = ForAll(Contains(w[i, j] @ x, S), (x, S), (j, Interval(1, n - 1, integer=True)), plausible=True) Eq << Eq.plausible.bisect(i.set, wrt=j) Eq.i_complement, Eq.i_intersection = Eq[-1].split() Eq << sets.imply.equality.intersection.apply(i, Interval(1, n - 1, integer=True)) Eq << Eq.i_intersection.this.limits[1].subs(Eq[-1]) Eq << Eq[-1].subs(w[i, i].equality_defined()) Eq << (Eq.i_complement & Eq.i_intersection) Eq << elementary.swap.transpose.apply(w).subs(j, 0) Eq << Eq.given_i.subs(Eq[-1].reversed) Eq << (Eq[-1] & Eq.plausible)
def prove(Eq): n = Symbol.n(integer=True, positive=True) Eq << apply(n) x = Eq[0].rhs.variable.base P = Eq[0].lhs P_quote = Eq[1].lhs i = Symbol.i(integer=True) x_quote = Symbol("x'", definition=LAMBDA[i:n + 1](Piecewise((n, Equality(i, n)), (x[i], True)))) Eq.x_quote_definition = x_quote.this.definition Eq << Eq.x_quote_definition[:n] Eq.mapping = Eq[-1].this.rhs().function.simplify() Eq << Eq.x_quote_definition[i] Eq << Eq[-1].set.union_comprehension((i, 0, n - 1)) Eq.x_quote_n_definition = Eq[-2].subs(i, n) Eq << sets.imply.conditionset.apply(P) Eq << Eq[-2].subs(Eq[-1]) Eq.P2P_quote = ForAll[x[:n]:P](Contains(x_quote, P_quote), plausible=True) Eq << Eq.P2P_quote.definition.split() Eq << sets.imply.conditionset.apply(P_quote) Eq << Eq[-1].split() Eq << Eq[-2].reversed + Eq.x_quote_n_definition Eq.mapping_quote = ForAll[x[:n + 1]:P_quote](Equality(x_quote, x[:n + 1]), plausible=True) Eq << Eq.mapping_quote.this.function.bisect(Slice[-1:]).split() Eq << Eq[-1].subs(Eq.mapping) Eq << ForAll[x[:n + 1]:P_quote](Contains(x[:n], P), plausible=True) Eq << Eq[-1].definition Eq << sets.forall_contains.forall_contains.forall_equality.forall_equality.imply.equality.apply(Eq[-1], Eq.P2P_quote, Eq.mapping_quote, Eq.mapping) Eq << Eq[-1].reversed
def limits_cond(limits): eqs = [] from sympy.sets.contains import Contains limitsdict = limits_dict(limits) for x, cond in limitsdict.items(): if isinstance(cond, list): if not cond: continue cond, baseset = cond cond &= Contains(x, baseset) elif cond.is_set: cond = Contains(x, cond) eqs.append(cond) return And(*eqs)
def prove(Eq): n = Symbol.n(integer=True, positive=True) x = Symbol.x(complex=True, shape=(n,)) A = Symbol.A(dtype=dtype.integer*n) B = Symbol.B(dtype=dtype.integer*n) Eq << apply(ForAll[x:A](Contains(x, B)), ForAll[x:B](Contains(x, A))) Eq << sets.forall_contains.imply.subset.apply(Eq[0]) Eq << sets.forall_contains.imply.subset.apply(Eq[1]) Eq <<= Eq[-1] & Eq[-2] Eq << Eq[-1].reversed
def apply(given): assert given.is_ForAll and len(given.limits) == 2 j, a, n_munis_1 = given.limits[0] assert a == 1 x, S = given.limits[1] contains = given.function assert contains.is_Contains ref, _S = contains.args assert S == _S and ref.is_LAMBDA and S.is_set dtype = S.element_type assert len(ref.limits) == 1 i, a, _n_munis_1 = ref.limits[0] assert _n_munis_1 == n_munis_1 and a == 0 piecewise = ref.function assert piecewise.is_Piecewise and len(piecewise.args) == 3 x0, condition0 = piecewise.args[0] assert condition0.is_Equality and {*condition0.args} == {i, j} xj, conditionj = piecewise.args[1] assert conditionj.is_Equality and {*conditionj.args} == {i, 0} xi, conditioni = piecewise.args[2] assert conditioni n = n_munis_1 + 1 assert x[j] == xj and x[i] == xi and x[0] == x0 and dtype == x.dtype w = Symbol.w(definition=LAMBDA[j:n, i:n](Swap(n, i, j))) return ForAll(Contains(w[i, j] @ x, S), (x, S), given=given)
def apply(*given): equality = given[0] assert equality.is_Equality intersection, a = equality.args if not intersection.is_Intersection: a, intersection = equality.args assert intersection.is_Intersection e_set, s = intersection.args if not e_set.is_FiniteSet: s, e_set = intersection.args assert e_set.is_FiniteSet assert len(e_set) == 1 e, *_ = e_set.args if len(given) > 1: positive = given[1] x_abs = positive.is_positive_relationship() assert x_abs is not None assert x_abs.is_Abs assert a == x_abs.arg else: assert abs(a) > 0 return Contains(e, s, given=given)
def pmf(self, x): x = sympify(x) if not (x.is_number or x.is_Symbol or is_random(x)): raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " "'RandomSymbol' not %s" % (type(x))) cond = Ge(x, 1) & Le(x, self.sides) & Contains(x, S.Integers) return Piecewise((S.One/self.sides, cond), (S.Zero, True))
def apply(n, dx, dz): x = Symbol.x(shape=(n, dx), real=True) W_Q = Symbol("W^Q", shape=(dx, dz), real=True) W_K = Symbol("W^K", shape=(dx, dz), real=True) W_V = Symbol("W^V", shape=(dx, dz), real=True) Q = Symbol.Q(definition=x @ W_Q) K = Symbol.K(definition=x @ W_K) i = Symbol.i(integer=True) j = Symbol.j(integer=True) k = Symbol.k(integer=True, positive=True) w_K = Symbol("w^K", shape=(2 * k + 1, dz), real=True) w_V = Symbol("w^V", shape=(2 * k + 1, dz), real=True) a_K = Symbol("a^K", definition=LAMBDA[j:n, i:n](w_K[k + clip(j - i, -k, k)])) a_V = Symbol("a^V", definition=LAMBDA[j:n, i:n](w_V[k + clip(j - i, -k, k)])) e = Symbol.e(definition=(Q @ K.T + LAMBDA[i:n](Q[i] @ a_K[i].T)) / sqrt(dz)) α = Symbol.α(definition=softmax(e)) z = Symbol.z(shape=(n, dz), definition=α @ (x @ W_V) + LAMBDA[i:n](α[i] @ a_V[i])) return Contains(k + clip(j - i, -k, k), Interval(0, 2 * k, integer=True)), Equality(z[i], Sum[j:n](α[i, j] * (x[j] @ W_V + a_V[i, j]))), Equality(e[i, j], (x[i] @ W_Q @ (x[j] @ W_K + a_K[i, j])) / sqrt(dz))
def image_set_definition(self, reverse=False): image_set = self.image_set() if image_set is None: return expr, variables, base_set = image_set from sympy.tensor.indexed import Slice from sympy.core.relational import Equality from sympy.concrete.expr_with_limits import ForAll, Exists if isinstance(base_set, Symbol): if reverse: return ForAll(Contains(expr, self), (variables, base_set)) element_symbol = self.element_symbol() assert expr.dtype == element_symbol.dtype condition = Equality(expr, element_symbol) return ForAll(Exists(condition, (variables, base_set)), (element_symbol, self)) else: if not isinstance(base_set, ConditionSet): return variable = base_set.variable if isinstance(variable, Symbol): ... elif isinstance(variable, Slice): condition = base_set.condition element_symbol = self.element_symbol() assert expr.dtype == element_symbol.dtype exists = Exists(condition.func(*condition.args), (variables, Equality(expr, element_symbol))) return ForAll(exists, (element_symbol, self))
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 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) w = Symbol.w(integer=True, shape=(n, n, n, n), definition=LAMBDA[j:n, i:n](Swap(n, i, j))) k = Symbol.k(integer=True) given = ForAll[x:S](Contains(LAMBDA[k:n](x[(w[i, j] @ LAMBDA[k:n](k))[k]]), S)) Eq.P_definition, Eq.w_definition, Eq.swap, Eq.axiom = apply(given) Eq << algebre.matrix.elementary.swap.identity.apply(x, w) Eq << Eq.swap.subs(Eq[-1]) Eq << swapn.permutation.apply(Eq[-1])
def as_image_set(self): try: expr, variable, base_set = self.base_set.image_set() from sympy import sets condition = Contains(variable, base_set).simplify() & self.condition._subs(self.variable, expr) return sets.image_set(expr, variable, ConditionSet(variable, condition)) except: ...
def apply(given, t): assert given.is_Contains e, interval = given.args a, b, _ = interval.args return Contains(e + t, interval.copy(start=a + t, stop=b + t), given=given)
def pmf(self, x): n, p = self.n, self.p x = sympify(x) if not (x.is_number or x.is_Symbol or is_random(x)): raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " "'RandomSymbol' not %s" % (type(x))) cond = Ge(x, 0) & Le(x, n) & Contains(x, S.Integers) return Piecewise((binomial(n, x) * p**x * (1 - p)**(n - x), cond), (S.Zero, True))
def test_GammaProcess_numeric(): t, d, x, y = symbols('t d x y', positive=True) X = GammaProcess("X", 1, 2) assert X.state_space == Interval(0, oo) assert X.index_set == Interval(0, oo) assert X.lamda == 1 assert X.gamma == 2 raises(ValueError, lambda: GammaProcess("X", -1, 2)) raises(ValueError, lambda: GammaProcess("X", 0, -2)) raises(ValueError, lambda: GammaProcess("X", -1, -2)) # all are independent because of non-overlapping intervals assert P((X(t) > 4) & (X(d) > 3) & (X(x) > 2) & (X(y) > 1), Contains(t, Interval.Lopen(0, 1)) & Contains(d, Interval.Lopen(1, 2)) & Contains(x, Interval.Lopen(2, 3)) & Contains(y, Interval.Lopen(3, 4))).simplify() == \ 120*exp(-10) # Check working with Not and Or assert P( Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) & Contains(d, Interval.Lopen( 7, 8))).simplify() == -4 * exp(-3) + 472 * exp(-8) / 3 + 1 assert P((X(t) > 2) | (X(t) < 4), Contains(t, Interval.Ropen(1, 4))).simplify() == \ -643*exp(-4)/15 + 109*exp(-2)/15 + 1 assert E(X(t)) == 2 * t # E(X(t)) == gamma*t/l assert E(X(2) + x * E(X(5))) == 10 * x + 4
def apply(*given): contains, subset = given if contains.is_Subset: subset, contains = given assert contains.is_Contains and subset.is_Subset x, A = contains.args _A, B = subset.args assert A == _A return Contains(x, B, given=given)
def apply(given, limit): assert given.is_Contains k, a, b = limit e, A = given.args assert Interval(a, b, integer=True) in A.domain_defined(k) return Contains(e, INTERSECTION[k:a:b](A), given=given)
def prove(Eq): x = Symbol.x(integer=True) given = Contains(x, {0, 1}) Eq << apply(given) Eq << Eq[-1].this.lhs.as_Piecewise() Eq << Eq[-1].as_Or()
def prove(Eq): e = Symbol.e(integer=True) s = Symbol.s(dtype=dtype.integer) contains = Contains(e, s, evaluate=False) Eq << apply(contains) assert Eq[0].plausible is None Eq << Eq[-1].definition
def prove(Eq): n = Symbol.n(integer=True, positive=True) x = Symbol.x(complex=True, shape=(n,)) A = Symbol.A(dtype=dtype.complex * n) B = Symbol.B(dtype=dtype.complex * n) Eq << apply(Contains(x, A), Subset(A, B)) # Eq <<= Eq[0] & Eq[1] Eq <<= Eq[1] & Eq[0]
def apply(given, var=None): assert given.is_Equality S_abs, one = given.args assert S_abs.is_Abs and one == 1 S = S_abs.arg assert S.is_set if var is None: var = S.element_symbol() assert not var.is_set return Contains(Sum[var:S](var), S, given=given)
def apply(*given): notcontains1, notcontains2 = given assert notcontains1.is_Contains assert notcontains2.is_Contains e, A = notcontains1.args _e, B = notcontains2.args assert e == _e return Contains(e, A & B, given=given)