Pith. sign in

REVIEW 3 major objections 5 minor 19 references

Stream programs are monoid homomorphisms with state

T0 review · 3 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read Stateful stream programs are exactly homomorphisms into a single State monoid, so stream-program optimization reduces to monoid algebra.

desk verdict The core decomposition and equational framework are correct and worth publishing; the title overstates the scope because the regularity conditions in Definition 3.14 do real work, but the paper is honest about that. read the letter →

arxiv 2507.10799 v1 pith:VPZN57AZ submitted 2025-07-14 cs.PL cs.DC

Tyler Hou , Michael Arntzenius , Max Willsey This is my paper · ORCID
classification cs.PLcs.DC
keywords streamprogrammingmonoidhomomorphismsstateincrementalcomputationdataflowoptimizationequationalreasoningfeedbackloopsdatabasejoins
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

Stream programs that consume inputs and produce outputs incrementally are often stateful, and statefulness is what keeps them from being ordinary monoid homomorphisms. This paper argues that a broad class of deterministic stream functions can nonetheless be represented exactly as homomorphisms into a single “state” monoid, whose elements are functions from a state set to an updated state plus an output. The representation splits every such program into a pure, stateless homomorphism followed by a final evaluation step, and it supports sequential, parallel, and feedback composition through the ordinary monoid laws. That matters for optimizers: database join fusion and partitioning, stratified negation with ticks, and a simplified TCP retransmission loop all become equational rewrites rather than bespoke program analyses.

What carries the argument

The load-bearing object is the State monoid $\mathrm{State}[S,M]$, whose elements are functions $S\to S\times M$; the monoidal product $\alpha\odot\beta$ runs $\alpha$ then $\beta$ on the evolving state and multiplies the two outputs in $M$. A stream processor is a tuple $(S,f,s_\varepsilon,o_\varepsilon)$ where $f:M\to\mathrm{State}[S,N]$ is a monoid homomorphism, $s_\varepsilon$ is an initial state, and $o_\varepsilon$ is an initial output. The decomposition theorem constructs $f$ from a stream function's update map, and the corollary $\sigma\sim\mathrm{pure}\,f;\mathrm{eval}_\sigma$ splits every processor into a stateless homomorphism followed by an evaluation. Around this object the paper assembles the rewrite rules that do the work: fusing a pure stage into a stateful stage, exchanging a post-processing homomorphism with an evaluation, splitting a processor across parallel inputs, and threading feedback through a loop.

What would settle it

To test the central equivalence, take any candidate stream function $F$ satisfying the regularity equations and compute its generic decomposition $f(m)=s\mapsto(s\cdot m,\Delta_F(s,m))$ with $S=M$; the claim says $f$ is always a homomorphism, so exhibiting inputs with $f(ab)\ne f(a)\odot f(b)$ would refute Theorem 3.21. The paper's own non-stratified set-difference function is a useful probe because it shows exactly where the equations fail when no such $\Delta_F$ exists.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that a stream function $F:M\to N$ is “stream” exactly when its incremental-update map $\Delta_F$ satisfies $F(pa)=F(p)\cdot\Delta_F(p,a)$ together with the regularity equations $\Delta_F(p,\varepsilon)=\varepsilon$ and $\Delta_F(p,ab)=\Delta_F(p,a)\cdot\Delta_F(pa,b)$. Theorem 3.21 shows that every such $F$ decomposes into an initial output $o_\varepsilon$ followed by the evaluation of a homomorphism $f:M\to\mathrm{State}[S,N]$ at an initial state, taking $S=M$ and $f(m)=s\mapsto(s\cdot m,\Delta_F(s,m))$ as the generic construction. Theorems 3.24 and 3.25 complete the circle: the functions computed by stream processors—homomorphisms into the State monoid with initial state and output—are exactly the stream functions. Sequential, parallel, and feedback composition all preserve this representation, so stateful dataflow can be reasoned about with homomorphism laws instead of the more intricate coherence conditions used by earlier semantic frameworks.

Load-bearing premise

The argument rests on the regularity premise that a program's incremental output for a whole batch equals the incremental output for the first piece followed by the incremental output for the rest, no matter how the batch is split; if that equation $\Delta_F(p,ab)=\Delta_F(p,a)\cdot\Delta_F(pa,b)$ fails, the constructed state functions are not a monoid homomorphism and the exact correspondence collapses.

Editorial extensions

If this is right

  • Every stream function in the framework gets a stream processor implementation with explicit state, so semantic proofs and implementations are interchangeable.
  • Optimizations like fusing a pure filter into a stateful join and partitioning a join across machines are valid equational rewrites, not heuristic transformations.
  • Homomorphisms are exactly the stateless processors, and every stateful processor factors as a pure homomorphism followed by an evaluation, giving a canonical decomposition for analysis.
  • Feedback loops have a stratified, deterministic semantics, making iterative computations such as Datalog fixed points and TCP-style retransmission amenable to the same laws.
  • State monoid elements can be represented as concrete data via defunctionalization or bounded static variation, so the framework is implementable rather than purely denotational.

Reading between the lines

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

  • A natural next step the authors do not spell out is to turn these laws into a complete normalization strategy: if every equational rewrite direction is oriented, any two equivalent processors should reduce to a common normal form that can serve as a canonical compiled implementation.
  • If the paper's concluding conjecture is right—that every function satisfying condition (1) can be extended to one satisfying regularity—the framework would cover all ordinary incremental functions, not just those over left-cancellative or idempotent output monoids.
  • The homomorphism-into-State view suggests a direct formal link between stream processing and incremental computation: the update map $\Delta_F$ behaves like a derivative with explicit state, so derivative-based optimization techniques might be expressible as monoid homomorphisms too.
  • A mechanized proof of Theorem 3.21 would give a verified core for an optimizing stream compiler, since every optimization in the paper is already stated as an equation between processor semantics.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper proposes a monoid-based semantic framework for deterministic stream programs. It defines stream functions as functions F : M -> N equipped with an update function Delta satisfying Eq. (1) plus regularity conditions (2a)-(2b). It defines stream processors as homomorphisms into the State monoid State[S,N] with an initial state and initial output, and proves (Theorems 3.21, 3.24, 3.25) that stream functions and stream processors denote exactly the same class of functions. The framework is then used to derive composition rules for sequential, parallel, and feedback composition, and is demonstrated on database join optimization, stratified negation, TCP, and on efficient representations via defunctionalization and bounded static variation.

Significance. If taken as a representation theorem for the regular class, the paper is a clean and useful contribution: it reduces stateful streaming semantics to the elementary laws of monoid homomorphisms, and the proofs of Theorems 3.21, 3.24, and 3.25 are fully given and correct. The composition transformations (fusion, exchange, parallelization, loop tightening) are attractive and are illustrated on realistic examples. The main caveat is that the advertised scope is broader than what is proved: the equivalence holds only for stream functions satisfying the regularity conditions, and the paper does not show that these conditions are benign for arbitrary output monoids. The TCP example also contains a type-level inconsistency with the loop definition. These issues are repairable, but they currently affect the paper's central framing and one of its three headline applications.

major comments (3)
  1. [Section 3.1, Definition 3.14 and Theorem 3.21] The regularity conditions (2a)-(2b) are load-bearing for the central representation theorem. In the proof of Theorem 3.21, f(m) = s -> (s.m, Delta(s,m)) is a monoid homomorphism exactly because of Eq. (2b); if a function satisfies Eq. (1) but has no regular refinement of Delta, the decomposition theorem and hence Expressive Completeness (Theorem 3.25) do not apply. The paper does not prove that every function satisfying the morally necessary condition (1) is regular: Propositions 3.15 and 3.16 cover only left-cancellative or idempotent image monoids, and Section 6 defers the general case to an unproved compactness conjecture. Therefore the unqualified title claim that stream programs are monoid homomorphisms with state is stronger than what is established. Please either prove the compactness claim or explicitly restrict the paper's claims to the regular class and adjust the title and abstract accordingly.
  2. [Section 3.9, Definition 3.71 and Proposition 3.75] There is a type mismatch in the TCP application. Definition 3.71 defines loop sigma : List[M] -> List[N] for sigma : M x U -> N x U, but Proposition 3.75 and the surrounding text use loop sigma : T[List[T]] -> List[T] and feed the single ticked input L topped with N ticks. Under the definition, one loop iteration consumes one element of the list, not one tick, so the proof's 'each round of loop sigma sends at least one message...' reasoning does not follow: a single batch L topped with N ticks is processed in one iteration, giving one output element, not N retransmission rounds. Please repair the TCP model, for example by defining a loop combinator over the ticked monoid in which ticks drive the rounds, or by feeding a list of batches and stating the output type and equality accordingly.
  3. [Section 3.8, Propositions 3.73 and 3.74] Proposition 3.73 (Left tightening) is stated without proof, with the comment that the proof is 'extremely similar' to Proposition 3.74, and Proposition 3.74 is only a proof sketch. These tightening rules are part of the claimed equational theory for feedback composition and are used to justify the usefulness of the loop operator. Please provide complete proofs or explicitly mark these as conjectures; if they are intended as lemmas, the proofs should be in the appendix.
minor comments (5)
  1. [Proposition 3.16] The proof of Proposition 3.16 says there are four cases and that the cases a = epsilon or b = epsilon are easy, then proceeds 'otherwise.' It does not handle the case a, b distinct from epsilon but ab = epsilon, which can occur when M has invertible elements. Please add this case or state an additional assumption (e.g., that M is a free monoid).
  2. [Propositions 3.15 and 3.16] The hypothesis 'Im(F) is a left-cancellative monoid' (and similarly for idempotent) is not well-defined unless the image of F is closed under the monoid operation and contains the identity. If the intended object is the submonoid generated by the image, the proofs cancel on Delta values that may lie outside that submonoid. Please state the assumption in terms of the output monoid N or the submonoid generated by the image, as appropriate.
  3. [Appendix, proof of Proposition 3.50] In the verification of condition (2b), the line '=(DeltaF(m,a), DeltaG(n,c))·( DeltaF(ma,b),·DeltaG(nc,d))' contains a misplaced dot before DeltaG; it should read '(DeltaF(ma,b), DeltaG(nc,d))'.
  4. [Appendix, proof of Proposition 3.49] The line '(f×g)((m2,g(m2)))' should be '(f×g)((m2, n2))'.
  5. [Section 3.1, after Example 3.18] The sentence 'if we define Delta_F by the generators of M for the second argument, then condition (2) is automatically satisfied' should explicitly say 'when M is a free monoid'; for arbitrary monoids, defining Delta on generators may not respect the relations.

Circularity Check

2 steps flagged · score 6.0 of 10

