Séminaire de l'équipe Méthodes Formelles (MF)

Le séminaire MF a lieu salle 178 presque tous les mardis à 14H.

Pour proposer un séminaire, le calendrier vous aidera à choisir une date disponible.

Pour s'abonner ou se désabonner de la liste de diffusion.


Prochains exposés

DateOrateurTitre
Tuesday 08 September 2020Guillermo A. Perez (University of Antwerp) Safe Learning for Near Optimal Scheduling
TBA
Tuesday 15 September 2020Damien Busatto-Gaston (ULB) Monte Carlo Tree Search guided by Symbolic Advice for MDPs
In this paper, we consider the online computation of a strategy that aims at optimizing the expected average reward in a Markov decision process. The strategy is computed with a receding horizon and using Monte Carlo tree search (MCTS). We augment the MCTS algorithm with the notion of symbolic advice, and show that its classical theoretical guarantees are maintained. Symbolic advice are used to bias the selection and simulation strategies of MCTS. We describe how to use QBF and SAT solvers to implement symbolic advice in an efficient way. We illustrate our new algorithm using the popular game Pac-Man and show that the performances of our algorithm exceed those of plain MCTS as well as the performances of human players.
Tuesday 22 September 2020Loïc Paulevé (CNRS, LaBRI) TBA
TBA
Tuesday 29 September 2020Mikael Monet () TBA
TBA
Tuesday 06 October 2020Igor Konnov (INRIA Nancy) TBA
TBA



Précédents exposés depuis janvier 2017

