GLP: A Grassroots, Multiagent, Concurrent, Logic Programming Language

Grassroots platforms are distributed systems with multiple instances that can (1) operate independently of each other and of any global resource other than the network, and (2) coalesce into ever larger instances, possibly resulting in a single global instance. Here, we present Grassroots Logic Programs (GLP), a multiagent concurrent logic programming language designed for the implementation of grassroots platforms. We introduce the language incrementally: We recall the standard operational semantics of logic programs; introduce the operational semantics of Concurrent (single-agent) GLP as a restriction of that of LP; recall the notion of multiagent transition systems and atomic transactions; introduce the operational semantics of multiagent GLP via a multiagent transition system specified via atomic transactions; and prove multiagent GLP to be grassroots. The accompanying programming example is the grassroots social graph – the infrastructure grassroots platform on which all others are based. With the mathematical foundations presented here: a workstation-based implementation of Concurrent GLP was developed by AI, based on the operational semantics of Concurrent GLP; a distributed peer-to-peer smartphone-based implementation of multiagent GLP is being developed by AI, based on the operational semantics of multiagent GLP; a moded type system for GLP was implemented by AI, to facilitate the specification of GLP programs by human and AI designers, for their programming by AI; all reported in detail in companion papers.

💡 Research Summary

The paper introduces Grassroots Logic Programs (GLP), a novel logic‑programming language designed to serve as the foundation for “Grassroots” platforms—distributed systems composed of many independent instances that can operate without any global resources other than the network and that can merge into ever larger, possibly single, global instances. GLP builds on the classic operational semantics of logic programs (LP) but adds three orthogonal constraints that fundamentally change how variables and unification work, thereby enabling safe concurrency and distributed execution.

First, each LP variable X is split into a writer X and a paired reader X?. A writer can be assigned a term at most once (acting like a promise), and the corresponding reader can consume that term at most once (acting like a future). This pairing enforces a linear‑logic style resource discipline while also providing a built‑in mechanism for asynchronous communication.

Second, GLP enforces a Single‑Occurrence (SO) invariant: any term, goal, or clause may contain each variable (writer or reader) at most once. This eliminates the possibility of multiple concurrent assignments to the same writer and simplifies matching to pure term‑matching rather than full unification.

Third, the Single‑Reader Single‑Writer (SRSW) restriction requires that a clause contains a writer X if and only if it also contains its paired reader X?. Consequently, every writer that produces a value has a unique consumer, and the language can guarantee that no two clauses race to assign the same variable.

The operational semantics are expressed as a transition system. Two kinds of transitions are defined: (a) Reduce, which uses a writer‑most‑general‑unifier (writer‑mgu) to match a unit goal with the first applicable clause, and (b) Communicate, which propagates a writer assignment to its paired reader via a readers substitution. Reduce differs from LP in that it only considers the first applicable clause (ensuring fairness) and uses writer‑mgu (preventing accidental variable capture). Communicate implements the promise/future communication pattern.

Key theoretical properties are proved: GLP retains the same logical consequence relation as LP (computation is deduction), preserves the SO invariant throughout any run, and is monotonic in the sense that a goal reducible now remains reducible later. The transition system is shown to be persistent (enabled transitions stay enabled) and, under a fairness assumption, every enabled transition will eventually fire.

A single‑agent fragment, called Concurrent GLP, is illustrated with several examples. The “fair merge” program demonstrates how two input streams can be merged without bias, using writer‑reader pairs to ensure each element is consumed exactly once. A more elaborate example is the “grassroots social graph,” a single‑agent GLP program that models a peer‑to‑peer social network. It includes three protocols: cold‑call befriending (exchanging a fresh variable to establish a bidirectional channel), text messaging over established channels, and mediated introduction (a mutual friend creates a pair of channels and distributes them). In the single‑agent version a simulated network switch routes messages between agents.

The paper then extends GLP to multiple agents, defining multi‑agent GLP (maGLP). Multi‑agent transition systems are built from atomic transactions, each transaction being a finite set of local actions that either reduce a local goal or communicate a writer value to a remote reader. Agents are named, operate independently, and interact only via paired variables. The crucial “cold‑call” transaction allows an agent to send a term together with its unbound variables to another agent while retaining the paired variables locally. This enables two previously disconnected components to become owners of the same variable pair, thereby establishing a new communication link without any central coordinator.

Using the same social‑graph scenario, the authors replace the simulated switch with a cold‑call transaction, yielding a fully decentralized peer‑to‑peer implementation. The multi‑agent semantics are shown to satisfy the formal definition of a grassroots platform: each agent can run autonomously, and agents can merge their states via atomic transactions, eventually forming a single global instance if desired.

Implementation work is summarized: a workstation‑based interpreter for Concurrent GLP has been built, adhering to the formal semantics. A distributed smartphone‑based prototype of maGLP is under development, with AI automatically deploying and managing the peer‑to‑peer network. Additionally, a moded type system for GLP has been created, capturing the writer‑reader discipline at the type level to aid both human and AI designers in writing correct programs.

In conclusion, GLP provides a mathematically grounded, operationally simple yet expressive language for building grassroots platforms. By integrating linear‑logic‑style resource handling, futures/promises, and atomic transaction‑based multi‑agent coordination, it offers a clean path from theory to practical, decentralized applications such as social networks, federated services, and potentially grassroots cryptocurrencies. The paper’s contributions lie in the precise language definition, the proof of grassroots properties, and the concrete roadmap toward real‑world deployments.