betaFeedback

WorksComputer Science

Probabilistic Simple Types for Almost-Sure Termination (Extended Version)

Abstract

We present a type system for almost-sure termination (AST) in higher-order probabilistic computation. Our vehicle is the recent Functional Machine Calculus (FMC), which combines the lambda-calculus with effectful imperative computation. Importantly for our purpose, it models branching and looping computation with sum types and a typed iterator construct. Our key observation is that by replacing sum types with probability distributions, types ensure that iteration has a non-zero chance of exiting, which then gives AST in a simple and natural way. Concretely, our type system assigns explicit probability distributions to termination outcomes, allowing probabilistic behaviour to be tracked compositionally at the type level. Types then soundly guarantee almost-sure termination, even in the presence of higher-order functions. The fragment of ground terms, which consists purely of the branching and iteration constructs with probabilistic sampling, is equivalent to finite Markov chains and is positively AST (expected evaluation time is finite). The full calculus is more expressive, which we demonstrate through an example term with infinite expected evaluation time.

2012 ACM Subject Classification Theory of computation →\rightarrow Lambda calculus; Theory of computation →\rightarrow Probabilistic computation

Keywords and phrases probabilistic lambda-calculus, type systems, almost-sure termination

Acknowledgements We thank Georgina Majury for her efforts on a precursor to this work, and the anonymous referees for their comments, in particular those leading to the observations in § 10.

Introduction

We are interested in applying the toolset of the λ\lambda-calculus, in particular confluent reduction and type systems, to probabilistic computation. In [12] we restored confluence to a probabilistic λ\lambda-calculus, the probabilistic event λ\lambda-calculus (PEL), by decomposing probabilistic choice into a sampling construct and a conditional. Then in [1] and [26], from different inspirations we converged on essentially the same probabilistic type system for the PEL to give lower bounds on the probability of termination. In this paper we further extend the calculus, and develop a type system for almost-sure termination (AST): termination with probability one. In doing so, our objective differs from that of many existing works in this area, which aim to capture as many AST programs as possible [11, 10], or even to study the feasibility of capturing all such programs [28]. Instead, we seek to understand the extent to which almost-sure termination can be obtained and explained in a natural manner, possibly using well-established methods, and guaranteed by a minimal extension to simple types. More powerful methods such as dependent types and intersection types may later build on this along standard lines.

We start from the following observation. Iteration, generally represented by while-loops, repeats a given function ff until a condition is fulfilled. In the typed case, illustrated below, the function ff is required to return a sum B+AB + A, where the choice between returning a value AA or BB represents the condition. Then iter⁡f\operatorname{iter} f evaluates ff, exits on BB, and repeats on AA [6].

f:A→B+Aiter⁡f:A→B\frac{f:A\to B+A}{\operatorname{iter} f:A\to B}

With the above rule, as with typed fixed-point combinators, typing no longer guarantees termination. However, we observe that if we replace B+AB+A by a probabilistic sum B⊕pAB\mathbin{\oplus_p}A with a fixed probability p∈(0,1]p\in(0,1], i.e. the probability of choosing BB is non-zero and does not depend on the input, then iter⁡f\operatorname{iter} f is almost-surely terminating (provided of course that ff is itself terminating). This opens a way to approach almost-sure termination via type systems. A crucial question arises: how can we handle a type constructor such as B⊕pAB\mathbin{\oplus_p}A within a λ\lambda-calculus with probabilistic choice in a compositional and elegant manner?

These considerations illustrate how probabilistic choice is connected to other imperative features such as sequentiality and iteration. Derived from the PEL, the second author has developed a new approach to unifying the λ\lambda-calculus with imperative computation and effects, the Functional Machine Calculus (FMC) [24]. Its most recent instance [25] features branching sequential computation and iteration, providing an ideal vehicle for our present study. In the FMC each branch of the computation is labelled with a choice label i,j,k,…i,j,k,\ldots, which takes the rôle of a constant, an exception, a case label, or an exit status. For example, the boolean constants ⊥\bot and ⊤\top are choice labels. Iteration of a term MM is written MiM^i, which evaluates MM and repeats if MM chooses ii, terminating for any other choice. The calculus encodes a fair probabilistic choice, which we write as M⊕NM\mathbin{\oplus}N.

