Pith. sign in

REVIEW 2 major objections 5 minor 52 references

Volition Elicitation: Operational Semantics for People and Their Machines

T0 review · 2 major / 5 minor · reviewed 2026-08-02 · deepseek-v4-flash

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

Pith's one-line read vGLP makes a machine reduction wait on a person's volition and derives the app's UI from the pending guarded clauses.

desk verdict Volition as a first-class semantic object is genuinely new, and the UI derivation from pending reductions is the real contribution; but the liveness theorems hinge on an unproved transfer of Monotonicity, and the deployment is not reproducible. read the letter →

arxiv 2607.14138 v1 pith:VZITMUM2 submitted 2026-07-10 cs.PL cs.AIcs.DCcs.HCcs.MA

Ehud Shapiro This is my paper
classification cs.PLcs.AIcs.DCcs.HCcs.MA
keywords volition-guardedclausesoperationalsemanticsconcurrentlogicprogramminggrassrootsplatformsvolitionelicitationuserinterfacederivationmultiagenttransactionscommunicatingvolitionalagents
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

Volition-Guarded GLP (vGLP) extends the Grassroots Logic Programming language with clauses that can be reduced only when the person operating the machine wills the reduction. Its operational semantics, vmaGLP, models each agent as a person plus machine: the person's volitional state is separate from the machine's resolvent, and a Change-Volition transition is the person's private act, carrying no liveness obligation. On top of this, the paper derives the user interface from the semantics: a pending volition-guarded clause becomes a question, and the manifest maps each clause to a concrete UI construct — a compose form for self-initiated actions, an inbox card with buttons for offers. The paper proves volitional soundness, elicitation completeness, liveness for simple programs, that every Communicating Volitional Agent platform is realised by a vGLP program, and that the compilation to ordinary GLP with person grants is correct. If the framework holds together, UI design for grassroots platforms becomes a by-product of specifying guarded transactions.

What carries the argument

The load-bearing mechanism is the volition-guarded clause, a GLP clause prefixed by *(X1=T1,...,Xi=Ti, Y1?,...,Yj?): the X's are the question (the answers the person must supply), the Y?'s are the context (the values that define which offer or situation is being answered). The paper's semantics pairs each agent's machine resolvent with a volitional state, makes Reduce read that state, removes a volition exactly when its reduction is taken, and places Change-Volition outside the liveness obligation. The manifest then assigns each volition-guarded clause a UI construct — content is the context, fields are the question, buttons are the sibling clauses — giving a formal derivation of compose for

What would settle it

Exhibit a proper correct run of a simple vGLP program with the hypotheses of Theorem 4.11 satisfied — a unit goal whose instance is present at every step, a persisting volition for clause C, no volition of any preceding clause — yet no reduction with C or a preceding unit clause ever occurs, e.g. because an interleaved Communicate instantiates a context reader so that a later instance of the goal no longer reduces with C. Such a run would refute the Monotonicity transfer and with it the liveness claim.

Watch

Extended reading notes

Core claim

The paper's central claim is that human volition can be made a first-class ingredient of operational semantics rather than an external input stream. In vGLP, a volition-guarded clause has the form *(X=T, Y?), where X are the question variables whose answers constrain applicability and Y? the context that identifies the situation; the clause is reducible only if the person has a matching volition in their volitional state, and the reduction fulfils exactly that volition. The person's changes to the volitional state are Change-Volition transitions that lie outside the liveness equivalence, so the machine can never compel a will. From this, the paper derives the UI: pending volitions are precis

Load-bearing premise

The load-bearing premise is that Monotonicity (Proposition 3.11 of the companion GLP development) carries over from ordinary GLP runs to vGLP's extended resolvents; it is cited, not re-proved, and the liveness theorem and Remark 1 depend on it.

Editorial extensions

If this is right

  • If correct, UI code for grassroots social graph, social network, and currency apps can be generated from the guarded-transaction specification rather than hand-authored.
  • Every CVA platform maps to a vGLP program, so the semantics covers any grassroots protocol expressible in the CVA restriction.
  • A single GLP engine plus one interpreter can render multiple dynamically-loaded platforms, each contributing only a manifest.
  • The formalism gives a precise account of consent: a machine transaction is blocked until the person's will is expressed, and that expression is consumed by the transaction.
  • The compilation result means no new runtime is required; the existing GLP implementation plus a mediator and standard UI constructs is sufficient.

