def test_agg_with_reset():
'test the aggregation of states with a reset'
# m1 dynamics: x' == 1, y' == 0, x0: [-3, -2], y0: [0, 1], step: 1.0
# m1 invariant: x + y <= 0
# m1 -> m2 guard: x + y >= 0 and y <= 0.5, reset = [[0, -1, 0], [1, 0, 0]] (x' = -y, y' = x, remove a)
# m2 dynamics: x' == 0, y' == 0
# time bound: 4
# expected result: last state is line (not box!) from (0, 0) to (-0.5, -0.5)
ha = HybridAutomaton()
# mode one: x' = 1, y' = 0, a' = 0
m1 = ha.new_mode('m1')
m1.set_dynamics([[0, 0, 1], [0, 0, 0], [0, 0, 0]])
# mode two: x' = 0, y' = 1
m2 = ha.new_mode('m2')
m2.set_dynamics([[0, 0], [0, 0]])
# invariant: x + y <= 0
m1.set_invariant([[1, 1, 0]], [0])
# guard: x + y == 0 & y <= 0.5
trans1 = ha.new_transition(m1, m2, 'trans1')
trans1.set_guard([[-1, -1, 0], [1, 1, 0], [0, 1, 0]], [0, 0, 0.5])
#trans1.set_reset(np.identity(3)[:2])
trans1.set_reset(np.array([[0, -1, 0], [1, 0, 0]], dtype=float))
# initial set has x0 = [-3, -2], y = [0, 1], a = 1
init_lpi = lputil.from_box([(-3, -2), (0, 1), (1, 1)], m1)
init_list = [StateSet(init_lpi, m1)]
# settings, step size = 1.0
settings = HylaaSettings(1.0, 4.0)
settings.stdout = HylaaSettings.STDOUT_NONE
settings.plot.plot_mode = PlotSettings.PLOT_NONE
# use agg_box
settings.aggstrat.agg_type = Aggregated.AGG_BOX
core = Core(ha, settings)
result = core.run(init_list)
lpi = result.last_cur_state.lpi
# 2 basis matrix rows, 4 init constraints rows, 6 rows from guard conditions (2 from each)
assert lpi.get_num_rows() == 2 + 4 + 6
verts = result.last_cur_state.verts(core.plotman)
assert len(verts) == 3
assert np.allclose(verts[0], verts[-1])
assert pair_almost_in((0, 0), verts)
assert pair_almost_in((-0.5, -0.5), verts)
def run_hylaa():
'runs hylaa, returning a HylaaResult object'
ha = define_ha()
init = define_init_states(ha)
settings = define_settings()
core = Core(ha, settings)
result = core.run(init)
#core.aggdag.show()
return result
def test_init_unsat():
'initial region unsat with multiple invariant conditions'
ha = HybridAutomaton()
mode = ha.new_mode('A')
mode.set_dynamics(np.identity(2))
mode.set_invariant([[1, 0], [1, 0]], [2, 3]) # x <= 2 and x <= 3
# initial set
lpi1 = lputil.from_box([(10, 11), (0, 1)], mode)
lpi2 = lputil.from_box([(0, 1), (0, 1)], mode)
init_list = [StateSet(lpi1, mode), StateSet(lpi2, mode)]
# settings
settings = HylaaSettings(1, 5)
settings.stdout = HylaaSettings.STDOUT_VERBOSE
settings.plot.plot_mode = PlotSettings.PLOT_NONE
core = Core(ha, settings)
core.run(init_list) # expect no exception during running
def test_multiple_init_states():
'test with multiple initial states in the same mode (should NOT do aggregation)'
ha = HybridAutomaton()
# with time and affine variable
mode = ha.new_mode('mode')
mode.set_dynamics([[0, 0], [0, 0]])
# initial set
init_lpi = lputil.from_box([(-5, -4), (0, 1)], mode)
init_lpi2 = lputil.from_box([(-5, -5), (2, 3)], mode)
init_list = [StateSet(init_lpi, mode), StateSet(init_lpi2, mode)]
# settings
settings = HylaaSettings(math.pi/4, math.pi)
settings.stdout = HylaaSettings.STDOUT_NONE
settings.plot.plot_mode = PlotSettings.PLOT_NONE
core = Core(ha, settings)
core.run(init_list)
def test_stateset_bad_init():
'test constructing a stateset with a basis matrix that is not the identity (should raise error)'
# this is from an issue reported by Mojtaba Zarei
ha = HybridAutomaton()
mode = ha.new_mode('mode')
mode.set_dynamics([[0, 1], [-1, 0]])
# initial set
init_lpi = lputil.from_box([(-5, -5), (0, 1)], mode)
init_list = [StateSet(init_lpi, mode)]
# settings
settings = HylaaSettings(math.pi/4, math.pi)
settings.stdout = HylaaSettings.STDOUT_NONE
settings.plot.store_plot_result = True
settings.plot.plot_mode = PlotSettings.PLOT_NONE
core = Core(ha, settings)
result = core.run(init_list)
# use last result
stateset = result.last_cur_state
mode = stateset.mode
lpi = stateset.lpi
try:
init_states = [StateSet(lpi, mode)]
settings = HylaaSettings(0.1, 0.1)
core = Core(ha, settings)
result = core.run(init_states)
assert False, "assertion should be raised if init basis matrix is not identity"
except RuntimeError:
pass
def test_ha():
'test for the harmonic oscillator example with line initial set (from ARCH 2018 paper)'
ha = HybridAutomaton()
# with time and affine variable
mode = ha.new_mode('mode')
mode.set_dynamics([[0, 1, 0, 0], [-1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0]])
error = ha.new_mode('error')
trans1 = ha.new_transition(mode, error)
trans1.set_guard([[1., 0, 0, 0], [-1., 0, 0, 0]], [4.0, -4.0])
# initial set
init_lpi = lputil.from_box([(-5, -5), (0, 1), (0, 0), (1, 1)], mode)
init_list = [StateSet(init_lpi, mode)]
# settings
settings = HylaaSettings(math.pi/4, 2*math.pi)
settings.stdout = HylaaSettings.STDOUT_VERBOSE
settings.plot.store_plot_result = True
settings.plot.plot_mode = PlotSettings.PLOT_NONE
core = Core(ha, settings)
result = core.run(init_list)
assert result.has_concrete_error
ce = result.counterexample[0]
# [-5.0, 0.6568542494923828, 0.0, 1.0] -> [4.0, 3.0710678118654737, 2.356194490192345, 1.0]
assert ce.mode == mode
assert np.allclose(ce.start, np.array([-5, 0.65685, 0, 1], dtype=float))
assert np.allclose(ce.end, np.array([4, 3.07106, 2.35619, 1], dtype=float))
# check the reachable state (should always have x <= 3.5)
obj_list = result.plot_data.mode_to_obj_list[0][mode.name]
for obj in obj_list:
verts = obj[0]
for vert in verts:
x, _ = vert
assert x <= 4.9
def run_hylaa(self, predictions):
self.ha = None
self.predictions = None
self.modeList = []
self.initialState = None
self.ha = HybridAutomaton()
self.predictions = predictions
self.graphPredictions()
self.make_automaton()
initialBox = self.make_init(self.predictions[0][0])
core = Core(self.ha, self.settings)
result = core.run(initialBox)
reachsets = [
result.plot_data.get_verts_list(mode)[0] for mode in self.modeList
]
return reachsets
def test_plain():
'test plain aggregation of states across discrete transitions'
# m1 dynamics: x' == 1, y' == 0, x0, y0: [0, 1], step: 1.0
# m1 invariant: x <= 3
# m1 -> m2 guard: True
# m2 dynamics: x' == 0, y' == 1
# time bound: 4
# excepted final states to be: x: [0, 4], y: [4,5]
# x is [1, 4] because no transitions are allowed at step 0 (simulation-equiv semantics) and a transition is
# allowed one step after the invariant becomes false
# y is [4,5] because after aggregation, the time elapsed for the aggregated set will be 0.0, the minimum
ha = HybridAutomaton()
# mode one: x' = 1, y' = 0, a' = 0
m1 = ha.new_mode('m1')
m1.set_dynamics([[0, 0, 1], [0, 0, 0], [0, 0, 0]])
# mode two: x' = 0, y' = 1, a' = 0
m2 = ha.new_mode('m2')
m2.set_dynamics([[0, 0, 0], [0, 0, 1], [0, 0, 0]])
# invariant: x <= 3.0
m1.set_invariant([[1, 0, 0]], [3.0])
# guard: True
trans1 = ha.new_transition(m1, m2, 'trans1')
trans1.set_guard(csr_matrix((0, 0)), [])
# initial set has x0 = [0, 1], t = [0, 1], a = 1
init_lpi = lputil.from_box([(0, 1), (0, 1), (1, 1)], m1)
init_list = [StateSet(init_lpi, m1)]
# settings, step size = 1.0
settings = HylaaSettings(1.0, 4.0)
settings.stdout = HylaaSettings.STDOUT_DEBUG
settings.plot.plot_mode = PlotSettings.PLOT_NONE
settings.plot.store_plot_result = True
core = Core(ha, settings)
result = core.run(init_list)
# check history
state = result.last_cur_state
assert state.mode == m2
assert len(state.aggdag_op_list) > 1
op0 = state.aggdag_op_list[0]
op1 = state.aggdag_op_list[1]
assert isinstance(op0, OpTransition)
assert len(core.aggdag.roots) == 1
assert op0.child_node.stateset.mode is m2
assert op0.transition == trans1
assert op0.parent_node == core.aggdag.roots[0]
assert isinstance(op0.poststate, StateSet)
assert op0.step == 1
assert isinstance(op0.child_node, AggDagNode)
assert op0.child_node == op1.child_node
assert op0.child_node not in core.aggdag.roots
assert len(op0.parent_node.stateset.aggdag_op_list) == 1
assert op0.parent_node.stateset.aggdag_op_list[0] is None
# check polygons in m2
polys2 = [obj[0] for obj in result.plot_data.mode_to_obj_list[0]['m2']]
assert 4 <= len(polys2) <= 5
assert_verts_is_box(polys2[0], [[1, 4], [0, 1]])
assert_verts_is_box(polys2[1], [[1, 4], [1, 2]])
assert_verts_is_box(polys2[2], [[1, 4], [2, 3]])
assert_verts_is_box(polys2[3], [[1, 4], [3, 4]])
def test_tt_09():
'test time-triggered transition at 0.9 bug'
# this test is from an issue reported by Mojtaba Zarei
tt_time = 0.9
ha = HybridAutomaton()
# the test seems to be sensitive to the a_matrix... my guess is the LP is barely feasible at the tt_time
a_matrix = np.array(
[[6.037291088, -4.007840286, 2.870370645, 43.12729646, 10.06751155, 23.26084098, -0.001965587832, 0, 0],
[3.896645707, -0.03417905392, -9.564966476, 15.25894014, -21.57196438, 16.60548055, 0.03473846441, 0, 0],
[22.72995871, 14.12055097, -0.9315267908, 136.9851951, -71.66383111, 109.7143863, 0.1169799769, 0, 0],
[-38.16694597, 3.349061908, -9.10171149, -185.1866526, 9.210877185, -165.8086527, -0.06858712649, 0, 0],
[46.78596597, 27.7996521, 17.18120319, 285.4632424, -135.289626, 235.9427441, 0.228154713, 0, 0],
[-8.31135303, 3.243945466, -4.523811735, -39.26067436, -9.385678542, -36.63193931, -0.0008874747046, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=float)
mode1 = ha.new_mode('mode')
mode1.set_dynamics(a_matrix)
# time-triggered invariant: t <= tt_time
mat = np.array([[0, 0, 0, 0, 0, 0, 0, 1, 0]], dtype=float)
rhs = [tt_time]
mode1.set_invariant(mat, rhs)
mode2 = ha.new_mode('mode2')
mode2.set_dynamics(a_matrix)
# transition, guard: x >= -2 & y > 4 & t >= tt_time
# transition, guard: t >= 0.9
mat = np.array([[0, 0, 0, 0, 0, 0, 0, -1, 0]], dtype=float)
rhs = [-tt_time]
t = ha.new_transition(mode1, mode2)
t.set_guard(mat, rhs)
# initial set
init_box = np.array([[-0.1584, -0.1000],
[-0.0124, 0.0698],
[-0.3128, 0.0434],
[-0.0208, 0.0998],
[-0.4895, 0.1964],
[-0.0027, 0.0262],
[42.40, 42.5],
[0, 0], # t(0) = 0
[1, 1]]) # affine(0) = 1
init_lpi = lputil.from_box(init_box, mode1)
init_list = [StateSet(init_lpi, mode1)]
# settings
settings = HylaaSettings(0.05, 1.0)
settings.stdout = HylaaSettings.STDOUT_DEBUG
settings.plot.store_plot_result = True
settings.plot.plot_mode = PlotSettings.PLOT_NONE #INTERACTIVE
#settings.plot.xdim_dir = 7 #None
#settings.plot.ydim_dir = 0
core = Core(ha, settings)
result = core.run(init_list)
mode2_list = result.plot_data.mode_to_obj_list[0]['mode2']
assert len(mode2_list) == 3, f"mode2_list len was {len(mode2_list)}, expected 3 (0.9, 0.95, 1.0)"
def test_tt_split():
'tests time-triggered dynamics where the state is split (based on state) after some amount of time elapses'
ha = HybridAutomaton()
# dynamics variable order: [x0, x1, x2, x3, u, t, affine]
pole = ha.new_mode('pole')
a_matrix = [ \
[0, 1, 0, 0, 0, 0, 0], \
[0, 0, 0.7164, 0, 0.9755, 0, 0], \
[0, 0, 0, 1, 0, 0, 0], \
[0, 0, 0.76, 0, 0.46, 0, 0], \
[0, 0, 0, 0, 0, 0, 0], \
[0, 0, 0, 0, 0, 0, 1], \
[0, 0, 0, 0, 0, 0, 0], \
]
pole.set_dynamics(a_matrix)
# 0.0 <= t & t <= 0.1
pole.set_invariant([[0, 0, 0, 0, 0, -1, 0], [0, 0, 0, 0, 0, 1, 0], ], [0, 0.1, ])
trans = ha.new_transition(pole, pole, 'b2')
# x3 <= 1.0229164510965 & x2 <= 2.0244571492076 & x3 > -10.0172335505486 & x2 <= 1.0329331979156 & t >= 0.1
trans.set_guard([[0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0],
[-0, -0, -0, -1, -0, -0, -0],
[0, 0, 1, 0, 0, 0, 0],
[-0, -0, -0, -0, -0, -1, -0],
], [1.0229164510965, 2.0244571492076, 10.0172335505486, 1.0329331979156, -0.1, ])
# Reset:
# t := 0.0
# u := 0.2
reset_mat = [ \
[1, 0, 0, 0, 0, 0, 0, ], \
[0, 1, 0, 0, 0, 0, 0, ], \
[0, 0, 1, 0, 0, 0, 0, ], \
[0, 0, 0, 1, 0, 0, 0, ], \
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ], \
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ], \
[0, 0, 0, 0, 0, 0, 1, ], \
]
reset_minkowski = [ \
[0, ], \
[0, ], \
[0, ], \
[0, ], \
[1, ], \
[0, ], \
[0, ], \
]
minkowski_constraints = [ \
[1, ], \
[-1, ], \
]
minkowski_rhs = [0.2, -0.2]
trans.set_reset(reset_mat, reset_minkowski, minkowski_constraints, minkowski_rhs)
# manually run ha.detect_tt_transitions() and check the result
def print_none(str):
'suppress printing'
pass
settings = HylaaSettings(0.05, 0.15)
settings.plot.plot_mode = PlotSettings.PLOT_IMAGE
settings.plot.xdim_dir = 0
settings.plot.ydim_dir = 3
settings.stdout = HylaaSettings.STDOUT_DEBUG
init_list = []
mode = ha.modes['pole']
mat = [[1, 0, 0, 0, 0, 0, 0], \
[-1, -0, -0, -0, -0, -0, -0], \
[0, 1, 0, 0, 0, 0, 0], \
[-0, -1, -0, -0, -0, -0, -0], \
[0, 0, 1, 0, 0, 0, 0], \
[-0, -0, -1, -0, -0, -0, -0], \
[0, 0, 0, -1, 0, 0, 0], \
[0, 0, 0, 1, 0, 0, 0], \
[0, 0, 0, 0, 1, 0, 0], \
[-0, -0, -0, -0, -1, -0, -0], \
[0, 0, 0, 0, 0, 1, 0], \
[-0, -0, -0, -0, -0, -1, -0], \
[0, 0, 0, 0, 0, 0, 1], \
[-0, -0, -0, -0, -0, -0, -1], ]
rhs = [0, -0, 0, -0, 0, -0, 1.3, -1.3, 0, -0, 0, -0, 1, -1, ]
init_list.append(StateSet(lputil.from_constraints(mat, rhs, mode), mode))
core = Core(ha, settings)
result = core.run(init_list) # expect no exception during running
assert result.last_cur_state.cur_steps_since_start[0] == 3
assert result.last_cur_state.cur_steps_since_start[1] == 3
