See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/329810899

On Testing Quantum Programs

Conference Paper · May 2019

DOI: 10.1109/ICSE-NIER.2019.00023

CITATIONS READS
58 179

2 authors:

Andriy V. Miranskyy Lei Zhang

Ryerson University University of Maryland, Baltimore County
110 PUBLICATIONS 841 CITATIONS 31 PUBLICATIONS 163 CITATIONS

SEE PROFILE SEE PROFILE

All content following this page was uploaded by Lei Zhang on 25 December 2018.

The user has requested enhancement of the downloaded file.

 On Testing Quantum Programs
Andriy Miranskyy and Lei Zhang
Department of Computer Science, Ryerson University, Toronto, Canada
{avm, leizhang}@ryerson.ca

Abstract—A quantum computer (QC) can solve many compu- time complexity class, BPP is a bounded-error probabilistic
tational problems more efficiently than a classic one. The field of polynomial time class, P#P is P with #P oracle class (#P
QCs is growing: companies (such as DWave, IBM, Google, and is a set of counting problems, and is a class of function
Microsoft) are building QC offerings. We position that software
engineers should look into defining a set of software engineering problems rather than decision problems), and PSPACE is a
practices that apply to QC’s software. To start this process, we polynomial space class, see [8] for details. Currently, the
arXiv:1812.09261v1 [cs.SE] 21 Dec 2018