Reading between the lines

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

  • I infer that the same pending-question mechanism could serve as a specification for consent dialogs beyond grassroots platforms, such as data-sharing permissions or smart-contract approvals, where the property that a question stands until answered is exactly what regulators expect.
  • I infer that the semantics could be lifted to standing volitions — the paper lists them as future work — which would let a person pre-authorise a class of reductions and would require a more complex fulfilment rule than one-shot removal.
  • I infer that if the imported Monotonicity fails for vGLP's extended resolvents, the liveness theorem would need a separate proof; the soundness and completeness theorems, however, are proved directly and would survive.
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

2 major / 5 minor

Summary. The paper defines volition-guarded GLP (vGLP), an extension of Grassroots Logic Programs with clauses guarded by a person's volitions, and gives it an operational semantics vmaGLP in which each agent pairs a volitional state with a GLP resolvent. It proves conservativity over GLP, volitional soundness, liveness for a syntactic class of simple programs, the realisation of every Communicating Volitional Agent (CVA) platform by a simple vGLP program, elicitation completeness of the derived user-interface constructs, and correctness of a compilation of vGLP onto GLP with a person channel and a mediator. The paper also reports a deployed smartphone app in which three grassroots platforms are implemented as vGLP programs whose UI is derived from the manifest and whose agent/mediator compilation is said to be realized informally.

Significance. If the formal claims are correct, the paper offers a principled way to make a person's will a first-class semantic guard in a distributed logic programming language, and it derives UI constructs from the semantics rather than from an ad-hoc design process. The main contributions are the vmaGLP operational semantics, volitional soundness, elicitation completeness, the CVA realisation theorem, and the compilation theorem showing vGLP can be implemented on an existing GLP engine plus a per-platform mediator. The deployed app provides proof-of-concept evidence, though the AI-generation and deployment claims are informal and not independently reproducible from the anonymized submission. The paper has no fitted parameters and makes precise, falsifiable semantic claims, which are strengths. However, the proofs rely on an imported Monotonicity result that is not adapted to the volitional setting, and the headline claim that vmaGLP is an instance of CVA is not formally substantiated; both need attention before the central claims are fully established.

major comments (2)
  1. [Section 4.2, Theorem 4.11 proof (Appendix C)] The proof of Theorem 4.11 appeals to 'Monotonicity (Proposition 3.11)' to conclude that the first succeeding clause eventually becomes fixed. Proposition 3.11 is a theorem about proper cGLP runs, where Reduce always selects the first GLP-succeeding clause and no volitional state exists. In vmaGLP a volition-guarded clause can be skipped for lack of a matching volition, and Change-Volition can alter which volition-guarded reductions succeed, so the proposition does not formally transfer to vmaGLP's extended resolvents. The theorem's hypotheses (the volition for C persists, and no clause preceding C is willed) are strong enough to support a direct vGLP persistence argument: the first succeeding clause is either C or an ordinary unit clause preceding C, and in each case its success persists until an instance of A is reduced. But that argument is not given; the same unadapted appeal occurs i
  2. [Section 4.2, Definition 4.4 vs Section 2.5] The abstract and §4.2 state that vmaGLP is 'an instance of CVA'. Definition 4.4 defines local states as (V_p,(G_p,sigma_p)) and transitions Reduce/Communicate/Cold-call/Change-Volition. CVA (Definitions 2.13-2.15) has local states (known, outbox, inbox, platform state, date) and platform transactions that are unary, guarded by {p} or empty, with preconditions over that local state and effects that update the platform state and/or append outbox messages. GLP Reduce can perform arbitrary rewriting of the resolvent and spawn new goals, so it is not evident that every vmaGLP transition is a CVA platform transaction. Since no embedding is provided, the 'instance of CVA' claim is currently unsupported. The later formal results (Theorems 4.9, 4.11, 4.13, 5.3, 5.5) do not appear to depend on this identification, so either supply the embedding or explicitly describe vmaGLP as CVA-like rather than
