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(X(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)
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 test_WienerProcess():
X = WienerProcess("X")
assert X.state_space == S.Reals
assert X.index_set == Interval(0, oo)
t, d, x, y = symbols('t d x y', positive=True)
assert isinstance(X(t), RandomIndexedSymbol)
assert X.distribution(t) == NormalDistribution(0, sqrt(t))
raises(ValueError, lambda: PoissonProcess("X", -1))
raises(NotImplementedError, lambda: X[t])
raises(IndexError, lambda: X(-2))
assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(
Lambda((X(2), X(3)),
sqrt(6) * exp(-X(2)**2 / 4) * exp(-X(3)**2 / 6) / (12 * pi)))
assert X.joint_distribution(4, 6) == JointDistributionHandmade(
Lambda((X(4), X(6)),
sqrt(6) * exp(-X(4)**2 / 8) * exp(-X(6)**2 / 12) / (24 * pi)))
assert P(X(t) < 3).simplify() == erf(3 * sqrt(2) /
(2 * sqrt(t))) / 2 + S(1) / 2
assert P(X(t) > 2, Contains(t, Interval.Lopen(3, 7))).simplify() == S(1)/2 -\
erf(sqrt(2)/2)/2
# Equivalent to P(X(1)>1)**4
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() ==\
(1 - erf(sqrt(2)/2))*(1 - erf(sqrt(2)))*(1 - erf(3*sqrt(2)/2))*(1 - erf(2*sqrt(2)))/16
# Contains an overlapping interval so, return Probability
assert P((X(t) < 2) & (X(d) > 3),
Contains(t, Interval.Lopen(0, 2))
& Contains(d, Interval.Ropen(2, 4))) == Probability(
(X(d) > 3) & (X(t) < 2),
Contains(d, Interval.Ropen(2, 4))
& Contains(t, Interval.Lopen(0, 2)))
assert str(P(Not((X(t) < 5) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) &
Contains(d, Interval.Lopen(7, 8))).simplify()) == \
'-(1 - erf(3*sqrt(2)/2))*(2 - erfc(5/2))/4 + 1'
# Distribution has mean 0 at each timestamp
assert E(X(t)) == 0
assert E(
x * (X(t) + X(d)) * (X(t)**2 + X(d)**2),
Contains(t, Interval.Lopen(0, 1))
& Contains(d, Interval.Ropen(1, 2))) == Expectation(
x * (X(d) + X(t)) * (X(d)**2 + X(t)**2),
Contains(d, Interval.Ropen(1, 2))
& Contains(t, Interval.Lopen(0, 1)))
assert E(X(t) + x * E(X(3))) == 0
#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_trig_inequalities():
# all the inequalities are solved in a periodic interval.
assert isolve(sin(x) < S.Half, x, relational=False) == Union(
Interval(0, pi / 6, False, True),
Interval(pi * Rational(5, 6), 2 * pi, True, False),
)
assert isolve(sin(x) > S.Half, x, relational=False) == Interval(
pi / 6, pi * Rational(5, 6), True, True
)
assert isolve(cos(x) < S.Zero, x, relational=False) == Interval(
pi / 2, pi * Rational(3, 2), True, True
)
assert isolve(cos(x) >= S.Zero, x, relational=False) == Union(
Interval(0, pi / 2), Interval(pi * Rational(3, 2), 2 * pi)
)
assert isolve(tan(x) < S.One, x, relational=False) == Union(
Interval.Ropen(0, pi / 4), Interval.Lopen(pi / 2, pi)
)
assert isolve(sin(x) <= S.Zero, x, relational=False) == Union(
FiniteSet(S.Zero), Interval(pi, 2 * pi)
)
assert isolve(sin(x) <= S.One, x, relational=False) == S.Reals
assert isolve(cos(x) < S(-2), x, relational=False) == S.EmptySet
assert isolve(sin(x) >= S.NegativeOne, x, relational=False) == S.Reals
assert isolve(cos(x) > S.One, x, relational=False) == S.EmptySet
def test_sympy_range_to_isabelle():
from sympy import Dummy, ImageSet, Lambda, S, pi
from sympy.sets import Interval
_n = Dummy("n")
assert_equals(
sympy_range_to_isabelle(
ImageSet(Lambda(_n, 2 * _n * pi + pi / 2), S.Integers)),
"{pi*1/2+pi*n*2|n. n \<in> Ints}")
assert_equals(sympy_range_to_isabelle(Interval.Lopen(1, 2)), "{1<..2}")
assert_equals(sympy_range_to_isabelle(S.Reals), "UNIV")
def test_PoissonProcess():
X = PoissonProcess("X", 3)
assert X.state_space == S.Naturals0
assert X.index_set == Interval(0, oo)
assert X.lamda == 3
t, d, x, y = symbols('t d x y', positive=True)
assert isinstance(X(t), RandomIndexedSymbol)
assert X.distribution(X(t)) == PoissonDistribution(3 * t)
raises(ValueError, lambda: PoissonProcess("X", -1))
raises(NotImplementedError, lambda: X[t])
raises(IndexError, lambda: X(-5))
assert X.joint_distribution(X(2), X(3)) == JointDistributionHandmade(
Lambda((X(2), X(3)), 6**X(2) * 9**X(3) * exp(-15) /
(factorial(X(2)) * factorial(X(3)))))
assert X.joint_distribution(4, 6) == JointDistributionHandmade(
Lambda((X(4), X(6)), 12**X(4) * 18**X(6) * exp(-30) /
(factorial(X(4)) * factorial(X(6)))))
assert P(X(t) < 1) == exp(-3 * t)
assert P(Eq(X(t), 0),
Contains(t, Interval.Lopen(3, 5))) == exp(-6) # exp(-2*lamda)
res = P(Eq(X(t), 1), Contains(t, Interval.Lopen(3, 4)))
assert res == 3 * exp(-3)
# Equivalent to P(Eq(X(t), 1))**4 because of non-overlapping intervals
assert P(
Eq(X(t), 1) & Eq(X(d), 1) & Eq(X(x), 1) & Eq(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))) == res**4
# Return Probability because of overlapping intervals
assert P(Eq(X(t), 2) & Eq(X(d), 3), Contains(t, Interval.Lopen(0, 2))
& Contains(d, Interval.Ropen(2, 4))) == \
Probability(Eq(X(d), 3) & Eq(X(t), 2), Contains(t, Interval.Lopen(0, 2))
& Contains(d, Interval.Ropen(2, 4)))
raises(ValueError, lambda: P(
Eq(X(t), 2) & Eq(X(d), 3),
Contains(t, Interval.Lopen(0, 4)) & Contains(d, Interval.Lopen(3, oo)))
) # no bound on d
assert P(Eq(X(3), 2)) == 81 * exp(-9) / 2
assert P(Eq(X(t), 2), Contains(t, Interval.Lopen(0,
5))) == 225 * exp(-15) / 2
# Check that probability works correctly by adding it to 1
res1 = P(X(t) <= 3, Contains(t, Interval.Lopen(0, 5)))
res2 = P(X(t) > 3, Contains(t, Interval.Lopen(0, 5)))
assert res1 == 691 * exp(-15)
assert (res1 + res2).simplify() == 1
# Check Not and Or
assert P(Not(Eq(X(t), 2) & (X(d) > 3)), Contains(t, Interval.Ropen(2, 4)) & \
Contains(d, Interval.Lopen(7, 8))).simplify() == -18*exp(-6) + 234*exp(-9) + 1
assert P(Eq(X(t), 2) | Ne(X(t), 4),
Contains(t, Interval.Ropen(2, 4))) == 1 - 36 * exp(-6)
raises(ValueError, lambda: P(X(t) > 2, X(t) + X(d)))
assert E(
X(t)) == 3 * t # property of the distribution at a given timestamp
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))) == 75
assert E(X(t)**2, Contains(t, Interval.Lopen(0, 1))) == 12
assert E(x*(X(t) + X(d))*(X(t)**2+X(d)**2), Contains(t, Interval.Lopen(0, 1))
& Contains(d, Interval.Ropen(1, 2))) == \
Expectation(x*(X(d) + X(t))*(X(d)**2 + X(t)**2), Contains(t, Interval.Lopen(0, 1))
& Contains(d, Interval.Ropen(1, 2)))
# Value Error because of infinite time bound
raises(ValueError, lambda: E(X(t)**3, Contains(t, Interval.Lopen(1, oo))))
# Equivalent to E(X(t)**2) - E(X(d)**2) == E(X(1)**2) - E(X(1)**2) == 0
assert E((X(t) + X(d)) * (X(t) - X(d)),
Contains(t, Interval.Lopen(0, 1))
& Contains(d, Interval.Lopen(1, 2))) == 0
assert E(X(2) + x * E(X(5))) == 15 * x + 6
assert E(x * X(1) + y) == 3 * x + y
assert P(Eq(X(1), 2) & Eq(X(t), 3),
Contains(t, Interval.Lopen(1, 2))) == 81 * exp(-6) / 4
Y = PoissonProcess("Y", 6)
Z = X + Y
assert Z.lamda == X.lamda + Y.lamda == 9
raises(ValueError,
lambda: X + 5) # should be added be only PoissonProcess instance
N, M = Z.split(4, 5)
assert N.lamda == 4
assert M.lamda == 5
raises(ValueError, lambda: Z.split(3, 2)) # 2+3 != 9
raises(
ValueError, lambda: P(Eq(X(t), 0),
Contains(t, Interval.Lopen(1, 3)) & Eq(X(1), 0)))
# check if it handles queries with two random variables in one args
res1 = P(Eq(N(3), N(5)))
assert res1 == P(Eq(N(t), 0), Contains(t, Interval(3, 5)))
res2 = P(N(3) > N(1))
assert res2 == P((N(t) > 0), Contains(t, Interval(1, 3)))
assert P(N(3) < N(1)) == 0 # condition is not possible
res3 = P(N(3) <= N(1)) # holds only for Eq(N(3), N(1))
assert res3 == P(Eq(N(t), 0), Contains(t, Interval(1, 3)))
# tests from https://www.probabilitycourse.com/chapter11/11_1_2_basic_concepts_of_the_poisson_process.php
X = PoissonProcess('X', 10) # 11.1
assert P(Eq(X(S(1) / 3), 3)
& Eq(X(1), 10)) == exp(-10) * Rational(8000000000, 11160261)
assert P(Eq(X(1), 1), Eq(X(S(1) / 3), 3)) == 0
assert P(Eq(X(1), 10), Eq(X(S(1) / 3), 3)) == P(Eq(X(S(2) / 3), 7))
X = PoissonProcess('X', 2) # 11.2
assert P(X(S(1) / 2) < 1) == exp(-1)
assert P(X(3) < 1, Eq(X(1), 0)) == exp(-4)
assert P(Eq(X(4), 3), Eq(X(2), 3)) == exp(-4)
X = PoissonProcess('X', 3)
assert P(Eq(X(2), 5) & Eq(X(1), 2)) == Rational(81, 4) * exp(-6)
# check few properties
assert P(
X(2) <= 3,
X(1) >= 1) == 3 * P(Eq(X(1), 0)) + 2 * P(Eq(X(1), 1)) + P(Eq(X(1), 2))
assert P(X(2) <= 3, X(1) > 1) == 2 * P(Eq(X(1), 0)) + 1 * P(Eq(X(1), 1))
assert P(Eq(X(2), 5) & Eq(X(1), 2)) == P(Eq(X(1), 3)) * P(Eq(X(1), 2))
assert P(Eq(X(3), 4), Eq(X(1), 3)) == P(Eq(X(2), 1))
domain = Interval.Lopen(1, 4)
e = (post(n * x) * u(W) > u(c / x)).subs(x, 5).subs(n, 6).subs(W, 50)
solve_univariate_inequality(e, rho, domain=domain)
c = exp(post(n) * log(W))
from sympy import Interval
rho = Symbol('rho')
x, n, W = symbols('x n W')
e = (n / ((2 + n * x)**2)) * (1 / (rho - 1)) <= 1 / (x**rho)
from sympy import Union
domain = Union(Interval.Ropen(-50, 1), Interval.Lopen(1, 4))
solve_univariate_inequality(e.subs(n, 6).subs(x, 50), rho, domain=domain)
solveset(e, rho, domain=domain)
c = np.exp(post(n) * np.log(W))
np.log(c / x)
post(n * x) * np.log(W)
##################################
# implicit H/L game solution -- WRONG
##################################
t, N, n = symbols('t N n')
def p_hat(n, t, prior=.5):