David A. Rosenblueth

Hidden Markov models (HMMs) have found myriad uses. When employed in robotics, however, a conspicuous difference compared with finite-state machine emerges: HMMs lack a direct way of incorporating inputs. Although a sequence of observations can be viewed as input, we argue that it is desirable to extend HMMs with inputs in the vein of finite-state machines. As robot controllers, HMMs exhibit another salient feature: such models primarily focus on capturing uncertainty and stochasticity in the operational environment while maintaining deterministic actions based on the robot’s belief state. We propose extendin HMMs in this other direction as well, embracing uncertainty also in the reactive behavior of the robot, resulting in stochastic behavior, thus making the robot act differently under the same conditions. We argue that this produces rich information, often sufficient for effective navigation without explicit maps. In addition, this approach significantly reduces the computational burden on the agent and simultaneously mitigates undesirable behaviors arising from deterministic policies under uncertainty of environmental perception. An input output extended HMM (IOEHMM) can be regarded as a Moore machine with stochastic inputs and outputs. We build IOEHMM robot behaviors using a genetic algorithm to find the best models and compare this approach with robot behavior implemented with a Markov decision process (MDP), whose parameters are also found by a genetic algorithm. Our method outperforms MDPs in cases where obstacles are large or the robot is used for exploration.

Sketch-based program synthesis allows users to guide the synthesizer by writing partial programs (sketches). Traditionally, the specifications of these sketches are safety properties expressed either as assertions or semantic equivalences. These specifications, however, lack expressiveness when the user wants to establish how the execution of the desired program evolves over time. This is especially important when synthesizing reactive programs, where the whole specification is about how the computation evolves over time. We explore an alternative method letting the user specify desired program executions as linear temporal logic (LTL) formulae. We define a method for transforming sketches with LTL assertions into sketches with only standard assertions. Specifically, for terminating programs, our method transforms and implements, within the sketch, the LTL formulae as runtime monitors. For non-terminating programs, our procedure defines and implements, into the sketch, fairness conditions (analyzing when an acceptance state of the Büchi automata equivalent to these LTL formulae occurs infinitely often). We prove the correctness of both constructions. Evaluation of our implementation in Sketch shows that our method enables the system to synthesize non-terminating programs, such as a round-robin arbiter for a variable number of devices and a lift controller for a variable number of floors. For terminating programs, our approach improves the synthesizer performance by restricting the search of program candidates without modifying the sketches structures.

This paper leans on two similar areas so far detached from each other. On the one hand, Dung's pioneering contributions to abstract argumentation, almost thirty years ago, gave rise to a plethora of successors, including abstract dialectical frameworks (ADFs). On the other hand, Boolean networks (BNs), devised as models of gene regulation, have been successful for studying the behavior of molecular processes within cells. ADFs and BNs are similar to each other: both can be viewed as functions from vectors of bits to vectors of bits. As soon as similarities emerge between these two formalisms, however, differences appear. For example, conflict-freedom is prominent in argumentation (where we are interested in a self-consistent, i.e., conflict-free, set of beliefs) but absent in BNs. By contrast, asynchrony (where only one gene is updated at a time) is conspicuous in BNs and lacking in argumentation. Finally, while a monotonicity-based notion occurs in signed reasoning of both argumentation and gene regulation, a different, derivative-based notion only appears in the BN literature. To identify common mathematical structure between both formalisms, these differences need clarification. This contribution is a partial review of both these areas, where we cover enough ground to exhibit their more evident similarities, to then reconcile some of their apparent differences. We highlight a range of avenues of research resulting from ironing out discrepancies between these two fields. Unveiling their common concerns should enable these two areas to cross-fertilize so as to transfer ideas and results between each other.

Any kind of dynamics in dynamic epistemic logic can be represented as an action model. Right? Wrong! In this contribution we prove that the update expressivity of communication patterns is incomparable to that of action models. Action models, as update mechanisms, were proposed by Baltag, Moss, and Solecki in 1998 and have remained the nearly universally accepted update mechanism in dynamic epistemic logics since then. Alternatives, such as arrow updates that were proposed by Kooi and Renne in 2011, have update equivalent action models. More recently, the picture is shifting. Communication patterns are update mechanisms originally proposed in some form or other by Ågotnes and Wang in 2017 (as resolving distributed knowledge), by Baltag and Smets in 2020 (as reading events), and by Velázquez, Castañeda, and Rosenblueth in 2021 (as communication patterns). All these logics have the same expressivity as the base logic of distributed knowledge. However, their update expressivity, the relation between pointed epistemic models induced by such an update, was conjectured to be different from that of action model logic. Indeed, we show that action model logic and communication pattern logic are incomparable in update expressivity. We also show that, given a history-based semantics and when restricted to (static) interpreted systems, action model logic is (strictly) more update expressive than communication pattern logic. Our results are relevant for distributed computing wherein oblivious models involve arbitrary iteration of communication patterns.

Runtime verification is a lightweight method for monitoring the formal specification of a system during its execution. It has recently been shown that a given state predicate can be monitored consistently by a set of crash-prone asynchronous distributed monitors observing the system, only if each monitor can emit verdicts taken from a large enough finite set. We revisit this impossibility result in the concrete context of linear-time logic ( ltl ) semantics for runtime verification, that is, when the correctness of the system is specified by an ltl formula on its execution traces. First, we show that monitors synthesized based on the 4-valued semantics of ltl ( rv-ltl ) may result in inconsistent distributed monitoring, even for some simple ltl formulas. More generally, given any ltl formula φ, we relate the number of different verdicts required by the monitors for consistently monitoring φ, with a specific structural characteristic of φ called its alternation number . Specifically, we show that, for every k ≥ 0 , there is an ltl formula φ with alternation number k that cannot be verified at runtime by distributed monitors emitting verdicts from a set of cardinality smaller than k + 1. On the positive side, we define a family of logics, called distributed ltl (abbreviated as dltl ), parameterized by k ≥ 0, which refines rv-ltl by incorporating 2k + 4 truth values. Our main contribution is to show that, for every k ≥ 0, every ltl formula φ with alternation number k can be consistently monitored by distributed monitors, each running an automaton based on a (2 ⌈ k /2 ⌉ +4)-valued logic taken from the dltl family.

We propose quantum Boolean networks, which can be classified as deterministic reversible asynchronous Boolean networks. This model is based on the concept of quantum Boolean functions. A quantum Boolean network is a Boolean network where the functions associated with the nodes are quantum Boolean functions. We study some properties of this novel model and, using a quantum simulator, we study how the dynamics change in function of the connectivity of the network and the set of operators we allow. For some configurations, the behavior of this model resembles that of reversible Boolean networks (RevBN), while for other configurations a more complex dynamics can emerge. For example, cycles larger than 2^N were observed. Additionally, using a scheme akin to one used previously with random Boolean networks, we computed the average entropy and complexity of the networks. As opposed to classic random Boolean networks, where “complex” dynamics are restricted mainly to a connectivity close to a phase transition, quantum Boolean networks can exhibit stable, complex, and unstable dynamics independently of their connectivity.