minor comments (5)
  1. [References] Reference [41] is listed as 'Submitted, arXiv XXXX.XXXXX, 2026'; this placeholder must be replaced with a real identifier or removed before publication.
  2. [Definition 4.10] The term 'unit clause' is used in the definition of a simple program but is not defined in this paper. Please define it explicitly (e.g., a GLP clause with empty body and no guard) or cite the definition from [40].
  3. [Section 5.3] The deployed implementation is introduced with 'We claim, informally, that the composite realises the compilation.' This is acceptable as a feasibility report, but it should be clearly marked as separate from the formal Theorem 5.5 so that readers do not conflate the informal claim with the proved statement.
  4. [Definition 5.1] In the manifest definition, the bullet for 'fields' should state explicitly that anonymous writers become editable fields while ground T_l are used only as button labels. The current wording leaves the role of ground T_l implicit.
  5. [Appendix C] The proof of Theorem 5.5 is dense and would benefit from a high-level summary of the stutter/image mapping, perhaps a diagram showing how grants, mediator transitions, and agent reduces map to vcGLP transitions.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the derivations are formal translations and internal-consistency proofs; the imported GLP Monotonicity lemma is a correctness-transfer concern, not a circular reduction.

full rationale

The paper contains no fitted parameters, no empirical predictions, and no quantity that is estimated and then re-reported as a finding. vGLP is given a concrete operational semantics in Definition 4.4 rather than being defined as the thing it then proves. The realisation theorem (4.13) and compilation theorem (5.5) are explicit constructions with mappings supplied in Appendix C, so they do not reduce to their own statements. Theorem 5.3 (elicitation completeness) is true essentially because 'offered' is defined in terms of 'pending' (Definitions 5.1 and 5.2), but this is a sanity lemma of a formalisation, not a predicted external fact, and it does not carry the paper's central claims. The only external support that is load-bearing is Proposition 3.11 (Monotonicity), imported from the author's prior GLP work in Remark 1 and in the proof of Theorem 4.11. That lemma is parameter-free and concerns proper cGLP runs; whether it transfers to vmaGLP's volition-dependent clause selection is a genuine proof-gap / correctness risk, but it is not a circular equation of a conclusion with an input. The paper's central claims therefore do not reduce by construction to their own assumptions.

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

No fitted parameters. The central theory is built mostly from the author's prior GLP/CVA models; the volition construct and mediator are internal to the formalism and demonstration. Main external dependencies are imported theorems from self-cited prior work and unverifiable AI-generation/deployment claims.

assumptions (5)
  • domain assumption Monotonicity of proper cGLP runs (Proposition 3.11 of [40]) holds in vmaGLP resolvent transitions.
    Imported from prior self-authored GLP paper; used in Remark 1 and in proofs of Theorems 4.11, 4.13, and 5.5; not re-proved here.
  • domain assumption CVA is an implementation-ready restriction of volitional multiagent atomic transactions, and CVA platforms are grassroots by construction.
    Takes [18]'s CVA model and correctness framework as given; all realisation and compilation correctness statements are relative to it.
  • domain assumption A person's volitional state is a finite set of volitions of the form (clause, answer, context), changed only by Change-Volition transitions.
    Definitions 4.2 and 4.4; the entire elicitation semantics rests on this representation of human will.
  • domain assumption A machine cannot directly observe the person's volitional state; volitions must be elicited through the UI.
    Introduction and Section 5: 'Given today's technologies, the only way for a machine to know what's in a person's head is for the person to express it.' This motivates why an implementation must elicit volitions.
  • ad hoc to paper AI can faithfully generate the vGLP programs and their 'manual' compilations from the abstract transactions.
    Sections 6 and 7 assert AI generation and a deployed app; no artifact or audit is provided, only an informal claim.
