def test_solve_poly_inequaltiy_neg_inf():
assert solve_poly_inequality(x**2 - 10 * x + 100, -oo, True) is EmptySet
assert solve_poly_inequality(x**2 - 10 * x + 100, -oo, False) is EmptySet
assert solve_poly_inequality(x**3 - 10 * x, -oo, True) is EmptySet
assert solve_poly_inequality(x**3 - 10 * x, -oo, False) == FiniteReal(-oo)
assert solve_poly_inequality(-x**2 + 10 * x + 100, -oo, True) is EmptySet
assert solve_poly_inequality(-x**2 + 10 * x + 100, -oo,
False) == FiniteReal(-oo, oo)
def test_solve_poly_inequaltiy_pos_inf():
assert solve_poly_inequality(x**2 - 10 * x + 100, oo, True) == Reals
assert solve_poly_inequality(x**2 - 10 * x + 100, oo, False) == ExtReals
assert solve_poly_inequality(-x**3 + 10 * x, oo, False) == ExtReals
assert solve_poly_inequality(-x**3 + 10 * x, oo,
True) == Reals | FiniteReal(oo)
assert solve_poly_inequality(x**3 - 10 * x, oo, False) == ExtReals
assert solve_poly_inequality(x**3 - 10 * x, oo,
True) == Reals | FiniteReal(-oo)
def test_event_containment_union():
assert (X << (Interval(0, 1) | Interval(2, 3))) \
== (((0 <= X) <= 1) | ((2 <= X) <= 3))
assert (X << (FiniteReal(0, 1) | Interval(2, 3))) \
== ((X << {0, 1}) | ((2 <= X) <= 3))
assert (X << FiniteNominal('a', b=True)) \
== EventFiniteNominal(X, FiniteNominal('a', b=True))
assert X << EmptySet == EventFiniteReal(X, EmptySet)
# Ordering is not guaranteed.
a = X << (Interval(0,1) | (FiniteReal(1.5) | FiniteNominal('a')))
assert len(a.subexprs) == 3
assert EventInterval(X, Interval(0,1)) in a.subexprs
assert EventFiniteReal(X, FiniteReal(1.5)) in a.subexprs
assert EventFiniteNominal(X, FiniteNominal('a')) in a.subexprs
def test_solver_finite_symbolic():
# Transform can never be symbolic.
event = Y << {'a', 'b'}
assert event.solve() == FiniteNominal('a', 'b')
# Complement the Identity.
event = ~(Y << {'a', 'b'})
assert event.solve() == FiniteNominal('a', 'b', b=True)
# Transform can never be symbolic.
event = Y**2 << {'a', 'b'}
assert event.solve() is EmptySet
# Complement the Identity.
event = ~(Y**2 << {'a', 'b'})
assert event.solve() == FiniteNominal(b=True)
# Solve Identity mixed.
event = Y << {9, 'a', '7'}
assert event.solve() == Union(
FiniteReal(9),
FiniteNominal('a', '7'))
# Solve Transform mixed.
event = Y**2 << {9, 'a', 'b'}
assert event.solve() == FiniteReal(-3, 3)
# Solve a disjunction.
event = (Y << {'a', 'b'}) | (Y << {'c'})
assert event.solve() == FiniteNominal('a', 'b', 'c')
# Solve a conjunction with intersection.
event = (Y << {'a', 'b'}) & (Y << {'b', 'c'})
assert event.solve() == FiniteNominal('b')
# Solve a conjunction with no intersection.
event = (Y << {'a', 'b'}) & (Y << {'c'})
assert event.solve() is EmptySet
# Solve a disjunction with complement.
event = (Y << {'a', 'b'}) & ~(Y << {'c'})
assert event.solve() == FiniteNominal('a', 'b')
# Solve a disjunction with complement.
event = (Y << {'a', 'b'}) | ~(Y << {'c'})
assert event.solve() == FiniteNominal('c', b=True)
# Union of interval and symbolic.
event = (Y**2 <= 9) | (Y << {'a'})
assert event.solve() == Interval(-3, 3) | FiniteNominal('a')
# Union of interval and not symbolic.
event = (Y**2 <= 9) | ~(Y << {'a'})
assert event.solve() == Interval(-3, 3) | FiniteNominal('a', b=True)
# Intersection of interval and symbolic.
event = (Y**2 <= 9) & (Y << {'a'})
assert event.solve() is EmptySet
# Intersection of interval and not symbolic.
event = (Y**2 <= 9) & ~(Y << {'a'})
assert event.solve() == EmptySet
def test_event_containment_real():
assert (X << Interval(0, 10)) == EventInterval(X, Interval(0, 10))
for values in [FiniteReal(0, 10), [0, 10], {0, 10}]:
assert (X << values) == EventFiniteReal(X, FiniteReal(0, 10))
# with pytest.raises(ValueError):
# X << {1, None}
assert X << {1, 2} == EventFiniteReal(X, {1, 2})
assert ~(X << {1, 2}) == EventOr([
EventInterval(X, Interval.Ropen(-oo, 1)),
EventInterval(X, Interval.open(1, 2)),
EventInterval(X, Interval.Lopen(2, oo)),
])
# https://github.com/probcomp/sum-product-dsl/issues/22
# and of EventBasic does not yet perform simplifications.
assert ~(~(X << {1, 2})) == \
((1 <= X) & ((X <= 1) | (2 <= X)) & (X <= 2))
def test_solver_finite_non_injective():
sqrt2 = sympy.sqrt(2)
# Abs.
solution = FiniteReal(-10, -3, 3, 10)
event = abs(Y) << {10, 3}
assert event.solve() == solution
# Abs(Poly).
solution = FiniteReal(-5, -Rat(3,2), Rat(3,2), 5)
event = abs(2*Y) << {10, 3}
assert event.solve() == solution
# Poly order 2.
solution = FiniteReal(-sqrt2, sqrt2)
event = (Y**2) << {2}
assert event.solve() == solution
# Poly order 3.
solution = FiniteReal(1, 3)
event = Y**3 << {1, 27}
assert event.solve() == solution
# Poly Abs.
solution = FiniteReal(-3, -1, 1, 3)
event = (abs(Y))**3 << {1, 27}
assert event.solve() == solution
# Abs Not.
solution = Union(
Interval.open(-oo, -1),
Interval.open(-1, 1),
Interval.open(1, oo))
event = ~(abs(Y) << {1})
assert event.solve() == solution
# Abs in EmptySet.
solution = EmptySet
event = (abs(Y))**3 << set()
assert event.solve() == solution
# Abs Not in EmptySet (yields all reals).
solution = Interval(-oo, oo)
event = ~(((abs(Y))**3) << set())
assert event.solve() == solution
# Log in Reals (yields positive reals).
solution = Interval.open(0, oo)
event = ~((Log(Y))**3 << set())
assert event.solve() == solution
def test_solver_finite_injective():
sqrt3 = sympy.sqrt(3)
# Identity.
solution = FiniteReal(2, 4, -10, sqrt3)
event = Y << {2, 4, -10, sqrt3}
assert event.solve() == solution
# Exp.
solution = FiniteReal(sympy.log(10), sympy.log(3), sympy.log(sqrt3))
event = Exp(Y) << {10, 3, sqrt3}
assert event.solve() == solution
# Exp2.
solution = FiniteReal(sympy.log(10, 2), 4, sympy.log(sqrt3, 2))
event = (2**Y) << {10, 16, sqrt3}
assert event.solve() == solution
# Log.
solution = FiniteReal(sympy.exp(10), sympy.exp(-3), sympy.exp(sqrt3))
event = Log(Y) << {10, -3, sqrt3}
assert event.solve() == solution
# Log2
solution = FiniteReal(sympy.Pow(2, 10), sympy.Pow(2, -3), sympy.Pow(2, sqrt3))
event = Logarithm(Y, 2) << {10, -3, sqrt3}
assert event.solve() == solution
# Radical.
solution = FiniteReal(7**4, 12**4, sqrt3**4)
event = Y**Rat(1, 4) << {7, 12, sqrt3}
assert event.solve() == solution
def test_event_inequality_parse():
assert (5 < (X < 10)) \
== ((5 < X) < 10) \
== EventInterval(X, Interval.open(5, 10))
assert (5 <= (X < 10)) \
== ((5 <= X) < 10) \
== EventInterval(X, Interval.Ropen(5, 10))
assert (5 < (X <= 10)) \
== ((5 < X) <= 10) \
== EventInterval(X, Interval.Lopen(5, 10))
assert (5 <= (X <= 10)) \
== ((5 <= X) <= 10) \
== EventInterval(X, Interval(5, 10))
# GOTCHA: This expression is syntactically equivalent to
# (5 < X) and (X < 10)
# Since and short circuits and 5 < X is not False,
# return value of expression is X < 10
assert (5 < X < 10) == (X < 10)
# Yields a finite set .
assert ((5 < X) < 5) == EventFiniteReal(X, EmptySet)
assert ((5 < X) <= 5) == EventFiniteReal(X, EmptySet)
assert ((5 <= X) < 5) == EventFiniteReal(X, EmptySet)
assert ((5 <= X) <= 5) == EventFiniteReal(X, FiniteReal(5))
# Negated single interval.
assert ~(5 < X) == (X <= 5)
assert ~(5 <= X) == (X < 5)
assert ~(X < 5) == (5 <= X)
assert ~(X <= 5) == (5 < X)
# Negated union of two intervals.
assert ~(5 < (X < 10)) \
== ~((5 < X) < 10) \
== (X <= 5) | (10 <= X)
assert ~(5 <= (X < 10)) \
== ~((5 <= X) < 10) \
== (X < 5) | (10 <= X)
assert ~(5 < (X <= 10)) \
== ~((5 < X) <= 10) \
== (X <= 5) | (10 < X)
assert ~(5 <= (X <= 10)) \
== ~((5 <= X) <= 10) \
== (X < 5) | (10 < X)
assert ~((10 < X) < 5) \
== ~(10 < (X < 5)) \
== EventInterval(X, Interval(-oo, oo))
# A complicated negated union.
assert ((~(X < 5)) < 10) \
== ((5 <= X) < 10) \
== EventInterval(X, Interval.Ropen(5, 10))
def test_solve_poly_equality_cubic_int_zero():
roots = solve_poly_equality(expr_cubic_int, 0)
assert roots == FiniteReal(-2, 1, 11)
def test_solve_poly_equality_quadratic_zero():
roots = solve_poly_equality(expr_quadratic, 0)
assert roots == FiniteReal(SymSqrt(2) / 10, -Rational(10, 7))
def test_solver_2_closed():
# (log(x) <= 2) & (x >= exp(2))
solution = FiniteReal(sympy.exp(2))
event = (Log(Y) >= 2) & (Y <= sympy.exp(2))
answer = event.solve()
assert answer == solution
def test_event_containment_string():
assert str(X << [10, 1]) == 'X << {1, 10}'
assert str(X << {1, 2}) == 'X << {1, 2}'
assert str(X << FiniteReal(1, 11)) == 'X << {1, 11}'
syms = get_symbols((X0 > 3) & (X1 < 4))
assert len(syms) == 2
assert X0 in syms
assert X1 in syms
syms = get_symbols((SymExp(X0) > SymLog(X1)+10) & (X2 < 4))
assert len(syms) == 3
assert X0 in syms
assert X1 in syms
assert X2 in syms
@pytest.mark.parametrize('a, b', [
([0, 1, 2, 3], [[0], [1], [2], [3]]),
([0, 1, 2, 1], [[0], [1, 3], [2]]),
(['0', '0', 2, '0'], [[0, 1, 3], [2]]),
])
def test_partition_list_blocks(a, b):
solution = partition_list_blocks(a)
assert solution == b
@pytest.mark.parametrize('a, b', [
(FiniteReal(0,1,2), [FiniteReal(0,1,2)]),
(FiniteReal(0,3,1,2), [FiniteReal(0,1,2,3)]),
(FiniteReal(-1,3,1,2), [FiniteReal(-1), FiniteReal(1,2,3)]),
(FiniteReal(-1,3,1,2,-2,-7), [FiniteReal(-7), FiniteReal(-1,-2), FiniteReal(1,2,3)]),
(FiniteReal(-1,3,1,2,-2,-7,0), [FiniteReal(-7), FiniteReal(-2,-1,0,1,2,3)]),
])
def test_parition_finite_real_contiguous(a, b):
solution = partition_finite_real_contiguous(a)
assert solution == b