Example 1 (Bernoulli Factory). The term (h⊕(t⊕i))i(h\mathbin{\oplus}(t\mathbin{\oplus}i))^i chooses heads, the choice hh, with probability 12\frac{1}{2}, tails tt with probability 14\frac{1}{4}, and iterates with probability 14\frac{1}{4}, to give an overall probability of 23\frac{2}{3} for hh and 13\frac{1}{3} for tt. We illustrate it as follows; it will remain a running example.

(h⊕(t⊕i))i=(h\mathbin{\oplus}(t\mathbin{\oplus}i))^i=

Figure 5.

The type system we introduce in this paper, simplified for this introduction to omit inputs and return values, records the probability of terminating with each given choice. A term MM is typed as follows, indicating that it may choose iki_k with probability pkp_k from the choices i1i_1 through ini_n. For simplicity, we restrict ourselves to rational probabilities, p,q∈[0,1]∩Qp,q\in[0,1]\cap\mathbb{Q}.

M:p1i1⊕⋯⊕pninM:p_1i_1\mathbin{\oplus}\cdots\mathbin{\oplus}p_ni_n

The type is a probability (sub-)distribution over the choices {i1,…,in}\{i_1,\ldots,i_n\}, written as a formal sum. If the sum probability over p1p_1 through pnp_n is one, the term is AST. For greater generality, and since our formalism readily incorporates it, we allow probabilities to sum to less than one, with the remainder representing an upper bound to the probability of divergence. We note here that, as a λ\lambda-calculus, the full calculus will have two means of non-termination: iteration with probability one, and higher-order non-terminating terms such as Ω=(λx.xx)(λx.xx)\Omega=(\lambda x.xx)(\lambda x.xx). The type system will address both, and a term is almost-surely terminating if the sum probability of its type is exactly one.

Example 2. The body of our example term, without the loop, has the following type.

h⊕(t⊕i):12h⊕14t⊕14ih\mathbin{\oplus}(t\mathbin{\oplus}i):\frac{1}{2}h\mathbin{\oplus}\frac{1}{4}t\mathbin{\oplus}\frac{1}{4}i

Iteration MiM^i removes the choice ii from the possible return choices. In the probabilistic setting, the remaining probabilities must then be renormalized to form a distribution. That is, if ii has probability qq (with q<1q < 1), the remaining choices (including divergence) have a total probability of 1−q1-q, and must be multiplied by 11−q\frac{1}{1-q} to return the total to one. Typing for iteration is then as follows.

M:p1i1⊕⋯⊕pnin⊕qjMj:p11−qi1⊕⋯⊕pn1−qin\begin{aligned} M &: p_1i_1 \oplus\cdots\oplus p_ni_n \oplus qj\\ M^j &: \frac{p_1}{1-q}i_1 \oplus\cdots\oplus\frac{p_n}{1-q}i_n \end{aligned}

▶ Example 3. The type for our example term is given by taking the type 12h⊕14t⊕14i\frac{1}{2}h \oplus\frac{1}{4}t \oplus\frac{1}{4}i of the body of the loop, removing the element 14i\frac{1}{4}i, and then multiplying the remaining sub-distribution 12h⊕14t\frac{1}{2}h \oplus\frac{1}{4}t by 43\frac{4}{3} to renormalize it, which yields the following.

(h⊕(t⊕i))i:23h⊕13t(h \oplus(t \oplus i))^i : \frac{2}{3}h \oplus\frac{1}{3}t

Types for iteration then correctly give the probabilities for each choice. Consider MjM^j where jj has probability qq in MM. For any other choice ii with probability pp in MM the chance of MjM^j choosing ii is given by the following geometric series, generated by choosing ii immediately, after one iteration, after two iterations, and so forth. The limit of this series is the probability given by the type system.

p+pq+pq2+pq3+⋯=p1−qp + pq + pq^2 + pq^3 + \cdots= \frac{p}{1-q}

Typed Term Calculus for Finite Markov Chains

Further introducing the calculus, we first consider the fragment of ground terms, as follows:

Ground terms:M,N::=i∣M ; i→N∣Mi∣a.a\textit{Ground terms:}\qquad M, N ::= i \mid M\,;\,i\to N \mid M^i \mid\boxed{a}.a

The first three are the control constructs, introduced in [25], which implement branching and iterating computation. The first (a choice ii) and the third (a loop MiM^i), we have seen. The second is a case M ; i→NM\,;\,i\to N which first evaluates MM, and if MM terminates with ii then continues with NN, otherwise discarding it. The control constructs reduce by the following rules:

i ; i→M  →  Mj ; i→M  →  j(i≠j)Mi  →  M ; i→Mii\,;\,i\to M \;\to\; M \qquad j\,;\,i\to M \;\to\; j\quad(i\ne j) \qquad M^i \;\to\; M\,;\,i\to M^i

These constructions generalise sequential computation, which uses a single choice ⋆\star, with imperative skip as ⋆\star and sequencing as M ; N=M ; ⋆→NM\,;\,N = M\,;\,\star\to N. The choice and case constructs are essentially throw and try/catch of exception handling, with exceptions ee as choices:

throw⁡ e=etry⁡ M catch⁡ e N=M ; e→N\operatorname{throw}\ e = e \qquad \operatorname{try}\ M\ \operatorname{catch}\ e\ N = M\,;\,e\to N

Since cases are fall-through, they may be iterated to give a standard case switch. A conditional then encodes as below, where cases associate left, M ; i→N ; j→P=(M ; i→N) ; j→PM\,;\,i\to N\,;\,j\to P = (M\,;\,i\to N)\,;\,j\to P. We do need to keep constants (⊤,⊥)(\top,\bot) and exceptions (e)(e) apart: for the conditional below, if MM were to use ⊥\bot as an exception, it would be caught by NN. A while-loop, below that, is as follows: if BB returns ⊥\bot, then MM is skipped, the loop exited, and ⊥\bot caught to return ⋆\star (success); if BB returns ⊤\top, then MM is evaluated, iterating upon ⋆\star.

if⁡ B then⁡ M else⁡ N=B ; ⊤→M ; ⊥→N\operatorname{if}\ B\ \operatorname{then}\ M\ \operatorname{else}\ N = B\,;\,\top\to M\,;\,\bot\to N
while⁡ B do⁡ M=(B ; ⊤→M)∗ ; ⊥→⋆\operatorname{while}\ B\ \operatorname{do}\ M = (B\,;\,\top\to M)^*\,;\,\bot\to\star

The fourth construct a.M\boxed{a}.M is the generator a.M\boxed{a}.M of the probabilistic event λ\lambda-calculus [12] restricted to a variable aa. The generator reduces as below: it flips a coin and binds the result, ⊤\top or ⊥\bot, to the variable aa in MM.

a.M→{⊤/a}M⊕{⊥/a}M\boxed{a}.M \mathbin{\to} \{\top/a\}M \mathbin{\oplus} \{\bot/a\}M

The restricted construct a.a\boxed{a}.a thus reduces to ⊤\top or ⊥\bot with equal probability. Using it, a probabilistic sum encodes as follows.

M⊕N=a.a;⊤→M;⊥→NM \mathbin{\oplus} N = \boxed{a}.a;\top\mathbin{\to}M;\bot\mathbin{\to}N

Example 4. Our running example term unfolds as a ground term as follows.

(h⊕(t⊕i))i=(a.a;⊤→h;⊥→(b.b;⊤→t;⊥→i))i(h\mathbin{\oplus}(t\mathbin{\oplus}i))^{i} = (\boxed{a}.a;\top\mathbin{\to}h;\bot\mathbin{\to}(\boxed{b}.b;\top\mathbin{\to}t;\bot\mathbin{\to}i))^{i}

Remark 5. The generator a.M\boxed{a}.M represents a fair coin toss, with equal probability for ⊤\top and ⊥\bot. We write ap.M\boxed{a}_{p}.M for an unfair coin with probability pp for ⊤\top and 1−p1-p for ⊥\bot. This may either be considered a primitive construct generalising a.M\boxed{a}.M, or constructed from fair coin tosses with iteration in the way our running example term generates 23\frac{2}{3} and 13\frac{1}{3}.