DateOrateurTitre
Tuesday 30 June 2020Helmut Seidl (TUM) When Is a Bottom-up Deterministic Tree Transducer Top-down Deterministic?
We consider two natural subclasses of deterministic top-down tree-to-tree transducers, namely, linear and uniform-copying transducers. For both classes we show that it is decidable whether the translation of a transducer with look-ahead can be realized by a transducer from the same class without look-ahead. The transducers constructed in this way, may still make use of inspection, i.e., have an additional top-down deterministic tree automaton restricting the domain. We provide a second procedure which decides whether inspection can be removed and if so, constructs an equivalent transducer without inspection. The construction relies on a precise abstract interpretation of inspection requirements and a dedicated earliest-normal form for linear as well as uniform-copying transducers which can be constructed in polynomial time. As a consequence, equivalence of these transducers can be decided in polynomial time. Applying these results to deterministic bottom-up transducers, we obtain that it is decidable whether or not their translations can be realized by deterministic uniform-copying top-down transducers without look-ahead (but with inspection) - or without both look-ahead and inspection.
Tuesday 23 June 2020Elena Gutierrez (IMDEA Software Institute) A Congruence-based Perspective on Automata Minimization Algorithms
Getting the deterministic finite-state automaton with the least possible number of states is an essential question in many applications such as text processing, image analysis and program verification and synthesis. Most of the minimization methods that have been proposed in the literature rely on building a partition of the set of states of the input automaton to obtain the minimal deterministic automaton. This is the case of Hopcroft's and Moore's algorithm. Another independent method is the classical textbook procedure proposed by Brzozowski. This algorithm simply combines a determinization (D) and reverse (R) operation twice applied to the input automaton N, i.e., DoRoDoR(N), to obtain the minimal automaton. Despite having an exponential worst-case complexity, its simplicity has recently motivated the study of this method and its connection with the partition-based methods, with the goal of providing more efficient versions of it. In this talk, I will address this study from a language-theoretical perspective. I will use equivalence relations on words to give a new and simple proof of correctness of the double-reversal method and shed light on the connection between this method and Moore's algorithm, a partition-based method.
Tuesday 02 June 2020Ana Ozaki (University of Bergen) Learning Description Logic Ontologies
Ontologies have been used to describe knowledge in various domains, in particular, in those related to life sciences. Semi-automating the process of building an ontology has attracted researchers from various communities into a field called "Ontology Learning". The process of building an ontology can be divided into two main tasks: finding the relevant vocabulary and the appropriate ontology language, and discovering how the vocabulary should be related using the logical constructs available in the chosen ontology language. In this presentation, I will provide a brief overview of five approaches from the literature which have been proposed to semi-automate the process of building an ontology formulated in description logic (DL), focusing on the second task. I will then present some results on the complexity of learning lightweight DL ontologies in the exact and probably approximately correct learning models from computational learning theory. Main references for this talk: Learning Query Inseparable ELH Ontologies AAAI 2020 Learning Description Logic Ontologies. Five Approaches. Where Do They Stand? KI 2020 (under review, minor revision) Exact Learning of Lightweight Description Logic Ontologies JMLR 2018 ExactLearner: A Tool for Exact Learning of EL Ontologies KR 2018 A Model for Learning Description Logic Ontologies Based on Exact Learning AAAI 2016
Tuesday 26 May 2020Abhishek De (IRIF) A parallel syntax for non-wellfounded proof theory
Proof theory is the study of proofs as mathematical objects in their own right. Infinite proofs (eg. infinite descent proofs) are pervasive in mathematics. A formal way of characterizing such proofs can be done by looking at fixed point logics (eg. mu calculus) from proof-theoretic lenses. Baelde et. al. have proposed an infinitary sequent calculus (i.e. infinitely deep, finitely wide proofs) for linear logic with fixed points (muMALL). In this talk, following a brief history of proof theory and infinite proofs, I will introduce muMALL. However, the sequent calculus of muMALL turns out to be ``too sequential". In order to achieve more liberal cut elimination, we have devised infinets which are proofs nets (à la Curien) for the multiplicative fragment (muMLL). The later part of the talk will focus on infinets and ongoing work on these nets. Joint work with: Alexis Saurin, Luc Pellisier
Tuesday 19 May 2020Antoine Amarilli (Télécom Paris) Query evaluation on probabilistic data: a story of dichotomies
Query evaluation is the problem of checking if some input data satisfies a fixed query, and probabilistic query evaluation (PQE) is its extension to probabilistic data, where we must compute the probability that the query is true. Specifically, we study this problem on tuple-independent databases of arity 2, aka probabilistic graphs: the graph has edges labeled with probabilities denoting how likely it is that the edge exists, independently from other edges. The PQE problem for a query Q, called PQE(Q) is to then take an input probabilistic graph of this kind, and compute the exact probability that a random possible world of this graph satisfies Q. We study this problem in data complexity, i.e., its complexity is measured as a function of the graph, when Q is fixed. The talk will present several dichotomies around the PQE problem. The first one is by Dalvi and Suciu [JACM'12] and applies to unions of conjunctive queries. They showed that for any such query Q, either PQE(Q) is in PTIME or it is #P-hard. I will present our recent extension of this dichotomy with Ismail Ilkan Ceylan [ICDT'20], for the larger query class of homomorphism-closed queries: for any such query Q, either PQE(Q) is in PTIME or it is #P-hard. Actually, the main result is that PQE(Q) is #P-hard for any homomorphism-closed query which is not a UCQ. I will also present our dichotomy with Pierre Bourhis and Pierre Senellart [ICALP'15, PODS'16] on restricting instance classes. We show that PQE(Q) is in PTIME, for the larger class of MSO queries, when the input probabilistic graphs are required to be trees or have bounded-treewidth. Conversely, PQE is intractable on unbounded-treewidth graphs under some technical assumptions. Last, I will present our ongoing work with Benny Kimelfeld, showing that the PQE dichotomy on self-join-free conjunctive queries also applies to unweighted PQE, i.e., when all probabilities of the graph are 1/2.
Tuesday 05 May 2020Thibault Godin (Université de Montpellier, Université de Lorraine) Order problem for automaton semigroups
The class of automaton (semi)groups--that is (semi)groups generated by functions defined using transducers--has been studied since the late 70's as many very interesting (semi)groups arise from it. From a computer scientist point of view it is also very nice because the underlying automaton structure allows to apply known tools, and for instance one can decide if an element represents the identity element using automaton minimization. In this talk, we focus on a the order problem, that is given an element g in the (semi)group, does there exist two distinct integers l,m such that g^l=g^m ? This problem was proven undecidable for general automaton (semi)groups by Gilibert, but Bondarenko, Bondarenko, Sidki and Zapata showed that, if one restricts the automaton, then the problem is decidable in the group case. We extend their result to the semigroup case, introducing several extensions of their work. This is joint work with Laurent Bartholdi, Ines Klimann and Matthieu Picantin
Tuesday 21 April 2020Filip Mazowiecki (Max Planck Institute for Software Systems) On polynomial recursive sequences
We study the expressive power of polynomial recursive sequences, a nonlinear extension of the well-known class of linear recursive sequences. These sequences arise naturally in the study of nonlinear extensions of weighted automata, where (non)expressiveness results translate to class separations. A typical example of a polynomial recursive sequence is b_n=n!. Our main result is that the sequence u_n=n^n is not polynomial recursive. This is joint work with Michaël Cadilhac, Charles Paperman, Michal Pilipczuk and Géraud Sénizergues available on arxiv https://arxiv.org/abs/2002.08630
Tuesday 14 April 2020Pierre Ohlmann (IRIF) Controlling a random population
Bertrand et al. (2017) introduced a model of parameterised systems, where each agent is represented by a finite state system, and studied the following control problem: for any number of agents, does there exist a controller able to bring all agents to a target state? They showed that the problem is decidable and EXPTIME-complete in the adversarial setting, and posed as an open problem the stochastic setting, where the agent is represented by a Markov decision process. In this paper, we show that the stochastic control problem is decidable. Our solution makes significant uses of well quasi orders, of the max-flow min- cut theorem, and of the theory of regular cost functions.
Tuesday 31 March 2020Jérôme Leroux (CNRS, LaBRI) Reachability in fixed dimension vector addition systems with states
The reachability problem is a central decision problem for formal verification based on vector addition systems with states (VASS), which are equivalent to Petri nets and form one of the most studied and applied models of concurrency. Reachability for VASS is also inter-reducible with a plethora of problems from a number of areas of computer science. In spite of recent progress, the complexity of the reachability problem remains unsettled, and it is closely related to the lengths of shortest VASS runs that witness reachability. We consider VASS of fixed dimension, and obtain three main results. For the first two, we assume that the integers in the input are given in unary, and that the control graph of the given VASS is flat (i.e., without nested cycles). We obtain a family of VASS in dimension 3 whose shortest reachability witnessing runs are exponential, and we show that the reachability problem is NP-hard in dimension 7. These results resolve negatively questions that had been posed by the works of Blondin et al. in LICS 2015 and Englert et al. in LICS 2016, and contribute a first construction that distinguishes 3-dimensional flat VASS from 2-dimensional VASS. Our third result, by means of a novel family of products of integer fractions, shows that 4-dimensional VASS can have doubly exponentially long shortest reachability witnessing runs. The smallest dimension for which this was previously known is 14. Joint work with Wojciech Czerwinski, Slawomir Lasota, Ranko Lazic, Filip Mazowiecki. Paper available at https://arxiv.org/abs/2001.04327
Tuesday 24 March 2020Abhishek De (IRIF) A parallel syntax for non-wellfounded proof theory
Proof theory is the study of proofs as mathematical objects in their own right. Infinite proofs (eg. infinite descent proofs) are pervasive in mathematics. A formal way of characterizing such proofs can be done by looking at fixed point logics (eg. mu calculus) from proof-theoretic lenses. Baelde et. al. have proposed an infinitary sequent calculus (i.e. infinitely deep, finitely wide proofs) for linear logic with fixed points (muMALL). In this talk, following a brief history of proof theory and infinite proofs, I will introduce muMALL. However, the sequent calculus of muMALL turns out to be ``too sequential". In order to achieve more liberal cut elimination, we have devised infinets which are proofs nets (à la Curien) for the multiplicative fragment (muMLL). The later part of the talk will focus on infinets and ongoing work on these nets. Joint work with: Alexis Saurin, Luc Pellisier
Tuesday 17 March 2020André Nies (University of Auckland ) Finite automata presentable groups
A mathematical structure M is called finite automata presentable if the elements of M can be represented by strings in a regular language, in such a way that the relations and functions of M are also decided by finite automata. We will discuss the extent of this notions in. the context of groups. Older work with Thomas shows that every finitely generated subgroup is abelian by finite. Recent work with Stephan gives new examples and counterexamples in the setting of groups that are nilpotent of class 2. We will also discuss the possibility of a complete description of such groups.
Tuesday 10 March 2020Florent Capelli (Université de Lille) An introduction to Knowledge compilation
Knowledge compilation aims to transform knowledge on a system, often represented in a natural but hard to query way, into a - hopefully small - data structure that is more practical to reason with. The idea is that after a potentially expensive offline compilation phase, one can efficiently extract new knowledge by directly querying the data structure. Originating in symbolic AI where it was mainly used to find better representations of CNF-formulas or to efficiently solve configuration problems, this idea has spread in many adjacent fields such as database theory where it has been used to efficiently compute aggregates in databases. In this talk, we will give a broad overview of knowledge compilation and its applications. We will presente some interesting data structure used in knowledge compilation and how they are used both theoretically and in practice.
Friday 28 February 2020Howard Straubing (Boston College) Two Variable Logic with a Between Relation
It is well-known that every sentence of first-order logic over <, interpreted in finite words (FO[<]), is equivalent to a sentence in which only three variables are used. The fragment FO2[<] of sentences using only two variables, has been the subject of considerable study, and admits interesting characterizations in algebra and temporal logic. In this talk, I will describe an extension of FO2[<] in which one allows a new binary relation that says, ‘there is an occurrence of the letter a between x and y’. In a sense, this is the simplest property that one can express that requires 3 variables. I will present several logics, both first-order and temporal, that have the same expressive power; matching lower and upper bounds for the complexity of satisfiability for each of these formulations; and effective necessary and sufficient conditions, based on the syntactic monoid, for a property to be expressible in these logics. This algebraic analysis allows one to prove, among other things, that these new logics have strictly less expressive power than full first-order logic FO[<]. The proofs use a novel method for obtaining factorizations of words that may have independent interest. This is joint work with Andreas Krebs, Kamal Lodaya, and Paritosh Pandya. The results are described in two papers presented at LICS 2016 and CSL 2018. A journal version, containing all the results and proofs (arXiv:1902.05905) will appear in Logical Methods in Computer Science.
Tuesday 18 February 2020Janusz Schmude (MIMUW, University of Warsaw) An algebraic approach to equivalence of MSO transductions of graphs of bounded treewidth
We prove MSO-transductions of graphs of bounded treewidth have decidable equivalence modulo fractional isomorphism with real coefficients (not necessarily nonnegative). The main goal of this talk is to present a new approach to equivalence problem of MSO-transductions of graphs of bounded treewidth. This approach relies on associating to a graph a list of polynomials or generating functions which can be updated by a polynomial function after join and forget operation of sourced graphs. This is joint work with Mikolaj Bojanczyk.
Tuesday 11 February 2020Paul-Elliot Anglès Auriac (Institut Camille Jordan, Lyon) The reverse mathematics of Hindman's theorem
Reverse mathematics consists of the study of the minimal axioms needed to prove a theorem. A phenomenon that appeared at the beginning of this study is that among the "natural" theorems, an enormous majority are equivalent to one out of five axiomatic systems: the Big Five. The exceptions to this are mainly mainly theorems from combinatorics, the most famous being the Ramsey theorem for pairs. This makes combinatorics especially interesting in the context of reverse mathematics. Some theorems still escape classification, such as Hindman's theorem, which says that for any finite coloring, there is an infinite set whose set of finite sums of distinct elements is monochromatic. This theorem has several proofs, but the most elementary is in the system ACA_0^+ (the existence of the omega-jump), while it is only known to imply arithmetical comprehension. We will start by presenting reverse mathematics and its use of calculability, before applying it to Hindman's theorem, presenting a sketch of the most elementary proof, and the latest advances on this subject.
Thursday 06 February 2020Maribel Fernandez (King's College London) Semantics and applications of PORGY - an interactive modelling framework based on strategic graph rewriting
In this talk I will describe the use of strategic port graph rewriting as a basis for the implementation of visual modelling tools. The goal is to facilitate the specification and analysis of complex systems. A system is represented by an initial graph and a collection of graph rewrite rules, together with a user-defined strategy to control the application of rules. The traditional operators found in strategy languages for term rewriting have been adapted to deal with the more general setting of graph rewriting, and some new constructs have been included in the strategy language to deal with graph traversal and management of rewriting positions in the graph. We give a formal semantics for the language, examples of application in the areas of biochemistry, social networks and database design, and a brief description of its implementation: the graph transformation and visualisation tool PORGY. This is joint work with members of the PORGY team at Bordeaux and King’s College London.
Tuesday 04 February 2020Jérôme Leroux (CNRS, LaBRI) Reachability in fixed dimension vector addition systems with states
The reachability problem is a central decision problem for formal verification based on vector addition systems with states (VASS), which are equivalent to Petri nets and form one of the most studied and applied models of concurrency. Reachability for VASS is also inter-reducible with a plethora of problems from a number of areas of computer science. In spite of recent progress, the complexity of the reachability problem remains unsettled, and it is closely related to the lengths of shortest VASS runs that witness reachability. We consider VASS of fixed dimension, and obtain three main results. For the first two, we assume that the integers in the input are given in unary, and that the control graph of the given VASS is flat (i.e., without nested cycles). We obtain a family of VASS in dimension 3 whose shortest reachability witnessing runs are exponential, and we show that the reachability problem is NP-hard in dimension 7. These results resolve negatively questions that had been posed by the works of Blondin et al. in LICS 2015 and Englert et al. in LICS 2016, and contribute a first construction that distinguishes 3-dimensional flat VASS from 2-dimensional VASS. Our third result, by means of a novel family of products of integer fractions, shows that 4-dimensional VASS can have doubly exponentially long shortest reachability witnessing runs. The smallest dimension for which this was previously known is 14. Joint work with Wojciech Czerwinski, Slawomir Lasota, Ranko Lazic, Filip Mazowiecki. Paper available at https://arxiv.org/abs/2001.04327
Tuesday 28 January 2020Sylvain Lombardy (LaBRI) A separation result on min-plus and max-plus automata
Work in collaboration with Thomas Colcombet. The talk shall start with an overview of min-plus and max-plus automata. These weighted automata realize functions which map words onto real numbers. We shall see that it may be thorny to give a description of their asymptotic behaviour. In contrast, it is pretty easy to study the functions realized by unambiguous weighted automata (with at most one accepting run for each input). It was known that a function that can be both realized by a min-plus and a max-plus automaton can actually be realized by an unambiguous one. We show a generalization of this result: if a function realized by a min-plus automaton is larger than a function realized by a max-plus automaton, then there exists an effectively computable unambiguous automaton which realizes a function in between. This result also applies on weighted tree automata.
Tuesday 21 January 2020Denis Kuperberg (CNRS, ENS Lyon) Computational content of circular proof systems
Cyclic proofs are a class of formal proof systems that allow some kind of circular reasoning. Unlike classical proofs, represented by finite trees with axioms as leaves, cyclic proofs are represented by trees containing infinite branches. The Curry-Howard correspondence allows us to see these cyclic proofs as programs. We investigate the computational content of a cyclic proof system based on Kleene algebra, where we see expressions as data types. Different proofs of the same sequent e |- f can be interpreted as different programs mapping every input of type e to an output of type f. We show that depending on the particular rules allowed in the system, the computational content of proofs matches different known complexity classes: regular languages, LogSpace, primitive recursive functions, system T. Various tools are used to pinpoint these different expressive powers, including a newly introduced class of automata (Jumping Multihead Automata), and results from the field of reverse mathematics. This is joint work with Laureline Pinault, Damien Pous, and Anupam Das.
Tuesday 14 January 2020Guillaume Lagarde (LaBRI) Lempel-Ziv: A "one-bit catastrophe" but not a tragedy
LZ'78 is a famous and very simple lossless data compression algorithm published by Abraham Lempel and Jacob Ziv in 1978. Although widely used in practise, we know little about its stability. The one-bit catastrophe question, introduced by Jack Lutz in the late 90s, asks whether an infinite word compressible by LZ'78 can become incompressible by adding a single bit in front of it. Our main result is to answer that question positively. We also give tight bounds on the maximal possible variation between the compression ratio of a finite word and its perturbation (when one bit is added in front of it), showing that to get a "catastrophe", the initial word needs already to be close to the threshold of incompressibility. This is a joint work with Sylvain Perifel.
Tuesday 07 January 2020Raphaël Berthon (ULB) Mixing sure, almost sure, exist and probable objectives in MDPs
We consider algorithms to decide the existence of strategies in MDPs for Boolean combinations of objectives. These objectives are omega-regular properties that need to be enforced either surely (whatever happens), almost surely (with probability one), existentially (it can happen), or with non-zero probability. Such a combination of properties could be e.g. that an agent reaches a target with high probability while guaranteeing it will not crash. We provide algorithms to solve the general case of Boolean combinations and we also investigate relevant subcases. We provide algorithms to solve the general case of Boolean combinations and we also investigate relevant subcases. We also report on complexity lower-bounds for these problems.
Tuesday 17 December 2019Mateusz Skomra (ENS Lyon) Using tropical geometry to obtain condition numbers of stochastic mean payoff games
In this talk, we introduce a condition number of stochastic mean payoff games. To do so, we interpret these games as feasibility problems over tropically convex cones. In this setting, the condition number is defined as the maximal radius of a ball in Hilbert's projective metric that is included in the (primal or dual) feasible set. We show that this conditioning controls the number of value iterations needed to decide whether a mean payoff game is winning. In particular, we obtain a pseudopolynomial bound for the complexity of value iteration provided that the number of random positions is fixed. We also discuss the implications of these results for convex optimization problems over nonarchimedean fields and present possible directions for future research. The talk is based on joint works with X. Allamigeon, S. Gaubert, and R. D. Katz.
Tuesday 10 December 2019Edwin Hamel-De Le Court (Université de Rouen) Algebraic tools for state complexity
Computing the state complexity of regular operations is usually a messy business. Every new operation needs to be carefully considered and the associated computations need to be tweaked. We present an attempt to generalize this process on a large class of rational operations, and use this framework to present new results.
Tuesday 03 December 2019Christine Tasson (IRIF, Paris 7) Semantics of Functional Probabilistic Programs
Probabilities are extensively used in Computer Science. Algorithms use probabilistic choices for solving problems that are untracktable deterministically or for improving efficiency. Recently, (Functional) Probabilistic Programming has been introduced for applications in Machine Learning and Artificial Intelligence. Probabilistic programs are used to describe statistical models and for developing probabilistic data analysis. As decisions in our society are often based on statistical models, it has become crucial to develop formal methods for probabilistic computing. The aim is to systemetize the analysis and certification of probabilistic programs. In this talk, I will first introduce functional probabilistic programing and the related problems. Then, I will present recent works in denotational semantics of probabilistic computing and their applications.
Tuesday 26 November 2019Sebastian Junges (RWTH Aachen) Parameter Synthesis in Markov Models: An Overview
Markov models comprise states with probabilistic transitions.. The analysis of these models is ubiquitous and studied in, among others, reliability engineering, artificial intelligence, systems biology, and formal methods. Naturally, their analysis crucially depends on the transition probabilities. Often, these probabilities are approximations based on data or reflect configurable parts of a modelled system. To represent the uncertainty about the probabilities, we study parametric Markov models, in which the probabilities are symbolic expressions rather than concrete values. More precisely, we consider parametric Markov decision processes (pMDPs) and parametric Markov chains (pMCs) as special case. Substitution of the parameters yields classical, parameter-free Markov decision processes (MDPs) and Markov chains (MCs). A pMDP thus induces uncountably many MDPs. Each MDP may satisfy reachability and reward properties, such as the maximal probability that the system reaches an `offline' state is less than 0.01%. Lifting these properties to pMDPs yields fundamental problems asking, e.g., Is there an induced MDP satisfying the property? We give an overview over such problems on a conceptual level, discuss their complexity, and survey both older and recent methods.
Tuesday 19 November 2019Nathanaël Fijalkow (CNRS, LaBRI) Learning probabilistic context-free grammars
In this talk I will present a solution to the following problem: given a set of strings, learn the underlying probabilistic context-free grammar generating these strings. The main difficulty is that we observe strings and not (for instance) derivation trees. In general, strings are not enough to identify a unique grammar (as for instance the string abc can be generated in various ways). I will introduce some structural properties ensuring this identifiability, and show that the corresponding class of probabilistic context-free grammars can be efficiently learned.
Tuesday 12 November 2019Bartek Klin (MIMUW, University of Warsaw) Monadic monadic second order logic
Monadic second order logic (MSO) is usually studied over specific kinds of structures, be it finite words, infinite words, finite or infinite trees, total orders of various shapes, etc. A monad is a rather abstract notion of "a kind of structures" that covers these and many other examples. One can formulate an abstract definition of MSO for a generic monad. I will explain how this is done, and I will describe some conditions that a monad should satisfy to ensure a basic "sanity check": that every definable language is recognized by a finite algebra. Familiarity with monads is not necessary, I will give a gentle introduction. (joint work with Mikolaj Bojanczyk and Julian Salamanca)
Tuesday 05 November 2019David Janin (LaBRI) An equational modeling of asynchronous concurrent programming
Asynchronous programing is a widely spread technique offering some simple concurrent programing primitives that are restricted enough so that the resulting concurrent programs are, to some extent, dead-lock free. In this talk, I shall present the notion of monadic references that allows for formally defining a model of asynchronous concurrent programming as an extension of the usual model of (say) sequential monad programing. I shall first review the notion of monadic programing, as popularized these last twenty years in typed functional programming languages such as Haskell. Then I will define in a progressive way what is asynchronous programing, how it relates with sequential programing, along with two series of simple equations capturing first, the basic semantics of promises and second, their asynchronous nature. Various theorems derive from such an approach, formally proving the intuition long gain by programmers that, simply said, asynchronous concurrent programing with promises is as at least as simple as sequential programing, but with additional smoothness and optimisations possibilities provided by light concurrency. If time permits, we may eventually prove that promises of (monadic) streams of data can be defined as (monadic) streams of promises of data, offering thus safe and robust ways to duplicate (monadic) streams in pure typed functional data flow programs.
Tuesday 22 October 2019Daniel Hausmann (Friedrich-Alexander University of Erlangen and Nürnberg) Computing Nested Fixpoints in Quasipolynomial Time
In this talk, we will see how the main idea behind Calude et al.'s breakthrough quasipolynomial time algorithm for solving parity games extends to the computation of nested fixpoints of arbitrary set-functions. This result can alternatively be phrased as a fixpoint theorem stating that the iterative computation of nested fixpoints by approximation stabilizes after a quasipolynomial number of iterations. Furthermore we show that the problem of computing nested fixpoints is contained in both NP and Co-NP. Time admitting, we will also see how Zielonka's algorithm for parity games can be used to compute nested fixpoints of arbitrary set-functions. These results find application in solving generalized parity games as well as model checking and satisfiability checking for extensions of the mu-calculus (e.g. graded, probabilistic or alternating-time), and prospectively in the computation of fair bisimulations and type checking for inductive-coinductive types. The main message of all this is that many results and algorithms for solving parity games naturally generalize to the computation of nested fixpoints, pointing to a close relation between the two problems.
Tuesday 15 October 2019Engel Lefaucheux (MPI SWS) Simple Priced Timed Games are not That Simple
Priced timed games are two-player zero-sum games played on priced timed automata (whose locations and transitions are labeled by weights modeling the price of spending time in a state and executing an action, respectively). The goals of the players are to minimise or maximise the price to reach a target location. While one can compute the optimal values that the players can achieve (and their associated optimal strategies) when the weights are all positive, this problem with arbitrary integer weights remains open. In this talk, I will explain what makes this case more difficult and show how to solve the problem for a subclass of priced timed games (the so-called simple priced timed games).
Tuesday 08 October 2019Guillaume Lagarde (LaBRI) Tradeoff between size and degree in Polynomial Calculus Resolution
Introduced by Cleggs et al. (STOC'96) to capture Gröbner basis computations, Polynomial Calculus Resolution (PCR) is an algebraic proof system for certifying the unsatisfiability of CNF formulas. Impagliazzo et al. (CC'99) established that if an unsatisfiable k-CNF formula over n variables has a refutation of small size in PCR (that is, polynomial size), then this formula also has a refutation of small degree, i.e., O(sqrt(n log n)). A natural question is to know whether we can achieve both small size and small degree in the same refutation. A situation similar in spirit arises in the more classical resolution proof system where degree is replaced by width and size by length. In this setting, Thapen (TOC '16) adressed the tradeoff question by providing a negative answer: the decrease in width necessarily comes at the expense of an exponential blow-up in length. Extending ideas from Thapen, our main result is to prove that a strong size-degree tradeoff is also necessary in PCR. Joint work with Jakob Nordström, Dmitry Sokolov, Joseph Swernofsky
Tuesday 01 October 2019Hugo Gimbert (CNRS, LaBRI) Les algorithmes de Parcoursup
« Parcoursup » est la plateforme nationale d’admission en première année de l’enseignement supérieur, mise en place en 2018 suite au vote de la loi ORE, en remplacement d’APB (Admission Post-Bac). Cette plateforme assure la mise en relation des formations du supérieur (licences, BTS, IUT, écoles, prépas, etc…) avec les candidats à ces formations, près de 900.000 en 2019. Les algorithmes de Parcoursup envoient automatiquement et quotidiennement des propositions aux candidats, sur la base des voeux formulés par les candidats et des classements réalisés par les formations. Je présenterai plusieurs aspects de ces algorithmes, de leur conception à leur implémentation et leur vérification. Ces travaux ont été réalisés dans le cadre de ma mission auprès du MESRI, en collaboration avec Claire Mathieu.
Tuesday 24 September 2019Bruno Courcelle et Yves Métivier (LaBRI) Arbres infinis réguliers et revêtements universels de graphes finis
The notion of graph covering, from which we get that of a universal covering (an infinite tree) is important in the theory of distributed computing. This aspect will be first reviewed by Yves Métivier. Universal coverings of finite graphs are regular infinite trees, but not all of them. They can be characterized as the strongly regular trees, i.e. those trees that yield finitely regular rooted trees up to isomorphism when taking any vertex as a root. A few words will be said about a beautiful and difficult theorem by Leighton. These facts will be presented by B. Courcelle (and also at BWG 2019).
Tuesday 10 September 2019Anantha Padmanabha (IMSC, Chennai) Two variable fragment of Term Modal logic
Multi-modal logics are commonly used to reason about systems of processes. Typically, we have formulas of the form Box_i alpha where "i" comes from a fixed finite set of agents or processes. In dynamic networks, the number of agents cannot be fixed a priori, and may even change from state to state. We are thus led to Term Modal Logic (TML) where variables range over agent names and we have quantification of such variables; the logic has formulas such as forall x (P(x) implies Box_x alpha). Thus TML is a first order logic in which we can talk of agent properties as predicates and also use modalities to talk about the moves by agents. As expected, this logic is highly undecidable. In this talk we consider the two variable fragment of TML and prove that it is decidable. This is in contrast to two-variable First order modal logic, which is undecidable. This is a joint work with Prof. R. Ramanujam and will be presented at MFCS, 2019.
Tuesday 09 July 2019Loïc Paulevé (CNRS, LaBRI) Most permissive semantics of Boolean networks
Dynamics of Boolean networks (BNs) are usually computed according to a fixed update mode (synchronous, asynchronous, etc.). However, update modes can miss important behaviours actually realisable in more concrete multilevel or quantitative models. We introduce the most permissive semantics of BNs which guarantees a correct over-approximation of behaviours of any multilevel refinement. Moreover, it turns out that analysing the most permissive dynamics of BNs is much simpler than with update modes: reachability is PTIME (instead of PSPACE-complete), and identifying attractors is NP-complete (instead of PSPACE-complete). Therefore, computing reachable attractors become tractable to very large networks, without any assumption on their structure. We conclude on the impact for the synthesis of BNs from reachability and stability constraints. https://arxiv.org/abs/1808.10240
Tuesday 02 July 2019Sreejith A V (IIT Goa) Block products for algebras over countable words
We look at words which are mappings from a countable linear ordering to a finite alphabet. Finite words, Omega words etc satisfy the above condition. In this talk, we study the languages (of words) definable by different logics. We consider monadic second order logic, first order logic, linear temporal logic etc. These logics can be characterized by an algebra called o-algebra and its subclasses. We first present a block product principle. Building on this, we generalize the well-known algebraic characterizations of first-order logic (resp. first-order logic with two variables) in terms of strongly (resp. weakly) iterated block products. We also explicate the role of block products for linear temporal logic by formulating a novel algebraic characterization of a natural fragment.
Tuesday 25 June 2019Yann Strozecki (Université de Versailles Saint-Quentin) Solving Simple Stochastic Games with few RandomNodes faster using Bland’s Rule
A simple stochastic game, SSG for short, is a two-player zero-sum game, a turn-based version of stochastic games. SSGs were introduced by Condon and provide a general framework that allows to study algorithmic complexity issues underlying reachability objectives. The best algorithm so far for solving SSGs is Ludwig’s randomized algorithm which works in expected 2^O(sqrt(n)) time. We first give a simpler iterative variant of this algorithm, using Bland’s rule from the simplex algorithm, which uses exponentially less random bits than Ludwig’s version. Then, we show how to adapt this method to the algorithm of Gimbert and Horn whose worst case complexity is O(k!), where k is the number of random nodes. Our algorithm has an expected running time of 2^O(k) , and works for general random nodes with arbitrary outdegree and probability distribution on outgoing arcs.
Tuesday 18 June 2019Matthew Hague (University of London) Generic and Complete Algorithms for Straight-Line String Constraints
Path-feasibility is an important problem in the symbolic execution of string-manipulating programs. A symbolic path is given as a finite, loop-free sequence of assertions and assignments and the task is to find concrete instantiations of the symbolic variables that satisfy all assertions along the path. If such instantiations are found, then the path is feasible. Such a path may witness an error in the program being analysed. Recent research has identified a number of string operations that can be supported by path-feasibility algorithms. We contribute two semantic conditions, which, if satisfied by the assertions and assignments in the program, imply decidability of the path-feasibility problem. This decidability is shown via a generic feasibility-checking algorithm. We have implemented this algorithm in a tool OSTRICH, which checks satisfiability of straight-line string constraints (paths). We have compared this tool with other leading solvers over a wide range of popular benchmarks. OSTRICH is competitive on well-supported benchmarks, while also increasing the expressivity and extensibility of the string-constraints supported.
Tuesday 11 June 2019Anca Muscholl (LaBRI) The many facets of string transducers
The talk will be a survey on some recent results about string transducers. It is based on an invited talk at STACS’19 and a survey co-authored with Gabriele Puppis. It will also address a result to appear at ICALP’19, about the decidability of the equivalence problem for finitely valued streaming string transducers.
Tuesday 04 June 2019Igor Walukiewicz (LaBRI) LambdaY-calculus with priorities
We will start with another view on alternating automata over finite ranked trees. We will see an automaton as powerset algebra with a monotone operation for each letter of the alphabet. Every automaton determines a finite powerset algebra with operations, and every finite powerset algebra determines an automaton. The advantage of powerset algebras is that they can be easily made to interpret simply typed lambda terms, while it is not obvious how to run an automaton on a lambda-term. The correspondence between automata and finite powerset algebras shows that finite powerset algebras can recognize exactly the properties of simply-typed lambda-terms expressible by tree automata. The goal of this talk is to present a similar correspondence but for parity automata and simply-typed lambda-terms with fixpoints, known as lambdaY-terms. For this we need to restrict lambdaY-terms to lambdaY-terms with priorities. As a counterpart of finite powerset algebras we obtain not all parity automata but only visibly-parity automata. The talk will not assume a familiarity with the lambda-calculus.
Tuesday 28 May 2019Karoliina Lehtinen (University of Liverpool) Parity, Buchi, Weak
This talk is about the trade-offs between different acceptance conditions for omega-word automata. I will present recent improvements that bring the blow-up up incurred during the translation of alternating parity automata into Buchi (and weak) automata into line with the current algorithms solving parity games. I will finish by discussing the gap between the upper and lower bounds for this problem, and what it tells us about where to go next. The technical part of this talk is based on currently unpublished work with Laure Daviaud and Marcin Jurdzinski on quasi-polynomially sized Buchi automata that use universal trees to recognise winning strategies in infinite parity games of fixed width.
Tuesday 21 May 2019Tobias Kappé (University College London) Kleene Algebras
Kleene Algebra (KA) is a paradigm for reasoning about equivalence between programs. Its (sound and complete) axioms allow us to answer verification questions such as "does program A refine specification B?" or "is this transformation semantics-preserving?". As a matter of fact, queries such as these can be answered mechanically. In recent years, extensions and refinements of KA have been proposed, each of which can be applied to reason about different kinds of programs in more detail. The question then arises: can we find sound and complete axioms for these variants? And can equivalence queries be similarly mechanised? While each flavour of KA has its own idiosyncrasies, it turns out that there are some common techniques that pop up when considering these questions. We start out with a brief introduction to KA, and then consider the features of three variants (synchronous, concurrent and guarded). For each variant, we discuss results and ongoing efforts towards axiomatisation and decidability, and the techniques that have proven successful so far. This talk includes joint work with Paul Brunet, Nate Foster, Justin Hsu, Dexter Kozen, Bas Luttik, Jurriaan Rot, Alexandra Silva, Steffen Smolka, Jana Wagemaker and Fabio Zanasi.
Tuesday 14 May 2019Joanna Ochremiak (CNRS, LaBRI) On the power of symmetric linear programs
We consider families of symmetric linear programs (LPs) that decide a property of graphs in the sense that, for each size of graph, there is an LP defining a polyhedral lift that separates the integer points corresponding to graphs with the property from those corresponding to graphs without the property. We show that this is equivalent, with at most polynomial blow-up in size, to families of symmetric Boolean circuits with threshold gates. In particular, when we consider polynomial-size LPs, the model is equivalent to definability in a non-uniform version of fixed-point logic with counting. This is joint work with Albert Atserias and Anuj Dawar.
Tuesday 07 May 2019Charles Paperman (Université de Lille) Topological Sorting under Regular Constraints
In this talk, I will present a joint work with Antoine Amarilli, published at ICALP 18 about what we call the constrained topological sorting problem (CTS): given a regular language K and a directed acyclic graph G with labeled vertices, determine if G has a topological sort that forms a word in K. This natural problem applies to several settings, e.g., scheduling with costs or verifying concurrent programs. I will present a complexity study to solve this problem with respect to some properties of the target regular language.
Tuesday 30 April 2019Pierre Clairambault (CNRS, ENS Lyon) Linearity in Higher-Order Recursion Schemes
Higher-Order Model-Checking (HOMC) has recently emerged as an approach to automated verification of higher-order programs, prompted by Ong's 2006 result that Monadic Second Order Logic (MSO) is decidable on infinite trees generated by Higher-Order Recursion Schemes (HORS). Implementations report encouraging results despite an awful theoretical worst case complexity. In principle, HOMC algorithms work by reduction to Ong's theorem. In practice, this often involves CPS translations which are costly in terms of complexity, and so as to get tight complexity people have instead reproved variations of Ong's theorem for extensions of HORS (with data, or call-by-value) and drastically restricted fragments of MSO. In this talk, I will introduce Linear HORS (LHORS), an extension of HORS with additional type constructors imported from Linear Logic. Data and call-by-value evaluation admit a finer translation to LHORS exploiting the idea of linearly-used continuations. Moreover LHORS enjoy a decidable model-checking problem, whose complexity essentially ignores linear types. In this way we recover and extend several developments that were originally proved independently of Ong's theorem. This is joint work with Andrzej Murawski and Charles Grellois, presented at POPL'18.
Tuesday 16 April 2019Uri Zwick (Tel Aviv University) Faster k-SAT algorithms using biased-PPSZ
The PPSZ algorithm, due to Paturi, Pudlak, Saks and Zane, is currently the fastest known algorithm for the k-SAT problem, for every k>3. For 3-SAT, a tiny improvement over PPSZ was obtained by Hertli. We introduce a biased version of the PPSZ algorithm using which we obtain an improvement over PPSZ for every k>=3. For k=3 we also improve on Herli's result and get a much more noticeable improvement over PPSZ, though still relatively small. In particular, for Unique 3-SAT, we improve the current bound from 1.308^n to 1.307^n. Joint work with Thomas Dueholm Hansen, Haim Kaplan and Or Zamir
Tuesday 09 April 2019Donald Stull (Université de Lorraine, LORIA) Selection, Divergence, and Dichotomy
The Schnorr-Stimm dichotomy theorem concerns finite-state gamblers that bet on infinite sequences of symbols taken from a finite alphabet. The theorem asserts that, for each such sequence S, the following two things are true. 1. If S is normal in the sense of Borel (meaning that any two strings of equal length appear with equal asymptotic frequency in S), then every finite-state gambler loses money at an exponential rate betting on S. 2. If S is not normal, then there is a finite-state gambler that wins money at an exponential rate betting on S. In this paper we use the Kullback-Leibler divergence (also known as the relative entropy) to generalize the dichotomy theorem to arbitrary probability measures on the alphabet and to quantify the exponential rates of winning and losing on the two sides of the dichotomy.
Tuesday 02 April 2019Sarah Winter (RWTH Aachen) Parameterized synthesis of sequential transducers from rational relations over finite words
The synthesis problem asks, given a specification that relates possible inputs to allowed outputs, whether there is a program realizing the specification, and if so, construct one. We consider synthesis of sequential transducers with synchronization parameters from rational relations over finite words. A sequential transducer is basically a deterministic finite automaton that outputs a finite word on each transition. A word relation can be represented by a set of synchronizations, called synchronization language. A synchronization of a pair of words is a single word where each position is annotated over {1,2}, which indicates whether it came from the input or output component, e.g., the synchronization (1a 2a 2b 1b 2a) represents the pair (ab,aba). The decision problems that have been studied so far either ask for synthesis by a synchronous sequential or by an arbitrary sequential transducer. We ask whether a sequential transducer whose allowed input/output behavior is specified by a given synchronization language can be synthesized from a given rational relation. The given synchronization language is referred to as synchronization parameter. Recently, main classes of rational relations have been characterized in terms of admissible synchronization languages, and we study the above problem for different combinations of classes of rational relations and classes of synchronization languages. The problem is undecidable in general, because it is known to be undecidable whether an arbitrary sequential transducer can be synthesized from a rational relation. For automatic relations (also called synchronized rational relations) it is known that it is decidable whether an arbitrary sequential transducer or a synchronous sequential transducer can be synthesized. Regarding our framework, the key contribution is that it is decidable whether a sequential transducer whose synchronization language lies within a given "automatic" synchronization language can be synthesized from an automatic relation.
Tuesday 26 March 2019Grégoire Sutre (LaBRI) Reachability for Two-Counter Machines with One Test and One Reset
We prove that the reachability relation of two-counter machines with one zero-test and one reset is Presburger-definable and effectively computable. Our proof is based on the introduction of two classes of Presburger-definable relations effectively stable by transitive closure. This approach generalizes and simplifies the existing different proofs and it solves an open problem introduced by Finkel and Sutre in 2000. This is a joint work with Alain Finkel and Jérôme Leroux.
Tuesday 19 March 2019Vaishnavi Sundararajan (IRISA, Rennes) A theory of assertions for Dolev-Yao models
We undertake an abstract study of certification in security protocols, concentrating on the logical properties and derivability of certificates. Specifically, we extend the Dolev-Yao model with a new class of objects called ‘assertions’, along with an associated algebra for deriving new assertions from old ones. We also provide a case study via the FOO e-voting protocol, and provide algorithms for the derivability problem and the active intruder problem for this system.
Tuesday 12 March 2019Nathanaël Fijalkow (CNRS, LaBRI) The complexity of mean payoff games using universal graphs
We study the computational complexity of solving mean payoff games. This class of games can be seen as an extension of parity games, and they have similar complexity status: in both cases solving them is in NP and coNP and not known to be in P. In a breakthrough result Calude, Jain, Khoussainov, Li, and Stephan constructed in 2017 a quasipolynomial time algorithm for solving parity games, which was quickly followed by two other algorithms with the same complexity. Our objective is to investigate how these techniques can be extended to the study of mean payoff games. We construct two new algorithms for solving mean payoff games. Our first algorithm depends on the largest weight N (in absolute value) appearing in the graph and runs in sublinear time in N, improving over the previously known linear dependence in N . Our second algorithm runs in polynomial time for a fixed number k of weights.
Tuesday 05 March 2019Bruno Courcelle (LaBRI) Betweenness in order-theoretical trees
The ternary betweenness relation on a tree, B(x,y,z), indicates that y is on the unique path between x and z. This notion can be extended to order-theoretic trees defined as partial orders such that the set of nodes greater than any node is linearly ordered. In such generalized trees, the unique "path" between two nodes can have infinitely many nodes. We axiomatize in first-order or monadic second-order logic several betweenness relations in order-theoretical trees.
Tuesday 12 February 2019Marc Noy (Universitat Politècnica de Catalunya) Logic and random graphs
We look at properties of graphs that can be expressed in first order (FO) logic. Given such a property A and a class G of random graphs, we are interested in the limiting probability that a graph in G satisfies A, when the number of vertices goes to infinity. First we survey what is known for the classical model G(n,p), including zero-one laws and the celebrated theorem of Shelah and Spencer. Then we move to classes of graphs defined by a global condition, such as being acyclic or planar, under the uniform distribution. We survey recent results on zero-one laws, convergence laws, and non-convergence phenomena, both in FO and in the stronger monadic second order (MSO) logic. In particular, for graphs embeddable in a fixed surface other than the sphere, there is a striking difference between the results in FO and MSO logic.
Monday 11 February 2019Paul-Elliot Angles d'Auriac (Institut Camille Jordan, Lyon) TBA
TBA
Tuesday 05 February 2019Nathan Grosshans (ENS Paris) The power of programs over monoids taken from some small varieties of finite monoids
The computational model of programs over monoids, introduced by Barrington and Thérien in the late 1980s, gives a way to generalise the notion of (classical) recognition through morphisms into monoids in such a way that almost all open questions about the internal structure of the complexity class NC^1 can be reformulated as understanding what languages (and, in fact, even regular languages) can be program-recognised by monoids taken from some given variety of finite monoids. Unfortunately, for the moment, this finite semigroup theoretical approach did not help to prove any new result about the internal structure of NC^1 and, even worse, any attempt to reprove well-known results about this internal structure (like the fact that the language of words over the binary alphabet containing a number of 1s not divisible by some fixed integer greater than 1 is not in AC^0) using techniques stemming from algebraic automata theory failed. In this talk, I shall present the model of programs over monoids, explain how it relates to "small" circuit complexity classes and present some of the contributions I made during my Ph.D. thesis to the understanding of the computational power of programs over monoids, focusing on the well-known varieties of finite monoids DA and J (giving rise to "small" circuit complexity classes well within AC^0). I shall conclude with a word about ongoing work and future research directions.
Tuesday 29 January 2019Meghyn Bienvenu (LaBRI) Ontology-Mediated Query Answering with OWL 2 QL Ontologies: Combined Complexity and Succinctness of Rewritings
The problem of ontology-mediated query answering (OMQA) has gained significant interest in recent years. One popular ontology language for OMQA is OWL 2 QL, a W3C standardized language based upon the DL-Lite description logic. This language has the desirable property that OMQA can be reduced to database query evaluation by means of query rewriting. In this talk, I will consider two fundamental questions about OMQA with OWL 2 QL ontologies: 1) How does the worst-case complexity of OMQA vary depending on the structure of the ontology-mediated query (OMQ)? In particular, under what conditions can we guarantee tractable query answering? 2) Is it possible to devise query rewriting algorithms that produce polynomial-size rewritings? More generally, how does the succinctness of rewritings depend on OMQ structure and the chosen format of the rewritings? After classifying OMQs according to the shape of their conjunctive queries (treewidth, the number of leaves) and the existential depth of their ontologies, we will determine, for each class, the combined complexity of OMQ answering, and whether all OMQs in the class have polynomial-size first-order, positive existential and nonrecursive datalog rewritings. The succinctness results are obtained using hypergraph programs, a new computational model for Boolean functions, which makes it possible to connect the size of OMQ rewritings and circuit complexity. This talk is based upon a recent JACM paper co-authored with Stanislav Kikot, Roman Kontchakov, Vladimir Podolskii, and Michael Zakharyaschev.
Tuesday 22 January 2019Vincent Penelle (LaBRI) On the Boundedness Problem for Higher-Order Pushdown Vector Addition Systems
Karp and Miller's algorithm is a well-known decision procedure that solves the termination and boundedness problems for vector addition systems with states (VASS), or equivalently Petri nets. This procedure was later extended to a general class of models, well-structured transition systems, and, more recently, to pushdown VASS. In this paper, we extend pushdown VASS to higher-order pushdown VASS (called HOPVASS), and we investigate whether an approach à la Karp and Miller can still be used to solve termination and boundedness. We provide a decidable characterisation of runs that can be iterated arbitrarily many times, which is the main ingredient of Karp and Miller's approach. However, the resulting Karp and Miller procedure only gives a semi-algorithm for HOPVASS. In fact, we show that coverability, termination and boundedness are all undecidable for HOPVASS, even in the restricted subcase of one counter and an order 2 stack. On the bright side, we prove that this semi-algorithm is in fact an algorithm for higher-order pushdown automata. This is a joint work with Sylvain Salvati and Grégoire Sutre.
Tuesday 15 January 2019Marie van den Bogaard (Université Libre de Bruxelles) Beyond admissibility: Dominance between chains of strategies
In this talk, we focus on the concept of rational behaviour in multi-player games on finite graphs, taking the point of view of a player that has access to the structure of the game but cannot make assumptions on the preferences of the other players. In the qualitative setting, admissible strategies have been shown to fit the rationality requirements, as they coincide with winning strategies when these exist, and enjoy the fundamental property that every strategy is either admissible or dominated by an admissible strategy. However, as soon as there are three or more payoffs, one finds that this fundamental property does not necessarily hold anymore: one may observe chains of strategies that are ordered by dominance and such that no admissible strategy dominates any of them. Thus, to recover a satisfactory rationality notion (still based on dominance), we depart from the single strategy analysis approach and consider instead chains of strategies as families of behaviours. We establish a sufficient criterion for games to enjoy a similar fundamental property, ie, all chains are below some maximal chain, and, as an illustration, we present a class of games where admissibility fails to capture some intuitively rational behaviours, while our chain-based analysis does. Based on a joint work with N.Basset, I. Jecker, A. Pauly and J.-F. Raskin, presented at CSL'18.
Tuesday 08 January 2019Gabriele Puppis (LaBRI) Unambiguous Register Automata
In the literature we find many computation models whose expressiveness goes beyond finite automata, however without attaining the full power of Turing machines. The common practice is to enrich finite automata with some internal memory (e.g. counters, clocks, stacks, etc.) that can be used to store, manipulate, and compare data from a potentially infinite domain. An intriguing model that results from this practice is the model of register automaton, which is essentially a finite automaton equipped with a finite number of registers. Register automata are used to recognize languages over infinite alphabets. The deterministic, unambiguous, and non-deterministic variants of these automata form a hierarchy of strictly increasing expressive power, where the bottom and top levels have, respectively, decidable and undecidable equivalence problems. Accordingly, the intermediate class of unambiguous register automata is an interesting object of study, since it is believed to be robust and algorithmically well-behaved. In this talk I will present some preliminary results obtained with Thomas Colcombet and Michal Skrzypczak towards proving the following conjecture: unambiguous register automata have a decidable equivalence problem and form the largest subclass of non-deterministic register automata that is closed under complement.
Tuesday 18 December 2018David Carral (TU Dresden) Reasoning over Existential Rules with Acyclicity Notions
The chase is a sound and complete (albeit non-terminating) algorithm for conjunctive query answering over ontologies of existential rules. On the theoretical side, we develop sufficient conditions to guarantee its termination (i.e., acyclicity notions), and study several restrictions that furthermore ensure its polynomiality. On the practical side, we empirically study the generality of these conditions and we extend the Datalog engine VLog to develop an efficient implementation of the chase. Furthermore, we conduct an extensive evaluation, and show that VLog can compete with the state of the art, regarding runtime, scalability, and memory efficiency.
Tuesday 11 December 2018Filip Mazowiecki (LaBRI) When are Emptiness and Containment Decidable for Probabilistic Automata?
The emptiness and containment problems for probabilistic automata are natural quantitative generalisations of the classical language emptiness and inclusion problems for Boolean automata. It is well known that both problems are undecidable. In this paper we provide a more refined view of these problems in terms of the degree of ambiguity of probabilistic automata. We show that a gap version of the emptiness problem (that is known be undecidable in general) becomes decidable for automata of polynomial ambiguity. We complement this positive result by showing that the emptiness problem remains undecidable even when restricted to automata of linear ambiguity. We then turn to finitely ambiguous automata. Here we show decidability of containment in case one of the automata is assumed to be unambiguous while the other one is allowed to be finitely ambiguous. Our proof of this last result relies on the decidability of the theory of real exponentiation, which has been shown, subject to Schanuel's Conjecture, by Macintyre and Wilkie.
Tuesday 04 December 2018Nathanaël Fijalkow (LaBRI) Data generation for programme synthesis
Programming by example is the problem of synthesising a program from a small set of pairs input and output. Despite having found applications in several areas it is notoriously computationally expensive. Recent works have considered hybrid approaches combining ML and PL based techniques. These techniques require generating a training dataset, which leads to significant difficulties related to finding the most informative inputs to characterise a given programme. In this paper we show that the data generation procedure has a significant impact on performance. The novelty of our approach relies on using an SMT solver to synthesize meaningful inputs with varied behaviour for a given program. By testing against several distributions, we show that our constraint-based approach improves on the generalizability of the models. Our results are consistent across two common learning architectures used in previous work.
Tuesday 20 November 2018Laurent Bienvenu (LaBRI) Optimal bounds for single-source Kolmogorov extractors
The rate of randomness (or dimension) of a binary string x is the ratio C(x)/|x| where C(x) is the Kolmogorov complexity of x. While it is known that a single computable transformation cannot increase the rate of randomness of all strings, Fortnow et al. showed that for any 0<alpha<beta<1, there are a finite number of computable transformations such that any string of rate at least alpha is turned into a string of rate at least beta by one of these transformations (ICALP 2006). However, their proof only gives very loose bounds on the correspondence between the number of transformations and the increase of rate of randomness one can achieve. Further work of Zimand (CCC 2011) gave a more precise estimate, but the exact correspondence between the number of computable transformations and the achievable rate of randomness increase remained an open question. By translating this problem to combinatorics on (hyper)graphs, we provide a tight bound, namely: Using k transformations, one can get an increase from rate alpha to any rate beta < kalpha/(1+(k-1)alpha), and this is optimal. This is joint work with Barbara Csima and Matthew Harrison-Trainor
Tuesday 13 November 2018Sylvain Schmitz (LSV, ENS Cachan) Complexity bounds for bisimulation equivalence in first-order grammars
Following Géraud Sénizergues' seminal results twenty years ago on the decidability of language equivalence of deterministic pushdown automata and of (weak) bisimilation equivalence of (epsilon-popping) pushshdown automata, several works have attempted to provide complexity bounds for these problems. For instance, some significant simplifications over the original proofs were provided by Colin Stirling and Petr Jancar, using in particular the formalism of first-order grammars instead of pushdown automata, and resulting in Tower upper bounds for the language equivalence problem in deterministic systems. But no complexity bounds were known for the bisimulation equivalence problem. In this talk, I will cover some work in progress with Petr Jancar. Using a recent reformulation of the proofs for checking bisimulation equivalence as a black box, I will show how to provide Ackermannian upper bounds for the crucial step, which is the computation of a so-called `candidate basis'. This entails that the decision problem itself is Ackermann-complete, thanks to a lower bound proven by Petr Jancar a few years ago; this is the first known completeness result in this entire line of work.
Tuesday 06 November 2018Jérôme Leroux (LaBRI) The Reachability Problem for Petri Nets is Not Elementary
Petri nets, also known as vector addition systems, are a long established and widely used model of concurrent processes. The complexity of their reachability problem is one of the most prominent open questions in the theory of verification. That the reachability problem is decidable was established by Mayr in his seminal STOC 1981 work, and the currently best upper bound is non-primitive recursive cubic-Ackermannian of Leroux and Schmitz from LICS 2015. We show that the reachability problem is not elementary. Until this work, the best lower bound has been exponential space, due to Lipton in 1976. Joint work with Wojciech Czerwinski, Slawomir Lasota, Ranko Lazic, Filip Mazowiecki.
Tuesday 23 October 2018Cristian Riveros (Pontificia Universidad Catolica de Chile) Foundations of Complex Event Processing
Complex event processing (CEP) emerges as a unified technology for efficiently processing data streams. Contrary to data streams management systems, CEP query languages model data streams as a continuous sequence of events and CEP queries define sets of events (complex events) that are of interest for the final user. In this talk, I will present our recent proposal for giving formal foundations to complex event processing. First, I will introduce complex event logic (CEL), a logical language for extracting complex events, that captures the main features used by CEP systems in practise. Then I will show how to efficiently represent CEL queries through so-called complex event automata, which are symbolic transducers that produce complex events from data streams. Then I will explain how to evaluate complex event automata with constant delay algorithms and present some preliminaries experimental results that show how our approach is order of magnitudes faster than current CEP systems developed in academy and industry. Finally, I will discuss some open problems regarding the connection between automata models, transducers, and constant delay algorithms.
Tuesday 09 October 2018Marie Fortin (LSV, ENS Cachan) It Is Easy to Be Wise After the Event: Communicating Finite-State Machines Capture First-Order Logic with "Happened Before"
Message sequence charts (MSCs) naturally arise as executions of communicating finite-state machines (CFMs), in which finite-state processes exchange messages through unbounded FIFO channels. We study the first-order logic of MSCs, featuring Lamport's happened-before relation. We introduce a star-free version of propositional dynamic logic (PDL) with loop and converse. Our main results state that (i) every first-order sentence can be transformed into an equivalent star-free PDL sentence (and conversely), and (ii) every star-free PDL sentence can be translated into an equivalent CFM. This answers an open question and settles the exact relation between CFMs and fragments of monadic second-order logic. As a byproduct, we show that first-order logic over MSCs has the three-variable property. This is joint work with Benedikt Bollig and Paul Gastin, presented at CONCUR’18.
Tuesday 02 October 2018A. V. Sreejith (IIT Goa) Languages over countable linear orderings
We look at words which are mappings from a countable linear ordering to a finite alphabet. Finite words, Omega words etc satisfy the above condition. We will also look at other kind of words. In this talk, we study the languages (of words) definable by different logics. We consider first order logic, weak monadic second order logic, two variable fragments and a host of other logics. We are interested in the relationship between these logics. Are these logics expressively different? We will show that all these logics can be characterized by an algebraic structure called o-algebra and its subclasses. This helps us compare the respective expressive power of these logics. Moreover, since there is an effective translation to o-algebras from formulas, we have decidability for the satisfiability problem.
Tuesday 25 September 2018María Emilia Descotte (LaBRI) Closure properties of synchronized relations
A standard approach to define k-ary word relations over a finite alphabet A is through k-tape finite state automata that recognize regular languages L over {1, ... , k} x A, where (i,a) is interpreted as reading letter a from tape i. Accordingly, a word w in L denotes the tuple (u_1, ... , u_k) of words over A in which u_i is the projection of w onto i-labelled letters. While this formalism defines the well-studied class of Rational relations, enforcing restrictions on the reading regime from the tapes, which we call "synchronization", yields various sub-classes of relations. Such synchronization restrictions are imposed through regular properties on the projection of the language L onto {1, ... , k}. In this way, for each regular language C over the alphabet {1, ... , k}, one obtains a class Rel(C) of relations. Synchronous, Recognizable, and Length-preserving rational relations are all examples of classes that can be defined in this way. We study basic properties of these classes of relations, in terms of closure under intersection, complement, concatenation, Kleene star and projection. In each case we characterize the classes with the property through a decidable property.
Tuesday 03 July 2018Filip Murlak (University of Warsaw) Ontology-mediated query answering for expressive description logics, or yet another family of (potentially) decidable fragments of first-order logic
Evaluating queries in the presence of background knowledge has been extensively studied in several communities. In database theory, it is known as query answering under integrity constraints: given a finite database instance and a set of constraints, determine answers to a query that are certain to hold over any extension of the given instance that satisfies the constraints. In the knowledge representation community, the database instance and the set of constraints are treated as a single object, called an ontology, but otherwise the problem remains the same, except that different kinds of constraints are interesting. While in database theory constraints are usually very simple, like functionality of relations, or inclusions between relations, in knowledge representation more expressive logics are used. I will focus on so called description logics, which are a family of extensions of modal logic. I will cover some basic techniques, a highly non-trivial result by Rudolph and Glimm (2010), as well as some recent results obtained with Tomek Gogacz (U Warsaw) and Yazmin Ibanez-Garcia (TU Wien).
Tuesday 26 June 2018Sébastien Labbé (LaBRI) On Jeandel-Rao aperiodic tilings
In 2015, Jeandel and Rao showed by exhaustive computer search that every Wang tile set of cardinality <=10 either admit a periodic tiling of the plane or admit no tiling of the plane at all. Moreover, they found a Wang tile set of cardinality 11 which admits tilings of the plane but never periodically. Their algorithm is based on the representation of Wang tilings as the execution of a transducer on biinfinite sequences. In this talk, we present an alternate definition of the aperiodic tilings of Jeandel-Rao as the coding of a $mathbb{Z}^2$-action on the torus. We conjecture that it is a complete characterization.
Tuesday 19 June 2018František Blahoudek (Masaryk University) Semi-deterministic automata: How to obtain and complement them
Semi-deterministic Büchi automata (sDBA) are useful for example in model checking of probabilistic systems or in termination analysis. While in probabilistic model checking sDBA represent the set of behaviours of interest, in termination analysis they represent terminating behaviours of programs and are often complemented to perform a language difference. In my talk, I first introduce the class of semi-deterministic Büchi automata (sDBA). Then I will explain how can we convert nondeterministic Büchi automata (NBA) into sDBA, followed by a discussion on how to efficiently convert generalized Büchi automata into sDBA. After we learn how to build sDBA, I will introduce a complementation algorithm sDBA. The algorithm produces a complement automata with at most 4^n states while the best upper bound on complementation of NBA is O((0.76n)^n). Further, our algorithm produces automata with a very low degree of nondeterminism, indeed, the resulting automata are even unambiguous.
Tuesday 12 June 2018Bruno Guillon (University of Milan) Undecidability of MSO+“ultimately periodic”
We prove that MSO on omega-words becomes undecidable if allowing to quantify over sets of positions that are ultimately periodic, i.e., sets X such that for some positive integer p, ultimately either both or none of positions x and x+p belong to X. We obtain it as a corollary of the undecidability of MSO on omega-words extended with the second-order predicate U1(X) which says that the distance between consecutive positions in a set X of naturals is unbounded. This is achieved by showing that adding U1 to MSO gives a logic with the same expressive power as MSO+U, a logic on omega-words with undecidable satisfiability. This is joint work with Mikolaj Bojanczyk, Laure Daviaud, Vincent Penelle and Sreejith.
Tuesday 05 June 2018Laure Daviaud (University of Warwick) A pseudo-quasi-polynomial algorithm for mean-payoff parity games
In a mean-payoff parity game, one of the two players aims both to achieve a qualitative parity objective and to minimize a quantitative long-term average of payoffs (aka. mean payoff). The game is zerosum and hence the aim of the other player is to either foil the parity objective or to maximize the mean payoff. I will present a pseudo-quasi-polynomial algorithm for solving mean-payoff parity games. All algorithms for the problem that have been developed for over a decade have a pseudo-polynomial and an exponential factors in their running times; in the running time of our algorithm the latter is replaced with a quasi-polynomial one.
Tuesday 22 May 2018K. Narayan Kumar (Chennai Mathematical Institute) Verification of Asynchronous Programs with Nested Locks
We consider asynchronous programs consisting of multiple recursive threads (modeled as pushdown systems) running in parallel. Each of the threads is equipped with a multi-set. The threads can create tasks and post them onto the multi-sets or read a task from their own. In addition, they can synchronize through a finite set of locks. We examine the decidability of the state reachability problem for this model. The problem is already known to be undecidable for a system consisting of two recursive threads (and no tasks) and we examine a decidable subclass. In the first half of the talk we survey, quickly, the previous results for recursive programs communicating via locks and in the second half we will describe our results on the asynchronous program model. Based on Joint work with M.F. Atig, A. Bouajjani and P. Saivasan.
Tuesday 15 May 2018Madhavan Mukund (Chennai Mathematical Institut) Modelling replicated data stores with multiple correctness levels
Replicated data stores typically sacrifice strong consistency guarantees in favour of availability and partition tolerance. These data stores usually provide specific weaker consistency guarantees, such as eventual consistency, monotonic reads or causal consistency. Recently, there have been proposals for data stores that support multiple consistency guarantees. An example is a speculative response based on a quick local check, followed by either a confirmation or an "apology" after a more detailed reconciliation of updates. A typical situation is an online purchase where the order is initially confirmed and later you are told the item is out of stock. We describe a formal semantics for replicated data-stores with multiple correctness levels and explore decidability issues. This is ongoing joint work with Ahmed Bouajjani, Constantin Enea, Gautham Shenoy R and S P Suresh.
Tuesday 24 April 2018Armin Weiß (Stuttgart University) The isomorphism problem for virtually free group
Since Muller and Schupp's result it is well-known that the finitely generated virtually free groups are precisely the context-free groups. The isomorphism problem for virtually free groups, has shown to be decidable by Kristic. In the special case that the input groups are either given as context-free grammars for their word problems or as so-called virtually free presentations, it is primitive recursive by the work of Sénizergues. In this talk I will present an elementary time solution for these two special cases. The proof is based on analyzing the structure trees assigned to the Cayley graphs of the input groups. By Bass-Serre theory this yields graphs of groups which can be tested for isomorphism as in Kristic's algorithm. The talk is based on joint work with Géraud Sénizergues and Volker Diekert.
Tuesday 17 April 2018Pierre Ohlmann (IRIF, Paris 7) Arithmetic circuits as automata, and applications
We give a syntactic correspondence between non-associative arithmetic circuits and acyclic weighted tree automata. We may then export results from automata theory to non-associative circuits and characterize the size of a minimal circuit for a given polynomial as the rank of a Hankel matrix. We will then show how this can be used to re-obtain Nisan's theorem on Algebraic Branching Programs as well as recent results on Unique Parse Tree circuits. Lastly, we will highlight a new way of obtaining lower bounds for general (associative) arithmetic circuits.
Tuesday 10 April 2018Nathanaël Fijalkow (LaBRI) The State Complexity of Alternating Automata
We study the complexity of languages of finite words using automata theory. To go beyond the class of regular languages, we consider infinite automata and the notion of state complexity defined by Karp. We look at alternating automata as introduced by Chandra, Kozen and Stockmeyer: such machines run independent computations on the word and gather their answers through boolean combinations. We devise a lower bound technique relying on boundedly generated lattices of languages, and give two applications of this technique. The first is a hierarchy theorem, stating that there are languages of arbitrarily high polynomial alternating state complexity, and the second is a linear lower bound on the alternating state complexity of the prime numbers written in binary. This second result strengthens a result of Hartmanis and Shank from 1968, which implies an exponentially worse lower bound for the same model. To be presented at LICS'18.
Tuesday 03 April 2018Louis-Marie Dando (LaBRI) On Rotating Q-Automata
I present results on rotating Q-automata, which are (memoryless) automata with weights in Q that can read the input tape from left to right several times. We show that the series realized by valid rotating Q-automata are Q-Hadamard series (which are the closure of Q-rational series by pointwise inverse), and that every Q-Hadamard series can be realized by such an automaton. We prove that, although validity of rotating Q-automata is undecidable, the equivalence problem is decidable on rotating Q-automata. Finally, we prove that every valid two-way Q -automaton admits an equivalent rotating Q-automaton. The conversion, which is effective, implies the decidability of equivalence of two-way Q-automata.
Tuesday 27 March 2018Valia Mitsou (Université Paris Diderot, IRIF) Limitations of treewidth for problems beyond NP.
***Joint seminar with Graphes et Optimisation*** In this seminar, we will take a closer look at the parameterized complexity of existsforallSAT, the prototypical complete problem of the class $Sigma^p_2$, the second level of the polynomial hierarchy. We will provide tight fine-grained bounds on the complexity of this problem with respect to the most important structural graph parameters. Specifically we will show that existsforallSAT cannot be solved in time $2^{2^{o(tw)}}$ under the Exponential Time Hypothesis. More strongly, we establish the same bound with respect to the formula’s primal vertex cover, a much more restrictive measure. Our reduction is a 'textbook' reduction that could be used in order to provide similar lower bounds for problems in the second level of the polynomial hierarchy.
Tuesday 20 March 2018Dominik Velan (Masaryk University) Asymptotic Bounds on Termination Time in VASS
Vector Addition Systems with States (VASS) provide a well-known and fundamental model for the analysis of concurrent processes, parametrized systems, and are also used as abstract models of programs in resource bound analysis. We study the problem of obtaining asymptotic bounds on the termination time of a given VASS. In particular, we focus on the practically important case of obtaining polynomial bounds on termination time. First, I will present a characterization for VASS with linear asymptotic complexity. I will also show that if a complexity of a VASS is not linear, it is at least quadratic. Second, I will talk about classification of VASS according to quantitative properties of their cycles. I will show that certain singularities in these properties are the key reason for their non-polynomial asymptotic complexity. In absence of singularities, I will show that the asymptotic complexity is always polynomial and of the form Theta(n^k), for some integer k <= d. I will present a polynomial-time algorithm computing the integer k. The results are based on insights into the geometry of VASS dynamics, which hold the potential for further applicability to VASS analysis.
Tuesday 13 March 2018Jérôme Leroux (LaBRI) Polynomial Vector Addition Systems With States
The reachability problem for vector addition systems is one of the most difficult and central problem in theoretical computer science. The problem is known to be decidable, but despite instance investigations during the last four decades, the exact complexity is still open. For some sub-classes, the complexity of the reachability problem is known. Structurally bounded vector addition systems, the class of vector addition systems with finite reachability sets from any initial configuration, is one of those classes. In fact, the reachability problem was shown to be polynomial-space complete for that class by Praveen and Lodaya in 2008. Surprisingly, extending this property to vector addition systems with states is open. In fact, there exist vector addition systems with states that are structurally bounded but with Ackermannian large sets of reachable configurations. It follows that the reachability problem for that class is between exponential space and Ackermannian. In this paper we introduce the class of polynomial vector addition systems with states, defined as the class of vector addition systems with states with size of reachable configurations bounded polynomially in the size of the initial ones. We prove that the reachability problem for polynomial vector addition systems is exponential-space complete. Additionally, we show that we can decide in polynomial time if a vector addition system with states is polynomial. This characterization introduces the notion of iteration scheme with potential applications to the reachability problem for general vector addition systems.
Tuesday 06 March 2018Pierre Casteran (LaBRI) The hydra and the rooster
The Hydra game was introduced in 1982 by the mathematicians L. Kirby and J. Paris in their article: "Accessible Independence Results for Peano Arithmetic". This article contains two theorems: 1. Whichever the strategy of Hercules and the Hydra, any battle eventually terminates with Hercules' victory. 2. The previous result cannot be proved in Peano Arithmetic. We present a formal, self-contained (axiom-free) proof of a variant of both theorems, with the help of the Coq proof assistant. Since Coq's logic is higher-order intuitionnistic logic, the reference to Peano Arithmetic is replaced with a study of a class of proofs of termination indexed by ordinal numbers less or equal than epsilon_0. We present the main parts of this proof, as well as the main features of Coq that made its construction possible.
Tuesday 27 February 2018María Emilia Descotte (LaBRI) Resynchronizing Classes of Word Relations
A natural approach to defining binary word relations over a finite alphabet A is through two-tape finite state automata, which can be seen as regular languages L over the alphabet {1,2}xA, where (i,a) is interpreted as reading letter a from tape i. Thus, a word w of the language L denotes the pair (u_1,u_2) in A* x A* in which u_i is the projection of w onto i-labelled letters. While this formalism defines the well-studied class of Rational relations (a.k.a. non-deterministic finite state transducers), enforcing restrictions on the reading regime from the tapes, that we call synchronization, yields various sub-classes of relations. Such synchronization restrictions are imposed through regular properties on the projection of the language onto {1,2}. In this way, for each regular language C contained in {1,2}*, one obtains a class Rel(C) of relations, such as the classes of Regular, Recognizable, or length-preserving relations, as well as (infinitely) many other classes. We study the problem of containment for synchronized classes of relations: given C,D sub-languages of {1,2}*, is Rel(C) contained in Rel(D)? We show a characterization in terms of C and D which gives a decidability procedure to test for class inclusion. This also yields a procedure to re-synchronize languages from {1,2}xA preserving the denoted relation whenever the inclusion holds.
Tuesday 13 February 2018Michael Raskin (LaBRI) Complementing the languages of unambigous automata
Unambiguous non-deterministic finite automata have intermediate expressive power and succinctness between deterministic and non-deterministic automata. It has been conjectured that every unambiguous non-deterministic one-way finite automaton (1UFA) recognizing some language L can be converted into a 1UFA recognizing the complement of the original language L with polynomial increase in the number of states. A counterexample to this conjecture using only the 1-letter alphabet will be presented.
Tuesday 06 February 2018Lukas Fleischer (Stuttgart University) The Complexity of Decision Problems for Recognizing Morphisms
We discuss the complexity of decision problems on regular languages represented by morphisms to finite semigroups. There are two canonical ways of specifying the semigroup: giving its multiplication table or an implicit description as the subsemigroup of a transformation semigroup (generated by the images of the given morphism). For both representations, we will consider * the membership problem, * the emptiness/universality/inclusion/equivalence problems, * the intersection non-emptiness problem, and their restrictions to a certain classes of finite semigroups. Complexity results and open problems will be presented.
Tuesday 30 January 2018David Janin (LaBRI) Animation 3D et produit semi-direct
We define a simple and sound mathematical framework for describing temporal media programming language semantics based on the various concepts offered by semigroup theory. As a result a fairly general programming scheme can be defined in order to specify, compose and render both spatial media objects (e.g. 3D drawings) and timed media objects (e.g. Animation or Music). As an example, a simple monoid based semantics model of the turtle command language of Logo is detailed and extended throughout. Joint work with Simon Archipoff
Tuesday 23 January 2018Filip Mazowiecki (LaBRI) Pumping lemmas for weighted automata
We present three pumping lemmas for three classes of functions definable by fragments of weighted automata over the min-plus semiring and the semiring of natural numbers. As a corollary we show that the hierarchy of functions definable by unambiguous, finitely-ambiguous, polynomially-ambiguous weighted automata, and the full class of weighted automata is strict for the min-plus semiring. This is joint work with Cristian Riveros to be presented at stacs 2018.
Tuesday 09 January 2018Philippe Duchon (LaBRI) Simulabilité à mémoire finie de lois de probabilités continues
On s'intéresse à la question de la simulation exacte de lois de probabilités continues sur les réels, et plus précisément, à identifier quelles lois sont simulables exactement en n'utilisant qu'une mémoire finie - le modèle naturel étant une variante d'automates probabilistes, mais il est facile de voir que divers modèles sont équivalents (au moins au sens probabiliste de "presque sûrement"). Le premier résultat sur la question est une condition nécessaire dûe à Knuth et Yao, il y a plus de 40 ans: une loi à densité, et dont la densité est donnée par une fonction analytique, n'est pas simulable par automate si sa densité n'est pas en fait donnée par un polynôme. Je présenterai des résultats récents, qui permettent de caractériser les lois simulables parmi celles dont la densité est donnée par une fonction polynomiale par morceaux (de manière semi constructive dans le cas positif); et je discuterai de possibles extensions au cas multidimensionnel.
Tuesday 12 December 2017Cyril Gavoille (LaBRI) La coloration de graphe dans le modèle LOCAL - Partie II
Partie II: - Coloration rapide des cycles - Borne inférieure en log* sur la coloration des cycles (preuve de Linial) - Une preuve alternative fondé sur le théorème de Ramsey - Etat de l'art
Tuesday 05 December 2017Cyril Gavoille (LaBRI) La coloration de graphe dans le modèle LOCAL - Partie I
L'objectif de cette série d'exposés est de faire découvrir un résultat aussi élégant que surprenant du calcul distribué, à savoir la 3-coloration des n-cycles en temps log*(n). On démontrera l'optimalité de ce résultat ainsi que ces généralisations au cas des graphes arbitraires. Partie I: - Le modèle LOCAL - Le problème de la coloration - Coloration des 1-orientations en 6 couleurs - De 6 à 3 couleurs - Cas des graphes arbitraires
Tuesday 28 November 2017Ranko Lazic (Warwick University) Succinct progress measures and solving parity games in quasi-polynomial time
The recent breakthrough paper by Calude et al. (a winner of STOC 2017 Best Paper Award) has given the first algorithm for solving parity games in quasi-polynomial time, where previously the best algorithms were mildly sub-exponential. We devise an alternative quasi-polynomial time algorithm based on progress measures, which allows us to reduce the space required from quasi-polynomial to nearly linear. Our key technical tools are a novel concept of ordered tree coding, and a succinct tree coding result that we prove using bounded adaptive multi-counters, both of which are interesting in their own right. Apart from presenting our technical work on succinct progress measures, I will survey the relevance of parity games to the theory and practice of computer-aided verification and synthesis, their surprising impact on broader theoretical computer science, the history of results and techniques used for solving parity games, and the recent advances in the state of the art. This is joint work with Marcin Jurdzinski.
Tuesday 21 November 2017Angelo Montanari (University of Udine) Model Checking: the Interval Way
Model checking with interval temporal logics is emerging as a viable alternative to model checking with standard point-based temporal logics, such as LTL, CTL, CTL*, and the like. The behavior of the system is modelled by means of (finite) Kripke structures, as usual. However, while temporal logics which are interpreted "point-wise" describe how the system evolves state-by-state, and predicate properties of system states, those which are interpreted "interval-wise" express properties of computation stretches, spanning a sequence of states. A proposition letter is assumed to hold over a computation stretch (interval) if and only if it holds over each component state (homogeneity assumption). The most well-known interval temporal logic is Halpern and Shoham's modal logic of time intervals HS, which features one modality for each possible ordering relation between a pair of intervals, apart from equality. In the seminar, we provide an overview of the main results on model checking with HS and its fragments under the homogeneity assumption. In particular, we show that the problem turns out to be non-elementarily decidable and EXPSPACE-hard for full HS, but it is often computationally much better for its fragments. Then, we briefly compare the expressiveness of HS in model checking with that of LTL, CTL, CTL*. We conclude by discussing a recent generalization of the proposed MC framework that allows one to use regular expressions to define the behavior of proposition letters over intervals in terms of the component states.
Tuesday 14 November 2017MF (LaBRI) Reunion d'equipe MF
Tuesday 07 November 2017Loïc Paulevé (LRI - Paris Sud) Formal methods for capturing dynamics of biological networks
Computational models of biological networks aim at reporting the indirect influences between the different molecular entities acting within the cell (genes, RNA, proteins, ...). In this talk, I will give an overview of methods for the formal assessment of dynamics of biological networks by static analysis. After an introduction to Boolean networks and their relevance for modelling cell signalling and gene regulatory networks, I'll present an abstract interpretation of their trajectories based on a causal analysis. Then, I'll show how we can combine this abstraction with SAT approches to address systems biology challenges, such as model identification and cell reprogramming.
Tuesday 31 October 2017Vincent Penelle (LaBRI) Rewriting Higher-order Stack Trees
Higher-order pushdown systems and ground tree rewriting systems can be seen as extensions of suffix word rewriting systems. Both classes generate infinite graphs with interesting logical properties. Indeed, the satisfaction of any formula written in monadic second order logic (respectively first order logic with reachability predicates) can be decided on such a graph. The purpose of this talk is to propose a common extension to both higher-order stack operations and ground tree rewriting. We introduce a model of higher-order ground tree rewriting over trees labelled by higher-order stacks (henceforth called stack trees), which syntactically coincides with ordinary ground tree rewriting at order 1 and with the dynamics of higher-order pushdown automata over unary trees. The rewriting system is obtained through the definition of DAGs of operations. Our contribution is twofold (apart from the definition of the model): - define a automaton model over DAGs of operations, and show it is closed under iteration. - showing that the model checking problem for first-order logic with reachability is decidable for the infinite graphs generated by stack tree rewriting systems. This last proof uses the technique of finite set interpretations presented by Colcombet and Loding.
Tuesday 24 October 2017Amina Doumane (LIP - ENS Lyon) Constructive completeness for the linear-time mu-calculus
Modal mu-calculus is one of the central logics for verification. In his seminal paper, Kozen proposed an axiomatization for this logic, which was proved to be complete, 13 years later, by Kaivola for the linear-time case and by Walukiewicz for the branching-time one. These proofs are based on complex, non-constructive arguments, yielding no reasonable algorithm to construct proofs for valid formulas. The problematic of constructiveness becomes central when we consider proofs as certificates, supporting the answers of verification tools. We provide a new completeness argument for the linear-time mu-calculus which is constructive, i.e. it builds a proof for every valid formula. To achieve this, we decompose this difficult problem into several easier ones, taking advantage of the correspondence between the mu-calculus and automata theory. More precisely, we lift the well-known automata transformations (non-determinization for instance) to the logical level. To solve each of these smaller problems, we perform first a proof-search in a circular proof system, then we transform the obtained circular proofs into proofs in Kozen's axiomatization. This yields a constructive proof for the full linear-time mu-calculus.
Tuesday 17 October 2017David Janin (LaBRI) Timed domains: an appetizer
we develop a general theory of timed domains and timed morphisms that aims at offering a versatile and sound mathematical framework for the study of timed denotational semantics of networks of timed programs. The proposed compositional semantic model accounts for the fact that every non trivial computation step necessarily takes some non zero time. This is achieved by defining timed domains as classical domains (directed complete posets) where time appears everywhere: every increase of knowledge necessarily refers to the passage of time. Timed morphisms are defined as functions between timed domains which uniformly act on the underlying time scales. The resulting category is a (bi)cartesian closed category with (mostly) internal henceforth timed least fixpoint operators. Moreover, by allowing (almost) arbitrary posets as time scales, the proposed frame- work also covers typical features of parallel or concurrency theory such as parallel, indenpendant or conflicting computations. In other words, timed domains and timed morphisms provide a fully featured mathematical framework for the study of computable spatio-temporal functions.
Tuesday 10 October 2017Miguel Romero (Oxford University) The complexity of graph query languages
A graph database is a directed graph where each edge is additionally labeled with a symbol from a finite alphabet. Several data models, such as the ones occurring in the Semantic Web or semi-structured data, can be naturally captured via graph databases. In this context, one is not only interested in traditional queries, such as conjunctive queries, but also in navigational queries that take the topology of the data into account. In this talk, we consider one of the most prominent navigational query languages, namely, the class of conjunctive regular path queries (CRPQs). This class extends the class of conjunctive queries with the ability of checking the existence of a path between two nodes, whose label matches a given regular expression. As in the case of conjunctive queries, evaluating CRPQs is an NP-complete problem. We present some results about tractable restrictions of CRPQs, as well as several open problems.
Tuesday 03 October 2017Joanna Ochremiak (IRIF) Proof complexity of constraint satisfaction problems
Many natural computational problems, such as satisfiability and systems of equations, can be expressed in a unified way as constraint satisfaction problems (CSPs). In this talk I will show that the usual reductions preserving the complexity of the constraint satisfaction problem preserve also its proof complexity. As an application, I will present two gap theorems, which say that CSPs that admit small size refutations in some classical proof systems are exactly the constraint satisfaction problems which can be solved by Datalog. This is joint work with Albert Atserias.
Tuesday 26 September 2017Vincent Penelle (LaBRI) Which classes of origin graph are generated by transducers?
This talk is about transductions, which are binary relations on words. We are interested in various models computing transductions (ie, transducers), namely two-way automata with outputs, streaming string transducers and string-to-string MSO transductions. We observe that each of these formalisms provides more than just a set of pairs of words. Indeed, one can also reconstruct origin information, which says how positions of the output string originate from positions of the input string. On the other hand, it is also possible to provide any pair of words in a relation with an origin mapping, indicating an origin input position for each output position, in a similar way. This defines a general object called origin graph. We first show that the origin semantic is natural and corresponds to the intuition we have of the run of a transducer, and is stable from translation from one model to another. We then characterise the families of origin graphs which corresponds to the semantics of streaming string transducers. This is joint work with Mikolaj Bojanczyk, Laure Daviaud and Bruno Guillon, and has been published to ICALP17.
Tuesday 04 July 2017Stefan GRUNER (University of Pretoria, South Africa) SAT-based Bounded Model Checking for 3-Valued Abstractions - Part II
Continuation of his precedent talk.
Tuesday 27 June 2017Stefan GRUNER (University of Pretoria, South Africa) SAT-based Bounded Model Checking for 3-Valued Abstractions
In this talk I will present joint work with Nils Timm (and students) from the University of Pretoria on how to make model-checking of concurrent systems more effective and more efficient. In the first part of the talk, which is based on our SBMF'16 paper, I show how bounded model-checking over a three-valued truth domain {T:true, F:false, U:unknown} can be translated into a classical Boolean satisfiability problem which can then be given to any classical SAT solver. In the second part of the talk, which is based on our recent FSEN'17 paper, I speak about efficiency-increasing heuristics which are based on the availability of structural knowledge about the original system to be model-checked. On the basis of such structural knowledge the SAT solver can be guided into 'promising' search paths, whereby the probability of unnecessarily exploring fruitless paths is considerably diminished. The SBMF'16 paper was acknowledged as the "2nd-best paper of the conference", and the FSEN'17 paper was nominated among the "top three papers of the conference".
Tuesday 13 June 2017Emilia Descotte (UBA, Argentine) Axiomatizations for downward XPath on Data Trees
We give sound and complete axiomatizations for XPath with data tests by "equality" or "inequality", and containing the single "child" axis. This data-aware logic predicts over data trees, which are tree-like structures whose every node contains a label from a finite alphabet and a data value from an infinite domain. The language allows us to compare data values of two nodes but cannot access the data values themselves (i.e., there is no comparison by constants). Our axioms are in the style of equational logic, extending the axiomatization of data-oblivious XPath, by B. ten Cate, T. Litak and M. Marx. We axiomatize the full logic with tests by "equality" and "inequality", and also a simpler fragment with "equality" tests only. Our axiomatizations apply both to node expressions and path expressions. The proof of completeness relies on a novel normal form theorem for XPath with data tests.
Tuesday 30 May 2017Victor Marsault (University of Liège) An efficient algorithm to decide the periodicity of b-recognisable sets using MSDF convention
Given an integer base b>1, a set of integers is represented in base b by a language over {0,1,...,b-1}. The set is said b-recognisable if its representation is a regular language. It is known that eventually periodic sets are b-recognisable in every base b, and Cobham's theorem imply the converse: no other set is b-recognisable in every base b. We are interested in deciding whether a b-recognisable set of integers (given as a finite automaton) is eventually periodic. Honkala showed in 1986 that this problem is decidable and recent developments give efficient decision algorithms. However, they only work when the integers are written with the least significant digit first. In this work, we consider here the natural order of digits (Most Significant Digit First) and give a quasi-linear algorithm to solve the problem in this case.
Tuesday 23 May 2017Michael Raskin (LaBRI) A linear lower bound for incrementing a space-optimal integer representation in the bit-probe model
We present the first linear lower bound for the number of bits required to be accessed in the worst case to increment an integer in an arbitrary space-optimal binary representation. The best previously known lower bound was logarithmic. It is known that a logarithmic number of read bits in the worst case is enough to increment some of the integer representations that use one bit of redundancy, therefore we show an exponential gap between space-optimal and redundant counters. Our proof is based on considering the increment procedure for a space optimal counter as a permutation and calculating its parity. For every space optimal counter, the permutation must be odd, and implementing an odd permutation requires reading at least half the bits in the worst case. The combination of these two observations explains why the worst-case space-optimal problem is substantially different from both average-case approach with constant expected number of reads and almost space optimal representations with logarithmic number of reads in the worst case. https://arxiv.org/abs/1607.00242 ; ICALP 2017
Tuesday 16 May 2017Igor Walukiewicz (LaBRI) Proving safety of concurrent programs
This talk will be based on the paper from POPL 2017: Thread Modularity at Many Levels: a pearl of compositional verification by Jochen Hoenicke, Rupak Majumdar, and Andreas Podelski In the paper the authors consider the problem of proving safety of (parametrized) concurrent programs. They do not propose new techniques but rather revisit some existing ones. I have found putting these techniques next to each other very interesting and thought provoking. Since the considered problem is a fundamental problem for verification, I think it is worth to see this work at the seminar. This will not be a survey talk. Technically the talk will be very easy, as the results are straightforward. The goal is to present a view point on the problem that I have got from reading the paper.
Tuesday 09 May 2017Alain Finkel (LSV, ENS Cachan) WBTS: the new class of WSTS without WQO.
We present the ideal framework [FG09a,BFM14] which was recently used to obtain new deep results on Petri nets and extensions. If time, we will present the proof of the famous but unknown Erdös-Tarski theorem. We argue that the theory of ideals prompts a renewal of the theory of WSTS by providing a way to define a new class of monotonic systems, the so-called Well Behaved Transition Systems, which properly contains WSTS, and for which coverability is still decidable by a forward algorithm.
Tuesday 25 April 2017Nathan Lhote (LaBRI) On Reversible Transducers
Deterministic two-way transducers define the robust class of regular functions which is, among other good properties, closed under composition. However, the best known algorithms for composing two-way transducers cause a double exponential blow-up in the size of the inputs. We introduce a class of transducers for which the composition has polynomial complexity. It is the class of reversible transducers, for which the computation steps can be reversed deterministically. While in the one-way setting this class is not very expressive, any two-way transducer can be made reversible through a single exponential blow-up. As a consequence, the composition of two-way transducers can be done with a single exponential blow-up in the number of states. A uniformization of a relation is a function with the same domain and which is included in the original relation. Our main result actually states that we can uniformize any non-deterministic two-way transducer by a reversible transducer with a single exponential blow-up, improving the known result by de Souza which has a quadruple exponential complexity. As a side result, our construction also gives a quadratic transformation from copyless streaming string transducers to two-way transducers, improving the exponential previous bound.
Tuesday 04 April 2017Andrzej Murawski (University of Warwick) Automata theory and game semantics of higher-order computation
I will give a survey of various classes of automata that have been used to capture the game semantics of higher-order programs and, consequently, obtain decidability results for contextual equivalence.
Tuesday 28 March 2017David Janin (LaBRI) Time domain (for time denotational semantics)
Directed complete partial orders (cpos) are used in denotational semantics for describing the way each value is incrementally computed, passing from a completely unknown value to a completely known value. Then, continuous functions between cpos propagate increase of knowledge on their inputs to increase of knowledge on their outputs. In this talk, we define the notion timed cpo by means of a cut function that tells what part of any value is known before any given instant. In the induced partial order, the increase of knowledge explicitly refers to the passage of time. It follows that continuous functions between timed cpos provide denotational semantics model candidates for timed IO-system acting over (higher-order) time evolving values, e.g. timed streams, but also bounded below values, partial inductive structures, timed functions, etc. Definitions, examples and (closure) properties of these timed cpos and their continuous functions are provided throughout.
Tuesday 21 March 2017Laurent Bienvenu (LIRMM Montpellier) Learning probability measures
Suppose we have a probabilistic algorithm given as a black box and we have access to an output of this algorithm. There are two - related - questions one could ask. (1) Is it possible to make a plausible guess as to which algorithm is in the box? (2) Can we use the output of this algorithm as a random number generator by extracting `pure’ randomness from it? We will look at these questions from the point of view of computability and algorithmic learning theory. [Based on joint work with S. Figueira, B. Monin, and A. Shen]
Tuesday 14 March 2017Gabriele Puppis (LaBRI) On the decomposition of finite-valued streaming string transducers
I will present some preliminary results towards a proof of a decomposition theorem for streaming string transducers (SSTs). Roughly, the conjectured decomposition theorem states that every SST that associates at most k outputs to each input can be effectively decomposed as a finite union of functional SSTs. Such a result would imply, among other things, the decidability of the equivalence problem for the considered class of transducers as well as a correspondence with the classical two-way transducers. I will present a proof of this decomposition theorem in the special case of SSTs with 1 register. The proof heavily relies on a combinatorial result by Kortelainen concerning word equations with iterated factors.
Tuesday 07 March 2017Charles Grellois (University of Bologna) Verifying properties of functional programs: from the deterministic to the probabilistic case
In functional programs, also called higher-order programs, functions may take functions themselves as arguments. As a result, their model-checking relies in most approaches on semantic or type-theoretic tools. In this talk, I will explain how an analysis based on linear logic of a model-checking result of 2009 by Kobayashi and Ong led Melliès and I to the construction of a model for model-checking. This model is such that, when interpreting a term with recursion representing the tree of traces of a functional program, its denotation determines whether it satisfies a MSO property of interest. A related and similar model was obtained independently by Salvati and Walukiewicz. In the second part of the talk, I will discuss the verification of termination for functional programs with recursion and probabilistic choice. Dal Lago and I defined recently a type system which is such that typable programs terminate with probability 1. In other terms, their set of diverging executions is negligible. If time allows, I will sketch ideas towards an extension of the model-checking results of the deterministic case to quantitative logics and functional programs with recursion.
Tuesday 28 February 2017Emmanuel Fleury (LaBRI) Digital Currencies
Electronic money is a quite old problem in cryptology (Chaum, 1982) but recent discoveries lead to the birth of a new type of digital currency such as Bitcoins or Ethereum. Most of the new crypto-currencies are based on the concept of Blockchain which is used to maintain a trusted consensus in a distributed manner thanks to cryptographic primitives. This talk will summarize the main concepts and mechanisms used to ensure the security of Bitcoins and Blockchain.
Tuesday 14 February 2017Hugo Gimbert (LaBRI) Emptiness of nonzero automata is decidable
Zero automata are a probabilistic extension of parity automata on infinite trees. Bojanczyk has shown recently that the satisfiability of a certain probabilistic variant of MSO, called TMSO+zero reduces to the emptiness problem for zero automata. These automata perform random walks on the input (binary) tree: when the automaton is in a state q on a node labelled with a, it selects non-deterministically a transition (q,a,r_0,r_1) and moves with equal probability 1/2 either to the left node in state r_0 or to the right node in state r_1.. The acceptance condition of zero automata impose conditions not only on the parity of individual branches of the run but as well on some other properties of runs that should occur almost-surely or with positive probability. We introduce a variant of zero automata called nonzero automata and we show that i) for every zero automaton there is an equivalent nonzero automaton of quadratic size ii) the emptiness problem of nonzero automata is decidable, with complexity {sc np}. These results imply that TMSO+zero has decidable satisfiability. Joint work with Mikolaj Danger Bojanczyk and Edon Kelmendi
Tuesday 24 January 2017Rasmus Ibsen-Jensen (IST Austria) Faster algorithms for program analysis
The talk is based on joint work with Krishnendu Chatterjee, Amir Kafshdar Goharshady, Prateesh Goyal, and Andreas Pavlogiannis. The talk is about solving graph problems (focusing on graph problems that are often reduced to in program analysis) faster when the graphs are composed of control flow graphs of methods in programs. Using that control flow graphs of methods typically have constant tree-width we consider when the program either (i) has a single method, (ii) has many methods, or (iii) concurrent threads, each on a single method. For cases (ii) and (iii), we consider the Algebraic Path Problem (APP), which is a very general problem, with many interesting special cases, such as (1) reachability and shortest path (with positive and negative weights), (2) the IDE/IDFS frameworks of program analysis and (3) most probable path. Since APP has already been optimally solved for single methods/constant tree-width graphs, up to factors of log^* n (n is the number of states), in (i), if time permits, we will consider other weighted graph problems that has been reduced to in program analysis (but which are not special cases of APP), specifically finding the cycle with the least mean of weights (the minimum mean-payoff problem) and for a given start node v, finding the minimum number c and a path from v where all prefix sums of the weights of the path are greater than -c (the minimum initial credit problem). In all cases, we give simple algorithms which are faster than the state-of-the-art in theory and practice. The talk is based on my POPL papers from 2015 and 2016, and, if time permits, my CAV paper from 2015 (see e.g. my homepage at http://rasmus.ibsen-jensen.com for the papers). No prior specialised knowledge is necessary to follow the talk.
Tuesday 10 January 2017B Srivathsan (CMI Chennai) Why liveness for timed automata is hard, and what we can do about it
The liveness problem for timed automata asks if a given automaton has an infinite run visiting an accepting state infinitely often. In this talk, we will show that if P is not equal to NP, the liveness problem is "more difficult" than the reachability problem - more precisely, we will exhibit a family of automata for which reachability is in P whereas liveness is NP-hard. We will then present a new algorithm to solve the liveness problem, and compare it with existing solutions. Joint work with F. Herbreteau, T.T. Tran and I. Walukiewicz.



Archives des années précédentes




Responsables

Nathanaël Fijalkow, Guillaume Lagarde