invented entities (2)
  • Volition (C, theta, theta') as a first-class semantic object
    purpose: Models a person's willingness to reduce a specific clause with a specific answer and context; elicitation and fulfilment definitions operate on it.
    Internal formal device; no falsifiable handle outside the paper and no prediction of measurable behavior.
  • Mediator component in the compilation
    purpose: Escrows pending reductions, renders cards and forms, routes granted commands and answers between person and agent.
    Implementation artifact whose correctness is claimed informally for the deployed app and proven only for the canonical compilation; no independently accessible code.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Volition Elicitation: Operational Semantics for People and Their Machines." pith.science (2026). https://pith.science/paper/VZITMUM2

@misc{pith2026260714138,
  author       = {Pith},
  title        = {Pith review of: Volition Elicitation: Operational Semantics for People and Their Machines},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VZITMUM2}},
  note         = {Machine review of arXiv:2607.14138}
}
read the original abstract

The most prevalent distributed systems today include people and their personal machines (smartphones). In such systems, computations are driven by people's volitions: a payment when a person wishes to pay someone, befriending when two people wish to become friends, etc. Volition-Guarded Multiagent Atomic Transactions were proposed as an abstract specification language for such systems, in which each agent consists of a person and their machine, and a transaction can be guarded by both the machine states and the personal volitions of its participating agents. Here, we define the programming language volition-guarded GLP (vGLP), which extends GLP with volition-guarded clauses, and define its operational semantics as an instance of Communicating Volitional Agents. As the semantics requires the person to will a volition-guarded clause reduction, a correct implementation must elicit the person's volitions: finding out ``what's in the person's head'' is the sole rationale for the UI, which is realised accordingly by standard constructs. We demonstrate the approach on the grassroots social graph, social network, and currencies: each platform is a vGLP program, generated by AI from volition-guarded multiagent atomic transactions; the implementation of vGLP, also created by AI, then maps its volition-guarded clauses into the user-interface constructs, resulting in a single working app deployed on a physical smartphone.

Figures

Figures reproduced from arXiv: 2607.14138 by the authors.

Figure 1
Figure 1. The grassroots app: one app over three grassroots platforms, each a vGLP program rendered by a single Dart interpreter from its manifest, and each shown here by its panel (the screen) and one elicitation construct. Social graph: (1) the Friends panel — the friends list, with Charlie’s request pending; (2) the friend￾offer card — the respond clause’s Accept and Decline siblings, which elicit Befriend. Coins: (3) the … view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

52 extracted references · 10 linked inside Pith

  1. [1]

    Batongbacal, Stephen M

    Marc Abrams, Constantinos Phanouriou, Alan L. Batongbacal, Stephen M. Williams, and Jonathan E. Shuster. UIML: An appliance-independent XML user interface language. InProc. 8th Int. World Wide Web Conf. (WWW), 1999

    1999

  2. [2]

    Akiki, Arosha K

    Pierre A. Akiki, Arosha K. Bandara, and Yijun Yu. Adaptive model-driven user interface development systems.ACM Computing Surveys, 47(1):9:1–9:33, 2015

    2015

  3. [3]

    The Esterel synchronous programming language: Design, semantics, implemen- tation.Science of Computer Programming, 19(2):87–152, 1992

    Gérard Berry and Georges Gonthier. The Esterel synchronous programming language: Design, semantics, implemen- tation.Science of Computer Programming, 19(2):87–152, 1992

    1992

  4. [4]

    A unifying reference framework for multi-target user interfaces.Interacting with Computers, 15(3):289–308, 2003

    Gaëlle Calvary, Joëlle Coutaz, David Thevenin, Quentin Limbourg, Laurent Bouillon, and Jean Vanderdonckt. A unifying reference framework for multi-target user interfaces.Interacting with Computers, 15(3):289–308, 2003

    2003

  5. [5]

    Card, Thomas P

    Stuart K. Card, Thomas P. Moran, and Allen Newell. The keystroke-level model for user performance time with interactive systems.Communications of the ACM, 23(7):396–410, 1980

    1980

  6. [6]

    Card, Thomas P

    Stuart K. Card, Thomas P. Moran, and Allen Newell.The Psychology of Human-Computer Interaction. Lawrence Erlbaum Associates, 1983

    1983

  7. [7]

    FUDGETS: A graphical user interface in a lazy functional language

    Mats Carlsson and Thomas Hallgren. FUDGETS: A graphical user interface in a lazy functional language. InProceedings of the Conference on Functional Programming Languages and Computer Architecture (FPCA), pages 321–330. ACM, 1993

    1993

  8. [8]

    Atomic broadcast: From simple message diffusion to byzantine agreement.Information and Computation, 118(1):158–179, 1995

    Flaviu Cristian, Houtan Aghili, Ray Strong, and Danny Dolev. Atomic broadcast: From simple message diffusion to byzantine agreement.Information and Computation, 118(1):158–179, 1995

    1995

