We propose a methodology for decentralized multi-agent control from Linear Temporal Logic (LTL) specifications. Each agent receives an independent specification to formally synthesize its own hybrid controller. Mutual satisfiability is not a priori guaranteed. Due to limited communication, the agents utilize meeting events to exchange their controller automata and verify satisfiability through model checking. Local interaction only when common atomic propositions exist reduces the overall computational cost, facilitating scalability. Provably correct collision avoidance and convergence is ensured by Decentralized Multi-Agent Navigation Functions.

This paper introduces an algorithm for automatically tuning analytic navigation functions for sphere worlds. The tuning parameter must satisfy a lower bound to ensure collision avoidance and convergence. Until now analytic navigation functions have been manually tuned, although existence of a lower bound had been proved. A theoretical improvement on this lower bound is provided and the method is extended to unbounded manifolds. Then the required formulas are derived and algorithm described. So the lower bound is here evaluated in terms of sphere world centers and radii. Automated tuning enables completely unattended solution of any navigation problem in unknown sphere worlds and a priori known worlds which belong to the sphere world diffeomorphism class.

Abstract-We extend Navigation Functions (NF) to worlds of more general geometry and topology. This is achieved without the need for diffeomorphisms, by direct definition in the geometrically complicated configuration space. Every obstacle boundary point should be partially sufficiently curved. This requires that at least one principal normal curvature be sufficient. A normal curvature is termed sufficient when the tangent sphere with diameter the associated curvature radius is a subset of the obstacle. Examples include ellipses with bounded eccentricity, tori, cylinders, one-sheet hyperboloids and others. Our proof establishes the existence of appropriate tuning for this purpose. Direct application to geometrically complicated cases is illustrated through nontrivial simulations.

Abstract-This tutorial describes TuLiP, the Temporal Logic Planning toolbox, a collection of tools for designing controllers for hybrid systems from specifications in temporal logic. The tools support a workflow that starts from a description of desired behavior, and of the system to be controlled. The system can have discrete state, or be a hybrid dynamical system with a mixed discrete and continuous state space. The desired behavior can be represented with temporal logic and discrete transition systems. The system description can include uncontrollable variables that take discrete or continuous values, and represent disturbances and other environmental factors that affect the dynamics, as well as communication signals that affect controller decisions.A control design problem is solved in phases that involve abstraction, discrete synthesis, and continuous feedback control. Abstraction yields a discrete description of system dynamics in logic. For piecewise affine dynamical systems, this abstraction is constructed automatically, guided by the geometry of the dynamics and under logical constraints from the specification. The resulting logic formulae describe admissible discrete behaviors that capture both controlled and environment variables. The discrete description resulting from abstraction is then conjoined with the desired logic specification. To find a controller, the toolbox solves a game of infinite duration. Existence of a discrete (winning) strategy for the controlled variables in this game is a proof certificate for the existence of a controller for the original problem, which guarantees satisfaction of the specification. This discrete strategy, concretized by using continuous controllers, yields a feedback controller for the original hybrid system. The toolbox frontend is written in Python, with backends in C, Python, and Cython.The tutorial starts with an overview of the theory behind TuLiP, and of its software architecture, organized into specification frontends and backends that implement algorithms for abstraction, solving games, and interfaces to other tools. Then, the main elements for writing a specification for input to TuLiP are introduced. These include logic formulae, discrete transition systems annotated with predicates, and hybrid dynamical systems, with linear or piecewise affine continuous dynamics. The working principles of the algorithms for predicate abstraction and discrete game solving using nested fixpoints are explained, by following the input specification through the various transformations that compile it to a symbolic representation that scales well to solving large games. The tutorial concludes with several design examples that demonstrate the toolbox's capabilities.

This paper proposes a language for describing reactive synthesis problems that integrates imperative and declarative elements. The semantics is defined in terms of two-player turn-based infinite games with full information. Currently, synthesis tools accept linear temporal logic (LTL) as input, but this description is less structured and does not facilitate the expression of sequential constraints. This motivates the use of a structured programming language to specify synthesis problems. Transition systems and guarded commands serve as imperative constructs, expressed in a syntax based on that of the modeling language PROMELA. The syntax allows defining which player controls data and control flow, and separating a program into assumptions and guarantees. These notions are necessary for input to game solvers. The integration of imperative and declarative paradigms allows using the paradigm that is most appropriate for expressing each requirement. The declarative part is expressed in the LTL fragment of generalized reactivity(1), which admits efficient synthesis algorithms, extended with past LTL. The implementation translates PROMELA to input for the SLUGS synthesizer and is written in PYTHON. The AMBA AHB bus case study is revisited and synthesized efficiently, identifying the need to reorder binary decision diagrams during strategy construction, in order to prevent the exponential blowup observed in previous work.