The central equivalence 'stream functions = monoid homomorphisms with state' is built into Definition 3.14: the regularity conditions (2a)–(2b) are exactly the State-monoid homomorphism laws, so Theorems 3.21 and 3.25 restate the definition rather than derive it.

  1. self definitional [Theorem 3.21 (proof), Definition 3.14, Section 3.1]
    "f(ab) = s↦(sab, Δ_F(s,ab)) = s↦(sab, Δ_F(s,a)·Δ_F(sa,b)) (by Eq. (2b) from Definition 3.14) = (s↦(sa, Δ_F(s,a)))⊙(s↦(sb, Δ_F(s,b))) = f(a)⊙f(b). ... We need it for a step in the (constructive) proof of Theorem 3.21, which constructs a stream processor from a stream function. Morally, condition (1) is the only condition we need for a function to be a stream function."

    The homomorphism conclusion f(ab) = f(a)⊙f(b) is condition (2b) restated in State-monoid notation: expanding ⊙ gives (s·ab, Δ_F(s,ab)) = (s·ab, Δ_F(s,a)·Δ_F(sa,b)), which is (2b) verbatim, and identity preservation is (2a) verbatim. The theorem that every stream function decomposes into a homomorphism into State is thus the definition of stream function unfolded through the construction S = M, f(m) = s↦(s·m, Δ_F(s,m)). The paper concedes the conditions were added for a step in the constructive proof of Theorem 3.21 and that condition (1) is morally the only necessary one.

  2. self definitional [Theorem 3.25 (proof), Definition 3.22, Section 5.1]
    "Morally, condition (1) is the only condition we need for a function to be a stream function. ... Theorem 3.25 (Expressive Completeness) ... Proof. This is really a restatement of Theorem 3.21 on the decomposition of stream functions. ... However, our definitions are stricter than Mamouras’, because we impose Alvarez-Picallo’s regularity conditions [p. 27, defn. 3.1.3; our Eqs. (2a)–(2b)]. This lets us replace Mamouras’ complex coherence conditions [p. 14, defn. 20] with the well-known monoid homomorphism laws."

    The claimed coincidence of semantics and syntax is the same equation in both directions: Expressive Soundness derives conditions (2a)–(2b) for a processor’s semantics from the homomorphism law of f (Lemma 3.27), and the decomposition derives the homomorphism law from (2a)–(2b). Expressive Completeness is declared a restatement of Theorem 3.21. Section 5.1 confirms the design direction: imposing the regularity conditions is what lets the authors replace Mamouras’ coherence conditions with monoid homomorphism laws. The title’s identity therefore holds for a class defined to make it true; functions satisfying only condition (1) are excluded, and the compactness conjecture of Section 6 that would close this gap is unproven.

full rationale

The paper’s central equivalence (Theorems 3.21, 3.24, 3.25) is self-definitional: Definition 3.14 defines a stream function as a function with an update function Δ satisfying conditions (2a)–(2b), and those conditions are exactly the identity-preserving and product-preserving laws for the map f(m) = s↦(s·m, Δ_F(s,m)) into the State monoid. The proof of Theorem 3.21 invokes (2b) literally to conclude that f is a homomorphism, and the paper admits the regularity was imposed for that proof and that condition (1) is morally the only one needed. This is a definition-chosen-to-match-the-theorem structure, not a derived characterization of a pre-existing class. The circularity is partial, not total. Substantial content is genuinely derived: Propositions 3.15–3.16 prove that condition (1) implies regularity for left-cancellative or idempotent image monoids; the functoriality of sequential, parallel, and feedback composition (Propositions 3.32, 3.52, 3.72) and the fusion/exchange rules (3.36, 3.42, 3.43) are real equational consequences; and the join-partitioning correctness proof (Theorem 3.63) is a genuine application that would stand even if the central equivalence were conceded to be definitional. No self-citation is load-bearing; the regularity conditions are imported from Alvarez-Picallo and Ong (2019), an external source. The unproven compactness conjecture of Section 6 is a coverage gap, honestly flagged by the authors, not an additional circular step. Because the headline claim reduces by construction while the applications and compositional laws remain independently verified, the score is 6.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The framework introduces no fitted parameters and no new physical or mathematical entities. It relies on standard monoid theory, on the choice of deterministic stream functions as the object of study, and on the regularity conditions as a definitional assumption that delimits the class of stream functions covered.

assumptions (4)
  • domain assumption Stream types are monoids with an associative product and identity.
    The entire formalism is built on monoids (Definition 3.1); for example, streams as lists under append, sets under union, and Z-sets. This excludes stream types that do not form a monoid in the intended way.
  • domain assumption Stream functions are deterministic and total.
    Definition 3.14 defines a stream function F:M→N as a function, so every input yields exactly one output. The paper explicitly restricts to deterministic stream programs.
  • domain assumption The regularity conditions (2a)-(2b) hold for the chosen update function Δ.
    Eqs. (2a)-(2b) are imposed in Definition 3.14; they are exactly what makes the State-monoid homomorphism construction work in Theorem 3.21. The paper shows they follow automatically from Eq. (1) when Im(F) is left-cancellative or idempotent (Propositions 3.15-3.16), but not in general.
  • ad hoc to paper In the TCP example, each packet p_i is eventually delivered after t_i rounds by net1 and net2.
    Used in Proposition 3.75's proof sketch to bound the number of rounds by Σt_i + 1. This liveness assumption is specific to the example and is not part of the general framework.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Stream programs are monoid homomorphisms with state." pith.science (2026). https://pith.science/paper/VPZN57AZ

