Pith. sign in

REVIEW 4 major objections 3 minor 58 references

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

T0 review · 4 major / 3 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A logic language whose multiagent runs are provably grassroots

desk verdict A clean, honest language-design paper whose central theorem is deferred: the proof that maGLP is grassroots is not in this text, and the obliviousness half is asserted, not shown. read the letter →

arxiv 2607.21189 v1 pith:F62XBZP7 submitted 2026-07-23 cs.PL cs.DCcs.LOcs.MA

Ehud Shapiro (London School of Economics) This is my paper
classification cs.PLcs.DCcs.LOcs.MA MSC 68N1768Q8568M14
keywords grassrootsplatformsconcurrentlogicprogrammingmultiagenttransitionsystemssingle-occurrencevariablesreader-writerpairscold-calltransactionsoperationalsemanticssocialgraph
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Grassroots Logic Programs (GLP) is a multiagent, concurrent logic programming language designed so that any program written in it — provided agents can initiate 'cold-call' connections — runs as a grassroots platform: independent groups can form and operate with no global resource, then coalesce into ever larger groups. The paper defines GLP's operational semantics in two layers, a single-agent concurrent semantics (cGLP) and a multiagent semantics (maGLP) built on volitional atomic transactions, and proves Theorem 5.1 that maGLP is grassroots. The practical claim is that the grassroots property becomes a language-level guarantee rather than a per-application proof burden: any GLP application that uses cold-calls inherits it (Proposition 5.3). Because the language replaces unification with single-occurrence reader/writer variable pairs, an assignment flows as a single message, and the paper shows how this supports streaming, reply channels, friend-mediated introductions, and the grassroots social graph.

What carries the argument

The load-bearing mechanism is the reader/writer variable pair plus the single-occurrence (SO) and single-reader/single-writer (SRSW) restrictions: each logic variable can be assigned at most once and consumed at most once, so a writer assignment to a reader held by another agent is exactly one network message, and that message can carry further reader/writer pairs for streaming, replies, or network reconfiguration. Around this, the paper defines maGLP as a transactions-based multiagent transition system whose transactions are Reduce, Communicate, and Cold-call, and proves grassrootsness via the transaction-closure construction (Definition 3.3) that lifts local transactions to arbitrary agent

What would settle it

Search for a counterexample to obliviousness: take two small GLP groups with disjoint agents, run each to a correct outcome under the maGLP semantics, then interleave their transitions in every possible order (e.g., with a model checker over the transition system of Definition 3.5) and check whether every interleaved run is safe and live; one deadlocked, unsafe, or non-live interleaving would falsify Theorem 5.1.

Watch

Extended reading notes

Core claim

The paper's central claim is that multiagent GLP is itself a grassroots protocol: two disjoint groups of agents can each run correct computations independently, and any interleaving of their correct runs remains a correct run of the combined system (obliviousness), while the Cold-call transaction — sending a term with fresh paired variables through network streams to a previously disconnected agent — creates genuinely new coordinated behavior that no interleaving of independent runs can produce (interactivity). This is proven as Theorem 5.1, and the paper derives Proposition 5.3: any GLP application that uses cold-calls is grassroots, with Corollary 5.4 applying the result to the social-grap

Load-bearing premise

The proof assumes that interleaving two correct runs of disjoint agent groups always yields a correct run of the combined system, the 'obliviousness' half of the grassroots definition; this paper supports that condition only by an informal sentence and a pointer to the full paper, not by a derivation.

Editorial extensions

