Nicolas Markey

Abstract

In formal verification, runtime monitoring consists of observing the execution of a system in order to decide as quickly as possible whether or not it satisfies a given property. We consider monitoring in a distributed setting, for properties given as reachability timed automata. In such a setting, the system is made of several components, each equipped with its own local clock and monitor. The monitors observe events occurring on their associated component, and receive timestamped events from other monitors through FIFO channels. Since clocks are local, they cannot be perfectly synchronized, resulting in imprecise timestamps. Consequently, they must be seen as intervals, leading monitors to consider possible reorderings of events. In this context, each monitor aims to provide, as early as possible, a verdict on the property it is monitoring, based on its potentially incomplete and imprecise knowledge of the current execution. In this paper, we propose an on-line monitoring algorithm for timed properties, robust to time imprecision and partial information from distant components. We first identify the date at which a monitor can safely compute a verdict based on received events. We then propose a monitoring algorithm that updates this date when new information arrives, maintains the current set of states in which the property can reside, and updates its verdict accordingly.

@inproceedings{rv2024-HJMR,
  author =              {Henry, L{\'e}o and J{\'e}ron, Thierry and Markey,
                         Nicolas and Roussanaly, Victor},
  title =               {Distributed Monitoring of Timed Properties},
  editor =              {{\'A}brah{\'a}m, Erikz and Abbas, Houssam},
  booktitle =           {{P}roceedings of the 24th {I}nternational {W}orkshop
                         on {R}untime {V}erification ({RV}'24)},
  acronym =             {{RV}'24},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {15191},
  pages =               {243-261},
  year =                {2024},
  month =               oct,
  doi =                 {10.1007/978-3-031-74234-7_16},
  abstract =            {In formal verification, runtime monitoring consists
                         of observing the execution of a system in order to
                         decide as quickly as possible whether or not it
                         satisfies a given property. We consider monitoring
                         in a distributed setting, for properties given as
                         reachability timed automata. In~such a setting,
                         the~system is made of several components, each
                         equipped with its own local clock and monitor.
                         The~monitors observe events occurring on their
                         associated component, and receive timestamped events
                         from other monitors through FIFO channels. Since
                         clocks are local, they cannot be perfectly
                         synchronized, resulting in imprecise timestamps.
                         Consequently, they must be seen as intervals,
                         leading monitors to consider possible reorderings of
                         events. In this context, each monitor aims to
                         provide, as early as possible, a verdict on the
                         property it is monitoring, based on its potentially
                         incomplete and imprecise knowledge of the current
                         execution. In~this~paper, we~propose an on-line
                         monitoring algorithm for timed properties, robust to
                         time imprecision and partial information from
                         distant components. We~first identify the date at
                         which a monitor can safely compute a verdict based
                         on received events. We~then propose a monitoring
                         algorithm that updates this date when new
                         information arrives, maintains the current set of
                         states in which the property can reside, and updates
                         its verdict accordingly.},
}

Abstract

We introduce a new class of automata (which we coin EU-automata) running on infininte trees of arbitrary (finite) arity. We develop and study several algorithms to perform classical operations (union, intersection, complement, projection, alternation removal) for those automata, and precisely characterise their complexities. We also develop algorithms for solving membership and emptiness for the languages of trees accepted by EU-automata.

We then use EU-automata to obtain several algorithmic and expressiveness results for the temporal logic QCTL (which extends CTL with quantification over atomic propositions) and for MSO. On the one hand, we obtain decision procedures with optimal complexity for QCTL satisfiability and model checking; on the other hand, we obtain an algorithm for translating any QCTL formula with k quantifier alternations to formulas with at most one quantifier alternation, at the expense of a (k+1)-exponential blow-up in the size of the formulas. Using the same techniques, we prove that any MSO formula can be translated into a formula with at most four quantifier alternations (and only two second-order-quantifier alternations), again with a (k+1)-exponential blow-up in the size of the formula.

@techreport{arxiv2410.18799-LM,
  author =              {Laroussinie, Fran{\c c}ois and Markey, Nicolas},
  title =               {Arbitrary-arity Tree Automata and QCTL},
  number =              {2410.18799},
  year =                {2024},
  month =               oct,
  doi =                 {10.48550/arXiv.2410.18799},
  institution =         {arXiv},
  abstract =            {We~introduce a new class of automata (which we coin
                         \emph{EU-automata}) running on infininte trees of
                         arbitrary (finite) arity. We~develop and study
                         several algorithms to perform classical operations
                         (union, intersection, complement, projection,
                         alternation removal) for those automata, and
                         precisely characterise their complexities. We~also
                         develop algorithms for solving membership and
                         emptiness for the languages of trees accepted by
                         EU-automata. \par We~then use EU-automata to obtain
                         several algorithmic and expressiveness results for
                         the temporal logic \textsf{QCTL} (which extends
                         \textsf{CTL} with quantification over atomic
                         propositions) and for \textsf{MSO}. On the one hand,
                         we obtain decision procedures with optimal
                         complexity for \textsf{QCTL} satisfiability and
                         model checking; on the other hand, we obtain an
                         algorithm for translating any \textsf{QCTL} formula
                         with \(k\) quantifier alternations to formulas with
                         at most one quantifier alternation, at~the~expense
                         of a \((k+1)\)-exponential blow-up in the size of
                         the formulas. Using the same techniques, we~prove
                         that any \textsf{MSO} formula can be translated into
                         a formula with at most four quantifier alternations
                         (and only two second-order-quantifier alternations),
                         again with a \((k+1)\)-exponential blow-up in the
                         size of the formula.},
}

@inproceedings{fossacs2024-Pra,
  author =              {Prakash, Aditya},
  title =               {Checking History-Determinism is {NP}-hard for Parity
                         Automata},
  editor =              {Kobayashi, Naoki and Worrell, James},
  booktitle =           {{P}roceedings of the 27th {I}nternational
                         {C}onference on {F}oundations of {S}oftware
                         {S}cience and {C}omputation {S}tructure
                         ({FoSSaCS}'24)},
  acronym =             {{FoSSaCS}'24},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {14574},
  pages =               {212-233},
  year =                {2024},
  month =               apr,
  doi =                 {10.1007/978-3-031-57228-9_11},
}

Abstract

We consider the automatic online synthesis of black-box test cases from functional requirements specified as automata for reactive implementations. The goal of the tester is to reach some given state, so as to satisfy a coverage criterion, while monitoring the violation of the requirements. We develop an approach based on Monte Carlo Tree Search, which is a classical technique in reinforcement learning for efficiently selecting promising inputs. Seeing the automata requirements as a game between the implementation and the tester, we develop a heuristic by biasing the search towards inputs that are promising in this game. We experimentally show that our heuristic accelerates the convergence of the Monte Carlo Tree Search algorithm, thus improving the performance of testing.

@techreport{2407.18994-SJMMN,
  author =              {Sankur, Ocan and J{\'e}ron, Thierry and Markey,
                         Nicolas and Mentr{\'e}, David and Noguchi, Reiya},
  title =               {Online Test Synthesis From Requirements: Enhancing
                         Reinforcement Learning with Game Theory},
  number =              {2407-18994},
  year =                {2024},
  month =               jul,
  doi =                 {10.48550/arXiv.2407-18994},
  institution =         {arXiv},
  abstract =            {We consider the automatic online synthesis of
                         black-box test cases from functional requirements
                         specified as automata for reactive implementations.
                         The goal of the tester is to reach some given state,
                         so as to satisfy a coverage criterion, while
                         monitoring the violation of the requirements. We
                         develop an approach based on Monte~Carlo Tree
                         Search, which is a classical technique in
                         reinforcement learning for efficiently selecting
                         promising inputs. Seeing the automata requirements
                         as a game between the implementation and the tester,
                         we develop a heuristic by biasing the search towards
                         inputs that are promising in this game.
                         We~experimentally show that our heuristic
                         accelerates the convergence of the Monte~Carlo Tree
                         Search algorithm, thus improving the performance of
                         testing.},
}

Abstract

Synchronizing a (deterministic, finite-state) automaton is the problem of finding a sequence of actions to be played in the automaton in order to end up in the same state independently of the starting state. We consider synchronization with LTL constraints on the executions leading to synchronization, extending the results of [Petra Wolf. Synchronization under dynamic constraints. FSTTCS'20] by showing that the problem is PSPACE-complete for LTL as well as for restricted fragments (involving only modality F or G), while it is NP-complete for constraints expressed using only modality X.

@article{ipl182()-BFM,
  author =              {Bertrand, Nathalie and Francon, Hugo and Markey,
                         Nicolas},
  title =               {Synchronizing words under {LTL} constraints},
  publisher =           {Elsevier},
  journal =             {Information Processing Letters},
  volume =              {182},
  year =                {2023},
  month =               aug,
  doi =                 {10.1016/j.ipl.2023.106392},
  abstract =            {Synchronizing a (deterministic, finite-state)
                         automaton is the problem of finding a sequence of
                         actions to be played in the automaton in order to
                         end up in the same state independently of the
                         starting state. We~consider synchronization
                         with~\textsf{LTL} constraints on the executions
                         leading to synchronization, extending the results
                         of~[Petra~Wolf. Synchronization under dynamic
                         constraints. FSTTCS'20] by~showing that the problem
                         is \textsf{PSPACE}-complete for~\textsf{LTL} as well
                         as for restricted fragments (involving only
                         modality~\textsf{F} or~\textsf{G}), while it is
                         \textsf{NP}-complete for constraints expressed using
                         only modality~\textsf{X}.},
}

Abstract

Temporal logics are extensively used for the specification of on-going behaviors of computer systems. Two significant developments in this area are the extension of traditional temporal logics with modalities that enable the specification of on-going strategic behaviors in multi-agent systems, and the transition of temporal logics to a quantitative setting, where different satisfaction values enable the specifier to formalize concepts such as certainty or quality. In the first class, SL (Strategy Logic) is one of the most natural and expressive logics describing strategic behaviors. In the second class, a notable logic is LTL[F], which extends LTL with quality operators.

In this work we introduce and study SL[F], which enables the specification of quantitative strategic behaviors. The satisfaction value of an SL[F] formula is a real value in [0,1], reflecting "how much" or "how well" the strategic on-going objectives of the underlying agents are satisfied. We demonstrate the applications of SL[F] in quantitative reasoning about multi-agent systems, showing how it can express and measure concepts like stability in multi-agent systems, and how it generalizes some fuzzy temporal logics. We also provide a model-checking algorithm for SL[F], based on a quantitative extension of Quantified CTL*. Our algorithm provides the first decidability result for a quantitative extension of Strategy Logic. In addition, it can be used for synthesizing strategies that maximize the quality of the systems' behavior

@article{tocl24(3)-BKMMMP,
  author =              {Bouyer, Patricia and Kupferman, Orna and Markey,
                         Nicolas and Maubert, Bastien and Murano, Aniello and
                         Perelli, Giuseppe},
  title =               {Reasoning about Quality and Fuzziness of Strategic
                         Behaviours},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Computational Logic},
  volume =              {24},
  number =              {3},
  pages =               {21:1-21:38},
  year =                {2023},
  month =               jul,
  doi =                 {10.1145/3582498},
  abstract =            {Temporal logics are extensively used for the
                         specification of on-going behaviors of computer
                         systems. Two significant developments in this area
                         are the extension of traditional temporal logics
                         with modalities that enable the specification of
                         on-going strategic behaviors in multi-agent systems,
                         and the transition of temporal logics to a
                         quantitative setting, where different satisfaction
                         values enable the specifier to formalize concepts
                         such as certainty or quality. In~the first class,
                         SL~(Strategy~Logic)~is one of the most natural and
                         expressive logics describing strategic behaviors. In
                         the second class, a notable logic is
                         \(\textsf{LTL}[\mathcal{F}]\), which extends
                         \textsf{LTL} with quality operators. \par In~this
                         work we introduce and study
                         \(\textsf{SL}[\mathcal{F}]\), which enables the
                         specification of quantitative strategic behaviors.
                         The satisfaction value of an
                         \(\textsf{SL}[\mathcal{F}]\) formula is a real value
                         in \([0,1]\), reflecting {"}how~much{"} or
                         {"}how~well{"} the strategic on-going objectives of
                         the underlying agents are satisfied. We demonstrate
                         the applications of \(\textsf{SL}[\mathcal{F}]\) in
                         quantitative reasoning about multi-agent systems,
                         showing how it can express and measure concepts like
                         stability in multi-agent systems, and how it
                         generalizes some fuzzy temporal logics. We also
                         provide a model-checking algorithm for
                         \(\textsf{SL}[\mathcal{F}]\), based on a
                         quantitative extension of
                         Quantified~\(\textsf{CTL}^*\). Our~algorithm
                         provides the first decidability result for a
                         quantitative extension of Strategy Logic. In
                         addition, it can be used for synthesizing strategies
                         that maximize the quality of the systems' behavior},
}

Abstract

Network congestion games are a simple model for reasoning about routing problems in a network. They are a very popular topic in algorithmic game theory, and a huge amount of results about existence and (in)efficiency of equilibrium strategy profiles in those games have been obtained over the last 20 years.

In particular, the price of anarchy has been defined as an important notion for measuring the inefficiency of Nash equilibria. Generic bounds have been obtained for the price of anarchy over various classes of networks, but little attention has been put on the effective computation of this value for a given network. This talk presents recent results on this problem in different settings.

@inproceedings{formats2023-Mar,
  author =              {Markey, Nicolas},
  title =               {Computing the price of anarchy in atomic network
                         congestion games (invited~talk)},
  editor =              {Petrucci, Laure and Sproston, Jeremy},
  booktitle =           {{P}roceedings of the 21st {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'23)},
  acronym =             {{FORMATS}'23},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {14138},
  pages =               {3-12},
  year =                {2023},
  month =               sep,
  doi =                 {10.1007/978-3-031-42626-1_1},
  abstract =            {Network congestion games are a simple model for
                         reasoning about routing problems in a network. They
                         are a very popular topic in algorithmic game theory,
                         and a huge amount of results about existence and
                         (in)efficiency of equilibrium strategy profiles in
                         those games have been obtained over the last
                         20~years. \par In~particular, the price of anarchy
                         has been defined as an important notion for
                         measuring the inefficiency of Nash equilibria.
                         Generic bounds have been obtained for the price of
                         anarchy over various classes of networks, but little
                         attention has been put on the effective computation
                         of this value for a given network. This talk
                         presents recent results on this problem in different
                         settings.},
}

@patent{EP4064057B1,
  author =              {Noguchi, Reiya and J{\'e}ron, Thierry and Markey,
                         Nicolas and Sankur, Ocan},
  title =               {Method and system for correcting the operation of a
                         target computer system by using timed requirements},
  number =              {EP 4 064 057 B1},
  year =                {2023},
  month =               jul,
}

@inproceedings{fsttcs2023-AAB,
  author =              {Almagor, Shaull and Assa, Daniel and Boker, Udi},
  title =               {Synchronized {CTL} over One-Counter Automata},
  editor =              {Bouyer, Patricia and Srinivasan, Srikanth},
  booktitle =           {{P}roceedings of the 43rd {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'23)},
  acronym =             {{FSTTCS}'23},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {284},
  pages =               {19:1-19:22},
  year =                {2023},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2023.19},
}

@article{siglog-news35()-BL,
  author =              {Boker, Udi and Lehtinen, Karoliina},
  title =               {When a Little Nondeterminism Goes a Long Way: an
                         Introduction to History-Determinism},
  publisher =           {ACM Press},
  journal =             {SIGLOG News},
  volume =              {35},
  pages =               {24-51},
  year =                {2023},
  month =               jan,
}

@article{mathprog-CDS,
  author =              {Cominetti, Roberto and Dose, Valerio and Scarsini,
                         Marco},
  title =               {The~price of anarchy in routing games as a function
                         of the demand},
  journal =             {Mathematical Programming},
  year =                {2023},
  doi =                 {10.1007/s10107-021-01701-7},
  note =                {To~appear},
}

@techreport{GoG-fij23,
  author =              {Fijalkow, Nathana{\"e}l and Bertrand, Nathalie and
                         Bouyer, Patricia and Brenguier, Romain and Carayol,
                         Arnaud and Fearnley, John and Gimbert, Hugo an Horn,
                         Florian and Ibsen{-}Jensen, Rasmus and Markey,
                         Nicolas and Monmege, Benjamin and Novotn{\'y}, Petr
                         and Randour, Mickael and Sankur, Ocan and Schmitz,
                         Sylvain and Serre, Olivier and Skomra, Mateusz},
  title =               {Games on graphs},
  number =              {2305.10546},
  year =                {2023},
  month =               may,
  doi =                 {10.48550/arXiv.2305.10546},
  institution =         {arXiv},
}

@phdthesis{phd-ganguly,
  author =              {Ganguly, Ritam},
  title =               {Runtime verification of distributed systems},
  year =                {2023},
  school =              {Michigan State University, USA},
  type =                {{PhD} thesis},
}

@inproceedings{csl2023-HK,
  author =              {Hazard, {\'E}mile and Kuperberg, Denis},
  title =               {Explorable automata},
  editor =              {Klin, Bartek and Pimentel, Elaine},
  booktitle =           {{P}roceedings of the 31st {EACSL} {A}nnual
                         {C}onference on {C}omputer {S}cience {L}ogic
                         ({CSL}'23)},
  acronym =             {{CSL}'23},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {252},
  pages =               {24:1-24:18},
  year =                {2023},
  month =               feb,
  doi =                 {10.4230/LIPIcs.CSL.2023.24},
}

@article{mathprog199(1)-WMRX,
  author =              {Wu, Zijun and M{\"o}hring, Rolf H. and Ren, Chunying
                         and Xu, Dachaun},
  title =               {A~convergence analysis of the price of anarchy in
                         atomic congestion games},
  journal =             {Mathematical Programming},
  volume =              {199},
  number =              {1},
  pages =               {937-993},
  year =                {2023},
  month =               may,
  doi =                 {10.1007/s10107-022-01853-0},
}

Abstract

Partial observability and controllability are two well-known issues in test-case synthesis for reactive systems. We address the problem of partial control in the synthesis of test cases from timed-automata specifications. We extend a previous approach to this problem from the untimed to the timed setting. This extension requires a deep reworking of the models, game interpretation and test-synthesis algorithms. We exhibit strategies of a game that try to minimize both cooperations of the system and distance to the satisfaction of a test purpose or to the next cooperation, and prove they are winning under some fairness assumptions. This entails that when turning those strategies into test cases, we get properties such as soundness and exhaustiveness of the test synthesis method. We finally propose a symbolic algorithm to compute those strategies.

@article{fmsd60(2)-HJM,
  author =              {Henry, L{\'e}o and J{\'e}ron, Thierry and Markey,
                         Nicolas},
  title =               {Control strategies for off-line testing of timed
                         systems},
  publisher =           {Springer-Verlag},
  journal =             {Formal Methods in System Design},
  volume =              {60},
  number =              {2},
  pages =               {147-194},
  year =                {2022},
  month =               apr,
  doi =                 {10.1007/s10703-022-00403-w},
  abstract =            {Partial observability and controllability are two
                         well-known issues in test-case synthesis for
                         reactive systems. We address the problem of partial
                         control in the synthesis of test cases from
                         timed-automata specifications. We extend a previous
                         approach to this problem from the untimed to the
                         timed setting. This extension requires a deep
                         reworking of the models, game interpretation and
                         test-synthesis algorithms. We exhibit strategies of
                         a game that try to minimize both cooperations of the
                         system and distance to the satisfaction of a test
                         purpose or to the next cooperation, and prove they
                         are winning under some fairness assumptions. This
                         entails that when turning those strategies into test
                         cases, we get properties such as soundness and
                         exhaustiveness of the test synthesis method. We
                         finally propose a symbolic algorithm to compute
                         those strategies.},
}

Abstract

We study games with reachability objectives under energy constraints. We first prove that under strict energy constraints (either only lower-bound constraint or interval constraint), those games are LOGSPACE-equivalent to energy games with the same energy constraints but without reachability objective (i.e., for infinite runs). We then consider two relaxations of the upper-bound constraints (while keeping the lower-bound constraint strict): in the first one, called weak upper bound, the upper bound is absorbing, i.e., when the upper bound is reached, the extra energy is not stored; in the second one, we allow for temporary violations of the upper bound, imposing limits on the number or on the amount of violations.

We prove that when considering weak upper bound, reachability objectives require memory, but can still be solved in polynomial-time for one-player arenas; we prove that they are in NP in the two-player setting. Allowing for bounded violations makes the problem PSPACE-complete for one-player arenas and EXPTIME-complete for two players. We then address the problem of existence of bounds for a given arena. We show that with reachability objectives, existence can be a simpler problem than the game itself, and conversely that with infinite games, existence can be harder.

@article{icomp2022-HMR,
  author =              {H{\'e}lou{\"e}t, Lo{\"\i}c and Markey, Nicolas and
                         Raha, Ritam},
  title =               {Reachability games with relaxed energy constraints},
  publisher =           {Elsevier},
  journal =             {Information and Computation},
  volume =              {285~(Part~B)},
  year =                {2022},
  month =               may,
  doi =                 {10.1016/j.ic.2021.104806},
  abstract =            {We study games with reachability objectives under
                         energy constraints. We first prove that under strict
                         energy constraints (either only lower-bound
                         constraint or interval constraint), those games are
                         LOGSPACE-equivalent to energy games with the same
                         energy constraints but without reachability
                         objective (i.e., for infinite runs). We then
                         consider two relaxations of the upper-bound
                         constraints (while keeping the lower-bound
                         constraint strict): in the first one, called weak
                         upper bound, the upper bound is absorbing, i.e.,
                         when the upper bound is reached, the extra energy is
                         not stored; in the second one, we allow for
                         temporary violations of the upper bound, imposing
                         limits on the number or on the amount of violations.
                         \par We prove that when considering weak upper
                         bound, reachability objectives require memory, but
                         can still be solved in polynomial-time for
                         one-player arenas; we prove that they are in NP in
                         the two-player setting. Allowing for bounded
                         violations makes the problem PSPACE-complete for
                         one-player arenas and EXPTIME-complete for two
                         players. We then address the problem of existence of
                         bounds for a given arena. We show that with
                         reachability objectives, existence can be a simpler
                         problem than the game itself, and conversely that
                         with infinite games, existence can be harder.},
}

Abstract

We consider atomic congestion games on series-parallel networks, and study the structure of the sets of Nash equilibria and social local optima on a given network when the number of players varies. We establish that these sets are definable in Presburger arithmetic and that they admit semilinear representations whose all period vectors have a common direction. As an application, we prove that the prices of anarchy and stability converge to 1 as the number of players goes to infinity, and show how to exploit these semilinear representations to compute these ratios precisely for a given network and number of players.

@inproceedings{fsttcs2022-BMSS,
  author =              {Bertrand, Nathalie and Markey, Nicolas and
                         Sadhukhan, Suman and Sankur, Ocan},
  title =               {Semilinear Representations for Series-Parallel
                         Atomic Congestion Games},
  editor =              {Dawar, Anuj and Guruswami, Venkatesan},
  booktitle =           {{P}roceedings of the 42nd {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'22)},
  acronym =             {{FSTTCS}'22},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {250},
  pages =               {32:1-32:20},
  year =                {2022},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2022.32},
  abstract =            {We~consider atomic congestion games on
                         series-parallel networks, and study the structure of
                         the sets of Nash equilibria and social local optima
                         on a given network when the number of players
                         varies. We establish that these sets are definable
                         in Presburger arithmetic and that they admit
                         semilinear representations whose all period vectors
                         have a common direction. As~an~application, we~prove
                         that the prices of anarchy and stability converge
                         to~1 as the number of players goes to infinity, and
                         show how to exploit these semilinear representations
                         to compute these ratios precisely for a given
                         network and number of players.},
}

Abstract

We consider the parameterized verification problem for distributed algorithms where the goal is to develop techniques to prove the correctness of a given algorithm regardless of the number of participating processes. Motivated by an asynchronous binary consensus algorithm of [J. Aspnes; Fast deterministic consensus in a noisy environment; J. Algorithms, 2002], we consider round-based distributed algorithms communicating with shared memory. A particular challenge in these systems is that 1) the number of processes is unbounded, and, more importantly, 2) there is a fresh set of registers at each round. A verification algorithm thus needs to manage both sources of infinity. In this setting, we prove that the safety verification problem, which consists in deciding whether all possible executions avoid a given error state, is PSPACE-complete. For negative instances of the safety verification problem, we also provide exponential lower and upper bounds on the minimal number of processes needed for an error execution and on the minimal round on which the error state can be covered.

@inproceedings{icalp2022-BMSW,
  author =              {Bertrand, Nathalie and Markey, Nicolas and Sankur,
                         Ocan and Waldburger, Nicolas},
  title =               {Parameterized safety verification of round-based
                         shared-memory systems},
  editor =              {Woodruff, David and Boja{\'n}czyk, Miko{\l}aj},
  booktitle =           {{P}roceedings of the 49th {I}nternational
                         {C}olloquium on {A}utomata, {L}anguages and
                         {P}rogramming ({ICALP}'22)},
  acronym =             {{ICALP}'22},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  pages =               {113:1-113:20},
  year =                {2022},
  month =               jul,
  doi =                 {10.4230/LIPIcs.ICALP.2022.113},
  abstract =            {We consider the parameterized verification problem
                         for distributed algorithms where the goal is to
                         develop techniques to prove the correctness of a
                         given algorithm regardless of the number of
                         participating processes. Motivated by an
                         asynchronous binary consensus algorithm~of
                         [J.~Aspnes; Fast deterministic consensus in a noisy
                         environment; J.~Algorithms,~2002], we~consider
                         round-based distributed algorithms communicating
                         with shared memory. A~particular challenge in these
                         systems is that 1)~the~number of processes is
                         unbounded, and, more importantly, 2)~there is a
                         fresh set of registers at each round. A~verification
                         algorithm thus needs to manage both sources of
                         infinity. In~this setting, we~prove that the safety
                         verification problem, which consists in deciding
                         whether all possible executions avoid a given error
                         state, is PSPACE-complete. For~negative instances of
                         the safety verification problem, we~also provide
                         exponential lower and upper bounds on the minimal
                         number of processes needed for an error execution
                         and on the minimal round on which the error state
                         can be covered.},
}

Abstract

A chronicle is a temporal model introduced by Dousson et al. for situation recognition. In short, a chronicle consists of a set of events and a set of real-valued temporal constraints on the delays between pairs of events. This work investigates the relationship between chronicles and classical temporal model formalisms, namely TPTL and MTL. More specifically, we answer the following question: is it possible to find an equivalent formula in such formalisms for any chronicle? This question arises from the observation that a single chronicle captures complex temporal behaviours that do not order the events in time.

In this article, we introduce the subclass of linear chronicles, which defines a temporal order of occurrence of the event to be recognized in a temporal sequence. Our first result is that any chronicle can be expressed as a disjunction of linear chronicles. Our second result is that any linear chronicle has an equivalent TPTL formula. Using existing expressiveness results between TPTL and MTL, we show that some chronicles have no equivalent in MTL. This confirms that the model of chronicle has interesting properties for situation recognition.

@inproceedings{time2022-GM,
  author =              {Guyet, {\relax Th}omas and Markey, Nicolas},
  title =               {Logical forms of chronicles},
  editor =              {Artikis, Alexander and Posenato, Roberto and
                         Tonetta, Stefano},
  booktitle =           {{P}roceedings of the 29th {I}nternational
                         {S}ymposium on {T}emporal {R}epresentation and
                         {R}easoning ({TIME}'22)},
  acronym =             {{TIME}'22},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  pages =               {7:1-7:15},
  year =                {2022},
  month =               nov,
  doi =                 {10.4230/LIPIcs.TIME.2022.7},
  abstract =            {A~chronicle is a temporal model introduced by
                         Dousson~\textit{et~al.} for situation recognition.
                         In~short, a chronicle consists of a set of events
                         and a set of real-valued temporal constraints on the
                         delays between pairs of events. This~work
                         investigates the relationship between chronicles and
                         classical temporal model formalisms, namely
                         \textsf{TPTL} and~\textsf{MTL}. More~specifically,
                         we~answer the following question: is~it possible to
                         find an equivalent formula in such formalisms for
                         any chronicle? This~question arises from the
                         observation that a single chronicle captures complex
                         temporal behaviours that do not order the events in
                         time.\par In~this article, we~introduce the subclass
                         of linear chronicles, which defines a temporal order
                         of occurrence of the event to be recognized in a
                         temporal sequence. Our~first result is that any
                         chronicle can be expressed as a disjunction of
                         linear chronicles. Our~second result is that any
                         linear chronicle has an equivalent \textsf{TPTL}
                         formula. Using existing expressiveness results
                         between \textsf{TPTL} and~\textsf{MTL}, we~show that
                         some chronicles have no equivalent in~\textsf{MTL}.
                         This confirms that the model of chronicle has
                         interesting properties for situation recognition.},
}

Abstract

Network congestion games are a convenient model for reasoning about routing problems in a network: agents have to move from a source to a target vertex while avoiding congestion, measured as a cost depending on the number of players using the same link. Network congestion games have been extensively studied over the last 40 years, while their extension with timing constraints were considered more recently.

Most of the results on network congestion games consider blind strategies: they are static, and do not adapt to the strategies selected by the other players. We extend the recent results of [Bertrand et al., Dynamic network congestion games. FSTTCS'20] to timed network congestion games, in which the availability of the edges depend on (discrete) time. We prove that computing Nash equilibria satisfying some constraint on the total cost (and in particular, computing the best and worst Nash equilibria), and computing the social optimum, can be achieved in exponential space. The social optimum can be computed in polynomial space if all players have the same source and target.

@inproceedings{formats2022-GMS,
  author =              {Goeminne, Aline and Markey, Nicolas and Sankur,
                         Ocan},
  title =               {Non-Blind Strategies in Timed Network Congestion
                         Games},
  editor =              {Bogomolov, Sergiy and Parker, David},
  booktitle =           {{P}roceedings of the 20th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'22)},
  acronym =             {{FORMATS}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13465},
  pages =               {183-199},
  year =                {2022},
  month =               sep,
  doi =                 {10.1007/978-3-031-15839-1_11},
  abstract =            {Network congestion games are a convenient model for
                         reasoning about routing problems in a network:
                         agents have to move from a source to a target vertex
                         while avoiding congestion, measured as a cost
                         depending on the number of players using the same
                         link. Network congestion games have been extensively
                         studied over the last 40 years, while their
                         extension with timing constraints were considered
                         more recently. \par Most of the results on network
                         congestion games consider blind strategies: they are
                         static, and do not adapt to the strategies selected
                         by the other players. We extend the recent results
                         of [Bertrand~\textit{et~al.}, Dynamic network
                         congestion games. FSTTCS'20] to timed network
                         congestion games, in which the availability of the
                         edges depend on (discrete) time. We prove that
                         computing Nash equilibria satisfying some constraint
                         on the total cost (and in particular, computing the
                         best and worst Nash equilibria), and computing the
                         social optimum, can be achieved in exponential
                         space. The social optimum can be computed in
                         polynomial space if all players have the same source
                         and target.},
}

Abstract

We consider the problem of repairing inconsistent real-time requirements with respect to two consistency notions: non-vacuity, which means that each requirement can be realized without violating other ones, and rt-consistency, which means that inevitable violations are detected immediately. We provide an iterative algorithm, based on solving SMT queries, to replace designated parameters of real-time requirements with new Boolean expressions and time constraints, so that the resulting set of requirements becomes consistent.

@inproceedings{atva2022-NSJMM,
  author =              {Noguchi, Reiya and Sankur, Ocan and J{\'e}ron,
                         Thierry and Markey, Nicolas and Mentr{\'e}, David},
  title =               {Repairing Real-Time Requirements},
  editor =              {Bouajjani, Ahmed and Hol{\'\i}k, Luk{\'a}{\v s} and
                         Wu, Zhilin},
  booktitle =           {{P}roceedings of the 20th {I}nternational
                         {S}ymposium on {A}utomated {T}echnology for
                         {V}erification and {A}nalysis ({ATVA}'22)},
  acronym =             {{ATVA}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13505},
  pages =               {371-387},
  year =                {2022},
  month =               oct,
  doi =                 {10.1007/978-3-031-19992-9_24},
  abstract =            {We~consider the problem of repairing inconsistent
                         real-time requirements with respect to two
                         consistency notions: non-vacuity, which means that
                         each requirement can be realized without violating
                         other ones, and rt-consistency, which means that
                         inevitable violations are detected immediately.
                         We~provide an iterative algorithm, based on solving
                         SMT queries, to replace designated parameters of
                         real-time requirements with new Boolean expressions
                         and time constraints, so that the resulting set of
                         requirements becomes consistent.},
}

@patent{EP3907615B1,
  author =              {Noguchi, Reiya and J{\'e}ron, Thierry and Markey,
                         Nicolas and Sankur, Ocan},
  title =               {Method and system for testing the operation of a
                         target computer system by using timed requirements},
  number =              {EP 3 907 615 B1},
  year =                {2022},
  month =               nov,
}

@inproceedings{rp2022-BHLST,
  author =              {Bose, Sougata and Henzinger, Thomas A. and Lehtinen,
                         Karoliina and Schewe, Sven and Totzke, Patrick},
  title =               {History-deterministic timed automata are not
                         determinizable},
  editor =              {Lin, Anthony W. and Zetzsche, Georg and Potapov,
                         Igor},
  booktitle =           {{P}roceedings of the 16th {W}orkshop on
                         {R}eachability {P}roblems in {C}omputational
                         {M}odels ({RP}'22)},
  acronym =             {{RP}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13608},
  pages =               {67-76},
  year =                {2022},
  month =               oct,
  doi =                 {10.1007/978-3-031-19135-0_5},
}

@inproceedings{fossacs2022-BL,
  author =              {Boker, Udi and Lehtinen, Karoliina},
  title =               {Token Games and History-Deterministic Quantitative
                         Automata},
  editor =              {Bouyer, Patricia and Schr{\"o}der, Lutz},
  booktitle =           {{P}roceedings of the 25th {I}nternational
                         {C}onference on {F}oundations of {S}oftware
                         {S}cience and {C}omputation {S}tructure
                         ({FoSSaCS}'22)},
  acronym =             {{FoSSaCS}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13242},
  pages =               {120-139},
  year =                {2022},
  month =               apr,
  doi =                 {10.1007/978-3-030-99253-8_7},
}

@inproceedings{fossacs2022-BLS,
  author =              {Boker, Udi and Lehtinen, Karoliina and Sickert,
                         Salomon},
  title =               {On the Translation of Automata to Linear Temporal
                         Logic},
  editor =              {Bouyer, Patricia and Schr{\"o}der, Lutz},
  booktitle =           {{P}roceedings of the 25th {I}nternational
                         {C}onference on {F}oundations of {S}oftware
                         {S}cience and {C}omputation {S}tructure
                         ({FoSSaCS}'22)},
  acronym =             {{FoSSaCS}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13242},
  pages =               {140-160},
  year =                {2022},
  month =               apr,
  doi =                 {10.1007/978-3-030-99253-8_8},
}

@inproceedings{concur2022-HLT,
  author =              {Henzinger, Thomas A. and Lehtinen, Karoliina and
                         Totzke, Patrick},
  title =               {History-deterministic timed automata},
  editor =              {Klin, Bartek and Lasota, S{\l}awomir and Muscholl,
                         Anca},
  booktitle =           {{P}roceedings of the 33rd {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'22)},
  acronym =             {{CONCUR}'22},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {243},
  pages =               {14:1-14:21},
  year =                {2022},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CONCUR.2022.14},
}

@inproceedings{wine2022-HM,
  author =              {Hao, Bainian and Michini, Carla},
  title =               {Inefficiency of Pure Nash Equilibria in
                         Series-Parallel Network Congestion Games},
  editor =              {Hansen, Kristoffer Arnsfelt and Liu, Tracy Xiao and
                         Malekian, Azarakhsh},
  booktitle =           {{P}roceedings of the 18th {I}nternational
                         {C}onference on {W}eb and {I}nternet {E}conomics
                         ({WINE}'22)},
  acronym =             {{WINE}'22},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13778},
  pages =               {3-20},
  year =                {2022},
  month =               jul,
  doi =                 {10.1007/978-3-031-22832-2_1},
}

Abstract

In this paper, we propose a novel framework for the synthesis of robust and optimal energy-aware controllers. The framework is based on energy timed automata, allowing for easy expression of timing-constraints and variable energy-rates. We prove decidability of the energy-constrained infinite-run problem in settings with both certainty and uncertainty of the energy-rates. We also consider the optimization problem of identifying the minimal upper bound that will permit existence of energy-constrained infinite runs. Our algorithms are based on quantifier elimination for linear real arithmetic. Using Mathematica and Mjollnir, we illustrate our framework through a real industrial example of a hydraulic oil pump. Compared with previous approaches our method is completely automated and provides improved results.

@article{fac2020-BBFLMR,
  author =              {Bacci, Giovanni and Bouyer, Patricia and Fahrenberg,
                         Uli and Larsen, Kim Guldstrand and Markey, Nicolas
                         and Reynier, Pierre-Alain},
  title =               {Optimal and Robust Controller Synthesis Using Energy
                         Timed Automata with Uncertainty},
  publisher =           {Springer-Verlag},
  journal =             {Formal Aspects of Computing},
  volume =              {33},
  number =              {1},
  pages =               {3-25},
  year =                {2021},
  month =               jan,
  doi =                 {10.1007/s00165-020-00521-4},
  abstract =            {In~this paper, we~propose a novel framework for the
                         synthesis of robust and optimal energy-aware
                         controllers. The~framework is based on energy timed
                         automata, allowing for easy expression of
                         timing-constraints and variable energy-rates.
                         We~prove decidability of the energy-constrained
                         infinite-run problem in settings with both certainty
                         and uncertainty of the energy-rates. We~also
                         consider the optimization problem of identifying the
                         minimal upper bound that will permit existence of
                         energy-constrained infinite runs. Our~algorithms are
                         based on quantifier elimination for linear real
                         arithmetic. Using Mathematica and Mjollnir,
                         we~illustrate our framework through a real
                         industrial example of a hydraulic oil pump. Compared
                         with previous approaches our method is completely
                         automated and provides improved results.},
}

Abstract

We consider the problems of efficiently diagnosing (and predicting) what did (and will) happen after a given sequence of observations of the execution of a partially-observable one-clock timed automaton. This is made difficult by the facts that timed automata are infinite-state systems, and that they can in general not be determinized.

We introduce timed markings as a formalism to keep track of the evolution of the set of reachable configurations over time. We show how timed markings can be used to efficiently represent the closure under silent transitions of such automata. We report on our implementation of this approach compared to the approach of [Tripakis, Fault diagnosis for timed automata, 2002], and provide some insight to a generalization of our approach to n-clock timed automata.

@article{sttt23(2)-BHJJM,
  author =              {Bouyer, Patricia and Henry, L{\'e}o and Jaziri, Samy
                         and J{\'e}ron, Thierry and Markey, Nicolas},
  title =               {Diagnosing timed automata using timed markings},
  publisher =           {Springer-Verlag},
  journal =             {International Journal on Software Tools for
                         Technology Transfer},
  volume =              {23},
  number =              {2},
  pages =               {229-253},
  year =                {2021},
  month =               apr,
  doi =                 {10.1007/s10009-021-00606-2},
  abstract =            {We~consider the problems of efficiently diagnosing
                         (and~predicting) what did (and~will) happen after a
                         given sequence of observations of the execution of a
                         partially-observable one-clock timed automaton. This
                         is made difficult by the facts that timed automata
                         are infinite-state systems, and that they can in
                         general not be determinized. \par We~introduce timed
                         markings as a formalism to keep track of the
                         evolution of the set of reachable configurations
                         over time. We show how timed markings can be used to
                         efficiently represent the closure under silent
                         transitions of such automata. We report on our
                         implementation of this approach compared to the
                         approach of [Tripakis, Fault diagnosis for timed
                         automata,~2002], and provide some insight to a
                         generalization of our approach to {{\(n\)}}-clock
                         timed automata.},
}

@article{tecs20(5s)-AZZZ,
  author =              {An, Jie and Zhan, Bohua and Zhan, Naijun and Zhang,
                         Miaomiao},
  title =               {Learning nondeterministic real-time automata},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Embedded Computing Systems},
  volume =              {20},
  number =              {5s},
  pages =               {99:1-99:26},
  year =                {2021},
  month =               oct,
  doi =                 {10.1145/3477030},
}

@article{tocl22(1)-BFFGMMPPRS,
  author =              {Berthon, Rapha{\"e}l and Fijalkow, Nathana{\"e}l and
                         Filiot, Emmanuel and Guha, Shibashis and Maubert,
                         Bastien and Murano, Aniello and Pinault, Laureline
                         and Pinchinat, Sophie and Rubin, Sasha and Serre,
                         Olivier},
  title =               {Alternating Tree Automata with Qualitative
                         Semantics},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Computational Logic},
  volume =              {22},
  number =              {1},
  pages =               {7:1-7:24},
  year =                {2021},
  month =               jan,
  doi =                 {10.1145/3431860},
}

@inproceedings{fsttcs2021-BK,
  author =              {Boker, Udi and Lehtinen, Karoliina},
  title =               {History Determinism vs.~Good for Gameness in
                         Quantitative Automata},
  editor =              {Boja{\'n}czyk, Miko{\l}aj and Chekuri, Chandra},
  booktitle =           {{P}roceedings of the 41st {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'21)},
  acronym =             {{FSTTCS}'21},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {213},
  pages =               {38:1-38:20},
  year =                {2021},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2021.38},
}

@incollection{hat-ch8,
  author =              {L{\"o}ding, Christof},
  title =               {Automata on infinite trees},
  editor =              {Pin, Jean-{\'E}ric},
  booktitle =           {Handbook of automata theory},
  publisher =           {EMS~Press},
  volume =              {1},
  pages =               {265-302},
  chapter =             {8},
  year =                {2021},
  doi =                 {10.4171/AUTOMATA-1/8},
}

@inproceedings{ijcai2020-MPSS,
  author =              {Maubert, Bastien and Pinchinat, Sophie and
                         Schwarzentruber, Fran{\c c}ois and Stranieri,
                         Silvia},
  title =               {Concurrent Games in Dynamic Epistemic Logic},
  editor =              {Bessiere, Christian},
  booktitle =           {{P}roceedings of the 29th {I}nternational {J}oint
                         {C}onference on {A}rtificial {I}ntelligence
                         ({IJCAI}'20)},
  acronym =             {{IJCAI}'20},
  publisher =           {IJCAI organization},
  pages =               {1877-1883},
  year =                {2021},
  month =               jan,
  doi =                 {10.24963/ijcai.2020/260},
}

@book{hat-pin-1,
  title =               {Handbook of automata theory},
  editor =              {Pin, Jean-{\'E}ric},
  booktitle =           {Handbook of automata theory},
  publisher =           {EMS~Press},
  volume =              {1},
  year =                {2021},
  doi =                 {10.4171/AUTOMATA-1},
}

@phdthesis{phd-sadhukhan,
  author =              {Sadhukhan, Suman},
  title =               {A Verification Viewpoint on Network Congestion
                         Games},
  year =                {2021},
  month =               dec,
  school =              {Universit{\'e} Rennes~1, France},
}

@inproceedings{sbmf2021-SK,
  author =              {Saeedloei, Neda and Klu{\'z}niak, Feliks},
  title =               {Minimization of the Number of Clocks for Timed
                         Scenarios},
  editor =              {Campos, S{\'e}rgio Vale Aguiar and Minea, Marius},
  booktitle =           {{P}roceedings of the24th {B}razilian {S}ymposium on
                         {F}ormal {M}ethods ({SBMF}'21)},
  acronym =             {{SBMF}'21},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {13130},
  pages =               {122-139},
  year =                {2021},
  confmonth =           {12},
  doi =                 {10.1007/978-3-030-92137-8_8},
}

Abstract

Parametric timed automata (PTA) are a powerful formalism to model and reason about concurrent systems with some unknown timing delays. In this paper, we address the (untimed) language- and trace-preservation problems: given a reference parameter valuation, does there exist another parameter valuation with the same untimed language, or with the same set of traces? We show that these problems are undecidable both for general PTA and for the restricted class of L/U-PTA, even for integer-valued parameters, or over bounded time. On the other hand, we exhibit decidable subclasses: 1-clock PTA, and 1-parameter deterministic L-PTA and U-PTA. We also consider robust versions of these problems, where we additionally require that the language be preserved for all valuations between the reference valuation and the new valuation.

@article{lmcs16(1)-ALM,
  author =              {Andr{\'e}, {\'E}tienne and Lime, Didier and Markey,
                         Nicolas},
  title =               {Language-preservation problems in parametric timed
                         automata},
  journal =             {Logical Methods in Computer Science},
  volume =              {16},
  number =              {1},
  year =                {2020},
  month =               jan,
  doi =                 {10.23638/LMCS-16(1:5)2020},
  abstract =            {Parametric timed automata (PTA) are a powerful
                         formalism to model and reason about concurrent
                         systems with some unknown timing delays. In~this
                         paper, we~address the (untimed) language- and
                         trace-preservation problems: given a reference
                         parameter valuation, does there exist another
                         parameter valuation with the same untimed language,
                         or with the same set of traces? We~show that these
                         problems are undecidable both for general PTA and
                         for the restricted class of L{\slash}U-PTA, even for
                         integer-valued parameters, or over bounded time.
                         On~the other~hand, we~exhibit decidable subclasses:
                         1-clock PTA, and 1-parameter deterministic L-PTA and
                         U-PTA. We~also consider robust versions of these
                         problems, where we additionally require that the
                         language be preserved for all valuations between the
                         reference valuation and the new valuation.},
}

Abstract

Strategy Logic (SL) is a very expressive temporal logic for specifying and verifying properties of multi-agent systems: in SL, one can quantify over strategies, assign them to agents, and express LTL properties of the resulting plays. Such a powerful framework has two drawbacks: first, model checking SL has non-elementary complexity; second, the exact semantics of SL is rather intricate, and may not correspond to what is expected. In this paper, we focus on strategy dependences in SL, by tracking how existentially-quantified strategies in a formula may (or may not) depend on other strategies selected in the formula, revisiting the approach of [Mogavero et al., Reasoning about strategies: On the model-checking problem, 2014]. We explain why elementary dependences, as defined by Mogavero et al., do not exactly capture the intended concept of behavioral strategies. We address this discrepancy by introducing timeline dependences, and exhibit a large fragment of SL for which model checking can be performed in 2EXPTIME under this new semantics.

@article{tocsys64(3)-GBM,
  author =              {Gardy, Patrick and Bouyer, Patricia and Markey,
                         Nicolas},
  title =               {Dependences in Strategy Logic},
  publisher =           {Springer-Verlag},
  journal =             {Theory of Computing Systems},
  volume =              {64},
  number =              {3},
  pages =               {467-507},
  year =                {2020},
  month =               apr,
  doi =                 {10.1007/s00224-019-09926-y},
  abstract =            {Strategy Logic~(\textsf{SL}) is a very expressive
                         temporal logic for specifying and verifying
                         properties of multi-agent systems: in~\textsf{SL},
                         one can quantify over strategies, assign them to
                         agents, and express \textsf{LTL} properties of the
                         resulting plays. Such a powerful framework has two
                         drawbacks: first, model checking \textsf{SL} has
                         non-elementary complexity; second, the exact
                         semantics of \textsf{SL} is rather intricate, and
                         may not correspond to what is expected. In~this
                         paper, we~focus on \emph{strategy dependences}
                         in~\textsf{SL}, by tracking how
                         existentially-quantified strategies in a formula may
                         (or~may~not) depend on other strategies selected in
                         the formula, revisiting the approach of~[Mogavero
                         \emph{et~al.}, Reasoning about strategies: On~the
                         model-checking problem,~2014]. We~explain why
                         \emph{elementary} dependences, as defined by
                         Mogavero~\emph{et~al.}, do not exactly capture the
                         intended concept of behavioral strategies.
                         We~address this discrepancy by introducing
                         \emph{timeline} dependences, and exhibit a large
                         fragment of \textsf{SL} for which model checking can
                         be performed in \textsf{2EXPTIME} under this new
                         semantics.},
}

Abstract

Congestion games are a classical type of games studied in game theory, in which n players choose a resource, and their individual cost increases with the number of other players choosing the same resource. In network congestion games (NCGs), the resources correspond to simple paths in a graph, e.g. representing routing options from a source to a target. In this paper, we introduce a variant of NCGs, referred to as dynamic NCGs: in this setting, players take transitions synchronously, they select their next transitions dynamically, and they are charged a cost that depends on the number of players simultaneously using the same transition.

We study, from a complexity perspective, standard concepts of game theory in dynamic NCGs: social optima, Nash equilibria, and subgame perfect equilibria. Our contributions are the following: the existence of a strategy profile with social cost bounded by a constant is in PSPACE and NP-hard. (Pure) Nash equilibria always exist in dynamic NCGs; the existence of a Nash equilibrium with bounded cost can be decided in EXPSPACE, and computing a witnessing strategy profile can be done in doubly-exponential time. The existence of a subgame perfect equilibrium with bounded cost can be decided in 2EXPSPACE, and a witnessing strategy profile can be computed in triply-exponential time.

@inproceedings{fsttcs2020-BMSS,
  author =              {Bertrand, Nathalie and Markey, Nicolas and
                         Sadhukhan, Suman and Sankur, Ocan},
  title =               {Dynamic network congestion games},
  editor =              {Saxena, Nitin and Simon, Sunil},
  booktitle =           {{P}roceedings of the 40th {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'20)},
  acronym =             {{FSTTCS}'20},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {182},
  pages =               {40:1-40:16},
  year =                {2020},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2020.40},
  abstract =            {Congestion games are a classical type of games
                         studied in game theory, in which n players choose a
                         resource, and their individual cost increases with
                         the number of other players choosing the same
                         resource. In network congestion games~(NCGs), the
                         resources correspond to simple paths in a graph,
                         e.g.~representing routing options from a source to a
                         target. In this paper, we introduce a variant
                         of~NCGs, referred to as dynamic~NCGs: in~this
                         setting, players take transitions synchronously,
                         they select their next transitions dynamically, and
                         they are charged a cost that depends on the number
                         of players simultaneously using the same transition.
                         \par We~study, from a complexity perspective,
                         standard concepts of game theory in dynamic NCGs:
                         social optima, Nash equilibria, and subgame perfect
                         equilibria. Our contributions are the following: the
                         existence of a strategy profile with social cost
                         bounded by a constant is in PSPACE and NP-hard.
                         (Pure)~Nash equilibria always exist in dynamic~NCGs;
                         the existence of a Nash equilibrium with bounded
                         cost can be decided in EXPSPACE, and computing a
                         witnessing strategy profile can be done in
                         doubly-exponential time. The~existence of a subgame
                         perfect equilibrium with bounded cost can be decided
                         in 2EXPSPACE, and a witnessing strategy profile can
                         be computed in triply-exponential~time.},
}

Abstract

Timed automata are a convenient mathematical model for modelling and reasoning about real-time systems. While they provide a powerful way of representing timing aspects of such systems, timed automata assume arbitrary precision and zero-delay actions; in particular, a state might be declared reachable in a timed automaton, but impossible to reach in the physical system it models.

In this paper, we consider permissive strategies as a way to overcome this problem: such strategies propose intervals of delays instead of single delays, and aim at reaching a target state whichever delay actually takes place. We develop an algorithm for computing the optimal permissiveness (and an associated maximally-permissive strategy) in acyclic timed automata and games.

@inproceedings{formats2020-CJMM,
  author =              {Clement, Emily and J{\'e}ron, Thierry and Markey,
                         Nicolas and Mentr{\'e}, David},
  title =               {Computing maximally-permissive strategies in acyclic
                         timed automata},
  editor =              {Bertrand, Nathalie and Jansen, Nils},
  booktitle =           {{P}roceedings of the 18th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'20)},
  acronym =             {{FORMATS}'20},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {12288},
  pages =               {111-126},
  year =                {2020},
  month =               sep,
  doi =                 {10.1007/978-3-030-57628-8_7},
  abstract =            {Timed automata are a convenient mathematical model
                         for modelling and reasoning about real-time systems.
                         While they provide a powerful way of representing
                         timing aspects of such systems, timed automata
                         assume arbitrary precision and zero-delay actions;
                         in~particular, a~state might be declared reachable
                         in a timed automaton, but impossible to reach in the
                         physical system it models. \par In this paper, we
                         consider permissive strategies as a way to overcome
                         this problem: such strategies propose intervals of
                         delays instead of single delays, and aim at reaching
                         a target state whichever delay actually takes place.
                         We develop an algorithm for computing the optimal
                         permissiveness (and~an associated
                         maximally-permissive strategy) in acyclic timed
                         automata and games.},
}

Abstract

Active learning of timed languages is concerned with the inference of timed automata by observing some of the timed words in their languages. The learner can query for the membership of words in the language, or propose a candidate model and ask if it is equivalent to the target. The major difficulty of this framework is the inference of clock resets, which are central to the dynamics of timed automata but not directly observable.

Interesting first steps have already been made by restricting to the subclass of event-recording automata, where clock resets are tied to observations. In order to advance towards learning of general timed automata, we generalize this method to a new class, called reset-free event-recording automata, where some transitions may reset no clocks.

Central to our contribution is the notion of invalidity, and the algorithm and data structures to deal with it, allowing on-the-fly detection and pruning of reset hypotheses that contradict observations. This notion is a key to any efficient active-learning procedure for generic timed automata.

@inproceedings{formats2020-HJM,
  author =              {Henry, L{\'e}o and J{\'e}ron, Thierry and Markey,
                         Nicolas},
  title =               {Active learning of timed automata with unobservable
                         resets},
  editor =              {Bertrand, Nathalie and Jansen, Nils},
  booktitle =           {{P}roceedings of the 18th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'20)},
  acronym =             {{FORMATS}'20},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {12288},
  pages =               {144-160},
  year =                {2020},
  month =               sep,
  doi =                 {10.1007/978-3-030-57628-8_9},
  abstract =            {Active learning of timed languages is concerned with
                         the inference of timed automata by observing some of
                         the timed words in their languages. The learner can
                         query for the membership of words in the language,
                         or propose a candidate model and ask if it is
                         equivalent to the target. The major difficulty of
                         this framework is the inference of clock resets,
                         which are central to the dynamics of timed automata
                         but not directly observable. \par Interesting first
                         steps have already been made by restricting to the
                         subclass of event-recording automata, where clock
                         resets are tied to observations. In order to advance
                         towards learning of general timed automata, we
                         generalize this method to a new class, called
                         reset-free event-recording automata, where some
                         transitions may reset no clocks. \par Central to our
                         contribution is the notion of invalidity, and the
                         algorithm and data structures to deal with it,
                         allowing on-the-fly detection and pruning of reset
                         hypotheses that contradict observations. This notion
                         is a key to any efficient active-learning procedure
                         for generic timed automata.},
}

Abstract

Requirements engineering is a key phase in the development process. Ensuring that requirements are consistent is essential so that they do not conflict and admit implementations. We consider the formal verification of rt-consistency, which imposes that the inevitability of definitive errors of a requirement should be anticipated, and that of partial consistency, which was recently introduced as a more effective check. We generalize and formalize both notions for discrete-time timed automata, develop three incremental algorithms, and present experimental results.

@inproceedings{formats2020-JMMNS,
  author =              {J{\'e}ron, Thierry and Markey, Nicolas and
                         Mentr{\'e}, David and Noguchi, Reiya and Sankur,
                         Ocan},
  title =               {Incremental methods for checking real-time
                         consistency},
  editor =              {Bertrand, Nathalie and Jansen, Nils},
  booktitle =           {{P}roceedings of the 18th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'20)},
  acronym =             {{FORMATS}'20},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {12288},
  pages =               {249-264},
  year =                {2020},
  month =               sep,
  doi =                 {10.1007/978-3-030-57628-8_15},
  abstract =            {Requirements engineering is a key phase in the
                         development process. Ensuring that requirements are
                         consistent is essential so that they do not conflict
                         and admit implementations. We~consider the formal
                         verification of rt-consistency, which imposes that
                         the inevitability of definitive errors of a
                         requirement should be anticipated, and that of
                         partial consistency, which was recently introduced
                         as a more effective check. We~generalize and
                         formalize both notions for discrete-time timed
                         automata, develop three incremental algorithms, and
                         present experimental results.},
}

@inproceedings{tacas2020-ACZZZ,
  author =              {An, Jie and Chen, Mingshuai and Zhan, Bohua and
                         Zhan, Naijun and Zhang, Miaomiao},
  title =               {Learning One-Clock Timed Automata},
  editor =              {Biere, Armin and Parker, David},
  booktitle =           {{P}roceedings of the 26th {I}nternational
                         {C}onference on {T}ools and {A}lgorithms for
                         {C}onstruction and {A}nalysis of {S}ystems
                         ({TACAS}'20)~-- {P}art~{I}},
  acronym =             {{TACAS}'20 (Part~{I})},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {12078},
  pages =               {444-462},
  year =                {2020},
  month =               apr,
  doi =                 {10.1007/978-3-030-45190-5_25},
}

@article{tcs807()-AHK,
  author =              {Avni, Guy and Henzinger, Thomas A. and Kupferman,
                         Orna},
  title =               {Dynamic Resource Allocation Games},
  publisher =           {Elsevier},
  journal =             {Theoretical Computer Science},
  volume =              {807},
  pages =               {42-55},
  year =                {2020},
  month =               feb,
  doi =                 {10.1016/j.tcs.2019.06.031},
}

@techreport{arxiv-AMPR,
  author =              {Amram, Gal and Maoz, Shahar and Pistiner, Or and
                         Ringert, Jan Oliver},
  title =               {Energy {{\(\mu\)}}-Calculus: Symbolic Fixed-Point
                         Algorithms for {{\(\omega\)}}-Regular Energy Games},
  number =              {2005.00641},
  year =                {2020},
  month =               may,
  institution =         {arXiv},
}

@techreport{arxiv2002.03664-BFFGMMPPRS,
  author =              {Berthon, Rapha{\"e}l and Fijalkow, Nathana{\"e}l and
                         Filiot, Emmanuel and Guha, Shibashis and Maubert,
                         Bastien and Murano, Aniello and Pinault, Laureline
                         and Pinchinat, Sophie and Rubin, Sasha and Serre,
                         Olivier},
  title =               {Alternating Tree Automata with Qualitative
                         Semantics},
  number =              {2002-03664},
  year =                {2020},
  month =               feb,
  institution =         {arXiv},
}

@inproceedings{fsttcs2020-BKLS,
  author =              {Boker, Udi and Kuperberg, Denis and Lehtinen,
                         Karoliina and Skrzypczak, Michal},
  title =               {On succinctness and recognisability of alternating
                         good-for-games automata},
  editor =              {Saxena, Nitin and Simon, Sunil},
  booktitle =           {{P}roceedings of the 40th {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'20)},
  acronym =             {{FSTTCS}'20},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {182},
  pages =               {41:1-41:13},
  year =                {2020},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2020.41},
}

@article{or68(2)-CCMS,
  author =              {Colini{-}Baldeschi, Riccardo and Cominetti, Roberto
                         and Mertikopoulos, Panayotis and Scarsini, Marco},
  title =               {When is selfish routing bad? {T}he~price of anarchy
                         in light and heavy traffic},
  publisher =           {Informs},
  journal =             {Operations Research},
  volume =              {68},
  number =              {2},
  pages =               {411-434},
  year =                {2020},
  month =               apr,
  doi =                 {10.1287/opre.2019.1894},
}

@book{Had20-IEDES,
  author =              {Hadjicostis, Christoforos N.},
  title =               {Estimation and Inference in Discrete Event
                         Systems~-- A~model-based approach with finite
                         automata},
  publisher =           {Springer-Verlag},
  series =              {Communications and Control Engineering},
  year =                {2020},
}

@inproceedings{lics2020-LZ,
  author =              {Lehtinen, Karoliina and Zimmermann, Martin},
  title =               {Good-for-games {\(\omega\)}-pushdown automata},
  editor =              {Hermanns, Holger and Zhang, Lijun and Kobayashi,
                         Naoki and Miller, Dale},
  booktitle =           {{P}roceedings of the 35th {A}nnual {S}ymposium on
                         {L}ogic in {C}omputer {S}cience ({LICS}'20)},
  acronym =             {{LICS}'20},
  publisher =           {IEEE Comp. Soc. Press},
  pages =               {689-702},
  year =                {2020},
  month =               jul,
  doi =                 {10.1145/3373718.3394737},
}

@techreport{arxiv2001.07141-MMPSS,
  author =              {Maubert, Bastien and Murano, Aniello and Pinchinat,
                         Sophie and Schwarzentruber, Fran{\c c}ois and
                         Stranieri, Silvia},
  title =               {Dynamic Epistemic Logic Games with Epistemic
                         Temporal Goals},
  number =              {2001-07141},
  year =                {2020},
  month =               jan,
  institution =         {arXiv},
}

@phdthesis{phd-roussanaly,
  author =              {Roussanaly, Victor},
  title =               {Efficient verification of real-time systems},
  year =                {2020},
  month =               nov,
  school =              {Universit{\'e} Rennes~1, France},
  type =                {Th\`ese de doctorat},
}

@inproceedings{fsttcs2020-Wol,
  author =              {Wolf, Petra},
  title =               {Synchronization under Dynamic Constraints},
  editor =              {Saxena, Nitin and Simon, Sunil},
  booktitle =           {{P}roceedings of the 40th {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'20)},
  acronym =             {{FSTTCS}'20},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {182},
  pages =               {58:1-58:14},
  year =                {2020},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2020.58},
}

Abstract

We introduce and study SL[F]—a quantitative extension of SL (Strategy Logic), one of the most natural and expressive logics describing strategic behaviours. The satisfaction value of an SL[F] formula is a real value in [0,1], reflecting "how much" or "how well" the strategic on-going objectives of the underlying agents are satisfied. We demonstrate the applications of SL[F] in quantitative reasoning about multi-agent systems, by showing how it can express concepts of stability in multi-agent systems, and how it generalises some fuzzy temporal logics. We also provide a model-checking algorithm for our logic, based on a quantitative extension of Quantified CTL.

@inproceedings{ijcai2019-BKMMMP,
  author =              {Bouyer, Patricia and Kupferman, Orna and Markey,
                         Nicolas and Maubert, Bastien and Murano, Aniello and
                         Perelli, Giuseppe},
  title =               {Reasoning about Quality and Fuzziness of Strategic
                         Behaviours},
  editor =              {Kraus, Sarit},
  booktitle =           {{P}roceedings of the 28th {I}nternational {J}oint
                         {C}onference on {A}rtificial {I}ntelligence
                         ({IJCAI}'19)},
  acronym =             {{IJCAI}'19},
  publisher =           {IJCAI organization},
  pages =               {1588-1594},
  year =                {2019},
  month =               aug,
  doi =                 {10.24963/ijcai.2019/220},
  abstract =            {We~introduce and study
                         {\(\textsf{SL}[\mathcal{F}]\)}---a~quantitative
                         extension of {\(\textsf{SL}\)} (Strategy Logic),
                         one~of the most natural and expressive logics
                         describing strategic behaviours. The satisfaction
                         value of an {\(\textsf{SL}[\mathcal{F}]\)} formula
                         is a real value in~{\([0,1]\)}, reflecting {"}how
                         much{"} or {"}how well{"} the strategic on-going
                         objectives of the underlying agents are satisfied.
                         We~demonstrate the applications of
                         {\(\textsf{SL}[\mathcal{F}]\)} in quantitative
                         reasoning about multi-agent systems, by showing how
                         it can express concepts of stability in multi-agent
                         systems, and how it generalises some fuzzy temporal
                         logics. We~also provide a model-checking algorithm
                         for our logic, based on a quantitative extension of
                         Quantified~\textsf{CTL}.},
}

Abstract

We study games with reachability objectives under energy constraints. We first prove that under strict energy constraints (either only lower-bound constraint or interval constraint), those games are LOGSPACE-equivalent to energy games with the same energy constraints but without reachability objective (i.e., for infinite runs). We then consider two kinds of relaxations of the upper-bound constraints (while keeping the lower-bound constraint strict): in the first one, called weak upper bound, the upper bound is absorbing, in the sense that it allows receiving more energy when the upper bound is already reached, but the extra energy will not be stored; in the second one, we allow for temporary violations of the upper bound, imposing limits on the number or on the amount of violations.

We prove that when considering weak upper bound, reachability objectives require memory, but can still be solved in polynomial-time for one-player arenas; we prove that they are in coNP in the two-player setting. Allowing for bounded violations makes the problem PSPACE-complete for one-player arenas and EXPTIME-complete for two players.

@inproceedings{gandalf2019-HMR,
  author =              {H{\'e}lou{\"e}t, Lo{\"\i}c and Markey, Nicolas and
                         Raha, Ritam},
  title =               {Reachability games with relaxed energy constraints},
  editor =              {Leroux, J{\'e}r{\^o}me and Raskin, Jean-Fran{\c
                         c}ois},
  booktitle =           {{P}roceedings of the 10th {I}nternational
                         {S}ymposium on {G}ames, {A}utomata, {L}ogics and
                         {F}ormal {V}erification ({GandALF}'19)},
  acronym =             {{GandALF}'19},
  series =              {Electronic Proceedings in Theoretical Computer
                         Science},
  volume =              {305},
  pages =               {17-33},
  year =                {2019},
  month =               sep,
  doi =                 {10.4204/EPTCS.305.2},
  abstract =            {We study games with reachability objectives under
                         energy constraints. We first prove that under strict
                         energy constraints (either only lower-bound
                         constraint or interval constraint), those games are
                         \textsf{LOGSPACE}-equivalent to energy games with
                         the same energy constraints but without reachability
                         objective (i.e., for infinite runs). We then
                         consider two kinds of relaxations of the upper-bound
                         constraints (while keeping the lower-bound
                         constraint strict): in the first one, called
                         \emph{weak upper bound}, the upper bound is
                         \emph{absorbing}, in the sense that it allows
                         receiving more energy when the upper bound is
                         already reached, but the extra energy will not be
                         stored; in~the second~one, we~allow for
                         \emph{temporary violations} of the upper bound,
                         imposing limits on the number or on the amount of
                         violations.\par We prove that when considering weak
                         upper bound, reachability objectives require memory,
                         but can still be solved in polynomial-time for
                         one-player arenas; we prove that they are in
                         \textsf{coNP} in the two-player setting. Allowing
                         for bounded violations makes the problem
                         \textsf{PSPACE}-complete for one-player arenas and
                         \textsf{EXPTIME}-complete for two players.},
}

Abstract

We present abstraction-refinement algorithms for model checking safety properties of timed automata. The abstraction domain we consider abstracts away zones by restricting the set of clock constraints that can be used to define them, while the refinement procedure computes the set of constraints that must be taken into consideration in the abstraction so as to exclude a given spurious counterexample. We implement this idea in two ways: an enumerative algorithm where a lazy abstraction approach is adopted, meaning that possibly different abstract domains are assigned to each exploration node; and a symbolic algorithm where the abstract transition system is encoded with Boolean formulas.

@inproceedings{cav2019-RSM,
  author =              {Roussanaly, Victor and Sankur, Ocan and Markey,
                         Nicolas},
  title =               {Abstraction Refinement Algorithms for Timed
                         Automata},
  editor =              {Dillig, I{\c s}il and Ta{\c s}iran, Serdar},
  booktitle =           {{P}roceedings of the 31st {I}nternational
                         {C}onference on {C}omputer {A}ided {V}erification
                         ({CAV}'19)},
  acronym =             {{CAV}'19},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {11561},
  pages =               {22-40},
  year =                {2019},
  month =               jul,
  doi =                 {10.1007/978-3-030-25540-4_2},
  abstract =            {We~present abstraction-refinement algorithms for
                         model checking safety properties of timed automata.
                         The~abstraction domain we consider abstracts away
                         zones by restricting the set of clock constraints
                         that can be used to define them, while the
                         refinement procedure computes the set of constraints
                         that must be taken into consideration in the
                         abstraction so as to exclude a given spurious
                         counterexample. We~implement this idea in two~ways:
                         an~enumerative algorithm where a lazy abstraction
                         approach is adopted, meaning that possibly different
                         abstract domains are assigned to each exploration
                         node; and a symbolic algorithm where the abstract
                         transition system is encoded with Boolean formulas.},
}

@inproceedings{concur2019-BBGRB,
  author =              {Brihaye, {\relax Th}omas and Bruy{\`e}re,
                         V{\'e}ronique and Goeminne, Aline and Raskin,
                         Jean-Fran{\c c}ois and Van{~}den{ }Bogaard, Marie},
  title =               {The~Complexity of Subgame Perfect Equilibria in
                         Quantitative Reachability Games},
  editor =              {Fokkink, Wan J. and van Glabbeek, Rob},
  booktitle =           {{P}roceedings of the 30th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'19)},
  acronym =             {{CONCUR}'19},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {140},
  pages =               {13:1-13:16},
  year =                {2019},
  month =               aug,
  doi =                 {10.4230/LIPIcs.CONCUR.2019.13},
}

@inproceedings{cav2019-BMRS,
  author =              {Busatto-Gaston, Damien and Monmege, Benjamin and
                         Reynier, Pierre-Alain and Sankur, Ocan},
  title =               {Robust Controller Synthesis in Timed B{\"u}chi
                         Automata: A~Symbolic Approach},
  editor =              {Dillig, I{\c s}il and Ta{\c s}iran, Serdar},
  booktitle =           {{P}roceedings of the 31st {I}nternational
                         {C}onference on {C}omputer {A}ided {V}erification
                         ({CAV}'19)},
  acronym =             {{CAV}'19},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {11561},
  pages =               {572-590},
  year =                {2019},
  month =               jul,
  doi =                 {10.1007/978-3-030-25540-4_33},
}

@inproceedings{concur2019-BL,
  author =              {Boker, Udi and Lehtinen, Karoliina},
  title =               {Good-for-game Automata: from Non-determinism to
                         Alternation},
  editor =              {Fokkink, Wan J. and van Glabbeek, Rob},
  booktitle =           {{P}roceedings of the 30th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'19)},
  acronym =             {{CONCUR}'19},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {140},
  pages =               {19:1-19:16},
  year =                {2019},
  month =               aug,
  doi =                 {10.4230/LIPIcs.CONCUR.2019.19},
}

@article{moor44(4)-CJKU,
  author =              {Correa, Jos{\'e} R. and de~Jong, Jasper and
                         de~Keizer, Bart and Uetz, Marc},
  title =               {The inefficiency of {N}ash and subgame-perfect
                         equilibria for network routing},
  publisher =           {Informs},
  journal =             {Mathematics of Operations Research},
  volume =              {44},
  number =              {4},
  pages =               {1286-1303},
  year =                {2019},
  month =               nov,
  doi =                 {10.1287/moor.2018.0968},
}

@article{jcss100()-DMS,
  author =              {Doyen, Laurent and Massart, {\relax Th}ierry and
                         Shirmohammadi, Mahsa},
  title =               {The complexity of synchronizing {M}arkov decision
                         processes},
  publisher =           {Elsevier},
  journal =             {Journal of Computer and System Sciences},
  volume =              {100},
  pages =               {96-129},
  year =                {2019},
  month =               mar,
  doi =                 {10.1016/j.jcss.2018.09.004},
}

@inproceedings{mfcs2019-FGHHVW,
  author =              {Fernau, Henning and Gusev, Vladimir V. and Hoffmann,
                         Stefan and Holzer, Markus and Volkov, Mikhail V. and
                         Wolf, Petra},
  title =               {Computational Complexity of Synchronization under
                         Regular Constraints},
  editor =              {Rossmanith, Peter and Heggernes, Pinar and Katoen,
                         Joost-Pieter},
  booktitle =           {{P}roceedings of the 44th {I}nternational
                         {S}ymposium on {M}athematical {F}oundations of
                         {C}omputer {S}cience ({MFCS}'19)},
  acronym =             {{MFCS}'19},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {138},
  pages =               {63:1-63:14},
  year =                {2019},
  month =               aug,
  doi =                 {10.4230/LIPIcs.MFCS.2019.63},
}

Abstract

This article focuses on the existence and synthesis of strategies in double-weighted Markov decision processes, which satisfy both a probability constraint over a weighted reachability condition, and a quantitative constraint on the expected value of a random variable defined using another reachability condition. This work generalizes a scheduling problem for energy consumption (typically the problem of charging electric vehicles). We study the set of values of a parameter (a threshold) for which the problem has a solution, and show how a partial characterization of this set can be obtained via two sequences of optimization problems. We also discuss the completeness and feasibility of the resulting approach.

@inproceedings{gretsi2019-GBLM,
  author =              {Gonz{\'a}lez, Mauricio and Bouyer, Patricia and
                         Lasaulce, Samson and Markey, Nicolas},
  title =               {Optimisation en pr\'esence de contraintes en
                         probabilit\'es et processus markoviens
                         contr\^ol\'es},
  booktitle =           {{A}ctes du 27{\`e}me {C}olloque du {G}roupe
                         d'{\'E}tudes du {T}raitement du {S}ignal et des
                         {I}mages ({GRETSI}'19)},
  acronym =             {{GRETSI}'19},
  year =                {2019},
  month =               aug,
  abstract =            {This article focuses on the existence and synthesis
                         of strategies in double-weighted Markov decision
                         processes, which satisfy both a probability
                         constraint over a weighted reachability condition,
                         and a quantitative constraint on the expected value
                         of a random variable defined using another
                         reachability condition. This work generalizes a
                         scheduling problem for energy consumption (typically
                         the problem of charging electric vehicles). We~study
                         the set of values of a parameter (a~threshold) for
                         which the problem has a solution, and show how a
                         partial characterization of this set can be obtained
                         via two sequences of optimization problems. We~also
                         discuss the completeness and feasibility of the
                         resulting approach.},
}

@phdthesis{phd-jaziri,
  author =              {Jaziri, Samy},
  title =               {Automata on timed structures},
  year =                {2019},
  month =               sep,
  school =              {{\'E}cole Normale Sup{\'e}rieure de Cachan, France},
}

@article{mscs29(1)-KMS,
  author =              {Knight, Sophia and Maubert, Bastien and
                         Schwarzentruber, Fran{\c c}ois},
  title =               {Reasoning about knowledge and messages in
                         asynchronous multi-agent systems},
  journal =             {Mathematical Structures in Computer Science},
  volume =              {29},
  number =              {1},
  pages =               {127-168},
  year =                {2019},
  month =               jan,
  doi =                 {10.1017/S0960129517000214},
}

@inproceedings{re2019-LDWHP,
  author =              {Langenfeld, Vincent and Dietsch, Daniel and
                         Westphal, Bernd and Hoenicke, Jochen and Post,
                         Amalinda},
  title =               {Scalable Analysis of Real-Time Requirements},
  editor =              {Damian, Daniela E. and Perini, Anna and Lee,
                         Seok-Won},
  booktitle =           {{P}roceedings of the 27th {I}nternaitonal
                         {R}equirements Engineering {C}onference ({RE}'19)},
  acronym =             {{RE}'19},
  publisher =           {IEEE Comp. Soc. Press},
  pages =               {234-244},
  year =                {2019},
  month =               sep,
  doi =                 {10.1109/RE.2019.00033},
}

@inproceedings{ijcai2019-MPS,
  author =              {Maubert, Bastien and Pinchinat, Sophie and
                         Schwarzentruber, Fran{\c c}ois},
  title =               {Reachability Games in Dynamic Epistemic Logic},
  editor =              {Kraus, Sarit},
  booktitle =           {{P}roceedings of the 28th {I}nternational {J}oint
                         {C}onference on {A}rtificial {I}ntelligence
                         ({IJCAI}'19)},
  acronym =             {{IJCAI}'19},
  publisher =           {IJCAI organization},
  pages =               {499-505},
  year =                {2019},
  month =               aug,
  doi =                 {10.24963/ijcai.2019/71},
}

@article{jalc24(2-4)-Nic,
  author =              {Nicaud, Cyril},
  title =               {The {{\v{C}}}ern{\'y} conjecture holds with high
                         probability},
  journal =             {Journal of Automata, Languages and Combinatorics},
  volume =              {24},
  number =              {2-4},
  pages =               {343-365},
  year =                {2019},
  doi =                 {10.25596/jalc-2019-343},
}

@article{tocl20(2)-QS,
  author =              {Quaas, Karin and Shirmohammadi, Mahsa},
  title =               {Synchronizing Data Words for Register Automata},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Computational Logic},
  volume =              {20},
  number =              {2},
  pages =               {11:1-11:27},
  year =                {2019},
  month =               apr,
  doi =                 {10.1145/3309760},
}

@article{jalc24(2-4)-Shi,
  author =              {Shitov, Yaroslav},
  title =               {An Improvement to a Recent Upper Bound for
                         Synchronizing Words of Finite Automata},
  journal =             {Journal of Automata, Languages and Combinatorics},
  volume =              {24},
  number =              {2-4},
  pages =               {367-373},
  year =                {2019},
  doi =                 {10.25596/jalc-2019-367},
}

@phdthesis{phd-sickert,
  author =              {Sickert, Salomon},
  title =               {A~unified translation of Linear Temporal Logic to
                         {\(\omega\)}-automata},
  year =                {2019},
  month =               jul,
  school =              {Technischen Universit{\"a}t M{\"u}nchen, Germany},
}

Abstract

Two-player quantitative zero-sum games provide a natural framework to synthesize controllers with performance guarantees for reactive systems within an uncontrollable environment. Classical settings include mean-payoff games, where the objective is to optimize the long-run average gain per action, and energy games, where the system has to avoid running out of energy. We study average-energy games, where the goal is to optimize the long-run average of the accumulated energy. We show that this objective arises naturally in several applications, and that it yields interesting connections with previous concepts in the literature. We prove that deciding the winner in such games is in NP∩coNP and at least as hard as solving mean-payoff games, and we establish that memoryless strategies suffice to win. We also consider the case where the system has to minimize the average-energy while maintaining the accumulated energy within predefined bounds at all times: this corresponds to operating with a finite-capacity storage for energy. We give results for one-player and two-player games, and establish complexity bounds and memory requirements.

@article{acta55(2)-BMRLL,
  author =              {Bouyer, Patricia and Markey, Nicolas and Randour,
                         Mickael and Larsen, Kim Guldstrand and Laursen,
                         Simon},
  title =               {Average-energy games},
  publisher =           {Springer-Verlag},
  journal =             {Acta Informatica},
  volume =              {55},
  number =              {2},
  pages =               {91-127},
  year =                {2018},
  month =               mar,
  doi =                 {10.1007/s00236-016-0274-1},
  abstract =            {Two-player quantitative zero-sum games provide a
                         natural framework to synthesize controllers with
                         performance guarantees for reactive systems within
                         an uncontrollable environment. Classical settings
                         include mean-payoff games, where the objective is to
                         optimize the long-run average gain per action, and
                         energy games, where the system has to avoid running
                         out of energy. We study average-energy games, where
                         the goal is to optimize the long-run average of the
                         accumulated energy. We show that this objective
                         arises naturally in several applications, and that
                         it yields interesting connections with previous
                         concepts in the literature. We prove that deciding
                         the winner in such games is in
                         \(\textsf{NP}\cap\textsf{coNP}\) and at least as
                         hard as solving mean-payoff games, and we establish
                         that memoryless strategies suffice to win. We also
                         consider the case where the system has to minimize
                         the average-energy while maintaining the accumulated
                         energy within predefined bounds at all times: this
                         corresponds to operating with a finite-capacity
                         storage for energy. We give results for one-player
                         and two-player games, and establish complexity
                         bounds and memory requirements.},
}

Abstract

We present a correct-by-design method of state-dependent control synthesis for sampled switching systems. Given a target region R of the state space, our method builds a capture set S and a control that steers any element of S into R. The method works by iterated backward reachability from R. It is also used to synthesize a recurrence control that makes any state of R return to R infinitely often. We explain how the synthesis method can be performed in a compositional manner, and apply it to the synthesis of a compositional control for a concrete floor-heating system with 11 rooms and up to 211=2048 switching modes.

@article{tcs750()-LFMDC,
  author =              {Le{~}Co{\"e}nt, Adrien and Fribourg, Laurent and
                         Markey, Nicolas and De{~}Vuyst, Florian and Chamoin,
                         Ludovic},
  title =               {Distributed Synthesis of State-Dependent Switching
                         Control},
  publisher =           {Elsevier},
  journal =             {Theoretical Computer Science},
  volume =              {750},
  pages =               {53-68},
  year =                {2018},
  month =               nov,
  doi =                 {10.1016/j.tcs.2018.01.021},
  abstract =            {We present a correct-by-design method of
                         state-dependent control synthesis for sampled
                         switching systems. Given a target region~\(R\) of
                         the state space, our~method builds a capture
                         set~\(S\) and a~control that steers any element
                         of~\(S\) into~\(R\). The~method works by iterated
                         backward reachability from~\(R\). It~is also used to
                         synthesize a recurrence control that makes any state
                         of~\(R\) return to~\(R\) infinitely often.
                         We~explain how the synthesis method can be performed
                         in a compositional manner, and apply it to the
                         synthesis of a compositional control for a concrete
                         floor-heating system with 11~rooms and up to
                         \(2^{11}=2048\) switching modes.},
}

Abstract

In this paper, we propose a novel framework for the synthesis of robust and optimal energy-aware controllers. The framework is based on energy timed automata, allowing for easy expression of timing-constraints and variable energy-rates. We prove decidability of the energy-constrained infinite-run problem in settings with both certainty and uncertainty of the energy-rates. We also consider the optimization problem of identifying the minimal upper bound that will permit existence of energy-constrained infinite runs. Our algorithms are based on quantifier elimination for linear real arithmetic. Using Mathematica and Mjollnir, we illustrate our framework through a real industrial example of a hydraulic oil pump. Compared with previous approaches our method is completely automated and provides improved results.

@inproceedings{fm2018-BBFLMR,
  author =              {Bacci, Giovanni and Bouyer, Patricia and Fahrenberg,
                         Uli and Larsen, Kim Guldstrand and Markey, Nicolas
                         and Reynier, Pierre-Alain},
  title =               {Optimal and Robust Controller Synthesis Using Energy
                         Timed Automata with Uncertainty},
  editor =              {Havelund, Klaus and Peleska, Jan and Roscoe, Bill W.
                         and de Vink, Erik},
  booktitle =           {{P}roceedings of the 22nd {I}nternational
                         {S}ymposium on {F}ormal {M}ethods ({FM}'18)},
  acronym =             {{FM}'18},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10951},
  pages =               {203-221},
  year =                {2018},
  month =               jul,
  doi =                 {10.1007/978-3-319-95582-7_12},
  abstract =            {In this paper, we propose a novel framework for the
                         synthesis of robust and optimal energy-aware
                         controllers. The framework is based on energy timed
                         automata, allowing for easy expression of
                         timing-constraints and variable energy-rates. We
                         prove decidability of the energy-constrained
                         infinite-run problem in settings with both certainty
                         and uncertainty of the energy-rates. We also
                         consider the optimization problem of identifying the
                         minimal upper bound that will permit existence of
                         energy-constrained infinite runs. Our algorithms are
                         based on quantifier elimination for linear real
                         arithmetic. Using Mathematica and Mjollnir, we
                         illustrate our framework through a real industrial
                         example of a hydraulic oil pump. Compared with
                         previous approaches our method is completely
                         automated and provides improved results.},
}

Abstract

Reconfigurable broadcast networks provide a convenient formalism for modelling and reasoning about networks of mobile agents broadcasting messages to other agents following some (evolving) communication topology. The parameterized verification of such models aims at checking whether a given property holds irrespective of the initial configuration (number of agents, initial states and initial communication topology). We focus here on the synchronization property, asking whether all agents converge to a set of target states after some execution. This problem is known to be decidable in polynomial time when no constraints are imposed on the evolution of the communication topology (while it is undecidable for static broadcast networks).

In this paper we investigate how various constraints on reconfigurations affect the decidability and complexity of the synchronization problem. In particular, we show that when bounding the number of reconfigured links between two communications steps by a constant, synchronization becomes undecidable; on the other hand, synchronization remains decidable in PTIME when the bound grows with the number of agents.

@inproceedings{tacas2018-2-BBM,
  author =              {Balasubramanian, A. R. and Bertrand, Nathalie and
                         Markey, Nicolas},
  title =               {Parameterized verification of synchronization in
                         constrained reconfigurable broadcast networks},
  editor =              {Beyer, Dirk and Huisman, Marieke},
  booktitle =           {{P}roceedings of the 24th {I}nternational
                         {C}onference on {T}ools and {A}lgorithms for
                         {C}onstruction and {A}nalysis of {S}ystems
                         ({TACAS}'18)~-- {P}art~{II}},
  acronym =             {{TACAS}'18 (Part~{II})},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10806},
  pages =               {38-54},
  year =                {2018},
  month =               apr,
  doi =                 {10.1007/978-3-319-89963-3_3},
  abstract =            {Reconfigurable broadcast networks provide a
                         convenient formalism for modelling and reasoning
                         about networks of mobile agents broadcasting
                         messages to other agents following some (evolving)
                         communication topology. The parameterized
                         verification of such models aims at checking whether
                         a given property holds irrespective of the initial
                         configuration (number of agents, initial states and
                         initial communication topology). We~focus here on
                         the \emph{synchronization property}, asking whether
                         all agents converge to a set of target states after
                         some execution. This~problem is known to be
                         decidable in polynomial time when no constraints are
                         imposed on the evolution of the communication
                         topology (while~it~is undecidable for static
                         broadcast networks).\par In this paper we
                         investigate how various constraints on
                         reconfigurations affect the decidability and
                         complexity of the synchronization problem.
                         In~particular, we show that when bounding the number
                         of reconfigured links between two communications
                         steps by a constant, synchronization becomes
                         undecidable; on~the other hand, synchronization
                         remains decidable in PTIME when the bound grows with
                         the number of agents.},
}

Abstract

In this paper, we are interested in the synthesis of schedulers in double-weighted Markov decision processes, which satisfy both a percentile constraint over a weighted reachability condition, and a quantitative constraint on the expected value of a random variable defined using a weighted reachability condition. This problem is inspired by the modelization of an electric-vehicle charging problem. We study the cartography of the problem, when one parameter varies, and show how a partial cartography can be obtained via two sequences of opimization problems. We discuss completeness and feasability of the method.

@inproceedings{gandalf2018-BGMR,
  author =              {Bouyer, Patricia and Gonz{\'a}lez, Mauricio and
                         Markey, Nicolas and Randour, Mickael},
  title =               {Multi-weighted Markov Decision Processes with
                         Reachability Objectives},
  editor =              {Orlandini, Andrea and Zimmermann, Martin},
  booktitle =           {{P}roceedings of the 9th {I}nternational {S}ymposium
                         on {G}ames, {A}utomata, {L}ogics and {F}ormal
                         {V}erification ({GandALF}'18)},
  acronym =             {{GandALF}'18},
  series =              {Electronic Proceedings in Theoretical Computer
                         Science},
  volume =              {277},
  pages =               {250-264},
  year =                {2018},
  month =               sep,
  doi =                 {10.4204/EPTCS.277.18},
  abstract =            {In~this paper, we~are interested in the synthesis of
                         schedulers in double-weighted Markov decision
                         processes, which satisfy both a percentile
                         constraint over a weighted reachability condition,
                         and a quantitative constraint on the expected value
                         of a random variable defined using a weighted
                         reachability condition. This~problem is inspired by
                         the modelization of an electric-vehicle charging
                         problem. We study the cartography of the problem,
                         when one parameter varies, and show how a partial
                         cartography can be obtained via two sequences of
                         opimization problems. We~discuss completeness and
                         feasability of the method.},
}

Abstract

We consider the problems of efficiently diagnosing and predicting what did (or will) happen in a partially-observable one-clock timed automaton. We introduce timed sets as a formalism to keep track of the evolution of the reachable configurations over time, and use our previous work on automata over timed domains to build a candidate diagnoser for our timed automaton. We report on our implementation of this approach compared to the approach of [Tripakis, Fault diagnosis for timed autmata, 2002].

@inproceedings{rv2018-BJM,
  author =              {Bouyer, Patricia and Jaziri, Samy and Markey,
                         Nicolas},
  title =               {Efficient timed diagnosis using automata with timed
                         domains},
  editor =              {Colombo, Christian and Leucker, Martin},
  booktitle =           {{P}roceedings of the 18th {I}nternational {W}orkshop
                         on {R}untime {V}erification ({RV}'18)},
  acronym =             {{RV}'18},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {11237},
  pages =               {205-221},
  year =                {2018},
  month =               nov,
  doi =                 {10.1007/978-3-030-03769-7_12},
  abstract =            {We consider the problems of efficiently diagnosing
                         and predicting what did (or~will) happen in a
                         partially-observable one-clock timed automaton.
                         We~introduce timed sets as a formalism to keep track
                         of the evolution of the reachable configurations
                         over time, and use our previous work on automata
                         over timed domains to build a candidate diagnoser
                         for our timed automaton. We~report on our
                         implementation of this approach compared to the
                         approach of [Tripakis, Fault diagnosis for timed
                         autmata,~2002].},
}

Abstract

Strategy Logic (SL) is a very expressive temporal logic for specifying and verifying properties of multi-agent systems: in SL, one can quantify over strategies, assign them to agents, and express LTL properties of the resulting plays. Such a powerful framework has two drawbacks: first, model checking SL has non-elementary complexity; second, the exact semantics of SL is rather intricate, and may not correspond to what is expected. In this paper, we focus on strategy dependences in SL, by tracking how existentially-quantified strategies in a formula may (or may not) depend on other strategies selected in the formula, revisiting the approach of [Mogavero et al., Reasoning about strategies: On the model-checking problem, 2014]. We explain why elementary dependences, as defined by Mogavero et al., do not exactly capture the intended concept of behavioral strategies. We address this discrepancy by introducing timeline dependences, and exhibit a large fragment of SL for which model checking can be performed in 2EXPTIME under this new semantics.

@inproceedings{stacs2018-GBM,
  author =              {Gardy, Patrick and Bouyer, Patricia and Markey,
                         Nicolas},
  title =               {Dependences in Strategy Logic},
  editor =              {Niedermeier, Rolf and Vall{\'e}e, Brigitte},
  booktitle =           {{P}roceedings of the 35th {S}ymposium on
                         {T}heoretical {A}spects of {C}omputer {S}cience
                         ({STACS}'18)},
  acronym =             {{STACS}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {96},
  pages =               {34:1-34:14},
  year =                {2018},
  month =               feb,
  doi =                 {10.4230/LIPIcs.STACS.2018.34},
  abstract =            {Strategy Logic~(\textsf{SL}) is a very expressive
                         temporal logic for specifying and verifying
                         properties of multi-agent systems: in~\textsf{SL},
                         one can quantify over strategies, assign them to
                         agents, and express \textsf{LTL} properties of the
                         resulting plays. Such a powerful framework has two
                         drawbacks: first, model checking \textsf{SL} has
                         non-elementary complexity; second, the exact
                         semantics of \textsf{SL} is rather intricate, and
                         may not correspond to what is expected. In~this
                         paper, we~focus on \emph{strategy dependences}
                         in~\textsf{SL}, by tracking how
                         existentially-quantified strategies in a formula may
                         (or~may~not) depend on other strategies selected in
                         the formula, revisiting the approach of~[Mogavero
                         \emph{et~al.}, Reasoning about strategies: On~the
                         model-checking problem,~2014]. We~explain why
                         \emph{elementary} dependences, as defined by
                         Mogavero~\emph{et~al.}, do not exactly capture the
                         intended concept of behavioral strategies.
                         We~address this discrepancy by introducing
                         \emph{timeline} dependences, and exhibit a large
                         fragment of \textsf{SL} for which model checking can
                         be performed in \textsf{2EXPTIME} under this new
                         semantics.},
}

Abstract

Partial observability and controllability are two well-known issues in test-case synthesis for interactive systems. We address the problem of partial control in the synthesis of test cases from timed-automata specifications. Building on the tioco timed testing framework, we extend a previous game interpretation of the test-synthesis problem from the untimed to the timed setting. This extension requires a deep reworking of the models, game interpretation and test-synthesis algorithms. We exhibit strategies of a game that tries to minimize both control losses and distance to the satisfaction of a test purpose, and prove they are winning under some fairness assumptions. This entails that when turning those strategies into test cases, we get properties such as soundness and exhaustiveness of the test synthesis method.

@inproceedings{spin2018-HJM,
  author =              {Henry, L{\'e}o and J{\'e}ron, Thierry and Markey,
                         Nicolas},
  title =               {Control strategies for off-line testing of timed
                         systems},
  editor =              {Gallardo, Mar{\'\i}a-del-Mar and Merino, Pedro},
  booktitle =           {{P}roceedings of the 25th {I}nternational
                         {S}ymposium on {M}odel-{C}herking {S}oftware
                         ({SPIN}'18)},
  acronym =             {{SPIN}'18},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10869},
  pages =               {171-189},
  year =                {2018},
  month =               jun,
  doi =                 {10.1007/978-3-319-94111-0_10},
  abstract =            {Partial observability and controllability are two
                         well-known issues in test-case synthesis for
                         interactive systems. We~address the problem of
                         partial control in the synthesis of test cases from
                         timed-automata specifications. Building on the tioco
                         timed testing framework, we~extend a previous game
                         interpretation of the test-synthesis problem from
                         the untimed to the timed setting. This extension
                         requires a deep reworking of the models, game
                         interpretation and test-synthesis algorithms.
                         We~exhibit strategies of a game that tries to
                         minimize both control losses and distance to the
                         satisfaction of a test purpose, and prove they are
                         winning under some fairness assumptions. This
                         entails that when turning those strategies into test
                         cases, we get properties such as soundness and
                         exhaustiveness of the test synthesis method.},
}

Abstract

This chapter surveys timed automata as a formalism for model checking real-time systems. We begin with introducing the model, as an extension of finite-state automata with real-valued variables for measuring time. We then present the main model-checking results in this framework, and give a hint about some recent extensions (namely weighted timed automata and timed games).

@incollection{hmc2018-BFLMOW,
  author =              {Bouyer, Patricia and Fahrenberg, Uli and Larsen, Kim
                         Guldstrand and Markey, Nicolas and Ouaknine,
                         Jo{\"e}l and Worrell, James},
  title =               {Model Checking Real-Time Systems},
  editor =              {Clarke, Edmund M. and Henzinger, Thomas A. and
                         Veith, Helmut and Bloem, Roderick},
  booktitle =           {Handbook of Model Checking},
  publisher =           {Springer-Verlag},
  pages =               {1001-1046},
  chapter =             {29},
  year =                {2018},
  month =               may,
  doi =                 {10.1007/978-3-319-10575-8_29},
  abstract =            {This chapter surveys timed automata as a formalism
                         for model checking real-time systems. We begin with
                         introducing the model, as an extension of
                         finite-state automata with real-valued variables for
                         measuring time. We then present the main
                         model-checking results in this framework, and give a
                         hint about some recent extensions (namely weighted
                         timed automata and timed games).},
}

@inproceedings{mfcs2018-AGK,
  author =              {Avni, Guy and Guha, Shibashis and Kupferman, Orna},
  title =               {Timed Network Games with Clocks},
  editor =              {Potapov, Igor and Spirakis, Paul G. and Worrell,
                         James},
  booktitle =           {{P}roceedings of the 43rd {I}nternational
                         {S}ymposium on {M}athematical {F}oundations of
                         {C}omputer {S}cience ({MFCS}'18)},
  acronym =             {{MFCS}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {117},
  pages =               {23:1-23:18},
  year =                {2018},
  month =               aug,
  doi =                 {10.4230/LIPIcs.MFCS.2018.23},
}

@inproceedings{ijcai2018-AKP,
  author =              {Almagor, Shaull and Kupferman, Orna and Perelli,
                         Giuseppe},
  title =               {Synthesis of Controllable {N}ash Equilibria in
                         Quantitative Objective Games},
  editor =              {Lang, J{\'e}r{\^o}me},
  booktitle =           {{P}roceedings of the 27th {I}nternational {J}oint
                         {C}onference on {A}rtificial {I}ntelligence
                         ({IJCAI}'18)},
  acronym =             {{IJCAI}'18},
  publisher =           {IJCAI organization},
  pages =               {35-41},
  year =                {2018},
  month =               jul,
  doi =                 {10.24963/ijcai.2018/5},
}

@article{icomp261(4)-AMMR,
  author =              {Aminof, Benjamin and Malvone, Vadim and Murano,
                         Aniello and Rubin, Sasha},
  title =               {Graded modalities in Strategy Logic},
  publisher =           {Elsevier},
  journal =             {Information and Computation},
  volume =              {261},
  number =              {4},
  pages =               {634-649},
  year =                {2018},
  month =               aug,
  doi =                 {10.1016/j.ic.2018.02.021},
}

@inproceedings{concur2018-BEK,
  author =              {Blondin, Michael and Esparza, Javier and Ku{\v
                         c}era, Anton{\'\i}n},
  title =               {Automatic Analysis of Expected Termination Time for
                         Population Protocols},
  editor =              {Schewe, Sven and Zhang, Lijun},
  booktitle =           {{P}roceedings of the 29th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'18)},
  acronym =             {{CONCUR}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {118},
  pages =               {33:1-33:16},
  year =                {2018},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CONCUR.2018.33},
}

@book{lectRV-BF18,
  title =               {Lectures on Runtime Verification},
  editor =              {Bartocci, Ezio and Falcone, Yli{\`e}s},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10457},
  year =                {2018},
  doi =                 {10.1007/978-3-319-75632-5},
}

@inproceedings{fsttcs2018-BMR,
  author =              {Busatto-Gaston, Damien and Monmege, Benjamin and
                         Reynier, Pierre-Alain},
  title =               {Symbolic Approximation of Weighted Timed Games},
  editor =              {Ganguli, Sumit and Pandya, Paritosh K.},
  booktitle =           {{P}roceedings of the 38th {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'18)},
  acronym =             {{FSTTCS}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {122},
  pages =               {28:1-28:16},
  year =                {2018},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2018.28},
}

@inproceedings{fsttcs2018-BK,
  author =              {Bagnol, Marc and Kuperberg, Denis},
  title =               {B{\"u}chi Good-for-game Automata are Efficiently
                         Recognizable},
  editor =              {Ganguli, Sumit and Pandya, Paritosh K.},
  booktitle =           {{P}roceedings of the 38th {C}onference on
                         {F}oundations of {S}oftware {T}echnology and
                         {T}heoretical {C}omputer {S}cience ({FSTTCS}'18)},
  acronym =             {{FSTTCS}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {122},
  pages =               {16:1-16:14},
  year =                {2018},
  month =               dec,
  doi =                 {10.4230/LIPIcs.FSTTCS.2018.16},
}

@inproceedings{lpar2018-Bok,
  author =              {Boker, Udi},
  title =               {Why these automata types?},
  editor =              {Barthe, Gilles and Sutcliffe, Geoff and Veanes,
                         Margus},
  booktitle =           {{P}roceedings of the 22nd {I}nternational
                         {C}onference {L}ogic {P}rogramming and {A}utomated
                         {R}easoning ({LPAR}'18)},
  acronym =             {{LPAR}'18},
  publisher =           {EasyChair},
  series =              {EPiC Series in Computing},
  volume =              {57},
  pages =               {143-163},
  year =                {2018},
  month =               nov,
  doi =                 {10.29007/c3bj},
}

@book{hbmc18-CHVB,
  author =              {Clarke, Edmund M. and Henzinger, Thomas A. and
                         Veith, Helmut and Bloem, Roderick},
  title =               {Handbook of Model Checking},
  publisher =           {Springer-Verlag},
  year =                {2018},
  month =               apr,
  doi =                 {10.1007/978-3-319-10575-8},
}

@inproceedings{aamas2018-DM,
  author =              {Della{ }Monica, Dario and Murano, Aniello},
  title =               {Parity-energy {ATL} for Qualitative and Quantitative
                         Reasoning in~{MAS}},
  editor =              {Andr{\'e}, Elisabeth and Koenig, Sven and Dastani,
                         Mehdi and Sukthankar, Gita},
  booktitle =           {{P}roceedings of the 17th {I}nternational
                         {C}onference on {A}utonomous {A}gents and
                         {M}ultiagent {S}ystems ({AAMAS}'18)},
  acronym =             {{AAMAS}'18},
  publisher =           {International Foundation for Autonomous Agents and
                         Multiagent Systems},
  pages =               {1441-1449},
  year =                {2018},
  month =               jul,
}

@article{tocl19(3)-DMS,
  author =              {Dima, C{\u a}t{\u a}lin and Maubert, Bastien and
                         Pinchinat, Sophie},
  title =               {Relating Paths in Transition Systems: The~Fall of
                         the Modal Mu-Calculus},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Computational Logic},
  volume =              {19},
  number =              {3},
  pages =               {23:1-23:33},
  year =                {2018},
  month =               sep,
  doi =                 {10.1145/3231596},
}

@inproceedings{csl2018-FMMR,
  author =              {Fijalkow, Nathana{\"e}l and Maubert, Bastien and
                         Murano, Aniello and Rubin, Sasha},
  title =               {Quantifying Bounds in Strategy Logic},
  editor =              {Ghica, Dan R. and Jung, Achim},
  booktitle =           {{P}roceedings of the 27th {EACSL} {A}nnual
                         {C}onference on {C}omputer {S}cience {L}ogic
                         ({CSL}'18)},
  acronym =             {{CSL}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {119},
  pages =               {23:1-23:23},
  year =                {2018},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CSL.2018.23},
}

@article{ipl132()-Had,
  author =              {Haddad, Serge},
  title =               {Memoryless determinacy of finite parity games:
                         Another simple proof},
  publisher =           {Elsevier},
  journal =             {Information Processing Letters},
  volume =              {132},
  pages =               {19-21},
  year =                {2018},
  month =               apr,
  doi =                 {10.1016/j.ipl.2017.11.012},
}

@article{tocl19(4)-HvdM,
  author =              {Huang, Xiaowei and van der Meyden, Ron},
  title =               {An Epistemic Strategy Logic},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Computational Logic},
  volume =              {19},
  number =              {4},
  pages =               {26:1-26:45},
  year =                {2018},
  month =               dec,
  doi =                 {10.1145/3233769},
}

@inproceedings{acsd2018-HMM,
  author =              {H{\'e}lou{\"e}t, Lo{\"\i}c and Marchand, Herv{\'e}
                         and Mullins, John},
  title =               {Concurrent secrets with quantified suspicion},
  editor =              {Chatain, {\relax Th}omas and Grosu, Radu and
                         Juh{\'a}s, Gabriel},
  booktitle =           {{P}roceedings of the 18th {I}nternational
                         {C}onference on {A}pplication of {C}oncurrency to
                         {S}ystem {D}esign ({ACSD}'18)},
  acronym =             {{ACSD}'18},
  publisher =           {IEEE Comp. Soc. Press},
  pages =               {75-84},
  year =                {2018},
  month =               jun,
  doi =                 {10.1109/ACSD.2018.00011},
}

@inproceedings{cdc2018-JW,
  author =              {Jacquot, Paulin and Wan, Cheng},
  title =               {Routing game on parallel networks: the~convergence
                         of atomic to nonatomic},
  booktitle =           {{P}roceedings of the 57th {IEEE} {C}onference on
                         {D}ecision and {C}ontrol ({CDC}'18)},
  acronym =             {{CDC}'18},
  publisher =           {IEEE Comp. Soc. Press},
  pages =               {6951-6956},
  year =                {2018},
  month =               dec,
  doi =                 {10.1109/CDC.2018.8619369},
}

@article{aric45()-LLH,
  author =              {Lafortune, St{\'e}phane and Lin, Feng and
                         Hadjicostis, Christoforos N.},
  title =               {On~the history of diagnosability and opacity in
                         discrete event systems},
  publisher =           {Elsevier},
  journal =             {Annual Reviews in Control},
  volume =              {45},
  pages =               {257-266},
  year =                {2018},
  doi =                 {10.1016/j.arcontrol.2018.04.002},
}

@inproceedings{stacs2018-Szy,
  author =              {Szyku{\l}a, Marek},
  title =               {Improving the Upper Bound on the Length of the
                         Shortest Reset Word},
  editor =              {Niedermeier, Rolf and Vall{\'e}e, Brigitte},
  booktitle =           {{P}roceedings of the 35th {S}ymposium on
                         {T}heoretical {A}spects of {C}omputer {S}cience
                         ({STACS}'18)},
  acronym =             {{STACS}'18},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {96},
  pages =               {56:1-56:13},
  year =                {2018},
  month =               feb,
  doi =                 {10.4230/LIPIcs.STACS.2018.56},
}

Abstract

The development of formal methods for control design is an important challenge with potential applications in a wide range of safety-critical cyber-physical systems. Focusing on switched dynamical systems, we propose a new abstraction, based on time-varying regions of invariance (control funnels), that models behaviors of systems as timed automata. The main advantage of this method is that it allows for the automated verification and reactive controller synthesis without discretizing the evolution of the state of the system. Efficient and analytic constructions are possible in the case of linear dynamics whereas bounding funnels with conjectured properties based on numerical simulations can be used for general nonlinear dynamics. We demonstrate the potential of our approach with three examples.

@article{rts53(3)-BMPS,
  author =              {Bouyer, Patricia and Markey, Nicolas and Perrin,
                         Nicolas and Schlehuber{-}Caissier, Philipp},
  title =               {Timed automata abstraction of switched dynamical
                         systems using control funnels},
  publisher =           {Kluwer Academic},
  journal =             {Real-Time Systems},
  volume =              {53},
  number =              {3},
  pages =               {327-353},
  year =                {2017},
  month =               may,
  doi =                 {10.1007/s11241-016-9262-3},
  abstract =            {The development of formal methods for control design
                         is an important challenge with potential
                         applications in a wide range of safety-critical
                         cyber-physical systems. Focusing on switched
                         dynamical systems, we propose a new abstraction,
                         based on time-varying regions of invariance (control
                         funnels), that models behaviors of systems as timed
                         automata. The~main advantage of this method is that
                         it allows for the automated verification and
                         reactive controller synthesis without discretizing
                         the evolution of the state of the system. Efficient
                         and analytic constructions are possible in the case
                         of linear dynamics whereas bounding funnels with
                         conjectured properties based on numerical
                         simulations can be used for general nonlinear
                         dynamics. We~demonstrate the potential of our
                         approach with three examples.},
}

Abstract

We investigate a model for representing large multiplayer games, which satisfy strong symmetry properties. This model is made of multiple copies of an arena; each player plays in his own arena, and can partially observe what the other players do. Therefore, this game has partial information and symmetry constraints, which make the computation of Nash equilibria difficult. We show several undecidability results, and for bounded-memory strategies, we precisely characterize the complexity of computing pure Nash equilibria (for qualitative objectives) in this game model.

@article{icomp254()-BMV,
  author =              {Bouyer, Patricia and Markey, Nicolas and Vester,
                         Steen},
  title =               {{N}ash Equilibria in Symmetric Graph Games with
                         Partial Observation},
  publisher =           {Elsevier},
  journal =             {Information and Computation},
  volume =              {254},
  number =              {2},
  pages =               {238-258},
  year =                {2017},
  month =               jun,
  doi =                 {10.1016/j.ic.2016.10.010},
  abstract =            {We investigate a model for representing large
                         multiplayer games, which satisfy strong symmetry
                         properties. This model is made of multiple copies of
                         an arena; each player plays in his own arena, and
                         can partially observe what the other players do.
                         Therefore, this game has partial information and
                         symmetry constraints, which make the computation of
                         Nash equilibria difficult. We show several
                         undecidability results, and for bounded-memory
                         strategies, we precisely characterize the complexity
                         of computing pure Nash equilibria (for qualitative
                         objectives) in this game model.},
}

Abstract

We consider average-energy games, where the goal is to minimize the long-run average of the accumulated energy. Decidability of average-energy games with a lower-bound constraint on the energy level (but no upper bound) is an open problem; in particular, there is no known upper bound on the memory that is required for winning strategies.

By reducing average-energy games with lower-bounded energy to infinite-state mean-payoff games and analyzing the frequency of low-energy configurations, we show an almost tight doubly-exponential upper bound on the necessary memory, and that the winner of average-energy games with lower-bounded energy can be determined in doubly-exponential time. We also prove EXPSPACE-hardness of this problem.

Finally, we consider multi-dimensional extensions of all types of average-energy games: without bounds, with only a lower bound, and with both a lower and an upper bound on the energy. We show that the fully-bounded version is the only case to remain decidable in multiple dimensions.

@inproceedings{fossacs2017-BHMRZ,
  author =              {Bouyer, Patricia and Hofman, Piotr and Markey,
                         Nicolas and Randour, Mickael and Zimmermann, Martin},
  title =               {Bounding Average-energy Games},
  editor =              {Esparza, Javier and Murawski, Andrzej},
  booktitle =           {{P}roceedings of the 20th {I}nternational
                         {C}onference on {F}oundations of {S}oftware
                         {S}cience and {C}omputation {S}tructure
                         ({FoSSaCS}'17)},
  acronym =             {{FoSSaCS}'17},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10203},
  pages =               {179-195},
  year =                {2017},
  month =               apr,
  doi =                 {10.1007/978-3-662-54458-7_11},
  abstract =            {We~consider average-energy games, where the goal is
                         to minimize the long-run average of the accumulated
                         energy. Decidability of average-energy games with a
                         lower-bound constraint on the energy level (but~no
                         upper bound) is an open problem; in~particular,
                         there is no known upper bound on the memory that is
                         required for winning strategies.\par By~reducing
                         average-energy games with lower-bounded energy to
                         infinite-state mean-payoff games and analyzing the
                         frequency of low-energy configurations, we~show an
                         almost tight doubly-exponential upper bound on the
                         necessary memory, and that the winner of
                         average-energy games with lower-bounded energy can
                         be determined in doubly-exponential time. We~also
                         prove EXPSPACE-hardness of this problem.\par
                         Finally, we~consider multi-dimensional extensions of
                         all types of average-energy games: without bounds,
                         with only a lower bound, and with both a lower and
                         an upper bound on the energy. We show that the
                         fully-bounded version is the only case to remain
                         decidable in multiple dimensions.},
}

Abstract

We introduce a new formalism called automata over a timed domain which provides an adequate framework for the determinization of timed systems. In this formalism, determinization w.r.t. timed language is always possible at the cost of changing the timed domain. We give a condition for determinizability of automata over a timed domain without changing the timed domain, which allows us to recover several known determinizable classes of timed systems, such as strongly-non-zeno timed automata, integer-reset timed automata, perturbed timed automata, etc. Moreover in the case of timed automata this condition encompasses most determinizability conditions from the literature.

@inproceedings{formats2017-BJM,
  author =              {Bouyer, Patricia and Jaziri, Samy and Markey,
                         Nicolas},
  title =               {On the determinization of timed systems},
  editor =              {Abate, Alessandro and Geeraerts, Gilles},
  booktitle =           {{P}roceedings of the 15th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'17)},
  acronym =             {{FORMATS}'17},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10419},
  pages =               {25-41},
  year =                {2017},
  month =               sep,
  doi =                 {10.1007/978-3-319-65765-3_2},
  abstract =            {We introduce a new formalism called \emph{automata
                         over a timed domain} which provides an adequate
                         framework for the determinization of timed systems.
                         In~this formalism, determinization w.r.t. timed
                         language is always possible at the cost of changing
                         the timed domain. We~give a condition for
                         determinizability of automata over a timed domain
                         without changing the timed domain, which allows us
                         to recover several known determinizable classes of
                         timed systems, such as strongly-non-zeno timed
                         automata, integer-reset timed automata, perturbed
                         timed automata, etc. Moreover in the case of timed
                         automata this condition encompasses most
                         determinizability conditions from the literature.},
}

@inproceedings{mfcs2017-Mar,
  author =              {Markey, Nicolas},
  title =               {Temporal logics for multi-agent systems
                         (invited~talk)},
  editor =              {Larsen, Kim Guldstrand and Bodlaender, Hans L. and
                         Raskin, Jean-Fran{\c c}ois},
  booktitle =           {{P}roceedings of the 42nd {I}nternational
                         {S}ymposium on {M}athematical {F}oundations of
                         {C}omputer {S}cience ({MFCS}'17)},
  acronym =             {{MFCS}'17},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {84},
  pages =               {84:1-84:3},
  year =                {2017},
  month =               aug,
  doi =                 {10.4230/LIPIcs.MFCS.2017.84},
}

Abstract

Since the early 1990's, classical temporal logics have been extended with timing constraints. While temporal logics only express contraints on the order of events, their timed extensions can add quantitative constraints on delays between those events. We survey expressiveness and algorithmic results on those logics, and discuss semantic choices that may look unimportant but do have an impact on the questions we consider.

@incollection{kimfest2017-BLMOW,
  author =              {Bouyer, Patricia and Laroussinie, Fran{\c c}ois and
                         Markey, Nicolas and Ouaknine, Jo{\"e}l and Worrell,
                         James},
  title =               {Timed temporal logics},
  editor =              {Aceto, Luca and Bacci, Giorgio and Bacci, Giovanni
                         and Ing{\'o}lfsd{\'o}ttir, Anna and Legay, Axel and
                         Mardare, Radu},
  booktitle =           {Models, Algorithms, Logics and Tools: Essays
                         Dedicated to Kim Guldstrand Larsen on the Occasion
                         of His 60th Birthday},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10460},
  pages =               {211-230},
  year =                {2017},
  month =               aug,
  doi =                 {10.1007/978-3-319-63121-9_11},
  abstract =            {Since the early 1990's, classical temporal logics
                         have been extended with timing constraints. While
                         temporal logics only express contraints on the order
                         of events, their timed extensions can add
                         quantitative constraints on delays between those
                         events. We survey expressiveness and algorithmic
                         results on those logics, and discuss semantic
                         choices that may look unimportant but do have an
                         impact on the questions we consider.},
}

@article{scp148()-ABDDHRSWW,
  author =              {Althaus, Ernst and Beber, Bj{\"o}rn and Damm, Werner
                         and Disch, Stefan and Hagemann, Willem and Rakow,
                         Astrid and Scholl, Christoph and Waldmann, Uwe and
                         Wirtz, Boris},
  title =               {Verification of linear hybrid systems with large
                         discrete state spaces using counterexample-guided
                         abstraction refinement},
  publisher =           {Elsevier},
  journal =             {Science of Computer Programming},
  volume =              {148},
  pages =               {123-160},
  year =                {2017},
  month =               nov,
  doi =                 {10.1016/j.scico.2017.04.010},
}

@inproceedings{mfcs2017-AGK,
  author =              {Avni, Guy and Guha, Shibashis and Kupferman, Orna},
  title =               {Timed Network Games},
  editor =              {Larsen, Kim Guldstrand and Bodlaender, Hans L. and
                         Raskin, Jean-Fran{\c c}ois},
  booktitle =           {{P}roceedings of the 42nd {I}nternational
                         {S}ymposium on {M}athematical {F}oundations of
                         {C}omputer {S}cience ({MFCS}'17)},
  acronym =             {{MFCS}'17},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {84},
  pages =               {37:1-37:16},
  year =                {2017},
  month =               aug,
  doi =                 {10.4230/LIPIcs.MFCS.2017.37},
}

@inproceedings{concur2017-AGKS,
  author =              {Akshay, S. and Gastin, Paul and Krishna, Shankara
                         Narayanan and Sarkar, Ilias},
  title =               {Towards an Efficient Tree Automata Based Technique
                         for Timed Systems},
  editor =              {Meyer, Roland and Nestmann, Uwe},
  booktitle =           {{P}roceedings of the 28th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'17)},
  acronym =             {{CONCUR}'17},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {85},
  pages =               {39:1-39:15},
  year =                {2017},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CONCUR.2017.39},
}

@inproceedings{cav2017-AKRV,
  author =              {Almagor, Shaull and Kupferman, Orna and Ringert, Jan
                         Oliver and Velner, Yaron},
  title =               {Quantitative Assume Guarantee Synthesis},
  editor =              {Majumdar, Rupak and Kuncak, Viktor},
  booktitle =           {{P}roceedings of the 29th {I}nternational
                         {C}onference on {C}omputer {A}ided {V}erification
                         ({CAV}'17)},
  acronym =             {{CAV}'17},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10427},
  pages =               {353-374},
  year =                {2017},
  month =               jul,
  doi =                 {10.1007/978-3-319-63390-9_19},
}

@article{sigact-news48(1)-AT,
  author =              {Alur, Rajeev and Tripakis, Stavros},
  title =               {Automatic Synthesis of Distributed Protocols},
  publisher =           {ACM Press},
  journal =             {SIGACT News},
  volume =              {48},
  number =              {1},
  pages =               {55-90},
  year =                {2017},
  month =               mar,
  doi =                 {10.1145/3061640.3061652},
}

@inproceedings{concur2017-BDGG,
  author =              {Bertrand, Nathalie and Dewaskar, Miheer and Genest,
                         Blaise and Gimbert, Hugo},
  title =               {Controlling a population},
  editor =              {Meyer, Roland and Nestmann, Uwe},
  booktitle =           {{P}roceedings of the 28th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'17)},
  acronym =             {{CONCUR}'17},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {85},
  pages =               {12:1-12:16},
  year =                {2017},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CONCUR.2017.12},
}

@article{jacm64(5)-BGG,
  author =              {Bertrand, Nathalie and Genest, Blaise and Gimbert,
                         Hugo},
  title =               {Qualitative Determinacy and Decidability of
                         Stochastic Games with Signals},
  publisher =           {ACM Press},
  journal =             {Journal of the~ACM},
  volume =              {64},
  number =              {5},
  pages =               {33:1-33:48},
  year =                {2017},
  month =               oct,
  doi =                 {10.1145/3107926},
}

@article{acta54(1)-BGHM,
  author =              {Brihaye, {\relax Th}omas and Geeraerts, Gilles and
                         Haddad, Axel and Monmege, Benjamin},
  title =               {Pseudopolynomial iterative algorithm to solve
                         total-payoff games and min-cost reachability game},
  publisher =           {Springer-Verlag},
  journal =             {Acta Informatica},
  volume =              {54},
  number =              {1},
  pages =               {85-125},
  year =                {2017},
  month =               feb,
  doi =                 {10.1007/s00236-016-0276-z},
}

@article{tecs-BHM,
  author =              {B{\'e}rard, B{\'e}atrice and H{\'e}lou{\"e}t,
                         Lo{\"\i}c and Mullins, John},
  title =               {Non-interference in partial order models},
  publisher =           {ACM Press},
  journal =             {ACM Transactions on Embedded Computing Systems},
  year =                {2017},
  note =                {To~appear},
}

Abstract

Dynamic complexity is concerned with updating the output of a problem when the input is slightly changed. We study the dynamic complexity of model checking a fixed monadic second-order formula over evolving subgraphs of a fixed maximal graph having bounded tree-width; here the subgraph evolves by losing or gaining edges (from the maximal graph). We show that this problem is in DynFO (with LOGSPACE precomputation), via a reduction to a Dyck reachability problem on an acyclic automaton.

@techreport{arxiv1702.05183-BJM,
  author =              {Bouyer, Patricia and Jug{\'e}, Vincent and Markey,
                         Nicolas},
  title =               {{C}ourcelle's Theorem Made Dynamic},
  number =              {1702.05183},
  year =                {2017},
  month =               feb,
  institution =         {arXiv},
  abstract =            {Dynamic complexity is concerned with updating the
                         output of a problem when the input is slightly
                         changed. We study the dynamic complexity of model
                         checking a fixed monadic second-order formula over
                         evolving subgraphs of a fixed maximal graph having
                         bounded tree-width; here the subgraph evolves by
                         losing or gaining edges (from the maximal graph).
                         We~show that this problem is in DynFO (with LOGSPACE
                         precomputation), via a reduction to a Dyck
                         reachability problem on an acyclic automaton.},
}

@inproceedings{aamas2017-BMM,
  author =              {Berthon, Rapha{\"e}l and Maubert, Bastien and
                         Murano, Aniello},
  title =               {Decidability Results for {ATL\textsuperscript{*}}
                         with Imperfect Information and Perfect Recall},
  editor =              {Das, Sanmay and Durfee, Ed and Larson, Kate and
                         Winikoff, Michael},
  booktitle =           {{P}roceedings of the 16th {I}nternational
                         {C}onference on {A}utonomous {A}gents and
                         {M}ultiagent {S}ystems ({AAMAS}'17)},
  acronym =             {{AAMAS}'17},
  publisher =           {International Foundation for Autonomous Agents and
                         Multiagent Systems},
  pages =               {1250-1258},
  year =                {2017},
  month =               may,
}

@inproceedings{lics2017-BMMRV,
  author =              {Berthon, Rapha{\"e}l and Maubert, Bastien and
                         Murano, Aniello and Rubin, Sasha and Vardi, Moshe
                         Y.},
  title =               {Strategy Logic with Imperfect Information},
  booktitle =           {{P}roceedings of the 32nd {A}nnual {S}ymposium on
                         {L}ogic in {C}omputer {S}cience ({LICS}'17)},
  acronym =             {{LICS}'17},
  publisher =           {IEEE Comp. Soc. Press},
  pages =               {1-12},
  year =                {2017},
  month =               jun,
  doi =                 {10.1109/LICS.2017.8005136},
}

@article{acta54(1)-BRS,
  author =              {Brenguier, Romain and Raskin, Jean-Fran{\c c}ois and
                         Sankur, Ocan},
  title =               {Assume-admissible synthesis},
  publisher =           {Springer-Verlag},
  journal =             {Acta Informatica},
  volume =              {54},
  number =              {1},
  pages =               {41-83},
  year =                {2017},
  month =               feb,
  doi =                 {10.1007/s00236-016-0273-2},
}

@incollection{HMC-BW,
  author =              {Bradfield, Julian C. and Walukiewicz, Igor},
  title =               {The mu-calculus and model-checking},
  editor =              {Clarke, Edmund M. and Henzinger, Thomas A. and
                         Veith, Helmut},
  booktitle =           {Handbook of Model Checking},
  publisher =           {Springer-Verlag},
  year =                {2017},
  note =                {To~appear},
}

@inproceedings{kimfest2017-CDH,
  author =              {Chatterjee, Krishnendu and Doyen, Laurent and
                         Henzinger, Thomas A.},
  title =               {The Cost of Exactness in Quantitative Reachability},
  editor =              {Aceto, Luca and Bacci, Giorgio and Bacci, Giovanni
                         and Ing{\'o}lfsd{\'o}ttir, Anna and Legay, Axel and
                         Mardare, Radu},
  booktitle =           {Models, Algorithms, Logics and Tools: Essays
                         Dedicated to Kim Guldstrand Larsen on the Occasion
                         of His 60th Birthday},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10460},
  pages =               {367-381},
  year =                {2017},
  month =               aug,
  doi =                 {10.1007/978-3-319-63121-9_18},
}

@inproceedings{gandalf2017-DKRS,
  author =              {Droste, Manfred and Kutsia, Temur and Rahonis,
                         George and Schreiner, Wolfgang},
  title =               {{MK}-fuzzy Automata and {MSO} Logics},
  editor =              {Bouyer, Patricia and Orlandini, Andrea and
                         San{~}Pietro, Pierluigi},
  booktitle =           {{P}roceedings of the 8th {I}nternational {S}ymposium
                         on {G}ames, {A}utomata, {L}ogics and {F}ormal
                         {V}erification ({GandALF}'17)},
  acronym =             {{GandALF}'17},
  series =              {Electronic Proceedings in Theoretical Computer
                         Science},
  volume =              {256},
  pages =               {106-120},
  year =                {2017},
  month =               sep,
  doi =                 {10.4204/EPTCS.256.8},
}

@article{atca54(2)-EGLM,
  author =              {Esparza, Javier and Ganty, Pierre and Leroux,
                         J{\'e}r{\^o}me and Majumdar, Rupak},
  title =               {Verification of Population Protocols},
  publisher =           {Springer-Verlag},
  journal =             {Acta Informatica},
  volume =              {54},
  number =              {2},
  pages =               {191-215},
  year =                {2017},
  month =               mar,
  doi =                 {10.1007/s00236-016-0272-3},
}

@phdthesis{phd-gardy,
  author =              {Gardy, Patrick},
  title =               {Semantics of Strategy Logic},
  year =                {2017},
  month =               jun,
  school =              {Lab.~Sp\'ecification \& V\'erification, Univ.
                         Paris-Saclay, France},
  type =                {{PhD} thesis},
}

Abstract

Energy consumption problems (e.g., electric vehicles charging) are very related to communication problems. The "water-filling" algorithm can be used, but it is not robust w.r.t. the noise of the "non-flexible", i.e. not-controllable, energy consumption forecasting. We propose a robust algorithm using the probabilistic model-checker PRISM, to exploit the idea of discretizing the consumption action (as for a modulation to small constellation) and the dynamic structure of the problem in a Markov-decision-process model.

@inproceedings{gretsi2017-GBBLM,
  author =              {Gonz{\'a}lez, Mauricio and Beaude, Olivier and
                         Bouyer, Patricia and Lasaulce, Samson and Markey,
                         Nicolas},
  title =               {Strat{\'e}gies d'ordonnancement de consommation
                         d'{\'e}nergie en pr{\'e}sence d'information
                         imparfaite de pr{\'e}vision},
  booktitle =           {{A}ctes du 26{\`e}me {C}olloque du {G}roupe
                         d'{\'E}tudes du {T}raitement du {S}ignal et des
                         {I}mages ({GRETSI}'17)},
  acronym =             {{GRETSI}'17},
  year =                {2017},
  month =               sep,
  abstract =            {Energy consumption problems (e.g., electric vehicles
                         charging) are very related to communication
                         problems. The "water-filling" algorithm can be used,
                         but it is not robust w.r.t. the noise of the
                         "non-flexible", i.e. not-controllable, energy
                         consumption forecasting. We~propose a robust
                         algorithm using the probabilistic model-checker
                         PRISM, to exploit the idea of discretizing the
                         consumption action (as~for a modulation to small
                         constellation) and the dynamic structure of the
                         problem in a Markov-decision-process model.},
}

@inproceedings{concur2017-GHPW,
  author =              {Gutierrez, Julian and Harrenstein, Paul and Perelli,
                         Giuseppe and Wooldridge, Michael},
  title =               {{N}ash Equilibrium and Bisimulation Invariance},
  editor =              {Meyer, Roland and Nestmann, Uwe},
  booktitle =           {{P}roceedings of the 28th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'17)},
  acronym =             {{CONCUR}'17},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {85},
  pages =               {17:1-17:16},
  year =                {2017},
  month =               sep,
  doi =                 {10.4230/LIPIcs.CONCUR.2017.17},
}

@article{sttt19(3)-JBBEHKPRRSSTW,
  author =              {Jacobs, Swen and Bloem, Roderick and Brenguier,
                         Romain and Ehlers, R{\"u}diger and Hell, Timotheus
                         and K{\"o}nighofer, Robert and P{\'e}rez, Guillermo
                         A. and Raskin, Jean-Fran{\c c}ois and Ryzhyk, Leonid
                         and Sankur, Ocan and Seidl, Martin and Tentrup,
                         Leander and Walker, Adam},
  title =               {The first reactive synthesis competition
                         ({SYNTCOMP}~2014)},
  publisher =           {Springer-Verlag},
  journal =             {International Journal on Software Tools for
                         Technology Transfer},
  volume =              {19},
  number =              {3},
  pages =               {367-390},
  year =                {2017},
  month =               jun,
  doi =                 {10.1007/s10009-016-0416-3},
}

@article{lmcs13(1)-MMPV,
  author =              {Mogavero, Fabio and Murano, Aniello and Perelli,
                         Giuseppe and Vardi, Moshe Y.},
  title =               {Reasoning About Strategies: On~the~Satisfiability
                         Problem},
  journal =             {Logical Methods in Computer Science},
  volume =              {13},
  number =              {1},
  year =                {2017},
  month =               mar,
  doi =                 {10.23638/LMCS-13(1:9)2017},
}

@inproceedings{hscc2017-RPV,
  author =              {Roohi, Nima and Prabhakar, Pavithra and Viswanathan,
                         Mahesh},
  title =               {Robust model checking of timed automata under clock
                         drifts},
  editor =              {Frehse, Goran and Mitra, Sayan},
  booktitle =           {{P}roceedings of the 20th {I}nternational {W}orkshop
                         on {H}ybrid {S}ystems: {C}omputation and {C}ontrol
                         ({HSCC}'14)},
  acronym =             {{HSCC}'17},
  publisher =           {ACM Press},
  pages =               {153-162},
  year =                {2017},
  month =               apr,
  doi =                 {10.1145/3049797.3049821},
}

@inproceedings{tacas2017-ST,
  author =              {Sankur, Ocan and Talpin, Jean-Pierre},
  title =               {An~Abstraction Technique For Parameterized Model
                         Checking of Leader Election Protocols: Application
                         to~{FTSP}},
  editor =              {Legay, Axel and Margaria, Tiziana},
  booktitle =           {{P}roceedings of the 23rd {I}nternational
                         {C}onference on {T}ools and {A}lgorithms for
                         {C}onstruction and {A}nalysis of {S}ystems
                         ({TACAS}'17)~-- {P}art~{I}},
  acronym =             {{TACAS}'17},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10205},
  year =                {2017},
  month =               apr,
  doi =                 {10.1007/978-3-662-54577-5_2},
}

@phdthesis{phd-stan,
  author =              {Stan, Daniel},
  title =               {Randomized strategies in concurrent games},
  year =                {2017},
  month =               mar,
  school =              {Lab.~Sp\'ecification \& V\'erification, ENS Cachan,
                         France},
  type =                {Th\`ese de doctorat},
}

@inproceedings{formats2017-TM,
  author =              {T{\'o}th, Tam{\'a}s and Majzik, Istv{\'a}n},
  title =               {Lazy reachability checking for timed automata using
                         interpolants},
  editor =              {Abate, Alessandro and Geeraerts, Gilles},
  booktitle =           {{P}roceedings of the 15th {I}nternational
                         {C}onferences on {F}ormal {M}odelling and {A}nalysis
                         of {T}imed {S}ystems ({FORMATS}'17)},
  acronym =             {{FORMATS}'17},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {10419},
  pages =               {264-280},
  year =                {2017},
  month =               sep,
  doi =                 {10.1007/978-3-319-65765-3_15},
}

Abstract

We define and study a slight variation on the semantics of Strategy Logic: while in the classical semantics, all strategies are shifted during the evaluation of temporal modalities, we propose to only shift the strategies that have been assigned to a player, thus matching the intuition that we can assign the very same strategy to the players at different points in time. We prove that surprisingly, this renders the model-checking problem undecidable.

@article{ipl116(2)-BGM,
  author =              {Bouyer, Patricia and Gardy, Patrick and Markey,
                         Nicolas},
  title =               {On the semantics of Strategy Logic},
  publisher =           {Elsevier},
  journal =             {Information Processing Letters},
  volume =              {116},
  number =              {2},
  pages =               {75-79},
  year =                {2016},
  month =               feb,
  doi =                 {10.1016/j.ipl.2015.10.004},
  abstract =            {We define and study a slight variation on the
                         semantics of Strategy Logic: while in the classical
                         semantics, all strategies are shifted during the
                         evaluation of temporal modalities, we propose to
                         only shift the strategies that have been assigned to
                         a player, thus matching the intuition that we can
                         assign the very same strategy to the players at
                         different points in time. We prove that
                         surprisingly, this renders the model-checking
                         problem undecidable.},
}

Abstract

Weighted timed automata have been defined in the early 2000's for modelling resource-consumption or -allocation problems in real-time systems. Optimal reachability is decidable in weighted timed automata, and a symbolic forward algorithm has been developed to solve that problem. This algorithm uses so-called priced zones, an extension of standard zones with cost functions. In order to ensure termination, the algorithm requires clocks to be bounded. For unpriced timed automata, much work has been done to develop sound abstractions adapted to the forward exploration of timed automata, ensuring termination of the model-checking algorithm without bounding the clocks. In this paper, we take advantage of recent developments on abstractions for timed automata, and propose an algorithm allowing for symbolic analysis of all weighted timed automata, without requiring bounded clocks.

@inproceedings{cav2016-BCM,
  author =              {Bouyer, Patricia and Colange, Maximilien and Markey,
                         Nicolas},
  title =               {Symbolic Optimal Reachability in Weighted Timed
                         Automata},
  editor =              {Chaudhuri, Swarat and Farzan, Azadeh},
  booktitle =           {{P}roceedings of the 28th {I}nternational
                         {C}onference on {C}omputer {A}ided {V}erification
                         ({CAV}'16)},
  acronym =             {{CAV}'16},
  publisher =           {Springer-Verlag},
  series =              {Lecture Notes in Computer Science},
  volume =              {9779},
  pages =               {513-530},
  year =                {2016},
  month =               jul,
  doi =                 {10.1007/978-3-319-41528-4_28},
  url =                 {http://arxiv.org/abs/1602.00481},
  abstract =            {Weighted timed automata have been defined in the
                         early 2000's for modelling resource-consumption or
                         -allocation problems in real-time systems. Optimal
                         reachability is decidable in weighted timed
                         automata, and a symbolic forward algorithm has been
                         developed to solve that problem. This algorithm uses
                         so-called priced zones, an extension of standard
                         zones with cost functions. In order to ensure
                         termination, the algorithm requires clocks to be
                         bounded. For unpriced timed automata, much work has
                         been done to develop sound abstractions adapted to
                         the forward exploration of timed automata, ensuring
                         termination of the model-checking algorithm without
                         bounding the clocks. In this paper, we take
                         advantage of recent developments on abstractions for
                         timed automata, and propose an algorithm allowing
                         for symbolic analysis of all weighted timed
                         automata, without requiring bounded clocks.},
}

Abstract

We study the almost-sure reachability problem in a distributed system obtained as the asynchronous composition of N copies (called processes) of the same automaton (called protocol), that can communicate via a shared register with finite domain. The automaton has two types of transitions: write-transitions update the value of the register, while read-transitions move to a new state depending on the content of the register. Non-determinism is resolved by a stochastic scheduler. Given a protocol, we focus on almost-sure reachability of a target state by one of the processes. The answer to this problem naturally depends on the number N of processes. However, we prove that our setting has a cut-off property : the answer to the almost-sure reachability problem is constant when N is large enough; we then develop an EXPSPACE algorithm deciding whether this constant answer is positive or negative.

@inproceedings{icalp2016-BMRSS,
  author =              {Bouyer, Patricia and Markey, Nicolas and Randour,
                         Mickael and Sangnier, Arnaud and Stan, Daniel},
  title =               {Reachability in Networks of Register Protocols under
                         Stochastic Schedulers},
  editor =              {Chatzigiannakis, Ioannis and Mitzenmacher, Michael
                         and Rabani, Yuval and Sangiorgi, Davide},
  booktitle =           {{P}roceedings of the 43rd {I}nternational
                         {C}olloquium on {A}utomata, {L}anguages and
                         {P}rogramming ({ICALP}'16)~-- Part~{II}},
  acronym =             {{ICALP}'16},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {55},
  pages =               {106:1-106:14},
  year =                {2016},
  month =               jul,
  doi =                 {10.4230/LIPIcs.ICALP.2016.106},
  abstract =            {We study the almost-sure reachability problem in a
                         distributed system obtained as the asynchronous
                         composition of~\(N\) copies (called
                         \emph{processes}) of the same automaton (called
                         \emph{protocol}), that can communicate via a shared
                         register with finite domain. The automaton has two
                         types of transitions: write-transitions update the
                         value of the register, while read-transitions move
                         to a new state depending on the content of the
                         register. Non-determinism is resolved by a
                         stochastic scheduler. Given a protocol, we focus on
                         almost-sure reachability of a target state by one of
                         the processes. The answer to this problem naturally
                         depends on the number~\(N\) of processes. However,
                         we prove that our setting has a cut-off property :
                         the answer to the almost-sure reachability problem
                         is constant when \(N\) is large enough; we~then
                         develop an EXPSPACE algorithm deciding whether this
                         constant answer is positive or negative.},
}

Abstract

We study the existence of mixed-strategy equilibria in concurrent games played on graphs. While existence is guaranteed with safety objectives for each player, Nash equilibria need not exist when players are given arbitrary terminal-reward objectives, and their existence is undecidable with qualitative reachability objectives (and only three players). However, these results rely on the fact that the players can enforce infinite plays while trying to improve their payoffs. In this paper, we introduce a relaxed notion of equilibria, where deviations are imprecise. We prove that contrary to Nash equilibria, such (stationary) equilibria always exist, and we develop a PSPACE algorithm to compute one.

@inproceedings{gandalf2016-BMS,
  author =              {Bouyer, Patricia and Markey, Nicolas and Stan,
                         Daniel},
  title =               {Stochastic Equilibria under Imprecise Deviations in
                         Terminal-Reward Concurrent Games},
  editor =              {Cantone, Domenico and Delzanno, Giorgio},
  booktitle =           {{P}roceedings of the 7th {I}nternational {S}ymposium
                         on {G}ames, {A}utomata, {L}ogics and {F}ormal
                         {V}erification ({GandALF}'16)},
  acronym =             {{GandALF}'16},
  series =              {Electronic Proceedings in Theoretical Computer
                         Science},
  volume =              {226},
  pages =               {61-75},
  year =                {2016},
  month =               sep,
  doi =                 {10.4204/EPTCS.226.5},
  abstract =            {We study the existence of mixed-strategy equilibria
                         in concurrent games played on graphs. While
                         existence is guaranteed with safety objectives for
                         each player, Nash equilibria need not exist when
                         players are given arbitrary terminal-reward
                         objectives, and their existence is undecidable with
                         qualitative reachability objectives (and~only three
                         players). However, these results rely on the fact
                         that the players can enforce infinite plays while
                         trying to improve their payoffs. In this paper, we
                         introduce a relaxed notion of equilibria, where
                         deviations are imprecise. We prove that contrary to
                         Nash equilibria, such (stationary) equilibria always
                         exist, and we develop a PSPACE algorithm to compute
                         one.},
}

Abstract

QCTL extends the temporal logic CTL with quantification over atomic propositions. While the algorithmic questions for QCTL and its fragments with limited quantification depth are well-understood (e.g. satisfiability of QCTLk, with at most k nested blocks of quantifiers, is k+1-EXPTIME-complete), very few results are known about the expressiveness of this logic. We address such expressiveness questions in this paper. We first consider the distinguishing power of these logics (i.e., their ability to separate models), their relationship with behavioural equivalences, and their ability to capture the behaviours of finite Kripke structures with so-called characteristic formulas. We then consider their expressive power (i.e., their ability to express a property), showing that in terms of expressiveness the hierarchy QCTLk collapses at level 2 (in other terms, any QCTL formula can be expressed using at most two nested blocks of quantifiers).

@inproceedings{concur2016-DLM,
  author =              {David, Am{\'e}lie and Laroussinie, Fran{\c c}ois and
                         Markey, Nicolas},
  title =               {On~the expressiveness of~{QCTL}},
  editor =              {Desharnais, Jules and Jagadeesan, Radha},
  booktitle =           {{P}roceedings of the 27th {I}nternational
                         {C}onference on {C}oncurrency {T}heory
                         ({CONCUR}'16)},
  acronym =             {{CONCUR}'16},
  publisher =           {Leibniz-Zentrum f{\"u}r Informatik},
  series =              {Leibniz International Proceedings in Informatics},
  volume =              {59},
  pages =               {28:1-28:15},
  year =                {2016},
  month =               aug,
  doi =                 {10.4230/LIPIcs.CONCUR.2016.28},
  abstract =            {QCTL extends the temporal logic CTL with
                         quantification over atomic propositions. While the
                         algorithmic questions for QCTL and its fragments
                         with limited quantification depth are
                         well-understood (e.g. satisfiability of
                         QCTL\textsuperscript{\(k\)}, with at most \(k\)
                         nested blocks of quantifiers, is
                         \(k+1\)-EXPTIME-complete), very few results are
                         known about the expressiveness of this logic.
                         We~address such expressiveness questions in this
                         paper. We first consider the \emph{distinguishing
                         power} of these logics (i.e.,~their ability to
                         separate models), their relationship with
                         behavioural equivalences, and their ability to
                         capture the behaviours of finite Kripke structures
                         with so-called characteristic formulas. We then
                         consider their \emph{expressive power} (i.e.,~their
                         ability to express a property), showing that in
                         terms of expressiveness the hierarchy
                         QCTL\textsuperscript{\(k\)} collapses at level~2
                         (in~other terms, any~QCTL formula can be expressed
                         using at most two nested blocks of quantifiers).},
}