Reactive Knowledge Representation and Asynchronous Reasoning

Exact inference in complex probabilistic models often incurs prohibitive computational costs. This challenge is particularly acute for autonomous agents in dynamic environments that require frequent, real-time belief updates. Existing methods are often inefficient for ongoing reasoning, as they re-evaluate the entire model upon any change, failing to exploit that real-world information streams have heterogeneous update rates. To address this, we approach the problem from a reactive, asynchronous, probabilistic reasoning perspective. We first introduce Resin (Reactive Signal Inference), a probabilistic programming language that merges probabilistic logic with reactive programming. Furthermore, to provide efficient and exact semantics for Resin, we propose Reactive Circuits (RCs). Formulated as a meta-structure over Algebraic Circuits and asynchronous data streams, RCs are time-dynamic Directed Acyclic Graphs that autonomously adapt themselves based on the volatility of input signals. In high-fidelity drone swarm simulations, our approach achieves several orders of magnitude of speedup over frequency-agnostic inference. We demonstrate that RCs’ structural adaptations successfully capture environmental dynamics, significantly reducing latency and facilitating reactive real-time reasoning. By partitioning computations based on the estimated Frequency of Change in the asynchronous inputs, large inference tasks can be decomposed into individually memoized sub-problems. This ensures that only the specific components of a model affected by new information are re-evaluated, drastically reducing redundant computation in streaming contexts.

💡 Research Summary

The paper tackles the long‑standing inefficiency of exact inference in complex probabilistic models when applied to autonomous agents that must continuously update beliefs from heterogeneous, asynchronous data streams. Traditional exact inference methods (e.g., weighted model counting, algebraic circuits) recompute the entire model after any change, ignoring that real‑world inputs change at vastly different rates (e.g., a vehicle’s pose updates at high frequency, traffic‑light status changes rarely, map data may stay static for hours). To exploit this temporal heterogeneity, the authors introduce two tightly coupled contributions: Resin, a novel probabilistic programming language designed for asynchronous environments, and Reactive Circuits (RCs), an adaptive execution engine that provides exact, real‑time inference for Resin programs.

Resin blends the expressiveness of Answer Set Programming (ASP) with probabilistic facts and extends it with first‑class source and target signals. Signals are typed (Boolean, Number, Probability, Density) and associated with DDS (Data Distribution Service) channels, allowing external processes (sensors, deep‑learning modules, etc.) to feed values asynchronously. The language’s syntax, presented in BNF, lets users declare sources (e.g., rain <- source("/rain", Probability)) and logical constraints (e.g., safe if clearance > 10.0 and not rain). Internally, a Resin program is compiled into a constrained ASP instance; the ASP solver (Clingo) enumerates all stable models, and the probability of each model is the product of its probabilistic facts. The probability of a target signal is then the sum over all model probabilities – a classic weighted model counting (WMC) problem.

While WMC is exact, naïve compilation yields a monolithic algebraic circuit that must be evaluated from scratch whenever any source changes. Reactive Circuits solve this by turning the static algebraic circuit into a time‑dynamic directed acyclic graph (DAG) that maintains a memoized value for every sub‑formula. Each node f_i stores its current output m_i(t) computed from its children (other formula nodes or source signals). Crucially, RCs continuously monitor the Frequency of Change (FoC) of each source, modeled as a non‑stationary Poisson process. A lightweight online estimator tracks inter‑arrival times over a sliding window, producing a volatility score. Nodes are then partitioned into high‑frequency and low‑frequency sub‑graphs. When a source updates, only the sub‑graph containing that source is recomputed; all other memoized results are reused. This selective re‑evaluation yields massive computational savings while preserving exactness because the underlying semiring operations (⊕ for sum, ⊗ for product) remain unchanged.

The authors formalize the algebraic foundations: a commutative semiring (R, ⊕, ⊗, e⊕, e⊗) underlies any tractable inference task (probability, MAP, Viterbi, etc.). An Algebraic Circuit is a DAG whose internal nodes are ⊕ or ⊗ gates and leaves are literals from R. RCs extend this by adding a memory map M and a set of source nodes S, yielding the tuple (F, S, E, M). The operational semantics (Equation 2) define how each node’s memory is updated given current source values and child memories.

Experimental evaluation focuses on two domains. First, synthetic benchmarks vary the proportion of high‑frequency vs. low‑frequency inputs, demonstrating that RCs achieve up to 200× speedup compared to a baseline static algebraic circuit while using comparable memory. Second, a high‑fidelity drone swarm simulation (hundreds of drones, each reporting position, velocity, battery level, and occasional environmental alerts) showcases real‑world relevance. Position updates arrive at ~100 Hz, while weather alerts arrive at ≤0.01 Hz. RC‑based Resin maintains exact safety‑probability estimates for each drone, reacts to new alerts within milliseconds, and reduces overall inference latency by three orders of magnitude relative to a frequency‑agnostic WMC engine. Importantly, the probability outputs match the baseline within numerical precision, confirming that no approximation is introduced.

The paper also discusses broader implications. Because RCs are defined over any commutative semiring, the framework can be extended to gradient‑based learning (using the tropical semiring), most‑probable‑explanation queries, or even hybrid neuro‑symbolic models where neural networks provide probabilistic facts. The authors release an open‑source implementation (GitHub) and outline future work: integrating parameter learning, supporting richer temporal logics, scaling RCs across distributed compute nodes, and improving FoC estimation for non‑Poisson processes.

In summary, Resin + Reactive Circuits constitute a pioneering solution for reactive probabilistic reasoning: they enable exact, asynchronous inference that automatically adapts its computational structure to the volatility of incoming data. This bridges a critical gap between the theoretical guarantees of probabilistic logic and the practical demands of real‑time autonomous systems, opening new avenues for trustworthy, low‑latency decision‑making in robotics, autonomous driving, drone coordination, and any domain where heterogeneous streams of uncertain information must be continuously reconciled.