give examples of challenges associated with testing such software consensus (although not formally proved) is that some of the
and sketch potential solutions to some of these challenges. nondeterministic polynomial time (NP) problems do belong to
I. I NTRODUCTION the BQP set; however, BQP and NP-complete sets of problems
do not overlap (see [8], [7] for review), i.e., a QC will not be
A quantum computer (QC) can efficiently solve various able to solve an NP-complete problem.
problems that a classical computer (CC) cannot [1]; this is
3) QC timeline: The field of quantum computing is young:
known as the quantum supremacy [2]. Examples of such
Feynman introduced the idea of quantum computing in
problems (originating in various fields of science) are scal-
1982 [1]; Shor proposed the first practically relevant algorithm
able simulations of quantum systems in physics [1], efficient
(for breaking encryption protocols based on integer factoriza-
modelling of chemical reactions [3], and fast breaking of
tion) that can be efficiently computed on a QC in 1994 [6].
encryption codes1 in cryptography [6].
A QC can be simulated on a CC [9], [10]. A quantum
1) QC underlying principles: A CC operates on a sequence
simulator interprets a mathematical function as part of a
of bits taking the values of 0 or 1. A QC operated on quantum
physical model [11]; however, it will not yield performance
bits (hereon qubits), which are two-state quantum-mechanical
improvement that a QC would provide, as the underlying host
systems [7]. Unlike the bit, the qubit is represented by a
system of the simulator is still based on bits rather than qubits.
superposition of two states, inducing a probability distribution
Thus, one needs a real QC to reap performance benefits.
of the qubit’s outcome being 0 or 1 upon measurement [7].
It took a while to implement an actual QC. A partnership
Essentially, the qubit is a stochastic system: every time we
between academia and IBM created the first working 2-qubit
take a measurement on a given qubit, the probability of the
QC in 1998 [12], but it took the company 18 years to make a
outcome (0 or 1) would change. The beauty of the qubits lies in
5-qubit QC accessible to the public in 2016 [13].
the fact that qubits can be entangled, meaning that the number
of states that a QC can represent is proportional to 2q , where At present, a few QCs are commercially available. DWave
q is the number of qubits, whereas a CC operating on q bits started selling adiabatic QC in 2011 (although debate about
would be able to represent at most q states [7]. adiabatic QC being a “true” QC is ongoing2 [15]) with the
2) QC applicability: Not every problem can benefit from current offerings having > 2000 qubits. IBM gave access to
the QC architecture: those problems falling under the bounded 20- and 50-qubit gate-based superconducting QCs to academic
error quantum polynomial time (BQP) class defined in com- and industrial partners to explore practical applications in
putational complexity theory will [7]. The time complexity of 2017 [16].
algorithms, which solve BQP class problems, grows polyno- For non-commercial use, IBM offers 5- and 16-qubit QCs
mially with the increase of the input size on a QC. On the via IBM Q Experience online platform based on IBM Cloud
contrary, the time complexity of the algorithms solving the (along with local- and Cloud-based simulators) [9]. Microsoft
same problems on a CC is not bounded above by a polynomial provides access to a simulator of a topological QC via Mi-
function and may grow faster (e.g., exponentially) with the crosoft Quantum Development Kit [10] (and is planning to
increase of the size of the input. give access to an actual QC in the future). Google built 72-
Formally, it was shown that the relations between BQP qubit gate-based superconducting QC in 2018 [17], but it is
and other popular complexity classes are as follows: P ⊆ not publicly accessible at the time of writing.
BPP ⊆ BQP ⊆ P#P ⊆ PSPACE, where P is a polynomial 4) QC performance: When discussing the performance of
the abovementioned QCs, we have to be mindful of the fact
1 These encryption codes are based on integer factorization. Multiple QC-
that the performance of the QCs (which are based on different
resistant encryption methods have been proposed [4], but their implementation architectures) cannot be compared merely based on the number
will require significant changes to various software: web browsers and web
servers, mail and hard drive encryptors, etc. We conjecture that the amount
of work necessary to introduce these changes into legacy software may be 2 A hybrid of adiabatic and gate-based QC is promising [14], but no
similar to that of the Y2K problem [5]. commercial implementation is available.
of qubits that each QC has. Conceptually, it is similar to Language [20]), the code is passed to the QC for execution (the
the fact that we cannot compare the performance of CC complexities of the call are encapsulated in the library’s code).
central processing unit (CPU) based solely on the number Microsoft Q# behaviour is similar: the code is developed on
of CPU cores and the cores’ frequency. Standardization of a CC and then passed to a QC for execution.
benchmarks for QC is currently in the works by an IEEE 6) Our position: Based on the above, QCs are becoming
Working Group [18]. more mainstream; and we are not the only one making this
5) QC adoption: Given that P ⊆ BQP [8], one may argue claim, e.g., see [23]. Thus, we position that the Software Engi-
that QC will replace CC at some point in time. However, neering (SE) community should start thinking about bringing
we conjecture that QC will not replace CC in the short run. SE practices into the domain of QCs. To do this, we need
Rather, QCs will be integrated into a System of Systems to answer some research questions. To name a few: which of
(SoS), where QC-based components will solve BQP problems the SE practices that we use in the CC domain can be ported
(that CC cannot solve), while the solution will be passed to to the QC domain; which of the practices are not applicable;
CC components for post-processing. Let us elaborate on this and which novel practices should be created to address QC
conjecture. domain challenges?
Example I.1. Suppose that we need to create a software-as- In this paper, to start the discussion, we focus on testing
a-service for factoring large integers. The time complexity software created for QC. Due to a lack of space, we arbitrarily
of the best algorithms available for a CC in the family of selected two topics related to testing activities: white- and
general number field sieves) is sub-exponential [19]. Thus, black-box testing, discussed in Section II, and verification and
these algorithms will be ineffective for large integers. Instead, validation, discussed in Section III. Section IV concludes the
we will build a software component running Shor’s algorithm paper.
on a QC, which will be more efficient for large integers,
because Shor’s algorithm computation time (as other BQP II. W HITE - AND BLACK - BOX TESTING
class algorithms) will grow polynomially with the growth of Two widespread methods of testing are white-box and
the input integer N (when executed on a QC). The rest of black-box testing. The former method tests internal data
the components, such as user interface (UI) and application structures and program flow. The latter method tests the
program interface (API) for obtaining input (i.e., the value functionality, ignoring the inner workings of the software,
of N ) to be passed to the QC component and to return the answering the following question: will I get an expected output
~ back to the user will be implemented on
vector of factors L for a given input?
a CC, as depicted in Figure 1. This is similar in nature to We can perform all of the standard white-box activities on
the existing Cloud solution for online access to IBM QCs [9], the code listing, such as code reviews and code inspections.
where a Cloud-based interface for writing programs for a QC However, interactive debugging (another popular white-box
is running on a CC, while the program is then passed to the activity) is challenging, because a QC is a black-box, by
QC for execution. construction. Based on the classic quantum mechanics3 , we
Why cannot we implement all of this functionality on a cannot observe the inner working of a program (executed on
QC? In the distant future, as equipment becomes cheaper to a QC) without altering the program’s state and the final result,
procure and operate, and the higher-level languages for QC as measuring a qubit destroys superposition [24].
are created, the replacement of CC with QC will become This implies that, currently, we cannot perform interactive
more probable. However, we hypothesize that it is not going debugging of a program running on a QC, as we have to stop
to happen soon. Let us elaborate on the rationale for this the program and take the measurements. Thus, we have to re-
statement. First, the QCs are expensive: e.g., DWave QC is sort to black-box testing when dealing with a program running
valued at $15 million [21]. While other companies do not on an actual QC. Note that we can do white-box testing in QC
disclose their prices, we conjecture that the price tags of other simulators (e.g., we can use xUnit test framework to test Q#
QCs (magnitude-wise) are similar. Moreover, the operation of programs [22]).
these computers requires cryogenic equipment (operated by
highly qualified personnel), which further contributes to the III. V ERIFICATION AND VALIDATION
costs.
When testing the programs, how can we ensure that our code
Second, modern QC programming languages, such as IBM
follows the design document and that the QC is doing what it
QisKit Python package [9] and Microsoft Q# language [22],
is supposed to do? And even if our code reflects the design,
operate at the level of qubits and quantum circuits. Creation
how can we make certain that the output of the program
of a UI and API in such a language would be very time-
delivers what a user needs? The former will be discussed in
consuming and expensive.
Section III-A, the latter — in Section III-B.
Notwithstanding, these languages integrate nicely into CC
domain, simplifying the creation of SoS. IBM QisKit is 3 Recently, Vijay et al. [24] have invented a clever way of measuring a qubit
implemented as a Python library, running on a CC. Once trans- state without ending superposition. It remains to be seen if this technology
lated to QC machine language (via Open Quantum Assembly can be transferred to a QC.
 WebApp QC
user: WebApp’s UI WebApp’s Backend QC’s Controller QC’s Core
N
N
QASM
Control sequence
Return qubits’ state
~
Return L
~
Return L
~
Return L

Fig. 1. Sequence diagram for Example I.1. A user submits the value of integer N for factorization via UI of a Web App, which passes N to the WebApp’s
backend. At the backend where the value of N is passed to, Shor’s algorithm is implemented using, say QisKit library [9]. The library translates QisKit
code into Open Quantum Assembly Language (QASM) [20] and passes QASM listing to the Controller of a QC. The Controller, which initializes the QC
Core based on the QASM code, triggers its execution and measures the values of the qubits once execution ends. The Controller converts the measurements
~ These values are then returned to the Backend, UI, and, finally, the user. The sequence is depicted as synchronous, but can be made
into the elements of L.
asynchronous if required by a use case. Note that the WebApp UI and Backend, as well as the QC Controller, are running on CCs. The QC Core represents
the “true” QC. However, the QC Controller and the QC Core can be thought of as one QC system from practical perspective.

A. Verification requires a significant amount of computational resources and,

As discussed in Section II, we can apply the full spectra of probably, will not be implemented shortly. However, as the
verification techniques on the code listings, but verification of computing power of QCs will increase, this protocol will
a running program on an actual QC is more challenging, as become implementable in practice.
we cannot use interactive debugger. To verify the correctness, However, even if all of the above tests pass, it does not
we can try to run and debug our program in a local or online guarantee that the actual results returned by the QC are correct.
simulator, such as [9], [10]. However, as the simulators run This is where validation comes into play.
on CC, we will have to limit the complexity of our test cases B. Validation
to obtain results within a reasonable amount of time. This
When doing the validation, we need to make sure that the
will help us to eliminate some of the defects (a taxonomy of
output of the algorithm satisfies the conditions provided in
QC bugs is being developed [25]), but does not guarantee that
the requirements document (assuming that requirements were
no other defects will be encountered while solving production-
captured correctly). In other words, validation of a program
scale problems. The same issue, conceptually, arises with CCs
running on a QC is similar to that of a program executed by
too, e.g., when dealing with buffer-overrun- and resource-leak-
a CC. Essentially, the ease of validation will depend on the
related defects.
difficulty of implementing a program for validating the results
The above test assumes that a simulator correctly and
and the time needed4 to execute the validation.
accurately resembles the actual QC, which is not always the
Before implementing a program, we need to estimate how
case. Thus, a more definitive verification of correctness should
long the validation process would take. To do so, we can resort
be done on the the actual QC. Given the probabilistic nature
to complexity analysis. Say, if the execution time of the vali-
of QC, we may have to execute the same code multiple
dation5 program would belong to O(1), the validation process
times to increase the accuracy of our answer using Chernoff
(given that it is easy to code up) would be straightforward.
bound [7] (which is similar to probabilistic algorithms in
However, if the execution time would belong, say, to O(n!),
BPP class running on CC [7]). This repeating functionality
where n would be proportionate to the length of input into
is built into packages like QisKit, but it requires a higher
the validation process (and to the length of the solution), then
amount of computing resources (proportional to the number
the validation process for a significantly large n would be
of repetitions).
formidable.
The above approach assumes that the QC hardware, its
For simplicity, we can split the complexity of validation
operating system, and the compiler/translator of our program
into two classes: polynomial time P bounded by O(nk )
are running correctly, which is not always the case. To verify
(i.e., validation time is bounded above asymptotically by
their correctness, we may need to execute the same program
nk , where k > 0) and super-polynomial time PC , which is
on multiple QCs (preferably from different manufacturers) and
complementary to P, bounded by ω(nk ) (i.e., validation time
compare the results. If results differ significantly — it may
be a sign that there is an issue with one or more QCs under 4 As discussed in Section I, many problems in BQP are solved efficiently

test. This is akin to correctness testing of a database engine by on a QC, but are challenging to solve on a CC. However, the time needed to
running the same query against different database engines [26]. solve a problem is independent of the time needed to validate this solution.
5 In the algorithm-related literature, the term verification rather than valida-
A novel award-winning protocol, verifying QC computa- tion is used. We will use the term validation for consistency with the name
tions with the help of a CC has been proposed [27]. It of this section.
dominates asymptotically the nk ). We will look at examples of of a matrix. However, one may adopt a heuristic to estimate
the algorithms belonging to these classes in subsections below. goodness of findings (essentially, performing approximate
Where should we implement the validation program: on validation) using machine learning approach [29].
a CC or a QC? In the program belongs to P class, it can In the above example, to perform an accurate validation,
be implemented on either one, as P ⊆ BQP. However, as we need to do it on a QC. Ideally, this should be done on a
discussed in Section I, it is challenging to program a QC different QC to simultaneously check the correctness of the
as we are dealing with low-level programming language. computer itself (as was discussed in Section III-A). The code
Moreover, the cost of running a QC in comparison with a CC of the validation software would be similar to the one of the
is high. Thus, it is simpler and more economically feasible to solution software. Thus, if resources permit, one may want to
implement a validation program on a CC, if possible. create the validation code from scratch (rather than reusing
In the case of PC class, the answer is less straightforward. If the existing code from the solution) to avoid migration of the
the size of the input into validation program is small, we may defects from the solution code into validation code.
be able to still leverage a CC (especially if we can parallelize
the validation on a CC cluster). However, we may have to IV. C ONCLUSIONS
resort to a QC for larger problems. If the validation program
QCs are becoming more mainstream. Thus, we position
belongs to classes which are a subset of BQP, such as BPP
that software engineers should start the process of bringing
class, then QC is a good match. However, if the validation
SE practices into the domain of QCs. To do this, we need
belongs to a “harder” class, such as NP-complete, then QC
to identify which existing methods are transferable from the
may also fail to deliver timely results. In this case, we may
domain of CCs, which have to be altered, and which have to
have to resort to a heuristic that tries to roughly validate the
be created.
solution, but does not guarantee that solution is correct.
To start the discussion on this matter, we list a number of
Let us look at one example of algorithms from both classes
challenges associated with white- and black-box testing as well
and ways to run the validation.
as verification and validation of programs running on a QC.
1) Polynomial P: Shor’s integer factoring algorithm takes
~ We then list some of the existing SE practices that are readily
integer N as input and returns a vector of prime factors L
transferable to the QC domain (e.g., code review), some that
for N [6]. The solution runs on a QC in polynomial time,
are difficultly transferable (e.g., interactive debugging), and
O((log N )2 (log log N )(log log log N )) to be specific [6]. The
some that have to be introduced (e.g., complexity-dependent
validation complexity is independent of the solution complex-
~ deemed placement of a validation program).
ity, growing linearly with the number of elements in L,
l, as we simply need to multiply the elements in L ~ to do We hope that this paper will catalyze the process of defining
the validation. That is, the complexity of validation of Shor’s SE practices for QCs and that SE specialists in academia and
algorithm is O(l). Thus, we can easily6 perform validation on industry will start exploring this fascinating area of computing,
a CC. Note that validation of Shor’s algorithm can be carried expanding our work to other areas of testing and the remaining
on a QC, but this is economically inferior, as discussed above. phases of the software development life cycle.
2) Super-Polynomial PC : Boson sampling is a good ex-
R EFERENCES
ample of a problem that is challenging to verify. Yet, the
algorithm is crucial7 . Experimentally, the algorithm is typi- [1] R. P. Feynman, “Simulating physics with computers,” International
cally implemented using photons (belonging to the family of journal of theoretical physics, vol. 21, no. 6-7, pp. 467–488, 1982.
[2] J. Preskill, “Quantum computing and the entanglement frontier,” arXiv
boson particles [7]). To implement the algorithm, we need a preprint arXiv:1203.5813, 2012.
linear-optical circuit with m modes that is injected with h [3] A. Aspuru-Guzik, A. D. Dutoi et al., “Simulated quantum computation
individual photons (m > h) [29]. In this implementation, the of molecular energies,” Science, vol. 309, no. 5741, pp. 1704–1707,
2005.
boson sampling task reduces to creating a sample from the [4] D. J. Bernstein, J. Buchmann, and E. Dahmen, Eds., Post-Quantum
probability distribution of individual photon measurements at Cryptography. Berlin Heidelberg: Springer-Verlag, 2009.
the circuit’s output. [5] “Y2K bug — Definition, Hysteria, & Facts — Britannica.com,”
accessed on 2018-09-25. [Online]. Available: https://www.britannica.
This algorithm cannot be computed on a CC for large values com/technology/Y2K-bug
of m and h, as it requires computing a permanent of a matrix [6] P. W. Shor, “Polynomial-time algorithms for prime factorization and
which is a #P-hard problem [28], [30]. At best, it requires discrete logarithms on a quantum computer,” SIAM J. Comput.,
vol. 26, no. 5, pp. 1484–1509, Oct. 1997. [Online]. Available:
O(h2h + mh2 ) computations [31]. http://dx.doi.org/10.1137/S0097539795293172
However, the problem does fall [28] into PostBQP class [7] M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum
(BQP class with post-selection), which can be efficiently Information: 10th Anniversary Edition. Cambridge Univ. Press, 2010.
computed on a QC. Validation of the results on a CC is also a [8] U. Vazirani, “A survey of quantum complexity theory,” in Proceedings
of Symposia in Applied Mathematics, vol. 58, 2002, pp. 193–220.
#P-hard problem, as we again need to compute the permanent [9] “IBM Q Experience,” accessed on 2018-09-25. [Online]. Available:
https://quantumexperience.ng.bluemix.net/qx/experience
6 Although we may have to leverage existing libraries for multiplication of
[10] “Quantum computing | Microsoft,” accessed on 2018-09-25. [Online].
integers with arbitrary precision, such as Java BigInteger. Available: https://www.microsoft.com/en-us/quantum/
7 It may lead to the implementation of a non-universal QC, which will still [11] T. H. Johnson, S. R. Clark, and D. Jaksch, “What is a quantum
be more efficient than CC for some tasks, see [28] for details. simulator?” EPJ Quantum Technology, vol. 1, no. 1, p. 10, Jul 2014.
[12] I. L. Chuang, N. Gershenfeld, and M. Kubinec, “Experimental
implementation of fast quantum searching,” Phys. Rev. Lett., vol. 80,
pp. 3408–3411, Apr 1998. [Online]. Available: https://link.aps.org/doi/
10.1103/PhysRevLett.80.3408
[13] “IBM News room - 2016-05-04 IBM Makes Quantum Computing
Available on IBM Cloud to Accelerate Innovation - United States,”
accessed on 2018-09-25. [Online]. Available: https://www-03.ibm.com/
press/us/en/pressrelease/49661.wss
[14] R. Barends, A. Shabani et al., “Digitized adiabatic quantum computing
with a superconducting circuit,” Nature, vol. 534, pp. 222–226, Jun.
2016. [Online]. Available: http://dx.doi.org/10.1038/nature17658
[15] T. Albash, V. Martin-Mayor, and I. Hen, “Temperature scaling
law for quantum annealing optimizers,” Phys. Rev. Lett., vol.
119, pp. 110 502:1–110 502:7, Sep 2017. [Online]. Available: https:
//link.aps.org/doi/10.1103/PhysRevLett.119.110502
[16] “IBM Announces Collaboration with Leading Fortune 500 Companies,
Academic Institutions and National Research Labs to Accelerate
Quantum Computing - Dec 13, 2017,” accessed on 2018-09-25.
[Online]. Available: https://newsroom.ibm.com/2017-12-13-IBM-
Announces-Collaboration-with-Leading-Fortune-500-Companies-
Academic-Institutions-and-National-Research-Labs-to-Accelerate-
Quantum-Computing
[17] “Google AI Blog: A Preview of Bristlecone, Google’s New Quantum
Processor,” accessed on 2018-09-25. [Online]. Available: https://ai.
googleblog.com/2018/03/a-preview-of-bristlecone-googles-new.html
[18] “P7131 - Standard for Quantum Computing Performance Metrics
& Performance Benchmarking,” accessed on 2018-09-25. [Online].
Available: https://standards.ieee.org/project/7131.html
[19] C. Pomerance, “A tale of two sieves,” Notices Amer. Math. Soc, vol. 43,
pp. 1473–1485, 1996.
[20] A. W. Cross, L. S. Bishop et al., “Open quantum assembly language,”
arXiv preprint arXiv:1707.03429, 2017.
[21] “D-Wave 2000Q goes on sale — WIRED UK,” accessed on 2018-09-
25. [Online]. Available: https://www.wired.co.uk/article/d-wave-2000q-
quantum-computer
[22] K. Svore, A. Geller et al., “Q#: Enabling Scalable Quantum Computing
and Development with a High-level DSL,” in Proceedings of the Real
World Domain Specific Languages Workshop 2018, ser. RWDSL2018.
New York, NY, USA: ACM, 2018, pp. 7:1–7:10. [Online]. Available:
http://doi.acm.org/10.1145/3183895.3183901
[23] D. Castelvecchi, “Quantum computers ready to leap out of the lab in
2017,” Nature News, vol. 541, no. 7635, pp. 9–10, 2017.
[24] R. Vijay, C. Macklin et al., “Stabilizing Rabi oscillations in a supercon-
ducting qubit using quantum feedback,” Nature, vol. 490, pp. 77–80,
2012.
[25] Y. Huang and M. Martonosi, “QDB: from quantum algorithms towards
correct quantum programs,” arXiv preprint arXiv:1811.05447, 2018.
[26] E. Cialini, A. Loreto, and D. Godwin, “Method, system, and program
for determining discrepancies between database management systems,”
2007, US Patent App. US20070100783A1.
[27] U. Mahadev, “Classical verification of quantum computations,” in 2018
IEEE 59th Annual Symposium on Foundations of Computer Science
(FOCS), Oct 2018, pp. 259–267.
[28] S. Aaronson and A. Arkhipov, “The computational complexity of linear
optics,” in Proceedings of the Forty-third Annual ACM Symposium on
Theory of Computing, ser. STOC ’11. ACM, 2011, pp. 333–342.
[Online]. Available: http://doi.acm.org/10.1145/1993636.1993682
[29] T. Giordani, F. Flamini et al., “Experimental statistical signature of
many-body quantum interference,” Nature Photonics, vol. 12, no. 3,
pp. 173–178, Mar. 2018. [Online]. Available: https://doi.org/10.1038/
s41566-018-0097-4
[30] L. Valiant, “The complexity of computing the permanent,”
Theoretical Computer Science, vol. 8, no. 2, pp. 189 – 201,
1979. [Online]. Available: http://www.sciencedirect.com/science/article/
pii/0304397579900446
[31] P. Clifford and R. Clifford, “The classical complexity of boson
sampling,” in Proceedings of the 29th Annual ACM-SIAM Symposium
on Discrete Algorithms, ser. SODA ’18, 2018, pp. 146–155. [Online].
Available: http://dl.acm.org/citation.cfm?id=3174304.3175276

View publication stats