@misc{pith2026250710799,
  author       = {Pith},
  title        = {Pith review of: Stream programs are monoid homomorphisms with state},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VPZN57AZ}},
  note         = {Machine review of arXiv:2507.10799}
}
read the original abstract

We define a broad class of deterministic stream functions and show they can be implemented as homomorphisms into a "state" monoid. The homomorphism laws are simpler than the conditions of previous semantic frameworks for stream program optimization, yet retain support for rich equational reasoning over expressive dataflow programs, including sequential composition, parallel composition, and feedback. We demonstrate this using examples of partitioned database joins, stratified negation, and a simplified model of TCP.

Figures

Figures reproduced from arXiv: 2507.10799 by the authors.

Figure 1
Figure 1. Condition (3) for 𝑃, a concrete representation of Im(𝑓 ) We say then that Im(𝑓 ) embeds into 𝑃. Then, concrete implementations can manipulate and send elements of 𝑃 over the network. In most cases, given access to the source code of 𝑓 , we can construct 𝑃 using traditional compiler techniques. We demonstrate this by example. Example 4.1 (Full adder). Let 𝐵 = {0, 1} be bits. Let 𝜎 : List[𝐵 × 𝐵] { List[𝐵] = (𝐵, 𝑓 , 0,… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

19 extracted references · 14 canonical work pages

  1. [3]

    Change Actions: Models of Generalised Differentiation. In Foundations of Software Science and Computation Structures - 22nd International Conference, FOSSACS 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2019, Prague, Czech Republic, April 6-11, 2019, Proceedings (Lecture Notes in Computer Science, Vol. 114...

    work page doi:10.1007/978-3-030-17127-8_3 2019

  2. [10]

    Stream Types. Proc. ACM Program. Lang. 8, PLDI (2024), 1412–1436. doi:10.1145/3656434 Jeffrey Dean and Sanjay Ghemawat

    work page doi:10.1145/3656434 2024

  3. [12]

    Incremental𝜆-Calculus in Cache-Transfer Style: Static Memoization by Program Transformation. In Programming Languages and Systems - 28th European Symposium on Programming, ESOP 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2019, Prague, Czech Republic, April 6-11, 2019, Proceedings (Lecture Notes in Compute...

    doi:10.1007/978-3-030-17184-1_20 2019

  4. [14]

    Flo: A Semantic Foundation for Progressive Stream Processing. Proc. ACM Program. Lang. 9, POPL (2025), 241–270. doi:10.1145/3704845 Yanhong A. Liu

    doi:10.1145/3704845 2025

  5. [15]

    Incremental Computation: What Is the Essence? (Invited Contribution). In Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation, PEPM 2024, London, UK, 16 January 2024, Gabriele Keller and Meng Wang (Eds.). ACM, 39–52. doi:10.1145/3635800.3637447 Yanhong A. Liu and Tim Teitelbaum

    work page arXiv 2024

  6. [17]

    Semantic Foundations for Deterministic Dataflow and Stream Processing. In Programming Languages and Systems - 29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings (Lecture Notes in Computer Science, Vol. 12075), Pete...

    work page doi:10.1007/978-3-030-44914-8_15 2020

  7. [39]

    doi:10.1007/S00778-025-00922-Y David C. Y. Chu, Rithvik Panchapakesan, Shadaj Laddad, Lucky E. Katahanas, Chris Liu, Kaushik Shivakumar, Natacha Crooks, Joseph M. Hellerstein, and Heidi Howard

    doi:10.1007/s00778-025-00922-y

  8. [1972]

    In Proceedings of the ACM annual conference, ACM 1972, 1972, Volume 2 , John J

    Definitional interpreters for higher-order programming languages. In Proceedings of the ACM annual conference, ACM 1972, 1972, Volume 2 , John J. Donovan and Rosemary Shields (Eds.). ACM, 717–740. doi:10.1145/ 800194.805852 Tiark Rompf and Kevin J. Brown

    work page arXiv 1972

Show all 19 references
  1. [1995]

    In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, La Jolla, California, USA, June 21-23, 1995, Neil D

    Caching Intermediate Results for Program Improvement. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, La Jolla, California, USA, June 21-23, 1995, Neil D. Jones (Ed.). ACM Press, 190–201. doi:10.1145/215465.215590 Kon...

    1995

  2. [2000]

    Generalising monads to arrows. Sci. Comput. Program. 37, 1-3 (2000), 67–111. doi:10.1016/S0167- 6423(99)00023-4 Neil D Jones, Carsten K Gomard, and Peter Sestoft

    2000 doi

  3. [2004]

    In 6th Symposium on Operating System Design and Implementation (OSDI 2004), San Francisco, California, USA, December 6-8, 2004 , Eric A

    MapReduce: Simplified Data Processing on Large Clusters. In 6th Symposium on Operating System Design and Implementation (OSDI 2004), San Francisco, California, USA, December 6-8, 2004 , Eric A. Brewer and Peter Chen (Eds.). USENIX Association, 137–150. http://www.usenix.org/ev...

    2004

  4. [2010]

    In Datalog Reloaded - First International Workshop, Datalog 2010, Oxford, UK, March 16-19,

    Dedalus: Datalog in Time and Space. In Datalog Reloaded - First International Workshop, Datalog 2010, Oxford, UK, March 16-19,

    2010

  5. [2017]

    In Proceedings of the 2017 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (Paris, France) (PEPM 2017)

    Functional parallels of sequential imperatives (short paper). In Proceedings of the 2017 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation (Paris, France) (PEPM 2017). Association for Computing Machinery, New York, NY, USA, 83–88. doi:10.1145/3018882.3018891 ...

    2017

  6. [2019]

    Fixing incremental computation: Derivatives of fixpoints, and the recursive semantics of Datalog. In Programming Languages and Systems - 28th European Symposium on Programming, ESOP 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS ...

    2019 doi

  7. [2020]

    Change actions: from incremental computation to discrete derivatives . Ph. D. Dissertation. University of Oxford. arXiv:2002.05256 https://arxiv.org/abs/2002.05256 Mario Alvarez-Picallo, Alex Eyers-Taylor, Michael Peyton Jones, and C.-H. Luke Ong

    2002 arXiv

  8. [2023]

    DBSP: Automatic Incremental View Maintenance for Rich Query Languages. Proc. VLDB Endow. 16, 7 (2023), 1601–1614. doi:10.14778/3587136.3587137 26 Tyler Hou, Michael Arntzenius, and Max Willsey Mihai Budiu, Leonid Ryzhyk, Gerd Zellweger, Ben Pfaff, Lalith Suresh, Simon Kassing,...

    2023

  9. [2024]

    Optimizing Distributed Protocols with Query Rewrites. Proc. ACM Manag. Data 2, 1 (2024), 2:1–2:25. doi:10.1145/3639257 Joseph W. Cutler, Christopher Watson, Emeka Nkurumeh, Phillip Hilliard, Harrison Goldstein, Caleb Stanford, and Ben- jamin C. Pierce

    2024 doi

  10. [2025]

    DBSP: automatic incremental view maintenance for rich query languages. VLDB J. 34, 4 (2025),

    2025

  11. [6702]

    Springer, 262–281

    , Oege de Moor, Georg Gottlob, Tim Furche, and Andrew Jon Sellers (Eds.). Springer, 262–281. doi:10.1007/978-3-642-24206-9_16 Mihai Budiu, Tej Chajed, Frank McSherry, Leonid Ryzhyk, and Val Tannen

    doi

Pith tools

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