If this is right

  • If Theorem 5.1 holds, any GLP program can serve as a grassroots platform without designing a new distributed protocol for each application.
  • The social-graph program inherits the property, so befriending, friend-mediated introduction, and messaging need no server, global identity, or global resource beyond the network.
  • The Cold-call transaction supplies the interactivity half for every application: two disconnected groups can bootstrap shared state purely through network streams.
  • GLP recovers classic concurrent-logic programming techniques — streams, fair merge, monitors, meta-interpreters — within a single-assignment message-passing semantics, potentially making those techniques accessible to AI-assisted program development.
  • Because cGLP computation is still deduction (Proposition 2.13), the language keeps the logic-programming identification of computation with logical consequence in the multiagent setting.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A testable consequence we draw beyond the paper: if the guarantee is sound, auditing a GLP application for grassrootsness reduces to checking that its only cross-group bootstrap is a cold-call, a much lighter check than verifying a distributed protocol from scratch.
  • The proof structure suggests a general recipe: any multiagent language whose communication uses single-consumer channels and whose only cross-group bootstrap is a cold-call-like transaction may be grassroots by construction.
  • The paper notes that the SO restriction might be relaxed for ground (writer-free) values to allow native broadcast; we infer that relaxing it for arbitrary values would break the single-message communication model and likely the obliviousness proof.
  • We would test the abstract guarantee by model-checking all interleavings of two small GLP groups; the paper does not report such a check here, and the deferred obliviousness derivation is the natural place to start.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 3 minor

Summary. The paper introduces GLP, a logic programming language with single-occurrence variables paired into writers and readers, and defines two operational semantics: cGLP (a concurrent single-agent semantics) and maGLP (a multiagent, transaction-based semantics). It presents the grassroots social graph as a programming example and claims, in Theorem 5.1, that maGLP is grassroots: disjoint groups can operate independently (obliviousness) while the Cold-call transaction enables genuinely new cross-group behavior (interactivity). It further claims that any GLP application using cold-calls is grassroots (Proposition 5.3) and that the social graph is grassroots (Corollary 5.4). The paper also discusses AI-assisted implementation, guards, and programming techniques, with formal proofs deferred to a full version [39] and companions [42,43].

Significance. If the central result is correct, the paper offers a general-purpose, formally specified language whose multiagent executions are guaranteed to form grassroots platforms under a cold-call communication primitive. This would be a valuable bridge between concurrent logic programming and distributed-platform theory, with concrete examples and an open-source implementation. The paper's strengths are its precise operational definitions, the SRSW/SO invariants, the instructive fair-merge and social-graph examples, and the explicit identification of the Cold-call transaction as the source of interactivity. However, the central theorem's obliviousness half is asserted rather than proved in this manuscript, and several propositions are deferred to self-cited full/companion papers. The significance of the result is therefore contingent on those missing proofs being correct and available.

major comments (4)
  1. [Section 5, Theorem 5.1] The obliviousness half of Theorem 5.1 is not proved. The text states that 'their interleaved correct runs are correct runs of the combined system' and immediately concludes the theorem. Under Definition 2.5, a correct run must be safe and live; liveness requires that no enabled transaction class is omitted forever. An arbitrary interleaving of two correct runs can starve one group's enabled classes, so the claim is false for arbitrary interleavings. If a fair interleaving is intended, the paper must define the fairness condition and prove that a correct run of the combined system exists for any two correct runs of disjoint groups. The current proof is a missing-support gap in the central claim.
  2. [Section 5, Definition of grassroots] The formal definition of 'grassroots' is only cited to [19,42] and deferred to [39]; the informal characterization in the text ('obliviousness' and 'interactivity') is not sufficient to make Theorem 5.1 checkable. The proof should either reproduce the formal definition of grassroots from [19] or give a self-contained definition and then prove the theorem against it. As written, the theorem's conclusion is stated against an external, unstated definition, which also makes Proposition 5.3 and Corollary 5.4 difficult to evaluate.
  3. [Propositions 2.13, 3.6, 3.8] These propositions are stated without proof. Proposition 3.6 (maGLP SO Preservation) is needed to extend the safety properties to the multiagent setting, and Proposition 3.8 (simulation by cGLP) is a claimed deductive-correspondence result. Proposition 2.13 underlies the 'computation-as-deduction' claim. The paper defers all of these to [39]/[43]. For a paper whose advertised contribution is a proof of grassrootsness, deferring such load-bearing propositions makes the conference version unverifiable. At minimum, each should carry a proof sketch that identifies the key invariant or simulation argument.
  4. [Corollary 5.4] The grassroots social graph claim inherits the gap from Theorem 5.1 and Proposition 5.3. In addition, the social graph program is only partially reproduced in Section 4, with the full program deferred to the repository. The inheritance argument should be explicit: the social graph uses cold-calls and is therefore an instance of Proposition 5.3, but since Proposition 5.3 is unproved, Corollary 5.4 is currently unsupported.