We now turn to types. Deterministic types for the control constructs record the possible terminating choices for a term, as is standard for exception handling. Types are finite sets of choices, written as formal sums I=i1+⋯+inI=i_1+\cdots+i_n; semantically, these are coproducts. We have the following typing rules:

i:i+IM:I+iN:JM;i→N:I∪JM:I+iMi:I\begin{aligned} &i:i+I && M:I+i \qquad N:J && M; i\mathbin{\to}N:I\cup J \qquad M:I+i && M^i:I \end{aligned}

References

  1. [1]Melissa Antonelli, Ugo Dal Lago, and Paolo Pistone. Curry and Howard meet Borel. In Proceedings of the 37th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS’22), pages 45:1–45:13. ACM, 2022. doi:10.1145/3531130.3533361.DOI
  2. [2]Martin Avanzini, Gilles Barthe, and Ugo Dal Lago. On continuation-passing transformations and expected cost analysis. Proc. ACM Program. Lang., 5(ICFP):1–30, 2021. doi:10.1145/3473592.DOI
  3. [3]Martin Avanzini, Ugo Dal Lago, and Alexis Ghyselen. Type-based complexity analysis of probabilistic functional programs. In 34th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS, pages 1–13. IEEE, 2019. doi:10.1109/LICS.2019.8785725.DOI
  4. [4]Gilles Barthe, Justin Hsu, and Kevin Liao. A probabilistic separation logic. Proc. ACM Program. Lang., 4(POPL):55:1–55:30, 2020. doi:10.1145/3371123.DOI
  5. [5]Raven Beutner and Luke Ong. On probabilistic termination of functional programs with continuous distributions. In Stephen N. Freund and Eran Yahav, editors, Proceedings 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation (PLDI), pages 1312–1326. ACM, 2021. doi:10.1145/3453483.3454111.DOI
  6. [6]Stephen L. Bloom and Zoltán Ésik. Iteration Theories - The Equational Logic of Iterative Processes. EATCS Monographs on Theoretical Computer Science. Springer, 1993. doi:10.1007/978-3-642-78034-9.DOI
  7. [7]Flavien Breuvart, Ugo Dal Lago, and Agathe Herrou. On higher-order probabilistic subrecursion. Log. Methods Comput. Sci., 17(4), 2021. doi:10.46298/LMCS-17(4:25)2021.DOI
  8. [8]Raphaëlle Crubillé, Thomas Ehrhard, Michele Pagani, and Christine Tasson. The free exponential modality of probabilistic coherence spaces. In Javier Esparza and Andrzej S. Murawski, editors, Foundations of Software Science and Computation Structures - 20th International Conference, FOSSACS 2017, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2017, Uppsala, Sweden, April 22-29, 2017, Proceedings, volume 10203 of Lecture Notes in Computer Science, pages 20–35, 2017. doi:10.1007/978-3-662-54458-7\_2.DOI
  9. [9]Fredrik Dahlqvist and Dexter Kozen. Semantics of higher-order probabilistic programs with conditioning. Proceedings of the ACM on Programming Languages, 4(POPL):57:1–57:29, 2020. doi:10.1145/3371125.DOI
  10. [10]Ugo Dal Lago, Claudia Faggian, and Simona Ronchi Della Rocca. Intersection types and (positive) almost-sure termination. Proceedings of the ACM on Programming Languages, 5(POPL):1–32, 2021. doi:10.1145/3434313.DOI
  11. [11]Ugo Dal Lago and Charles Greliois. Probabilistic termination by monadic affine sized typing. ACM Trans. Program. Lang. Syst., 41(2):10:1–10:65, 2019. doi:10.1145/3293605.DOI
  12. [12]Ugo Dal Lago, Giulio Guerrieri, and Willem Heijltjes. Decomposing probabilistic lambda-calculi. In Jean Goubault-Larrecq and Barbara König, editors, Foundations of Software Science and Computation Structures, volume 12077 of LNCS, pages 136–156, Cham, 2020. Springer International Publishing. doi:10.1007/978-3-030-45231-5\_8.
  13. [13]Ugo Dal Lago and Luca Padovani. On the almost-sure termination of binary sessions. In Alessandro Bruni, Alberto Mogliano, Matteo Pradella, Matteo Rossi, and James Cheney, editors, Proceedings of the 26th International Symposium on Principles and Practice of Declarative Programming, PPDP, pages 9:1–9:12. ACM, 2024. doi:10.1145/3678232.3678239.DOI
  14. [14]Vincent Danos and Thomas Ehrhard. Probabilistic coherence spaces as a model of higher-order probabilistic computation. Inf. Comput., 209(6):966–991, 2011. doi:10.1016/J.IC.2011.02.001.
  15. [15]Ankush Das, Di Wang, and Jan Hoffmann. Probabilistic resource-aware session types. Proc. ACM Program. Lang., 7(POPL):1925–1956, 2023. doi:10.1145/3571259.DOI
  16. [16]Thomas Ehrhard. Differentials and distances in probabilistic coherence spaces. In Herman Geuvers, editor, 4th International Conference on Formal Structures for Computation and Deduction, FSCD 2019, Dortmund, Germany, June 24-30, 2019, volume 131 of LIPIcs, pages 17:1–17:17. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.FSCD.2019.17.DOI
  17. [17]Thomas Ehrhard and Christine Tasson. Probabilistic call by push value. Log. Methods Comput. Sci., 15(1), 2019. doi:10.23638/LMCS-15(1:3)2019.DOI
  18. [18]Javier Esparza, Antonín Kucera, and Richard Mayr. Model checking probabilistic pushdown automata. In 19th IEEE Symposium on Logic in Computer Science (LICS), pages 12–21. IEEE Computer Society, 2004. doi:10.1109/LICS.2004.1319596.DOI
  19. [19]Kousha Ettessami and Mihalis Yannakakis. Recursive markov chains, stochastic grammars, and monotone systems of nonlinear equations. J. ACM, 56(1):1:1–1:66, 2009. doi:10.1145/1462153.1462154.
  20. [20]Luis María Ferrer Fioriti and Holger Hermanns. Probabilistic termination: Soundness, completeness, and compositionality. In Srinam K. Rajamani and David Walker, editors, Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL, pages 489–501. ACM, 2015. doi:10.1145/2676726.2677001.DOI
  21. [21]Michèle Giry. A categorical approach to probability theory. In Categorical aspects of topology and analysis (Ottawa, Ont., 1980), volume 915 of Lecture Notes in Math., pages 68–85. Springer, 1982.DOI
  22. [22]Rob J. van Glabbeek, Scott A. Smolka, and Bernhard Steffen. Reactive, generative and stratified models of probabilistic processes. Inf. Comput., 121(1):59–80, 1995. doi:10.1006/INCO.1995.1123.
  23. [23]Simon Oddershede Gregersen, Alejandro Aguirre, Philipp G. Haselwarter, Joseph Tassarotti, and Lars Birkedal. Almost-sure termination by guarded refinement. Proc. ACM Program. Lang., 8(ICFP):203–233, 2024. doi:10.1145/3674632.DOI
  24. [24]Willem Heijltjes. The Functional Machine Calculus. Electronic Notes in Theoretical Informatics and Computer Science, Volume 1 - Proceedings of MFP XXVIII, 2023. URL: https://entics.episciences.org/10513, doi:10.46298/entics.10513.DOI
  25. [25]Willem Heijltjes. The Functional Machine Calculus III: Control. Electronic Notes in Theoretical Informatics and Computer Science, Volume 5 - Proceedings of MFPS XLI, 2025. URL: https://entics.episciences.org/16682, doi:10.46298/entics.16682.DOI
  26. [26]Willem Heijltjes and Georgina Majury. Simple types for probabilistic termination. In Jörg Endrullis and Sylvain Schmitz, editors, 33rd EACSL Annual Conference on Computer Science Logic (CSL), volume 326 of LIPIcs, pages 31:1–31:22. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPIcs.CSL.2025.31.DOI
  27. [27]Janez Ignacij Jereb and Alex Simpson. Safety, relative tightness and the probabilistic frame rule. In Clemens Kupke and Stefan Milius, editors, Proceedings of the 41st Conference on the Mathematical Foundations of Programming Semantics, MFPS XLI, University of Strathclyde, Glasgow, UK, June 16-21, 2025, volume 5 of Electronic Notes in Theoretical Informatics and Computer Science. EpiSciences, June 2025. doi:10.46298/ENTICS.16743.DOI
  28. [28]Naoki Kobayashi, Ugo Dal Lago, and Charles Grello is. On the termination problem for probabilistic higher-order recursive programs. Log. Methods Comput. Sci., 16(4), 2020. doi:10.23638/LMCS-16(4:2)2020.DOI
  29. [29]Dexter Kozen. Semantics of probabilistic programs. J. Comput. Syst. Sci., 22(3):328–350, 1981. doi:10.1016/0022-0000(81)90036-2.DOI
  30. [30]Jean-Louis Krivine. A call-by-name lambda-calculus machine. Higher-Order and Symbolic Computation, 20:199–207, 2007. doi:10.1007/s10990-007-9018-9.DOI
  31. [31]Satoshi Kura and Hiroshi Unno. Automated verification of higher-order probabilistic programs via a dependent refinement type system. Proc. ACM Program. Lang., 8(ICFP):973–1002, 2024. doi:10.1145/3674662.
  32. [32]Paul Blain Levy. Call-by-push-value: A functional/imperative synthesis, volume 2 of Semantic Structures in Computation. Springer Netherlands, 2003. doi:10.1007/978-94-007-0954-6.DOI
  33. [33]Annabelle McIver, Carroll Morgan, Benjamin Lucien Kaminski, and Joost-Pieter Katoen. A new proof rule for almost-sure termination. Proc. ACM Program. Lang., 2(POPL):33:1–33:28, 2018. doi:10.1145/3158121.DOI
  34. [34]Eugenio Moggi. Notions of computation and monads. Information and Computation, 93(1):55–92, 1991. doi:10.1016/0890-5401(91)90052–4.DOI
  35. [35]Alexandra Silva and Ana Sokolakova. Sound and complete axiomatization of trace semantics for probabilistic systems. In Michael W. Mislove and Joël Ouaknine, editors, Twenty-seventh Conference on the Mathematical Foundations of Programming Semantics, MFPS 2011, Pittsburgh, PA, USA, May 25-28, 2011, volume 276 of Electronic Notes in Theoretical Computer Science, pages 291–311. Elsevier, 2011. doi:10.1016/J.ENTCS.2011.09.027.DOI
  36. [36]Eugene W. Stark and Scott A. Smolka. A complete axiom system for finite-state probabilistic processes. In Gordon D. Plotkin, Colin Stirling, and Mads Tofte, editors, Proof, Language, and Interaction, Essays in Honour of Robin Milner, pages 571–596. The MIT Press, 2000.
  37. [37]Sam Staton. Commutative semantics for probabilistic programming. In Hongseok Yang, editor, Programming Languages and Systems - 26th European Symposium on Programming, ESOP 2017, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2017, Uppsala, Sweden, April 22-29, 2017, Proceedings, volume 10201 of Lecture Notes in Computer Science, pages 855–879. Springer, 2017. doi:10.1007/978–3–662–54434–1\_32.DOI
  38. [38]W.W. Tait. Intensional interpretations of functionals of finite type I. The Journal of Symbolic Logic, 32(2):198–212, 1967. doi:10.2307/2271658.DOI
  39. [39]Mateo Torres-Ruiz, Robin Piedeleu, Alexandra Silva, and Fabio Zanasi. On iteration in discrete probabilistic programming. In Jakob Rehof, editor, 9th International Conference on Formal Structures for Computation and Deduction (FSCD 2024), Leibniz International Proceedings in Informatics (LIPIcs), pages 20:1–20:21. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.FSCD.2024.20.
  40. [40]Matthijs Vákár, Ohad Kammar, and Sam Staton. A domain theory for statistical probabilistic programming. Proc. ACM Program. Lang., 3(POPL):36:1–36:29, 2019. doi:10.1145/3290349.DOI

Paper details

vlnc:W_3pqbkjq3
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 9

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents