def test_predicate_extensions(): lang = tarski.language() pred = lang.predicate('pred', lang.Object, lang.Object) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) model = Model(lang) with pytest.raises(errors.ArityMismatch): # This should raise an error, as the predicate is binary model.add(pred) with pytest.raises(ValueError): # This should raise an error, as the predicate sort does not coincide with the sort of the parameters model.add(pred, 1, 2) model.add(pred, o1, o2) assert not model.holds(pred, (o2, o1)) # Make sure the order in which the elements were added is respected! assert model.holds(pred, (o1, o2)) with pytest.raises(KeyError): # This should raise an error, as the tuple does not belong to the predicate's extension model.remove(pred, o2, o1) model.remove(pred, o1, o2) with pytest.raises(KeyError): # This should raise an error, as the tuple has been removed model.remove(pred, o1, o2)
def test_resource_lock_creation(): with pytest.raises(temporal.NDLSyntaxError): req = temporal.ResourceLock(**{ "ts": 0.0, "td": 1.0, "r": None }) L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC]) sensor_sort = L.sort('sensor') camera, range, bearing = [L.constant(name, sensor_sort) for name in ('camera', 'range', 'bearing')] int_t = L.Integer engaged = L.function('engaged', sensor_sort, int_t) req_1 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(camera) }) req_2 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(range) }) req_3 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(bearing) })
def test_model_list_extensions(): lang = tarski.language(theories=[]) p = lang.predicate('p', lang.Object, lang.Object) f = lang.function('f', lang.Object, lang.Object) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) model = Model(lang) model.evaluator = evaluate model.set(f, o1, o2) model.add(p, o1, o2) extensions = model.list_all_extensions() ext_f = extensions[f.signature] ext_p = extensions[p.signature] # We want to test that the `list_all_extensions` method correctly unwraps all TermReferences in the internal # representation of the model and returns _only_ actual Tarski terms. Testing this is a bit involved, as of # course we cannot just check for (o1, o2) in ext_f, because that will trigger the wrong __eq__ and __hash__ # methods - in other words, to test this we precisely need to wrap things back into TermReferences, so that we can # compare them properly assert len(ext_f) == 1 and len(ext_p) == 1 p, v = ext_f[0] assert TermReference(p) == TermReference(o1) and TermReference(v) == TermReference(o2) v1, v2 = ext_p[0] assert TermReference(v1) == TermReference(o1) and TermReference(v2) == TermReference(o2)
def test_matrix_evaluation_case_1(): from tarski.syntax.arithmetic import one lang = tarski.language('double_integrator', [Theory.EQUALITY, Theory.ARITHMETIC]) I = lang.matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], lang.Real) x0 = Model(lang) x0.evaluator = evaluate assert x0[I][0, 0].is_syntactically_equal(one(lang.Real))
def test_matrices_constants(): lang = tsk.language('test', [Theory.EQUALITY, Theory.ARITHMETIC]) A = lang.matrix([[0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]], lang.Real) assert isinstance(A, Matrix) N, M = A.shape for i in range(N): for j in range(M): assert isinstance(A.matrix[i, j], Term)
def test_zero_ary_predicate_set(): L = tarski.language() P = L.predicate('P') M = Model(L) M.add(P) assert evaluate(P(), M) is True
def create_small_world(): lang = tsk.language("TarskiWorld", theories=[Theory.EQUALITY]) lang.Cube = lang.predicate('Cube', lang.Object) lang.Tet = lang.predicate('Tet', lang.Object) lang.LeftOf = lang.predicate('LeftOf', lang.Object, lang.Object) lang.Dodec = lang.predicate('Dodec', lang.Object) lang.BackOf = lang.predicate('BackOf', lang.Object, lang.Object) return lang
def test_resource_level_creation(): L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC]) platform_t = L.sort('platform') rov1 = L.constant('rov1', platform_t) int_t = L.Integer direction = L.function('direction', platform_t, int_t) req_1 = temporal.ResourceLevel(**{ "ts": 0.0, "td": 20.0, "r": direction(rov1), "n": L.constant(0, int_t) })
def test_term_refs(): lang = tsk.language() _ = lang.function('f', lang.Object, lang.Integer) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) tr1 = symref(o1) tr2 = symref(o1) tr3 = symref(o2) assert tr1 == tr2 assert tr1 != tr3
def test_term_refs_compound(): lang = tsk.language() f = lang.function('f', lang.Object, lang.Integer) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) _ = lang.get('f') t1 = f(o1) t2 = f(o1) t3 = f(o2) assert t1.symbol == t2.symbol tr1 = symref(t1) tr2 = symref(t2) tr3 = symref(t3) assert tr1 == tr2 assert tr1 != tr3
def test_predicate_without_equality(): lang = tarski.language(theories=[]) leq = lang.predicate('leq', lang.Integer, lang.Integer) f = lang.function('f', lang.Object, lang.Integer) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) model = Model(lang) model.evaluator = evaluate model.set(f, o1, 1) model.set(f, o2, 2) for x in range(0, 5): for y in range(x, 5): model.add(leq, x, y) assert model[leq(f(o1), f(o2))] is True assert model[leq(f(o2), f(o1))] is False
def test_action_creation(): L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC]) int_t = L.Integer platform_t = L.sort('platform') rov1 = L.constant('rov1', platform_t) direction = L.function('direction', platform_t, int_t) sensor_sort = L.sort('sensor') camera, range, bearing = [ L.constant(name, sensor_sort) for name in ('camera', 'range', 'bearing') ] engaged = L.function('engaged', sensor_sort, int_t) region_t = L.sort('region') p0 = L.constant('p0', region_t) position = L.predicate('position', platform_t, region_t) observed = L.predicate('observed', region_t) req_1 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(camera) }) req_2 = temporal.ResourceLevel(**{ "ts": 0.0, "td": 20.0, "r": direction(rov1), "n": L.constant(0, int_t) }) act = temporal.Action(name='observe_poi', precondition=position(rov1, p0), requirements=[req_1, req_2], effects=[(21.0, observed(p0))]) assert len(act.locks) == 1 assert len(act.levels) == 1 assert len(act.effects) == 1
def test_matrix_evaluation_case_2(): lang = tarski.language('double_integrator', [Theory.EQUALITY, Theory.ARITHMETIC]) I = lang.matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], lang.Real) x = lang.function('x', lang.Real) y = lang.function('y', lang.Real) z = lang.function('z', lang.Real) v = lang.vector([x(), y(), z()], lang.Real) x0 = Model(lang) x0.evaluator = evaluate x0.setx(x(), 1.0) x0.setx(y(), 2.0) x0.setx(z(), 3.0) # print(x0[I @ v][2, 0]) assert x0[I @ v][2, 0].is_syntactically_equal(lang.constant(3.0, lang.Real))
def test_model_as_atoms(): lang = tarski.language(theories=[]) p = lang.predicate('p', lang.Object, lang.Object) f = lang.function('f', lang.Object, lang.Object) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) model = Model(lang) model.evaluator = evaluate model.set(f, o1, o2) model.add(p, o1, o2) atoms = model.as_atoms() patom, fatom = atoms assert patom.is_syntactically_equal(p(o1, o2)) term, value = fatom assert term.is_syntactically_equal( f(o1)) and value.is_syntactically_equal(o2)
def test_predicate_without_equality_reals(): import numpy lang = tarski.language(theories=[]) leq = lang.predicate('leq', lang.Real, lang.Real) w = lang.function('w', lang.Object, lang.Real) o1 = lang.constant("o1", lang.Object) o2 = lang.constant("o2", lang.Object) model = Model(lang) model.evaluator = evaluate model.setx(w(o1), 1.0) model.setx(w(o2), 2.0) for x in numpy.arange(0.0, 5.0): for y in numpy.arange(x, 5.0): model.add(leq, x, y) assert model[leq(w(o1), w(o2))] is True assert model[leq(w(o2), w(o1))] is False
def test_ite(): lang = tarski.language('arith', [Theory.EQUALITY, Theory.ARITHMETIC]) c = lang.constant(1, lang.Integer) x = lang.function('x', lang.Integer) y = lang.function('y', lang.Integer) phi = (x() <= y()) & (y() <= x()) t1 = x() + 2 t2 = y() + 3 tau = ite(phi, t1, t2) model = Model(lang) model.evaluator = evaluate model.setx(x(), 1) model.setx(y(), 2) assert model[tau].symbol == 5
def test_rddl_model_with_random_vars(): lang = tarski.language( 'lqg_nav_1d', [Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM]) the_task = Task(lang, 'lqg_nav_1d', 'instance_001') the_task.requirements = [ rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET ] the_task.parameters.discount = 1.0 the_task.parameters.horizon = 10 the_task.parameters.max_nondef_actions = 1 # variables x = lang.function('x', lang.Real) v = lang.function('v', lang.Real) u = lang.function('u', lang.Real) t = lang.function('t', lang.Real) # non fluents dt = lang.function('dt', lang.Real) gx = lang.function('gx', lang.Real) # Perturbation distribution parameters mu_w = lang.function('mu_w', lang.Real) sigma_w = lang.function('sigma_w', lang.Real) # cpfs the_task.add_cpfs(t(), t() + dt()) the_task.add_cpfs(v(), v() + dt() * u() + normal(mu_w(), sigma_w())) the_task.add_cpfs(x(), x() + dt() * v()) # constraints the_task.add_constraint((u() >= -1.0) & (u() <= 1.0), rddl.ConstraintType.ACTION) the_task.add_constraint((v() >= -5.0) & (v() <= 5.0), rddl.ConstraintType.STATE) the_task.add_constraint((x() >= -100.0) & (x() <= 100.0), rddl.ConstraintType.STATE) # cost function Q = (x() - gx()) * (x() - gx()) # MRJ: RDDL does not support the abs() algebraic construct R = ite( abs(x() - gx()) > 0.0, u() * u() * 0.01, lang.constant(0.0, lang.Real)) # R = u() * u() * 0.01 the_task.reward = Q + R # definitions the_task.x0.set(x(), 0.0) the_task.x0.set(v(), 0.0) the_task.x0.set(u(), 0.0) the_task.x0.set(t(), 0.0) the_task.x0.set(dt(), 0.5) the_task.x0.set(gx(), 20.0) the_task.x0.set(mu_w(), 0.0) the_task.x0.set(sigma_w(), 0.05) # fluent metadata the_task.declare_state_fluent(x(), 0.0) the_task.declare_state_fluent(t(), 0.0) the_task.declare_interm_fluent(v(), 1) the_task.declare_action_fluent(u(), 0.0) the_task.declare_non_fluent(dt(), 0.0) the_task.declare_non_fluent(gx(), 0.0) the_task.declare_non_fluent(mu_w(), 0.0) the_task.declare_non_fluent(sigma_w(), 0.0) the_writer = rddl.Writer(the_task) rddl_filename = os.path.join(tempfile.gettempdir(), 'lqg_nav_1d_001.rddl') the_writer.write_model(rddl_filename) mr_reader = rddl.Reader(rddl_filename) assert mr_reader.rddl_model is not None assert mr_reader.rddl_model.domain.name == 'lqg_nav_1d' mr_reader.translate_rddl_model() assert mr_reader.language is not None
def test_parametrized_model_with_random_vars_and_waypoints_boolean(): lang = tarski.language( 'lqg_nav_2d_multi_unit_bool_waypoints', [Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM]) the_task = Task(lang, 'lqg_nav_2d_multi_unit_bool_waypoints', 'instance_001') the_task.requirements = [ rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET ] the_task.parameters.discount = 1.0 the_task.parameters.horizon = 40 the_task.parameters.max_nondef_actions = 2 vehicle = lang.sort('vehicle', lang.Object) waypoint = lang.sort('waypoint', lang.Object) # variables x = lang.function('x', vehicle, lang.Real) y = lang.function('y', vehicle, lang.Real) wx = lang.function('wx', waypoint, lang.Real) wy = lang.function('wy', waypoint, lang.Real) vx = lang.function('vx', vehicle, lang.Real) vy = lang.function('vy', vehicle, lang.Real) ux = lang.function('ux', vehicle, lang.Real) uy = lang.function('uy', vehicle, lang.Real) t = lang.function('t', lang.Real) wv = lang.predicate('visited', waypoint) # objects v001 = lang.constant('v001', vehicle) p1 = lang.constant('p1', waypoint) p2 = lang.constant('p2', waypoint) p3 = lang.constant('p3', waypoint) # non fluents dt = lang.function('dt', lang.Real) wr = lang.function('waypoint_radius', lang.Real) # Perturbation distribution parameters mu_w = lang.function('mu_w', lang.Real) sigma_w = lang.function('sigma_w', lang.Real) # logical variable v = lang.variable('v', vehicle) wpt = lang.variable('wpt', waypoint) # cpfs the_task.add_cpfs(t(), t() + dt()) dist_vec_norm = ((x(v) - wx(wpt)) * (x(v) - wx(wpt))) + ((y(v) - wy(wpt)) * (y(v) - wy(wpt))) the_task.add_cpfs(wv(wpt), (wv(wpt) | (sqrt(dist_vec_norm) <= wr()))) the_task.add_cpfs(vx(v), vx(v) + dt() * ux(v) + normal(mu_w(), sigma_w())) the_task.add_cpfs(vy(v), vy(v) + dt() * uy(v) + normal(mu_w(), sigma_w())) the_task.add_cpfs(x(v), x(v) + dt() * vx(v)) the_task.add_cpfs(y(v), y(v) + dt() * vy(v)) # constraints the_task.add_constraint( forall(v, (ux(v) >= -1.0) & (ux(v) <= 1.0) & (uy(v) >= -1.0) & (uy(v) <= 1.0)), rddl.ConstraintType.ACTION) the_task.add_constraint( forall(v, (sqrt(vx(v) * vx(v) + vy(v) * vy(v)) <= 5.0)), rddl.ConstraintType.STATE) the_task.add_constraint(forall(v, (x(v) >= -100.0) & (x(v) <= 100.0)), rddl.ConstraintType.STATE) the_task.add_constraint(forall(v, (y(v) >= -100.0) & (y(v) <= 100.0)), rddl.ConstraintType.STATE) # cost function WV = sumterm( wpt, ite(wv(wpt), lang.constant(1.0, lang.Real), lang.constant(0.0, lang.Real))) # MRJ: RDDL does not support the abs() algebraic construct R = sumterm(v, (ux(v) * ux(v) * 0.01) + (uy(v) * uy(v) * 0.01)) # R = u() * u() * 0.01 the_task.reward = WV - R # definitions the_task.x0.set(x(v001), 0.0) the_task.x0.set(y(v001), 0.0) the_task.x0.set(vx(v001), 0.0) the_task.x0.set(vy(v001), 0.0) the_task.x0.set(ux(v001), 0.0) the_task.x0.set(uy(v001), 0.0) the_task.x0.set(wx(p1), 1.0) the_task.x0.set(wy(p1), -1.0) the_task.x0.set(wx(p2), 1.0) the_task.x0.set(wy(p2), 1.0) the_task.x0.set(wx(p3), 2.0) the_task.x0.set(wy(p3), 1.0) the_task.x0.set(t(), 0.0) the_task.x0.set(dt(), 0.5) the_task.x0.set(mu_w(), 0.0) the_task.x0.set(sigma_w(), 0.05) the_task.x0.set(wr(), 2.0) # fluent metadata the_task.declare_state_fluent(x(v), 0.0) the_task.declare_state_fluent(y(v), 0.0) the_task.declare_state_fluent(t(), 0.0) the_task.declare_state_fluent(wv(wpt), False) the_task.declare_interm_fluent(vx(v), 1) the_task.declare_interm_fluent(vy(v), 1) the_task.declare_action_fluent(ux(v), 0.0) the_task.declare_action_fluent(uy(v), 0.0) the_task.declare_non_fluent(dt(), 0.0) the_task.declare_non_fluent(mu_w(), 0.0) the_task.declare_non_fluent(sigma_w(), 0.0) the_task.declare_non_fluent(wx(wpt), 0.0) the_task.declare_non_fluent(wy(wpt), 0.0) the_task.declare_non_fluent(wr(), 0.0) the_writer = rddl.Writer(the_task) rddl_filename = os.path.join(tempfile.gettempdir(), 'lqg_nav_2d_multi_unit_bool_waypoints.rddl') the_writer.write_model(rddl_filename) mr_reader = rddl.Reader(rddl_filename) assert mr_reader.rddl_model is not None assert mr_reader.rddl_model.domain.name == 'lqg_nav_2d_multi_unit_bool_waypoints' mr_reader.translate_rddl_model() assert mr_reader.language is not None
def test_parametrized_model_with_random_vars(): lang = tarski.language( 'lqg_nav_2d_multi_unit', [Theory.EQUALITY, Theory.ARITHMETIC, Theory.SPECIAL, Theory.RANDOM]) the_task = Task(lang, 'lqg_nav_2d_multi_unit', 'instance_001') the_task.requirements = [ rddl.Requirements.CONTINUOUS, rddl.Requirements.REWARD_DET ] the_task.parameters.discount = 1.0 the_task.parameters.horizon = 10 the_task.parameters.max_nondef_actions = 1 vehicle = lang.sort('vehicle', lang.Object) # variables x = lang.function('x', vehicle, lang.Real) y = lang.function('y', vehicle, lang.Real) vx = lang.function('vx', vehicle, lang.Real) vy = lang.function('vy', vehicle, lang.Real) ux = lang.function('ux', vehicle, lang.Real) uy = lang.function('uy', vehicle, lang.Real) t = lang.function('t', lang.Real) # objects v001 = lang.constant('v001', vehicle) # non fluents dt = lang.function('dt', lang.Real) gx = lang.function('gx', lang.Real) gy = lang.function('gy', lang.Real) # Perturbation distribution parameters mu_w = lang.function('mu_w', lang.Real) sigma_w = lang.function('sigma_w', lang.Real) # logical variable v = lang.variable('v', vehicle) # cpfs the_task.add_cpfs(t(), t() + dt()) the_task.add_cpfs(vx(v), vx(v) + dt() * ux(v) + normal(mu_w(), sigma_w())) the_task.add_cpfs(vy(v), vy(v) + dt() * uy(v) + normal(mu_w(), sigma_w())) the_task.add_cpfs(x(v), x(v) + dt() * vx(v)) the_task.add_cpfs(y(v), y(v) + dt() * vy(v)) # constraints the_task.add_constraint( forall(v, (ux(v) >= -1.0) & (ux(v) <= 1.0) & (uy(v) >= -1.0) & (uy(v) <= 1.0)), rddl.ConstraintType.ACTION) the_task.add_constraint( forall(v, (sqrt(vx(v) * vx(v) + vy(v) * vy(v)) <= 5.0)), rddl.ConstraintType.STATE) the_task.add_constraint(forall(v, (x(v) >= -100.0) & (x(v) <= 100.0)), rddl.ConstraintType.STATE) the_task.add_constraint(forall(v, (y(v) >= -100.0) & (y(v) <= 100.0)), rddl.ConstraintType.STATE) # cost function Q = sumterm(v, ((x(v) - gx()) * (x(v) - gx())) + ((y(v) - gy()) * (y(v) * gy()))) # MRJ: RDDL does not support the abs() algebraic construct R = sumterm( v, ite( sqrt(vx(v) * vx(v) + vy(v) * vy(v)) > 0.0, (ux(v) * ux(v) * 0.01) + (uy(v) * uy(v) * 0.01), lang.constant(0.0, lang.Real))) # R = u() * u() * 0.01 the_task.reward = Q + R # definitions the_task.x0.set(x(v001), 0.0) the_task.x0.set(y(v001), 0.0) the_task.x0.set(vx(v001), 0.0) the_task.x0.set(vy(v001), 0.0) the_task.x0.set(ux(v001), 0.0) the_task.x0.set(uy(v001), 0.0) the_task.x0.set(t(), 0.0) the_task.x0.set(dt(), 0.5) the_task.x0.set(gx(), 20.0) the_task.x0.set(gy(), 20.0) the_task.x0.set(mu_w(), 0.0) the_task.x0.set(sigma_w(), 0.05) # fluent metadata the_task.declare_state_fluent(x(v), 0.0) the_task.declare_state_fluent(y(v), 0.0) the_task.declare_state_fluent(t(), 0.0) the_task.declare_interm_fluent(vx(v), 1) the_task.declare_interm_fluent(vy(v), 1) the_task.declare_action_fluent(ux(v), 0.0) the_task.declare_action_fluent(uy(v), 0.0) the_task.declare_non_fluent(dt(), 0.0) the_task.declare_non_fluent(gx(), 0.0) the_task.declare_non_fluent(gy(), 0.0) the_task.declare_non_fluent(mu_w(), 0.0) the_task.declare_non_fluent(sigma_w(), 0.0) the_writer = rddl.Writer(the_task) rddl_filename = os.path.join(tempfile.gettempdir(), 'lqg_nav_2d_multi_unit_001.rddl') the_writer.write_model(rddl_filename) mr_reader = rddl.Reader(rddl_filename) assert mr_reader.rddl_model is not None assert mr_reader.rddl_model.domain.name == 'lqg_nav_2d_multi_unit' mr_reader.translate_rddl_model() assert mr_reader.language is not None
def test_instance_creation(): L = tsk.language("mylang", theories=[Theory.EQUALITY, Theory.ARITHMETIC]) int_t = L.Integer obj_t = L.Object platform_t = L.sort('platform') rov1 = L.constant('rov1', platform_t) direction = L.function('direction', platform_t, int_t) sensor_sort = L.sort('sensor') camera, range, bearing = [L.constant(name, sensor_sort) for name in ('camera', 'range', 'bearing')] engaged = L.function('engaged', sensor_sort, int_t) region_t = L.sort('region') p0 = L.constant('p0', region_t) p1 = L.constant('p1', region_t) p2 = L.constant('p2', region_t) t0 = L.constant('t0', obj_t) t1 = L.constant('t1', obj_t) t2 = L.constant('t2', obj_t) #t0, t1, t2 = [L.constant('t{}'.format(i), obj_t) # for i in range(3)] position = L.predicate('position', obj_t, region_t) observed = L.predicate('observed', obj_t) estimated_range = L.predicate('estimated_range', obj_t) estimated_bearing = L.predicate('estimated_bearing', obj_t) req_1 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(camera) }) req_2 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(range) }) req_3 = temporal.ResourceLock(**{ "ts": 0.0, "td": 10.0, "r": engaged(bearing) }) req_4 = temporal.ResourceLevel(**{ "ts": 0.0, "td": 20.0, "r": direction(rov1), "n": L.constant(0, int_t) }) a1 = temporal.Action( name='localize_t0', parameters=[], precondition=position(rov1, p0), requirements=[ TimedEffect(0.0, req_2), TimedEffect(0.0, req_3)], timed_effects=[ TimedEffect(15.0, estimated_range(t0)), TimedEffect(20.0, estimated_bearing(t0))], untimed_effects=[] ) a2 = temporal.Action( name='observed_t0', parameters=[], precondition=land(position(rov1, p0), estimated_range(t0), estimated_bearing(t0)), requirements=[ TimedEffect(0.0, req_1), TimedEffect(0.0, req_2)], timed_effects=[ TimedEffect(21.0, observed(t0))], untimed_effects=[] ) initial = Model(L) initial.add(position, rov1, p0) initial.evaluator = evaluate inst = temporal.Instance( L=L, X=[position(rov1, p0), estimated_range(t0), estimated_bearing(t0), observed(t0), estimated_range(t1), estimated_bearing(t1), observed(t1), estimated_range(t2), estimated_bearing(t2), observed(t2)], I=initial, A=[a1, a2], G=observed(t0) ) assert len(inst.R) == 3