minor comments (3)
  1. [Remark 2.18 and Definition 3.5] Remark 2.18 forbids anonymous readers ('_?', '_Name?'), but Definition 3.5 and the surrounding text use the initial state agent(ch(_?,_),ch(_?,_)) containing '_?' occurrences. Please clarify whether anonymous readers are permitted in this context or fix the notation.
  2. [Definition 3.5] The Cold-call transaction refers to 'network output stream' and 'network input stream' in an agent's state, but the local state is defined as an asynchronous resolvent (G_p, σ_p). It is not formalized how these streams are represented in the local state. Please specify this representation or refine the definition.
  3. [Section 2.2, Definition 2.11] In the Communicate transition, assignments are removed from σ after instantiation, but the paper does not discuss when an assignment is considered 'consumed' across multiple reductions. This is a minor clarity issue; a brief remark would help.

Circularity Check

1 steps flagged · score 4.0 of 10

Theorem 5.1 is asserted rather than proved, with the formal proof deferred to the author's own full paper [39]; this is the main load-bearing self-citation, but the language design itself is not definitionally circular.

  1. self citation load bearing [Section 5, Theorem 5.1 (preceded by the informal grassroots definition); also Section 1 'Paper outline': 'Proofs and supporting material are in the full paper [39].']
    "We define the notion of grassroots following [19]; formal definitions appear in the full paper [39]. ... Informally, a protocol is grassroots if two disjoint groups of agents can each operate independently—their interleaved correct runs are correct runs of the combined system—yet the combined system offers genuinely new behaviours that neither group could produce on its own. ... Theorem 5.1. The maGLP protocol is grassroots."

    The theorem is the paper's central claim, but its proof is not given in the text. The two requirements in the quoted informal definition (obliviousness and interactivity) are exactly what must be verified for maGLP. The text argues interactivity directly from the Cold-call transaction (Definition 3.5) and asserts obliviousness in one sentence, then states the theorem. Formal definitions and proofs are deferred to the author's full paper [39]. Removing that self-citation leaves Theorem 5.1 unsupported, so the advertised guarantee rests on a self-citation chain rather than an in-text derivation. This is not a full definitional circle, because the theorem is not identical to its definitions and could fail if the deferred obliviousness proof is invalid, but the in-text support is not independe

full rationale

Most of the paper is ordinary language/semantics design and is not circular: cGLP is presented as a restriction of standard LP semantics (Definitions 2.9–2.11), with safety propositions (2.13–2.15) stated in-text, and maGLP is defined as a transactions-based multiagent transition system (Definitions 3.1–3.5). These parts do not reduce to the grassroots definition. The circularity concern is concentrated in Section 5. The interactivity half of Theorem 5.1 is argued directly from the Cold-call transaction, which is included in the definition of maGLP; that is a design choice, not a circular prediction. The obliviousness half, however, is asserted informally (“their interleaved correct runs are correct runs of the combined system”) and the formal proof is deferred to the author's own full paper [39]. Thus the central theorem is load-bearing on a self-citation/deferral. This is a proof-gap and self-citation issue, not a definitional identity: the theorem could in principle fail if the deferred proof is wrong, and the language semantics have independent content. A score of 4 reflects the self-citation chain supporting the theorem, without treating the whole derivation as equivalent to its inputs.

Assumptions & free parameters 0 free parameters · 5 assumptions · 2 invented entities

The central claim depends on the author's prior transactional framework for grassroots platforms, on the SRSW/SO syntactic invariants, and on the deferred full-paper proofs. No numerical parameters are fitted; the design choices (identical initial state, cold-call transaction) are hand-chosen to make the theorem work.

assumptions (5)
  • domain assumption Grassroots is adequately formalized as obliviousness + interactivity (following [19], formalized in [39]).
    Section 5 uses this informal characterization to state Theorem 5.1; no independent formalization is provided.
  • domain assumption The P-closure of transactions (Definition 3.3) yields a correct composition operation: interleavings of correct runs of disjoint groups remain correct.
    Definition 3.3 is taken from [34,42]; Theorem 5.1's obliviousness half relies on it. Not proved in this text.
  • domain assumption SO/SRSW invariants are preserved through Reduce, Communicate, and Cold-call, so each reader is assigned at most once.
    Proposition 3.6 states this but the proof is deferred to [39]; the multiagent communication model depends on it.
  • domain assumption The network can route a cold-call message from any agent p to any named agent q using only local network streams.
    Definition 3.5, item 3; no routing/addressability model is specified.
  • ad hoc to paper The statements and proofs in the cited full paper [39] and companion [43] are correct.
    Theorems and propositions in this paper are justified only by pointers to these self-authored documents.
invented entities (2)
  • Reader/writer variable pairs (X / X?)
    purpose: Asynchronous single-assignment channels between goals and agents.
    Introduced in Section 2.1; no independent falsifiable handle—they are language primitives whose behavior is enforced by SO/SRSW. Implementation is claimed in the repository but not validated here.
  • Cold-call transaction
    purpose: Connecting two agents that share no variables, by transferring a term with writers/readers over network streams.
    Defined in Definition 3.5(3); it is the load-bearing mechanism for the interactivity part of the grassroots theorem. No protocol implementation or test accompanies this paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GLP: A Grassroots, Multiagent, Concurrent, Logic Programming Language for AI." pith.science (2026). https://pith.science/paper/F62XBZP7

@misc{pith2026260721189,
  author       = {Pith},
  title        = {Pith review of: GLP: A Grassroots, Multiagent, Concurrent, Logic Programming Language for AI},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/F62XBZP7}},
  note         = {Machine review of arXiv:2607.21189}
}
read the original abstract

A grassroots platform is a multiagent distributed system in which multiple independent instances can form and operate independently of each other and of any global resource, yet may coalesce into ever larger instances, possibly resulting in a single global instance. Grassroots platforms aim to offer an egalitarian/democratic alternative to centralised/autocratic and decentralised/plutocratic global platforms. Here, we present Grassroots Logic Programs (GLP), a multiagent concurrent logic programming language designed for the implementation of grassroots platforms: we recall the standard operational semantics of logic programs; introduce the concurrent operational semantics of GLP as its restriction; recall multiagent atomic transactions; use them to introduce a multiagent operational semantics of GLP; and prove multiagent GLP to be grassroots. The grassroots social graph—the foundational grassroots platform on which all others are based—serves as a GLP programming example.

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

