index_1 - 1] + ' && ' if index_2 == 0: new_sys_collision_2 += 'init' + str(other_r) + ' )' else: new_sys_collision_2 += env_vars_list[other_r - 1][index_2 - 1] + ' )' new_sys_collision_2 += ' -> (!go' + str( r) + ' || ' + '!go' + str(other_r) + ' )' sys_collision_2 |= {new_sys_collision_2} # sys_safe |= sys_collision_2 sys_col_simple = {'!(s1a2a1 && s2a2a1)'} sys_safe |= sys_col_simple # Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) specs.qinit = '\A \E' # Moore initial condition synthesized too specs.moore = False specs.plus_one = False print('Start synthesis') ctrl = synth.synthesize(specs) print('End synthesis') assert ctrl is not None, 'unrealizable' # Generate a graphical representation of the controller for viewing if not ctrl.save('gr1_set_1111.png'): print(ctrl) machines.random_run(ctrl, N=30)
# Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) # # Controller synthesis # # The controller decides based on current variable values only, # without knowing yet the next values that environment variables take. # A controller with this information flow is known as Moore. specs.moore = True # Ask the synthesizer to find initial values for system variables # that, for each initial values that environment variables can # take and satisfy `env_init`, the initial state satisfies # `env_init /\ sys_init`. specs.qinit = '\E \A' # i.e., "there exist sys_vars: forall sys_vars" # At this point we can synthesize the controller # using one of the available methods. strategy = synth.synthesize(specs) assert strategy is not None, 'unrealizable' # Generate a graphical representation of the controller for viewing, # or a textual representation if pydot is missing. if not strategy.save('gr1.png'): print(strategy) # simulate print(strategy) machines.random_run(strategy, N=10)
# Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) # # Controller synthesis # # The controller decides based on current variable values only, # without knowing yet the next values that environment variables take. # A controller with this information flow is known as Moore. specs.moore = True # Ask the synthesizer to find initial values for system variables # that, for each initial values that environment variables can # take and satisfy `env_init`, the initial state satisfies # `env_init /\ sys_init`. specs.qinit = '\E \A' # i.e., "there exist sys_vars: forall sys_vars" # At this point we can synthesize the controller # using one of the available methods. strategy = synth.synthesize(specs) assert strategy is not None, 'unrealizable' # Generate a graphical representation of the controller for viewing, # or a textual representation if pydot is missing. if not strategy.save('gr1.png'): print(strategy) # simulate print(strategy) machines.random_run(strategy, N=10)
# [](X (X0reach) <-> X0 || (X0reach && !park)) # # Augment the system description to make it GR(1) sys_vars |= {'X0reach'} sys_init |= {'X0reach'} sys_safe |= {'(X (X0reach) <-> X0) || (X0reach && !park)'} sys_prog |= {'X0reach', 'X5'} # Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) # # Controller synthesis # # At this point we can synthesize the controller # using one of the available methods. # Here we make use of gr1c. # mealy_controller = synth.synthesize('gr1c', specs) # Generate a graphical representation of the controller for viewing, # or a textual representation if pydot is missing. if not mealy_controller.save('gr1.png'): print(mealy_controller) # simulate print(mealy_controller) machines.random_run(mealy_controller, N=10)
# [](X (X0reach) <-> X0 || (X0reach && !park)) # # Augment the system description to make it GR(1) sys_vars |= {'X0reach'} sys_init |= {'X0reach'} sys_safe |= {'(X (X0reach) <-> X0) || (X0reach && !park)'} sys_prog |= {'X0reach', 'X5'} # Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) # # Controller synthesis # # At this point we can synthesize the controller # using one of the available methods. # Here we make use of gr1c. # mealy_controller = synth.synthesize('gr1c', specs) # Generate a graphical representation of the controller for viewing, # or a textual representation if pydot is missing. if not mealy_controller.save('gr1.png'): print(mealy_controller) # simulate print(mealy_controller) machines.random_run(mealy_controller, N=10)
# Constraint 1: []<>([[0, 0], [0, 1], [0, 2]], 2) # Constraint 2: []!([1, 1], 1) # Constraint 3: ([]<>[1, 2], 2) #sys_prog |= {'(x1=0)'} #sys_safe |= {'!(x1=1 && y1=1)'} sys_prog |= {'(x1=0) && (x2=0)'} #sys_prog |= {'x1=1 && y1=0'} #sys_prog |= {'x2=1 && y2=0'} #sys_prog |= {'(x1=1) && (x2=1)'} sys_safe |= {'!(x1=1 && y1=1) && !(x2=1 && y2=1)'} sys_prog |= {'x1=1 && y1=2'} sys_prog |= {'x2=1 && y2=2'} # Create a GR(1) specification specs = spec.GRSpec(env_vars, sys_vars, env_init, sys_init, env_safe, sys_safe, env_prog, sys_prog) specs.qinit = '\E \A' # Moore initial condition synthesized too specs.moore = False specs.plus_one = False print(specs) specs.check_syntax() print('Start synthesis') ctrl = synth.synthesize(specs) print('End synthesis') assert ctrl is not None, 'unrealizable' machines.random_run(ctrl, N=100)