Implementing Grassroots Logic Programs with Multiagent Transition Systems and AI

Grassroots Logic Programs (GLP) is a concurrent logic programming language with variables partitioned into paired \emph{readers} and \emph{writers}, conjuring both linear logic and futures/promises: an assignment is produced at most once via the sole occurrence of a writer (promise) and consumed at most once via the sole occurrence of its paired reader (future), and may contain additional readers and/or writers, enabling the concise expression of rich multidirectional communication modalities. GLP was designed as a language for grassroots platforms – distributed systems with multiple instances that can operate independently of each other and of any global resource, and can coalesce into ever larger instances – with its target architecture being smartphones communicating peer-to-peer. The operational semantics of Concurrent (single-agent) GLP and of multiagent GLP (maGLP) were defined via transition systems/multiagent transition systems, respectively. Here, we describe the mathematics developed to facilitate the workstation- and smartphone-based implementations of GLP by AI in Dart. We developed dGLP – implementation-ready deterministic operational semantics for single-agent GLP – and proved it correct with respect to the Concurrent GLP operational semantics; dGLP was used by AI as a formal spec, from which it developed a workstation-based implementation of GLP. We developed madGLP – an implementation-ready multiagent operational semantics for maGLP – and proved it correct with respect to the maGLP operational semantics; madGLP is deterministic at the agent level (not at the system level due to communication asynchrony), and is being used by AI as a formal spec from which it develops a smartphone-based implementation of maGLP.

💡 Research Summary

The paper presents a comprehensive methodology for turning the theoretical foundations of Grassroots Logic Programs (GLP) into practical, working implementations for both single‑agent and multi‑agent settings. GLP is a concurrent logic programming language that distinguishes each logical variable into a writer (the “promise”) and a paired reader (the “future”). This pairing enforces a linear‑logic‑like discipline: a writer may be instantiated at most once, and its value may be consumed by the corresponding reader at most once. Additional readers or writers may coexist, allowing rich multidirectional communication patterns while avoiding traditional unification in favor of simple pattern matching.

The authors first formalize the original, nondeterministic operational semantics of GLP as a transition system (Concurrent GLP). Two transition rules are defined: Reduce, which selects the first applicable clause for a goal and computes a writer‑most‑general‑unifier (writer‑MGU); and Communicate, which propagates a writer’s assignment to its paired reader asynchronously. Nondeterminism arises from (i) the choice of which goal to reduce (and‑nondeterminism) and (ii) the order in which communication events are applied.

To obtain an implementation that can be executed on real hardware, the paper introduces dGLP, a deterministic transition system for single‑agent GLP. dGLP replaces the nondeterministic goal set with a FIFO queue, and it makes explicit three auxiliary structures: a set of suspended goals together with their “suspension set” of blocking readers, and a set of failed goals. The three possible transition types are: (a) Reduce, which succeeds with a writer‑MGU, updates the queue, applies the substitution, and re‑activates any suspended goals whose blocking readers have become instantiated; (b) Suspend, which records a goal together with the minimal set of readers that prevent its reduction; and (c) Fail, which records a goal that cannot be reduced by any clause.

A mapping σ from dGLP configurations to Concurrent GLP configurations is defined. σ collects all active, suspended, and failed goals into a multiset and composes all reader‑substitutions generated by Reduce steps. The authors prove two crucial properties of σ: (1) Liveness – every fair run of dGLP maps to a fair run of GLP, and (2) Completeness – for any complete GLP run there exists a corresponding dGLP run with the same outcome. The proof hinges on the Disjoint Substitution Commutativity lemma, which shows that writer‑MGUs produced by reductions on distinct goals assign disjoint variable sets and therefore commute. Consequently, the order in which dGLP processes goals (FIFO) does not affect the final substitution, guaranteeing that dGLP faithfully implements the nondeterministic GLP semantics.

For distributed execution, the paper extends the approach to madGLP, a multi‑agent deterministic semantics. Each agent runs its own dGLP instance, while inter‑agent communication is modeled as asynchronous message passing. At the agent level the semantics remain deterministic; at the system level nondeterminism re‑appears due to message ordering and network delays. The authors formalize this using a Multi‑Agent Transition System (MATS) together with an atomic transaction model, ensuring that each message delivery constitutes an atomic state change. They define a notion of fair run for the multi‑agent system, requiring that every enabled communication eventually occurs, and they prove that madGLP is a live and complete implementation of the original multi‑agent GLP (maGLP).

A distinctive contribution of the work is the AI‑driven development pipeline. The formal specifications (transition systems, invariants, and correctness lemmas) are fed to an AI system (Claude). The AI automatically generates an informal English‑plus‑code specification, then translates this into Dart code that can run on both workstations and smartphones. The development process is deliberately iterative: when the generated Dart code reveals gaps or inconsistencies in the informal spec, the AI reports them back, prompting revisions of the formal mathematics. This bidirectional feedback loop led to several major redesigns of madGLP before a stable version was achieved.

The paper’s structure follows a logical progression: Section 2 reviews transition systems and the notion of implementation; Section 3 introduces Concurrent GLP, its syntax, and the deterministic dGLP semantics; Section 4 recalls multi‑agent transition systems and atomic transactions; Section 5 defines maGLP, presents madGLP, and proves its correctness; Section 6 discusses related work; Section 7 concludes. Appendices contain full proofs, the complete madGLP specification, and detailed execution traces.

In summary, the authors deliver (1) a rigorous deterministic semantics for both single‑agent and multi‑agent GLP, (2) formal proofs that these semantics are live and complete with respect to the original nondeterministic models, (3) a concrete implementation strategy using Dart for peer‑to‑peer smartphone environments, and (4) an innovative AI‑assisted pipeline that bridges formal theory and executable code. This work demonstrates how formal methods, distributed systems theory, and modern AI tools can be combined to produce reliable, scalable logic programming platforms for decentralized, resource‑constrained devices.