Quality Attributes on Quantum Computing Platforms
QQuality Attributes on Quantum ComputingPlatforms
Balwinder Sodhi Indian Institute of Technology Ropar, Nangal Rd. Ropar PB 140001 India [email protected] ,WWW home page:
Abstract.
As the practical Quantum Computing Platforms (QCPs)rapidly become a reality, it is desirable to harness their true potentialin software applications. Thus it becomes important to determine theimplications of QCPs for software architecture.In this paper we present the in-depth examination of state-of-the-artQCPs for identifying all such characteristics of a QCP that are relevantfrom software architecture perspective. Lack of a native quantum op-erating system, a hard dependency on quantum algorithms, the lowerlevel of programming abstractions are few, out of many, examples ofQCP characteristics which may affect architecture of quantum softwareapplications.Key contributions of this paper include identifying: i) The general archi-tecture of a QCP, ii)
The programming model which is typically usedwhen developing software for a QCP, iii)
Architecturally significant char-acteristics of QCPs and iv)
The impact of these characteristics on variousQuality Attributes (QAs).We show that except performance and scalability, most of the other QAs(e.g. maintainability, testability, reliability etc.) are adversely affected bydifferent characteristics of a QCP.
Keywords:
Quantum Computing, Quantum Software Engineering, Qual-ity Attributes, Software Architecture, Computing Platforms
The idea of Quantum computers was proposed in the 1980s by Richard Feyn-man and Yuri Manin. However, the origin of quantum information processingcan traced back to the early 1970’s work on quantum communication channelsby Holevo[1], and on quantum information theory by Ingarden[2]. It was not un-til 1990s that usable algorithms which exploited quantum computing propertiesappeared: first due to Peter Shor for quickly factoring large integers[3], and an-other due to Lov Grover for fast database search[4]. It was only in 2011 that thefirst commercially viable quantum computer was reported[5]. Few recent devel-opments in QCP space include Intel’s delivery[6] of a 17-qubit superconductingquantum chip, and that of IBMs[7] 50-qubit quantum computer. It is possible a r X i v : . [ c s . S E ] M a r oday for a programmer to use a real quantum computer through cloud basedquantum programming platforms (e.g. IBM Q Experience[8]).From the perspective of software development, quantum computing is one ofthe most recent paradigm shifts which is underway. In this paper we use the term Quantum Computing Platform (QCP) to refer to the entire apparatus (hardwareand software) which is necessary to develop and deploy quantum software appli-cations. Considering the pace of development happening in the domain of QCPsit is pertinent to investigate how will the large scale professional developmentof quantum software be different (or similar) to building software for classicalcomputing platforms. Some of the important questions in this context could be:1. What are the key characteristics of QCPs which are efficacious for softwaredevelopment?2. In what way does a QCP affect the quality attributes (and non-functionalrequirements) of quantum software applications?3. What type of software architectures are suitable for quantum software?4. How to assess the suitability of a QCP for a given computing problem/task?5. How do QCPs affect SDLC activities? For instance, do the classical ap-proaches apply as-is for testing and verification of quantum software?6. What type of software development processes and methods would be suitedfor building quantum software?In this paper we address the first two question via in-depth examination ofthe QCPs available today.
The central idea underlying our approach for finding answers for these ques-tions is as follows:
In order to build various QAs into a software applicationa software architect (in)directly leverages (or mitigates) the characteristics ofthe target computing platform for which the software application is being built.
Consider this example: building the performance
QA into an application oftendemands exploiting parallelism present in a problem/task. However, if the tar-get computing platform does not offer multiprocessing (e.g. if it has only onesingle-core CPU) then the application will not be able to truly realize the QAof performance. A proficient software architect must know: i) which all charac-teristics of a computing platform affect different QAs for an application, and ii) how are the QAs affected.Addressing the point- i (i.e. which characteristics) is relatively straight for-ward – one mainly needs to examine in detail the available literature and softwareartifacts of a computing platform for identifying its key characteristics. However,the point- ii is not as straight forward to address. We take the following two-stepapproach for addressing point- ii (i.e. determining how a QA is affected by plat-form characteristics):1. Examine the definition and general scenario[9, Part-II] for a QA to identifythe cause-and-effect relationships[10], if any, between platform characteris-tics and the QA.. Examine[11,12] the design tactics prescribed[9, Part-II] for realizing a QAto identify the above relationships.Application of this approach is demonstrated in § § §
3. Char-acteristics of QCPs have been determined in § § Determining software architectural aspects of quantum software development re-quires deeper comprehension of important differences between the classical andthe quantum computers. Though a detailed treatment of theoretical underpin-ning of quantum phenomenon and computing is available in standard quantumcomputing texts such as [13], we present quantum computing concepts that arenecessary for our discussion.
A classical computer stores and processes information in the form of binarybits (1 and 0). At a physical level a bit is realized using suitable properties(e.g. voltage or current etc.) of some physical device. An n bit memory cell ina classical computer can potentially represent 2 n different symbols , but at anymoment it can represent only one of these 2 n possibilities. Information on aquantum computer is represented/stored using quantum bits (or qubits). Thesequbits are physically realized via suitable physical phenomena that obey thelaws of quantum mechanics. Examples of such phenomena can be: The spin of asingle electron or the configuration of an individual ion. A qubit can be observed in one of the two basis states which are labeled as | (cid:105) or a | (cid:105) . Normally, thequbit state | (cid:105) corresponds to classical bit 1, and | (cid:105) to classical 0 bit. One of theremarkable properties of qubits, which makes quantum computers much fasterthan classical computers, is the number of possible states in which the qubitcan exist (different from its observable state, which can be only one of the basisstates). At any instant one qubit can be in a | (cid:105) , a | (cid:105) state, or any quantumsuperposition [13] of the two. In other words, the basis states | (cid:105) and | (cid:105) and theirlinear combinations x | (cid:105) + y | (cid:105) describe the possible states of a single qubit. Incontrast, one classical bit at one time can be only in one of the two possiblestates: a 0 or 1.Another quantum property that is exploited by quantum computing is en-tanglement of qubits. Two or more individually independent quantum objectsre said to be entangled when: a) their individual behavior is random, but at thesame time b) it is too strongly correlated despite each object being independentfrom the other. A multi-qubit state that cannot be expressed as a list of theindividual constituent qubits is an entangled state. Consider the Bell State[14] q q := ( | (cid:105) + | (cid:105) ) / √
2. It is an example of an entangled two-qubit state. Thereis no way of expressing it as a list of one-qubit states. Suppose you measure(along some axis) one of the qubits, say q , that comprise this entangled state.It will behave randomly: in this case q can be | (cid:105) or | (cid:105) with equal probability.Suppose you measured q to be | (cid:105) then value of q will certainly be | (cid:105) . That is,you can predict exactly how the other qubit, q , would behave if measured alongthe same axis. No unentangled state exhibits this type of perfect correlation withperfect individual randomness.The above two properties – quantum superposition and quantum entangle-ment – are thus very useful resources in quantum computing. Physical quantum computing machinery of today (reminiscent of early classicalcomputers of 1940s) are big in size[15]. It requires special physical environmentand conditions for operating correctly. The general architecture of a QCP canbe depicted as shown in Fig. 1. It comprises of five layers three of which containpurely quantum hardware and circuitry and two consist of classical hardwareand software:1.
Quantum layers [15,16,17] One can think of these layers as comprising theQuantum Processing Unit (QPU).(a)
Physical building blocks –
Includes quantum hardware which typicallymakes use of superconducting loops for physical realization of qubits.In addition, it also contains the physical qubit coupler/interconnect cir-cuitry among other elements which are needed for qubit addressing andcontrol operations.(b)
Quantum logic gates –
Physical circuitry[16, § Quantum-classical interface –
It includes the hardware and softwarewhich provides interfacing between classical computers and a QPU.2.
Classical layers [18,19,8,20](a)
Quantum programming environment –
It provides items such as: i) quan-tum assembly language necessary for instructing a QPU, ii) the program-ming abstractions needed for writing quantum programs in a high-levelprogramming language and iii) simulator support as well as IDEs etc.(b)
Business applications –
Quantum software applications written to caterfor business requirements. ig. 1.
Architecture of quantum computing platform.
In preceding section we introduced the two fundamental properties – quantumsuperposition and quantum entanglement – which make a quantum computermuch faster than classical computers at solving certain types of problems. Natureof these two properties inherently make quantum computation to be mostlyprobabilistic in nature. Thus, implying that quantum programs are likely to beprobabilistic or randomized in nature. As such, expressing the logic or algorithmwhich is to be executed on a quantum computer requires special techniques andprogramming model.
Usefulness of quantum programs lies in their ability to exploit the fundamentalcharacteristics (superposition and entanglement of qubits) of a quantum com-puter. Over the past few decades quantum computing researchers have developeda handful of techniques[21] that exploit the characteristics of quantum computersfor quickly solving certain problems that take much longer to solve on a classicalcomputer. Some of these techniques and example algorithms that exploit themare shown in Table-1.There are several algorithms available today which exploit these techniquesto solve variety of computing problems much faster than a classical computer.In order to derive benefit from the capabilities of quantum computer one mustmap the problem at hand to one of the problems for which a quantum algorithmis known. able 1.
Techniques used by quantum algorithms
Technique Examples of target problem(s)
Amplitude amplification[22] Quantum counting/search (Grover’salgorithm[4]).Quantum Fourier transform[23] Discrete logarithm problem and the integer fac-torization problem in polynomial time (Shor’s al-gorithm), and so on.Phase kick-back[21] Estimating Gauss sums[24]Quantum phase estimation[21] Estimates the phase that a unitary transformationadds to one of its eigenvectors.Quantum walks[25,26] Element distinctness problem, Triangle-findingproblem, Formula evaluation, Group commutativ-ity
Fig. 2.
An example quantum circuit and corresponding Python code.
Quantum circuits[27] is one of the common models for representing quan-tum computation. Similar to digital logic gates which are employed by classicalcomputers, quantum gate s are used to compose a quantum circuit. In this modelthe steps of a quantum algorithm can be expressed as a sequence of quantumlogic gates. Each quantum logic gate transforms the input qubits in a well de-fined manner, typically expressed a operations on matrices and vectors. IBMQ-Experience[8] takes this approach to expressing quantum computations. Fig.2 shows the screen shot of a quantum circuit (and its corresponding Pythoncode) for implementing part of Grover’s[4] algorithm on IBM Q-Experience[8] ig. 3.
A quantum programming model.
We evaluated the programming abstractions, the high-level programming lan-guage libraries that expose these abstractions and the typical steps involved incomposing quantum programs on different QCPs such as [8,19,20,28] etc.We observe that a quantum program typically comprises of parts some ofwhich execute on a classical CPU and some on a Quantum Processing Unit(QPU). Creating such quantum programs mainly involved the following tasks:1. Mapping input/output from classical bits representation to qubits.2. Initializing the qubits state.3. Compose the quantum circuit using suitable quantum logic gates to expresssteps of a quantum algorithm. The steps are repeated suitable number oftimes to get a reliable measurement of the outcomes.4. Measure the output qubits state (measuring a qubit forces it to collapse intoa classical bit) and transfer it to the classical bits.A suitable high-level programming API or instructions[20,29,30] are typicallyused for composing the quantum programs. Based on these observation a quan-tum programming model as shown in Fig. 3 has been derived. We also checkedthe adherence to this programming model by manually examining the samplequantum programs that are supplied by different QCPs we considered.
In order to understand the effect of QCPs on software architecture it is necessaryto identify all those characteristics of a QCP which can affect the development,deployment, operation and management of quantum software.Some such characteristics of the QCPs of today are:1.
Platform heterogeneity –
The published technical details of differentQCPs[19,8,17,28] that are available today show the heterogeneous nature ofthe QCPs. Considering certain limitations such as various no-go theorems[31,32]hat quantum phenomenon obey, dependency on classical hardware/softwareis inevitable. Thus, the QPUs are expected to be inherently heterogeneous in nature. That is, both classical as well as quantum hardware and softwareare involved.2.
Physical environment –
The quantum hardware requires a completely dif-ferent type of physical environment. Most of the existing implementations[15,19,8,17]of quantum hardware circuitry make use of superconducting loops requiringultra-low temperatures. Achieving and maintaining such physical conditionsnecessitates very specialized environment for reliable operation of a QCP.3.
Large form factor –
Due to requirement of special physical environment,quantum computers of today are very large in size. For instance, the mainbox of D-Wave TM Energy efficiency –
Energy consumption can be looked at from two mainaspects: energy consumed by the QPU itself, and secondly the energy re-quirements for cooling and other ancillary circuitry which make up a quan-tum computer. It has been observed that a quantum computer spends[33]most of its energy on cooling. A QPU by itself, however, consumes much lessenergy[34]. As the computation speeds grow to exascale (i.e. 1000 petaflops),the energy consumption of a QPU is not expected to increase as fast as thatof a CPU/GPU. Experiments conducted with D-Wave’s 2000-qubit systemshowed[35] overall energy efficiency improvements of the order of 100x incomparison to state-of-the-art classical computing servers when consideringpure computation time for running specialized algorithms.5.
Lower level of the programming abstractions –
The programmingabstractions offered by QCPs of today[8,19,20,29] are of a low level. That is,a programmer has to work at the level of quantum logic gates (usually viaa high-level language representation of it) when expressing computationalsteps that he/she wants to execute via a QPU.6.
Remote software development and deployment –
Programming toolssuch as IDEs, debuggers, simulators etc. that a software developer can use tocreate quantum software are invariably cloud based[8,19]. Only a very limitedportion[20,29] of the quantum programming tools stack can be deployedand used on a programmer’s local machine. For development and testing ofproduction-ready quantum software a programmer typically requires accessto a remote QCP environment.7.
Dependency on quantum algorithms –
To exploit the real potentialof quantum computers a programmer has to express the logic of his/hersoftware using quantum algorithms. A computing task where one is lookingto gain speedup by running it on a QCP is typically mapped to or brokeninto another task(s) for which a quantum algorithm(s) is known.8.
Limited portability of software –
Quantum computing platforms arethemselves in their infancy, though under rapid growth. As such there is lackof standards that are necessary for developing quantum programs which canbe executed transparently on different QPUs. Each of the major providers ofQCPs offer their proprietary programming APIs and tools[19,20,30,28,8,29]..
Limited quantum networking –
Though long distance distribution ofquantum entanglement is feasible[36], realizing practical quantum commu-nication networks is still a work in progress[37,38]. As such practical quantumsoftware which depends on availability of a reliable quantum network wouldbe hard to achieve.10.
Lack of native quantum operating system –
The quantum processorsare still controlled via classical computing operating systems[39]. We do notyet have mature multitasking and multiprocessing capabilities available forquantum processors. Most existing QCPs[8,19,20,17] expose the quantumgates and qubits for direct manipulation by programmers. Mature protocolsand APIs that implement, for example, practical timesharing of a QuantumProcessing Unit (QPU) are not available yet[39]. Similarly, quantum algo-rithms which may exploit multiple QPUs in parallel is yet to be explored.11.
Limited multitasking and multiprocessing –
This follows from the lackof native quantum operating systems. A programmer has to rely on classicalcomputer’s OS for achieving any type of multitasking and multiprocessingon a given set of QPUs.12.
Fundamentally different programming model –
As discussed in § Dependency on classical storage –
Though limited time storage of entan-gled qubits is feasible[40,41], long term persistence of qubits in passive mediais still not possible. Besides, it is not feasible to store arbitrary non-entangledqubits due to different no-go theorems such as no-teleportation[42, Page 128],no-cloning[31] and no-deleting[32] theorems. Thus, permanent persistence ofcritical data in quantum programs still requires classical storage devices.
Quality attributes (QA) may be described as the factors which have system-wideimpact on an application’s architecture, implementation as well as operation[9].The QAs that are of concern for a majority of applications may be categorizeddepending on whether they affect design-, runtime-, system- or user- qualities ofthe application[43,44].The overall design and quality of a large majority of software applications canbe considered good when the applications possess a reasonable level of at leastthe following QAs[9,12,45]: Performance, Reliability, Scalability, Security andUsability. However, based on our experience, we considered a slightly expandedlist of QAs when examining how they are affected on a QCP:1. Availability2. Interoperability3. Maintainability4. Manageability 5. Performance6. Reliability7. Scalability8. Security 9. Testability10. Usabilityn subsequent paragraphs we discuss only those aspects of a QA that are rel-evant for identifying how the QA is affected by various characteristics of QCPs .We take each of the QCP characteristics identified in § favorable, unfavorable or neutral for building a QA into an application. Summaryof the QA impact of various characteristics of QCPs is shown in Table-2. Discussion Platform heterogeneity:
Heterogeneity makes it difficult to implementhigh cohesion in software. Therefore, QAs such as maintainability, reliabil-ity, robustness, reusability, and understandability get adversely affected dueto low cohesion. Heterogeneous environment also means more number of dis-parate elements (software and hardware) to managed thus adversely affectingmanageability and testability of the system.2.
Special physical environment:
A highly specialized physical environmentneeded by a QCP is difficult to create, maintain and operate. Effect of am-bient noise/interference is more pronounced in case of QPUs than it is onCPUs. Such properties have adversely affect on the QAs such as availability A detailed description and properties of individual QAs is readily available in stan-dard software architecture literature such as [9,44,45] etc.
Table 2.
Impact ∗ of QCP characteristics on QAs Characteristics A v a il a b ili t y I n t e r o p e r a b ili t y M a i n t a i n a b ili t y M a n ag e a b ili t y P e r f o r m a n c e R e li a b ili t y S c a l a b ili t y S e c u r i t y T e s t a b ili t y U s a b ili t y Platform heterogeneity U – U U – U – – U –Special physical environment U – – U – U U U U –Large form factor – – – – – – U – – –Higher energy efficiency – – – – F – F – – –Lower level of the programming abstractions U – U – – U – – U –Remote software development and deployment – – U – – – – – U –Dependency on quantum algorithms – U U – F – F – U –Limited portability of software U U U – – – U – – –Limited quantum networking U – – – U U U – – –Lack of native quantum operating system – – – U U U U U – –Fundamentally different programming model – U U – – U – U U –Dependency on classical storage – – – U U U U – – – ∗ Cell value indicates impact on QA: (F)avorable, (U)nfavorable, “–” → Unknown/Neutral e.g. due to “brittle” nature of physical qubits), manageability, scalability(e.g. due to difficulties in quickly launching additional QPU instances) andtestability of the system.3.
Large form factor:
Most of the QAs, except scalability, remain unaffectedby this property of QCPs. Large form factor makes it difficult to augmentthe capabilities of a QCP thus adversely affecting scalability.4.
Higher energy efficiency:
Except improving performance and scalability,this property does not have significant impact on most other QAs.5.
Lower level of the programming abstractions:
Programming the QCPsrequires one to work at the level of quantum gates[19,8,20] to compose thenecessary quantum circuits for implementing steps of a quantum algorithm.Working at such low levels of abstractions is not easy and increases complex-ity of the code. Moreover, there are not many (as of today at least) expertquantum programmers.This in turn adversely affects QAs such as maintainability, testability, relia-bility and availability.6.
Remote software development and deployment:
A major implicationof QCPs on testing and debugging arises due to the non-local nature ofa real quantum computer. The development tools/environment used for aQCP are sort of distributed. The decentralized (typically, offered via a cloudbased IDE) and heterogeneous nature of the development environment willmake programing, testing and debugging of quantum programs slower andtedious[46]. This adversely affects maintainability and testability.7.
Dependency on quantum algorithms:
Probabilistic nature of quan-tum computations and the results they produce adversely affect testabilityand interoperability (with classical software). Synthesizing realistic pairs of (cid:104) input, expected output (cid:105) for test case scenarios as well as reproducing thedefects that one wants to debug requires special approaches.Moreover, there are very few[47] – only about a dozen – quantum algorithmsknown for different types of problems. Software engineers have to map theirproblems to one of the existing few quantum algorithms. This adverselyaffects the ability to perform enhancement and corrective maintenance.8.
Limited portability of software:
Quantum computing, though rapidlyevolving, is still in its infancy. It lacks standardization in several areas rang-ing from high-level programming APIs to low-level hardware. For example,a quantum program written using Rigetti’s quantum ISA[30] may not be ex-ecutable on Open QASM[29] supported by IBM. As such the portability ofsoftware is adversely affected on QCPs. Lack of portability in turn adverselyaffects availability, interoperability, maintainability and scalability.9.
Limited quantum networking:
A reliable quantum network is necessaryfor building reliable and high-performance quantum software. Quantum net-works not yet production ready [37,38]. Thus, the performance, scalability,reliability and, in turn, availability will be adversely affected.10.
Lack of native quantum operating system:
A native operating sys-tem helps in harnessing full potential of a hardware in a secure and effectivemanner. This is lacking[39] in case of QCPs. It prohibits, for instance, practi-al timesharing of a QPU. Thus, the performance, manageability, reliability,scalability and security will be adversely affected.11.
Fundamentally different programming model:
Quantum programs areinherently probabilistic and requires a fundamentally different approach toprogramming (please see § Dependency on classical storage:
For durably persisting critical datathe quantum programs depend on classical storage devices due to differentno-go theorems such as no-teleportation[42, Page 128], no-cloning[31] andno-deleting[32] theorems. On a QCP this adversely affects manageability,performance and scalability.
Quantum computing is a fast evolving area of technology. The characteristics ofQCPs that we have identified are based on the study of currently available state-of-the-art quantum hardware and software. We expect advances in quantumcomputing will invalidate at least few of these characteristics in coming years.For example, the production-ready native quantum operating systems are likelyto be feasible in the years to come.Further, the list of characteristics that we have given is not an exhaustive list.It is quite likely that there are additional QCP characteristics which, taken to-gether, may be of significance in specific software development scenarios. Anotherpoint that we would like to highlight is that our findings are derived from: a) pub-lished information about QCPs and b) experimental programming on the QCPsaccessible to us. It is likely that there are unpublished features/information aboutthose QCPs which can affect the software architecture of quantum software ap-plications. Next, we have not covered every QA which is relevant for a widerset of application types. There may be QAs such as auditability, distributability,extensibility etc. which are relevant and may be affected by the QCPs. Lastly,our own experience and know-how as software architects has influenced to someextent what we identified as the effect of different QCPs on various QAs.
Programmers’ interest in applying quantum computing has surged in the recentpast. Leveraging this technology in solving general purpose business problemsrequires deeper understanding of important characteristics of QCPs, particularlythose which are relevant for software development.We have shown that the key characteristics of a QCP make it different froma classical computing platform. For instance, availability and know-how of quan-um algorithm(s) for solving a task at hand are a hard requirement for devel-oping quantum programs. Such characteristics of a QCP affect various QualityAttributes (QAs) of the quantum application software. The QCP characteristicssuch as limited portability of quantum programs, lack of native quantum oper-ating system services, dependency on quantum algorithms and so on, adverselyaffect the ability to realize various QAs such as scalability, portability, testabilityand maintainability etc. of the quantum application software. The QAs that arefavorably impacted by QCP characteristics include performance and scalability.Overall, the specialized nature of QCPs appears to have a significant impli-cation: it limits the use of QCPs for very specialized application areas where performance
QA is of chief importance. However, because the quantum com-puting is undergoing rapid development we expect that the evolution of thistechnology will likely introduce additional concerns and factors which may af-fect the architecture of quantum software applications.
References
1. Alexander Semenovich Holevo. Bounds for the quantity of information transmittedby a quantum communication channel.
Problemy Peredachi Informatsii , 9(3):3–11,1973.2. Roman S Ingarden. Quantum information theory.
Reports on MathematicalPhysics , 10(1):43–72, 1976.3. Peter W Shor. Algorithms for quantum computation: Discrete logarithms andfactoring. In
Foundations of Computer Science, 1994 Proceedings., 35th AnnualSymposium on , pages 124–134. Ieee, 1994.4. Lov K Grover. A fast quantum mechanical algorithm for database search. In
Proceedings of the twenty-eighth annual ACM symposium on Theory of computing ,pages 212–219. ACM, 1996.5. Hamish Johnston. Quantum-computing firm opens thebox. http://physicsworld.com/cws/article/news/2011/may/12/quantum-computing-firm-opens-the-box , 2011. Retrieved: Feb 2018.6. Intel Inc. Intel delivers 17-qubit superconducting chip with ad-vanced packaging to qutech. https://newsroom.intel.com/news/intel-delivers-17-qubit-superconducting-chip-advanced-packaging-qutech/ ,2017. Retrieved: Feb 2018.7. Will Knight. Ibm raises the bar with a 50-qubit quan-tum computer. , 2017. Retrieved:Feb 2018.8. IBM. Ibm q experience. https://quantumexperience.ng.bluemix.net/qx/experience , 2017. Retrieved: Feb 2018.9. Len Bass.
Software architecture in practice, 3rd edition . Pearson, 2012.10. Felix Bachmann, Len Bass, and Mark Klein. Illuminating the fundamental con-tributors to software architecture quality. Technical report, CARNEGIE-MELLONUNIV PITTSBURGH PA SOFTWARE ENGINEERING INST, 2002.11. Felix Bachmann, Len Bass, and Mark Klein. Deriving architectural tactics: A steptoward methodical architectural design. Technical report, CARNEGIE-MELLONUNIV PITTSBURGH PA SOFTWARE ENGINEERING INST, 2003.2. Len Bass, Mark Klein, and Felix Bachmann. Quality attribute design primitives.Technical report, CARNEGIE-MELLON UNIV PITTSBURGH PA SOFTWAREENGINEERING INST, 2000.13. Michael A Nielsen and Isaac Chuang. Quantum computation and quantum infor-mation, 2002.14. Paul G. Kwiat and Harald Weinfurter. Embedded bell-state analysis.
Phys. Rev.A , 58:R2623–R2626, 1998.15. D-Wave Systems Inc. Introduction to the D-Wave Quantum Hard-ware. , 2017. Retrieved: 2018-02-19.16. Matthias F. Brandl. A Quantum von Neumann Architecture for Large-Scale Quan-tum Computing. arXiv:1702.02583 [quant-ph] , 2017. arXiv: 1702.02583.17. Microsoft. With new microsoft breakthroughs, general purpose quantumcomputing moves closer to reality. https://news.microsoft.com/features/new-microsoft-breakthroughs-general-purpose-quantum-computing-moves-closer-reality/ ,2017. Retrieved: 2018-02-19.18. Rigetti Inc. The rigetti QPU – pyQuil 1.8.0 documentation.http://pyquil.readthedocs.io/en/latest/qpu.html, 2017. Retrieved: 2018-03-05.19. D-Wave Systems Inc. The D-Wave 2000q Quantum Computer TechnologyOverview. , 2017. Retrieved: 2018-02-19.20. Microsoft. Microsoft quantum development kit. , 2017. Retrieved: 2018-02-19.21. Richard Cleve, Artur Ekert, Chiara Macchiavello, and Michele Mosca. Quantumalgorithms revisited. In
Proceedings of the Royal Society of London A: Mathemat-ical, Physical and Engineering Sciences , volume 454, pages 339–354. The RoyalSociety, 1998.22. Michele Mosca Alain Tapp Gilles Brassard, Peter Hoyer. [quant-ph/0005055]Quantum Amplitude Amplification and Estimation. https://arxiv.org/abs/quant-ph/0005055 , 2000. Retrieved: 2018-03-05.23. Lisa Hales and Sean Hallgren. An improved quantum fourier transform algorithmand applications. In
Foundations of Computer Science, 2000. Proceedings. 41stAnnual Symposium on , pages 515–525. IEEE, 2000.24. Wim Van Dam and Gadiel Seroussi. Efficient quantum algorithms for estimatinggauss sums. arXiv preprint quant-ph/0207131 , 2002.25. Salvador E Venegas-Andraca. Quantum walks: a comprehensive review.
QuantumInformation Processing , 11(5):1015–1106, 2012.26. Andris Ambainis. Quantum walks and their algorithmic applications.
InternationalJournal of Quantum Information , 1(04):507–518, 2003.27. Mikko M¨ott¨onen, Juha J. Vartiainen, Ville Bergholm, and Martti M. Salomaa.Quantum circuits for general multiqubit gates.
Phys. Rev. Lett. , 93:130502, 2004.28. Rigetti Inc. The rigetti QVM – pyQuil 1.8.0 documentation.http://pyquil.readthedocs.io/en/latest/qvm.html, 2017. Retrieved: 2018-03-05.29. Andrew W Cross, Lev S Bishop, John A Smolin, and Jay M Gambetta. Openquantum assembly language. arXiv preprint arXiv:1707.03429 , 2017.30. Robert S. Smith, Michael J. Curtis, and William J. Zeng. A practical quantuminstruction set architecture. arXiv:1608.03355 [quant-ph] , 2016.31. William K Wootters and Wojciech H Zurek. A single quantum cannot be cloned.
Nature , 299(5886):802–803, 1982.2. Arun Kumar Pati and Samuel L Braunstein. Impossibility of deleting an unknownquantum state.
Nature , 404(6774):164, 2000.33. Jeremy Hsu. How much power will quantum computingneed? https://spectrum.ieee.org/tech-talk/computing/hardware/how-much-power-will-quantum-computing-need , 2017. Retrieved: 2018-03-02.34. Joni Ikonen, Juha Salmilehto, and Mikko Mttnen. Energy-efficient quantum com-puting. npj Quantum Information , 3(1):17, 2017.35. D-Wave Systems Inc. Computational power consumption and speedup. , 2017. Retrieved: 2018-03-02.36. Juan et al Yin. Satellite-based entanglement distribution over 1200 kilometers. arXiv:1707.01339 [physics, physics:quant-ph] , 2017.37. Christoph Simon. Towards a global quantum network.
Nature Photonics ,11(11):678–680, 2017.38. H. J. Kimble. The quantum internet.
Nature , 453:1023, 2008.39. Henry Corrigan-Gibbs, David J. Wu, and Dan Boneh. Quantum operating systems.In
Proceedings of the 16th Workshop on Hot Topics in Operating Systems , HotOS’17, pages 76–81. ACM, 2017.40. Christoph Clausen, Imam Usmani, F´elix Bussieres, Nicolas Sangouard, MikaelAfzelius, Hugues de Riedmatten, and Nicolas Gisin. Quantum storage of photonicentanglement in a crystal.
Nature , 469(7331):508, 2011.41. F´elix Bussi`eres, Christoph Clausen, Alexey Tiranov, Boris Korzh, Varun B Verma,Sae Woo Nam, Francesco Marsili, Alban Ferrier, Philippe Goldner, Harald Her-rmann, et al. Quantum teleportation from a telecom-wavelength photon to a solid-state quantum memory.
Nature Photonics , 8(10):775–778, 2014.42. Anirban Pathak.
Elements of quantum computation and quantum communication .Taylor & Francis, 2013.43. P. Bourque and eds. R.E. Fairley.
Guide to the Software Engineering Body ofKnowledge, Version 3.0 . IEEE Computer Society, 2014.44. Microsoft Patterns and Practices Team.
Microsoft Application Architecture Guide,2nd Edition . Microsoft, 2009.45. ISO/IEC. ISO/IEC25010:2011(en), systems and software engineering systems andsoftware quality requirements and evaluation (SQuaRE) system and software qual-ity models. , 2011. Retrieved: 11-03-2018.46. G. Fylaktopoulos, G. Goumas, M. Skolarikis, A. Sotiropoulos, and I. Maglogiannis.An overview of platforms for cloud based development.
SpringerPlus , 5, 2016.47. Peter W. Shor. Progress in Quantum Algorithms.
Quantum Information Process-ing , 3(1-5), 2004.48. Capers Jones. The economics of software maintenance in the twenty first cen-tury. http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.7697&rep=rep1&type=pdfhttp://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.7697&rep=rep1&type=pdf