Ioannis Filippidis

Decentralized multi-agent control from local LTL specifications

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.

Adjustable navigation functions for unknown sphere worlds

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.

Control design for hybrid systems with TuLiP: The Temporal Logic Planning toolbox

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 toolboxs capabilities.

Navigation Functions for everywhere partially sufficiently curved worlds

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.

A multi-paradigm language for reactive synthesis.

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.

An improvement of the piggyback algorithm for parallel model checking

This paper extends the piggyback algorithm to enlarge the set of liveness properties it can verify. Its extension is motivated by an attempt to express in logic the counterexamples it can detect and relate them to bounded liveness. The original algorithm is based on parallel breadth-first search and piggybacking of accepting states that are deleted after counting a fixed number of transitions. The main improvement is obtained by renewing the counter of transitions when the same accepting states are visited in the negated property automaton. In addition, we describe piggybacking of multiple states in either sets (exact) or Bloom filters (lossy but conservative), and use of local searches that attempt to connect cycles fragmented among processing cores. Finally it is proved that accepting cycle detection is in NC in the size of the product automatons entire state space, including unreachable states.

Navigation functions for focally admissible surfaces

This work presents a sharper condition for the applicability of Navigation Functions (NF). The condition depends on the placement of the destination with respect to the focal surfaces of obstacles. The focal surface is the locus of centers of principal curvatures. If each obstacle encompasses at least one of its focal surfaces, then the world is navigable using a Koditschek-Rimon NF (KRNF). Moreover, the Koditschek-Rimon (KR) potential is non-degenerate for all destinations which are not on a focal surface. So, for almost all destinations there exists a non-degenerate KR potential. This establishes a link between the differential geometry of obstacle surfaces and KRNFs. Channel surfaces (e.g. Dupin cyclides) and certain Boolean operations between shapes are examples of admissible obstacles. We also prove a weak converse result about the inexistence of a KRNF for obstacles with some concave point, for large tuning parameters. Finally, our results support non-trivial simulations in a forest, a pipeline and a cynlinder rig, with some notes about allowable types of non-smoothness.

Navigation functions learning from experiments: Application to anthropomorphic grasping

This paper proposes a method to construct Navigation Functions (NF) from experimental trajectories in an unknown environment. We want to approximate an unknown obstacle function and then use it within an NF. When navigating the same destinations with the experiments, this NF should produce the same trajectories as the experiments. This requirement is equivalent to a partial differential equation (PDE). Solving the PDE yields the unknown obstacle function, expressed with spline basis functions. We apply this new method to anthropomorphic grasping, producing automatic trajectories similar to the observed ones. The grasping experiments were performed for a set of different objects, Principal Component Analysis (PCA) allows reduction of the configuration space dimension, where the learning NF method is then applied.

Symbolic construction of GR(1) contracts for systems with full information

This work proposes a symbolic algorithm for the construction of assume-guarantee specifications that allow multiple agents to cooperate. Each agent is assigned goals expressed in a fragment of linear temporal logic known as generalized Streett with one pair, GR(1). These goals may be unrealizable, unless each agent makes additional assumptions, about the behavior of other agents. The algorithm constructs a contract among the agents, in that only the infinite behavior of the given goals is constrained, known as liveness, not the finite one, known as safety. This defers synthesis to a later stage of refinement, modularizing the design process. We prove that there exist GR(1) games that do not admit any refining GR(1) contract. For this reason, we formulate contracts with nested GR(1) properties and auxiliary communication variables, and prove that they always exist. The algorithms fixpoint structure is similar to GR(1) synthesis, enjoying time complexity polynomial in the number of states, and linear in number of recurrence goals.

Roadmaps using gradient extremal paths

This work proposes a motion planning method based on the construction of a roadmap connecting the critical points of a potential field or a distance function. It aims to overcome the limitation of potential field methods due to local minima caused by concave obstacles. The roadmap is incrementally constructed by a two-step procedure. Starting from a minimum, adjacent saddle-points are found using a local saddle-point search method. Then, the new saddle-points are connected to the minima by gradient descent. A numerical continuation algorithm from the computational chemistry literature is used to find saddle-points. It traces the valleys of the potential field, which are gradient extremal paths, defined as the points where the gradient is an eigenvector of the Hessian matrix. The definition of gradient bisectors is also discussed. The presentation conclude simulations in cluttered environments.