58 extracted references · 11 canonical work pages

  1. [39]

    arXiv preprint arXiv:2510.15747, Summary to appear in Proc

    Ehud Shapiro (2025): GLP: A Grassroots, Multiagent, Concurrent, Logic Programming Language for AI (full version). arXiv preprint arXiv:2510.15747, Summary to appear in Proc. of ICLP’26

    arXiv 2025

  2. [19]

    arXiv preprint arXiv:2604.25596

    Andy Lewis-Pye & Ehud Shapiro (2026): Volitional Multiagent Atomic Transactions: Describing People and their Machines. arXiv preprint arXiv:2604.25596

    arXiv 2026

  3. [43]

    arXiv:2602.06934

    Ehud Shapiro (2026): Implementing Grassroots Logic Programs with Multiagent Transition Systems and AI (Full Version). arXiv:2602.06934. Summary to appear in Proc. of LOPSTR+PPDP’26

    arXiv 2026

  4. [1]

    Communications of the ACM 53(9), pp

    Joe Armstrong (2010): Erlang. Communications of the ACM 53(9), pp. 68–75, doi:10.1145/1810891.1810910

    arXiv 2010

  5. [2]

    Baker & Carl Hewitt (1977): The Incremental Garbage Collection of Processes

    Henry G. Baker & Carl Hewitt (1977): The Incremental Garbage Collection of Processes . In: Proceed- ings of the 1977 Symposium on Artificial Intelligence and Programming Languages , ACM, pp. 55–59, doi:10.1145/800228.806932

    arXiv 1977

  6. [3]

    Prentice-Hall

    Per Brinch Hansen (1973): Operating System Principles. Prentice-Hall

    1973

  7. [4]

    In: CEUR Proceedings of the First International Forum on Digital and Democracy, 2781, CEUR-WS, pp

    Luca Cardelli, Liav Orgad, Gal Shahaf, Ehud Shapiro & Nimrod Talmon (2020): Digital social contracts: A foundation for an egalitarian and just digital society. In: CEUR Proceedings of the First International Forum on Digital and Democracy, 2781, CEUR-WS, pp. 51–60

    2020

  8. [5]

    ACM Transactions on Programming Languages and Systems (TOPLAS) 8(1), pp

    Keith Clark & Steve Gregory (1986): PARLOG: parallel programming in logic . ACM Transactions on Programming Languages and Systems (TOPLAS) 8(1), pp. 1–49, doi:10.1145/5001.5390

    arXiv 1986

Show all 58 references
  1. [6]

    In: International Conference on Logic Programming, Springer, pp

    Michael Codish & Ehud Shapiro (1986): Compiling OR-parallelism into AND-parallelism. In: International Conference on Logic Programming, Springer, pp. 283–297, doi:10.1007/3-540-16492-8 82

    1986 doi

  2. [7]

    arXiv:2607.02304

    Ohad Eitan, Idit Keidar & Ehud Shapiro (2026): Securing People and their Machines Against Major Faults. arXiv:2607.02304

    2026 arXiv

  3. [8]

    Friedman & David S

    Daniel P. Friedman & David S. Wise (1976): The Impact of Applicative Programming on Multiprocessing . Indiana University Computer Science Department Technical Report (TR-26)

    1976

  4. [9]

    Theoretical Computer Science 50(1), pp

    Jean-Yves Girard (1987): Linear Logic. Theoretical Computer Science 50(1), pp. 1–101, doi:10.1016/0304- 3975(87)90045-4

    1987 doi

  5. [10]

    Proc AAAI 2025; arXiv preprint arXiv:2405.19129

    Daniel Halpern, Ariel D Procaccia, Ehud Shapiro & Nimrod Talmon (2024): Federated Assemblies. Proc AAAI 2025; arXiv preprint arXiv:2405.19129

    2024 arXiv

  6. [11]

    C. A. R. Hoare (1974): Monitors: An operating system structuring concept . Communications of the ACM 17(10), pp. 549–557, doi:10.1145/355620.361161

    1974

  7. [12]

    The Journal of Logic Programming 7(2), pp

    Avshalom Houri & Ehud Shapiro (1989): A sequential abstract machine for Flat Concurrent Prolog . The Journal of Logic Programming 7(2), pp. 85–123, doi:10.1016/0743-1066(89)90011-3

    1989 doi

  8. [13]

    arXiv preprint arXiv:2505.19216

    Idit Keidar, Andrew Lewis-Pye & Ehud Shapiro (2025): Constitutional Consensus . arXiv preprint arXiv:2505.19216

    2025

  9. [14]

    In: Proceedings of the 1st international workshop on distributed infrastructure for com- mon good, pp

    Anne-Marie Kermarrec, Erick Lavoie & Christian Tschudin (2020): Gossiping with append-only logs in secure-Scuttlebutt. In: Proceedings of the 1st international workshop on distributed infrastructure for com- mon good, pp. 19–24, doi:10.1145/3428662.3428794

    2020

  10. [15]

    In: IFIP congress, 74, pp

    Robert Kowalski (1974): Predicate logic as programming language. In: IFIP congress, 74, pp. 569–574

    1974

  11. [16]

    In: Proc

    Giorgio Levi & Catuscia Palamidessi (1985): The Semantics of the Read-Only Variable. In: Proc. Symposium on Logic Programming, IEEE, pp. 128–137

    1985

  12. [17]

    arXiv preprint arXiv:2309.13191

    Andrew Lewis-Pye, Oded Naor & Ehud Shapiro (2023): Grassroots Flash: A Payment System for Grassroots Cryptocurrencies. arXiv preprint arXiv:2309.13191

    2023 arXiv

  13. [18]

    Andrew Lewis-Pye & Ehud Shapiro (2025): Morpheus Consensus: Excelling on trails and autobahns. Proc. 29th Conference on Principles of Distributed Systems, OPODIS 2025. arXiv preprint arXiv:2502.08465 , doi:10.4230/LIPIcs.OPODIS.2025.35

    2025

  14. [20]

    ACM SIGPLAN Notices 24(1), pp

    Yossi Lichtenstein & Ehud Shapiro (1988): Concurrent algorithmic debugging. ACM SIGPLAN Notices 24(1), pp. 248–260, doi:10.1145/68210.69239

    1988

  15. [21]

    (2022): Akka: Build Concurrent, Distributed, and Resilient Message-Driven Applications

    Lightbend Inc. (2022): Akka: Build Concurrent, Distributed, and Resilient Message-Driven Applications . https://akka.io. Accessed October 2025. 132 Grassroots Logic Programs

    2022

  16. [22]

    Lloyd (1987): Foundations of Logic Programming, 2nd edition

    John W. Lloyd (1987): Foundations of Logic Programming, 2nd edition. Springer-Verlag, doi:10.1007/978- 3-642-83189-8

    1987 doi

  17. [23]

    https://dotnet.github.io/ orleans

    Microsoft (2022): Orleans: Cloud Native Application Framework . https://dotnet.github.io/ orleans. Accessed October 2025

    2022

  18. [24]

    Mierowsky, S

    C. Mierowsky, S. Taylor, E. Shapiro, J. Levy & M. Safra (1985): On the implementation of Flat Concurrent Prolog. Proceedings of the 1985 Symposium on Logic Programming, pp. 276–286

    1985

  19. [25]

    In: Proceedings of the 10th annual international symposium on Computer architecture, pp

    Tohru Moto-Oka (1983): Overview to the fifth generation computer system project . In: Proceedings of the 10th annual international symposium on Computer architecture, pp. 417–422

    1983

  20. [26]

    In: Concurrent Prolog: Collected Papers , MIT Press, pp

    Shmuel Safra & Ehud Shapiro (1988): Meta interpreters for real. In: Concurrent Prolog: Collected Papers , MIT Press, pp. 166–179

    1988

  21. [27]

    Shafrir & E

    A. Shafrir & E. Shapiro (1987): Distributed Programming in Concurrent Prolog. In Ehud Shapiro, editor: Concurrent Prolog: Collected Papers, V olume 1, MIT Press, Cambridge, MA, pp. 318–338

    1987

  22. [28]

    Communications of the ACM 26(9), pp

    Ehud Shapiro (1983): The fifth generation project—a trip report . Communications of the ACM 26(9), pp. 637–641, doi:10.1145/358172.358179

    1983

  23. [29]

    ICOT Technical Report, TR-003

    Ehud Shapiro (1983): A subset of Concurrent Prolog and its interpreter. ICOT Technical Report, TR-003

    1983

  24. [30]

    In: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of Programming Languages , pp

    Ehud Shapiro (1984): Systems programming in concurrent prolog . In: Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of Programming Languages , pp. 93–105, doi:10.1145/800017.800520

    1984

  25. [31]

    I and II)

    Ehud Shapiro (1987): Concurrent Prolog: collected papers (Vols. I and II). MIT press

    1987

  26. [32]

    ACM Computing Surveys (CSUR) 21(3), pp

    Ehud Shapiro (1989): The family of concurrent logic programming languages . ACM Computing Surveys (CSUR) 21(3), pp. 413–510, doi:10.1145/72551.72555

    1989

  27. [33]

    The Journal of Logic Programming 6(3), pp

    Ehud Shapiro (1989): Or-parallel prolog in flat concurrent prolog. The Journal of Logic Programming 6(3), pp. 243–267, doi:10.1016/0743-1066(89)90016-2

    1989 doi

  28. [34]

    arXiv preprint arXiv:2112.13650

    Ehud Shapiro (2021): Multiagent Transition Systems: Protocol-Stack Mathematics for Distributed Comput- ing. arXiv preprint arXiv:2112.13650

    2021 arXiv

  29. [35]

    In: 37th International Symposium on Distributed Computing (DISC 2023)

    Ehud Shapiro (2023): Grassroots Distributed Systems: Concept, Examples, Implementation and Applications (Brief Announcement). In: 37th International Symposium on Distributed Computing (DISC 2023). (Extended version: arXiv:2301.04391), LIPICS, Italy, pp. 47:1, 47:7

    2023

  30. [36]

    In: OASIS ’23 , Association for Computing Machinery, doi:10.1145/3599696.3612898

    Ehud Shapiro (2023): Grassroots Social Networking: Serverless, Permissionless Protocols for Twitter/LinkedIn/WhatsApp . In: OASIS ’23 , Association for Computing Machinery, doi:10.1145/3599696.3612898

    2023

  31. [37]

    arXiv preprint arXiv:2202.05619

    Ehud Shapiro (2024): Grassroots Currencies: Foundations for Grassroots Digital Economies. arXiv preprint arXiv:2202.05619

    2024 arXiv

  32. [38]

    arXiv preprint arXiv:2511.03286

    Ehud Shapiro (2025): Characterising Global Platforms: Centralised, Decentralised, Federated, and Grass- roots. arXiv preprint arXiv:2511.03286

    2025 arXiv

  33. [40]

    Submitted

    Ehud Shapiro (2026): Child-Safe Social Networking. Submitted

    2026

  34. [41]

    arXiv:2603.13671

    Ehud Shapiro (2026): Grassroots Bonds as a Foundation for Market Liquidity. arXiv:2603.13671

    2026 arXiv

  35. [42]

    In: Proceedings of the 27th International Conference on Distributed Computing and Networking, pp

    Ehud Shapiro (2026): Grassroots Platforms with Atomic Transactions: Social Graphs, Cryptocurrencies, and Democratic Federations. In: Proceedings of the 27th International Conference on Distributed Computing and Networking, pp. 71–81, doi:10.1145/3772290.3772309. ArXiv preprint...

    2026

  36. [44]

    arXiv preprint arXiv:2601.17957

    Ehud Shapiro (2026): Types for Grassroots Logic Programs (Full version). arXiv preprint arXiv:2601.17957. Shapiro 133

    2026 arXiv

  37. [45]

    New Generation Computing 2(3), pp

    Ehud Shapiro & Colin Mierowsky (1984): Fair, biased, and self-balancing merge operators: Their spec- ification and implementation in Concurrent Prolog . New Generation Computing 2(3), pp. 221–240, doi:10.1007/BF03037058

    1984 doi

  38. [46]

    New Generation Computing 4(2), pp

    Ehud Shapiro & Shmuel Safra (1986): Multiway merge with constant delay in Concurrent Prolog . New Generation Computing 4(2), pp. 211–216, doi:10.1007/BF03037442

    1986 doi

  39. [47]

    New Gen- eration Computing 1(1), pp

    Ehud Shapiro & Akikazu Takeuchi (1983): Object oriented programming in Concurrent Prolog. New Gen- eration Computing 1(1), pp. 25–48, doi:10.1007/BF03037020

    1983 doi

  40. [48]

    Ehud Shapiro & Nimrod Talmon (2022): Foundations for Grassroots Democratic Metaverse. In: Proceed- ings of the 21st International Conference on Autonomous Agents and Multiagent Systems , AAMAS ’22, International Foundation for Autonomous Agents and Multiagent Systems, Richland...

    2022 doi

  41. [49]

    Communi- cations of the ACM 36(3), pp

    Ehud Shapiro & David HD Warren (1993): The 5th Generation Project: personal perspectives. Communi- cations of the ACM 36(3), pp. 47–49

    1993

  42. [50]

    In: Concurrent Prolog: Collected Papers, pp

    William Silverman, Michael Hirsch, Avshalom Houri & Ehud Shapiro (1988): The Logix system user manual Version 1.21. In: Concurrent Prolog: Collected Papers, pp. 46–77

    1988

  43. [51]

    Takeuchi & K

    A. Takeuchi & K. Furukawa (1987): Bounded Buffer Communication in Concurrent Prolog. In Ehud Shapiro, editor: Concurrent Prolog: Collected Papers, V olume 1, MIT Press, Cambridge, MA, pp. 464–475

    1987

  44. [52]

    arXiv preprint arXiv:2505.02208; also Proc

    Nimrod Talmon & Ehud Shapiro (2025): Grassroots Federation: Fair Democratic Governance at Scale . arXiv preprint arXiv:2505.02208; also Proc. of AAMAS’26

    2025 arXiv

  45. [53]

    E. D. Tribble, M. S. Miller, K. Kahn, D. G. Bobrow, C. Abbott & E. Shapiro (1987): Channels: A Gener- alization of Streams. In Ehud Shapiro, editor: Concurrent Prolog: Collected Papers, V olume 1, MIT Press, Cambridge, MA, pp. 446–463

    1987

  46. [54]

    Wikipedia, The Free Encyclopedia

    Ubique (1994): Ubique. Wikipedia, The Free Encyclopedia . Available at https://en.wikipedia.org/ wiki/Ubique_(company)

    1994

  47. [55]

    In: Logic Programming ’85 , Lecture Notes in Computer Science 221, Springer, pp

    Kazunori Ueda (1986): Guarded Horn Clauses. In: Logic Programming ’85 , Lecture Notes in Computer Science 221, Springer, pp. 168–179, doi:10.1007/3-540-16479-0 17

    1986 doi

  48. [56]

    Proceedings of TACS 2001, pp

    Kazunori Ueda (2001): Resource-passing concurrent programming. Proceedings of TACS 2001, pp. 95–126, doi:10.1007/3-540-45500-0 5

    2001 doi

  49. [57]

    New Generation Computing 12(4), pp

    Kazunori Ueda & Masao Morita (1994): Moded Flat GHC and Its Message-Oriented Implementation Tech- nique. New Generation Computing 12(4), pp. 337–368, doi:10.1007/BF03038307

    1994 doi

  50. [58]

    In: Proceed- ings of the International Symposium on Theory and Practice of Parallel Programming, Springer, pp

    Kazunori Ueda & Masao Morita (1995): I/O mode analysis in concurrent logic programming. In: Proceed- ings of the International Symposium on Theory and Practice of Parallel Programming, Springer, pp. 356–368, doi:10.1007/BFb0026579

    1995 doi

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.