Show all 52 references
  1. [9]

    Asynchronous functional reactive programming for GUIs

    Evan Czaplicki and Stephen Chong. Asynchronous functional reactive programming for GUIs. InProceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 411–422. ACM, 2013

    2013

  2. [10]

    Dix.Formal Methods for Interactive Systems

    Alan J. Dix.Formal Methods for Interactive Systems. Computers and People Series. Academic Press, 1991

    1991

  3. [11]

    Duke and Michael D

    David J. Duke and Michael D. Harrison. Abstract interaction objects.Computer Graphics Forum, 12(3):25–36, 1993

    1993

  4. [12]

    Functional reactive animation

    Conal Elliott and Paul Hudak. Functional reactive animation. InProceedings of the 2nd ACM SIGPLAN International Conference on Functional Programming (ICFP), pages 263–273. ACM, 1997

    1997

  5. [13]

    Statecharts: A visual formalism for complex systems.Science of Computer Programming, 8(3):231–274, 1987

    David Harel. Statecharts: A visual formalism for complex systems.Science of Computer Programming, 8(3):231–274, 1987

    1987

  6. [14]

    J. M. E. Hyland and C.-H. Luke Ong. On full abstraction for PCF: I, II, and III.Information and Computation, 163(2):285–408, 2000

    2000

  7. [15]

    John and David E

    Bonnie E. John and David E. Kieras. The GOMS family of user interface analysis techniques: Comparison and contrast. ACM Transactions on Computer-Human Interaction, 3(4):320–351, 1996

    1996

  8. [16]

    Krishnaswami and Nick Benton

    Neelakantan R. Krishnaswami and Nick Benton. A semantic model for graphical user interfaces. InProceedings of the 16th ACM SIGPLAN International Conference on Functional Programming (ICFP), pages 45–57. ACM, 2011

    2011

  9. [17]

    Grassroots flash: A payment system for grassroots cryptocurrencies

    Andrew Lewis-Pye, Oded Naor, and Ehud Shapiro. Grassroots flash: A payment system for grassroots cryptocurrencies. arXiv preprint arXiv:2309.13191, 2023

    2023 arXiv

  10. [18]

    Volitional multiagent atomic transactions: Describing people and their machines

    Andy Lewis-Pye and Ehud Shapiro. Volitional multiagent atomic transactions: Describing people and their machines. arXiv preprint arXiv:2604.25596, 2026

    2026 arXiv

  11. [19]

    USIXML: A language supporting multi-path development of user interfaces

    Quentin Limbourg, Jean Vanderdonckt, Benoît Michotte, Laurent Bouillon, and Víctor López-Jaquero. USIXML: A language supporting multi-path development of user interfaces. InEngineering Human Computer Interaction and Interactive Systems (EHCI-DSVIS), volume 3425 ofLNCS, pages 2...

    2004

  12. [20]

    Ceptre: A language for modeling generative interactive systems

    Chris Martens. Ceptre: A language for modeling generative interactive systems. InProceedings of the Eleventh AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment (AIIDE), pages 51–57. AAAI Press, 2015

    2015

  13. [21]

    Cyrus Omar, Ian Voysey, Michael Hilton, Jonathan Aldrich, and Matthew A. Hammer. Hazelnut: A bidirectionally typed structure editor calculus. InProceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL), pages 86–99. ACM, 2017. 26 Ehud Shapiro

    2017

  14. [22]

    Philippe Palanque and Fabio Paternò, editors.Formal Methods in Human-Computer Interaction. FACIT. Springer, 1998

    1998

  15. [23]

    Palanque and Rémi Bastide

    Philippe A. Palanque and Rémi Bastide. Petri net based design of user-driven interfaces using the interactive cooperative objects formalism. InDesign, Specification and Verification of Interactive Systems (DSV-IS), pages 383–400. Springer, 1994

    1994

  16. [24]

    Springer, 2000

    Fabio Paternò.Model-Based Design and Evaluation of Interactive Applications. Springer, 2000

    2000

  17. [25]

    PhD thesis, Trinity College Dublin, 2004

    Richard Pawson.Naked Objects. PhD thesis, Trinity College Dublin, 2004

    2004

  18. [26]

    Wiley, 2002

    Richard Pawson and Robert Matthews.Naked Objects. Wiley, 2002

    2002

  19. [27]

    Rinus Plasmeijer, Peter Achten, and Pieter W. M. Koopman. iTasks: Executable specifications of interactive work flow systems for the web. InProceedings of the 12th ACM SIGPLAN International Conference on Functional Programming (ICFP), pages 141–152. ACM, 2007

    2007

  20. [28]

    Task-oriented programming in a pure functional language

    Rinus Plasmeijer, Bas Lijnse, Steffen Michels, Peter Achten, and Pieter Koopman. Task-oriented programming in a pure functional language. InProc. 14th Int. Symp. on Principles and Practice of Declarative Programming (PPDP), pages 195–206. ACM, 2012

    2012

  21. [29]

    Rao and Michael P

    Anand S. Rao and Michael P. Georgeff. BDI agents: From theory to practice. InProceedings of the First International Conference on Multiagent Systems (ICMAS), pages 312–319. The MIT Press, 1995

    1995

  22. [30]

    Formal grammar and human factors design of an interactive graphics system.IEEE Transactions on Software Engineering, 7(2):229–240, 1981

    Phyllis Reisner. Formal grammar and human factors design of an interactive graphics system.IEEE Transactions on Software Engineering, 7(2):229–240, 1981

    1981

  23. [31]

    The synthesizer generator

    Thomas Reps and Tim Teitelbaum. The synthesizer generator. InProc. ACM SIGSOFT/SIGPLAN Software Engineering Symp. on Practical Software Development Environments, pages 42–48, 1984

    1984

  24. [32]

    Safer smart contract programming with Scilla.Proceedings of the ACM on Programming Languages, 3(OOPSLA):1–30, 2019

    Ilya Sergey, Vaivaswatha Nagaraj, Jacob Johannsen, Amrit Kumar, Anton Trunov, and Ken Chan Guan Hao. Safer smart contract programming with Scilla.Proceedings of the ACM on Programming Languages, 3(OOPSLA):1–30, 2019

    2019

  25. [33]

    The family of concurrent logic programming languages.ACM Computing Surveys (CSUR), 21(3):413–510, 1989

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

    1989

  26. [34]

    Multiagent transition systems: Protocol-stack mathematics for distributed computing.arXiv preprint arXiv:2112.13650, 2021

    Ehud Shapiro. Multiagent transition systems: Protocol-stack mathematics for distributed computing.arXiv preprint arXiv:2112.13650, 2021

    2021 arXiv

  27. [35]

    Grassroots distributed systems: Concept, examples, implementation and applications (brief announce- ment)

    Ehud Shapiro. Grassroots distributed systems: Concept, examples, implementation and applications (brief announce- ment). In37th International Symposium on Distributed Computing (DISC 2023). (Extended version: arXiv:2301.04391), pages 47:1, 47:7, Italy, 2023. LIPICS

    2023

  28. [36]

    Grassroots social networking: Serverless, permissionless protocols for twitter/linkedin/whatsapp

    Ehud Shapiro. Grassroots social networking: Serverless, permissionless protocols for twitter/linkedin/whatsapp. In OASIS ’23. Association for Computing Machinery, 2023

    2023

  29. [37]

    A grassroots architecture to supplant global digital platforms by a global digital democracy

    Ehud Shapiro. A grassroots architecture to supplant global digital platforms by a global digital democracy. arXiv:2404.13468, Proceedings of DA WO’24, 2024

    2024 arXiv

  30. [38]

    Grassroots currencies: Foundations for grassroots digital economies.arXiv preprint arXiv:2202.05619, 2024

    Ehud Shapiro. Grassroots currencies: Foundations for grassroots digital economies.arXiv preprint arXiv:2202.05619, 2024

    2024 arXiv

  31. [39]

    Characterising global platforms: Centralised, decentralised, federated, and grassroots.arXiv preprint arXiv:2511.03286, 2025

    Ehud Shapiro. Characterising global platforms: Centralised, decentralised, federated, and grassroots.arXiv preprint arXiv:2511.03286, 2025

    2025 arXiv

  32. [40]

    Glp: A grassroots, multiagent, concurrent, logic programming language for ai (full version).arXiv preprint arXiv:2510.15747, Summary to appear in Proc

    Ehud Shapiro. 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, 2025

    2025 arXiv

  33. [41]

    Child-safe social networking.Submitted, arXiv XXXX.XXXXX, 2026

    Ehud Shapiro. Child-safe social networking.Submitted, arXiv XXXX.XXXXX, 2026

    2026

  34. [42]

    Grassroots bonds: A grassroots foundation for market liquidity.arXiv preprint arXiv:2603.13671, 2026

    Ehud Shapiro. Grassroots bonds: A grassroots foundation for market liquidity.arXiv preprint arXiv:2603.13671, 2026

    2026 arXiv

  35. [43]

    Grassroots platforms with atomic transactions: Social graphs, cryptocurrencies, and democratic federations

    Ehud Shapiro. Grassroots platforms with atomic transactions: Social graphs, cryptocurrencies, and democratic federations. InProceedings of the 27th International Conference on Distributed Computing and Networking, pages 71–81,

  36. [44]

    Implementing grassroots logic programs with multiagent transition systems and ai (full version)

    Ehud Shapiro. Implementing grassroots logic programs with multiagent transition systems and ai (full version). arXiv:2602.06934. Summary to appear in Proc. of LOPSTR+PPDP’26, 2026

    2026 arXiv

  37. [45]

    Types for grassroots logic programs (full version).arXiv preprint arXiv:2601.17957, 2026

    Ehud Shapiro. Types for grassroots logic programs (full version).arXiv preprint arXiv:2601.17957, 2026

    2026 arXiv

  38. [46]

    Foundations for grassroots democratic metaverse

    Ehud Shapiro and Nimrod Talmon. Foundations for grassroots democratic metaverse. InProceedings of the 21st International Conference on Autonomous Agents and Multiagent Systems, AAMAS ’22, page 1814–1818, Richland, SC,

  39. [47]

    TopHat: A formal foundation for task-oriented programming

    Tim Steenvoorden, Nico Naus, and Markus Klinik. TopHat: A formal foundation for task-oriented programming. In Proceedings of the 21st International Symposium on Principles and Practice of Programming Languages (PPDP), pages 17:1–17:13. ACM, 2019

    2019

  40. [48]

    Why interaction is more powerful than algorithms.Communications of the ACM, 40(5):80–91, 1997

    Peter Wegner. Why interaction is more powerful than algorithms.Communications of the ACM, 40(5):80–91, 1997

    1997

  41. [49]

    Springer, 2017

    Benjamin Weyers, Judy Bowen, Alan Dix, and Philippe Palanque, editors.The Handbook of Formal Methods in Human-Computer Interaction. Springer, 2017

    2017

  42. [50]

    Pierce, and Steve Zdancewic

    Li yao Xia, Yannick Zakowski, Paul He, Chung-Kil Hur, Gregory Malecha, Benjamin C. Pierce, and Steve Zdancewic. Interaction trees: Representing recursive and impure programs in Coq.Proceedings of the ACM on Programming Volition Elicitation 27 Languages, 4(POPL):51:1–51:32, 202...

    2020

  43. [2022]

    International Foundation for Autonomous Agents and Multiagent Systems

  44. [2026]

    arXiv preprint arXiv:2502.11299

Pith tools

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