Loading…
A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery
Given a quantum gate circuit, how does one execute it in a fault-tolerant architecture with as little overhead as possible? In this paper, we discuss strategies for surface-code quantum computing on small, intermediate and large scales. They are strategies for space-time trade-offs, going from slow...
Saved in:
Published in: | arXiv.org 2019-02 |
---|---|
Main Author: | |
Format: | Article |
Language: | English |
Subjects: | |
Online Access: | Get full text |
Tags: |
Add Tag
No Tags, Be the first to tag this record!
|
cited_by | |
---|---|
cites | |
container_end_page | |
container_issue | |
container_start_page | |
container_title | arXiv.org |
container_volume | |
creator | Litinski, Daniel |
description | Given a quantum gate circuit, how does one execute it in a fault-tolerant architecture with as little overhead as possible? In this paper, we discuss strategies for surface-code quantum computing on small, intermediate and large scales. They are strategies for space-time trade-offs, going from slow computations using few qubits to fast computations using many qubits. Our schemes are based on surface-code patches, which not only feature a low space cost compared to other surface-code schemes, but are also conceptually simple, simple enough that they can be described as a tile-based game with a small set of rules. Therefore, no knowledge of quantum error correction is necessary to understand the schemes in this paper, but only the concepts of qubits and measurements. As an example, assuming a physical error rate of \(10^{-4}\) and a code cycle time of 1 \(\mu\)s, a classically intractable 100-qubit quantum computation with a \(T\) count of \(10^8\) and a \(T\) depth of \(10^6\) can be executed in 4 hours using 55,000 qubits, in 22 minutes using 120,000 qubits, or in 1 second using 330,000,000 qubits. |
doi_str_mv | 10.48550/arxiv.1808.02892 |
format | article |
fullrecord | <record><control><sourceid>proquest</sourceid><recordid>TN_cdi_proquest_journals_2092780150</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2092780150</sourcerecordid><originalsourceid>FETCH-LOGICAL-a520-27a25dc337cfc7a84bc7fc7dcd28962a2584d5700fd8cb57ab0b6a393143e6a43</originalsourceid><addsrcrecordid>eNotTl1LwzAUDYLgmPsBvgV8br29SZrUtzF0igWR7X3cJmntWNvZpn78ewP6dA6cT8ZuMkilUQruaPxuP9PMgEkBTYEXbIFCZImRiFdsNU1HAMBco1JiwV7WfEud50PNd_NYk_V8Mzg_3fOSxsYnO0snz99m6sPcRak7z6HtG_7VhvdoCaGNiZhs_PhzzS5rOk1-9Y9Ltn982G-ekvJ1-7xZlwkphAQ1oXJWCG1rq8nIyupInHXxbY5RNNIpDVA7YyulqYIqJ1GITAqfkxRLdvtXex6Hj9lP4XAc5rGPiweEArWBTIH4BWtBTdA</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2092780150</pqid></control><display><type>article</type><title>A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery</title><source>Publicly Available Content Database</source><creator>Litinski, Daniel</creator><creatorcontrib>Litinski, Daniel</creatorcontrib><description>Given a quantum gate circuit, how does one execute it in a fault-tolerant architecture with as little overhead as possible? In this paper, we discuss strategies for surface-code quantum computing on small, intermediate and large scales. They are strategies for space-time trade-offs, going from slow computations using few qubits to fast computations using many qubits. Our schemes are based on surface-code patches, which not only feature a low space cost compared to other surface-code schemes, but are also conceptually simple, simple enough that they can be described as a tile-based game with a small set of rules. Therefore, no knowledge of quantum error correction is necessary to understand the schemes in this paper, but only the concepts of qubits and measurements. As an example, assuming a physical error rate of \(10^{-4}\) and a code cycle time of 1 \(\mu\)s, a classically intractable 100-qubit quantum computation with a \(T\) count of \(10^8\) and a \(T\) depth of \(10^6\) can be executed in 4 hours using 55,000 qubits, in 22 minutes using 120,000 qubits, or in 1 second using 330,000,000 qubits.</description><identifier>EISSN: 2331-8422</identifier><identifier>DOI: 10.48550/arxiv.1808.02892</identifier><language>eng</language><publisher>Ithaca: Cornell University Library, arXiv.org</publisher><subject>Computation ; Cycle time ; Error correction ; Fault tolerance ; Gates (circuits) ; Quantum computing ; Quantum theory ; Qubits (quantum computing)</subject><ispartof>arXiv.org, 2019-02</ispartof><rights>2019. This work is published under http://creativecommons.org/licenses/by/4.0/ (the “License”). Notwithstanding the ProQuest Terms and Conditions, you may use this content in accordance with the terms of the License.</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://www.proquest.com/docview/2092780150?pq-origsite=primo$$EHTML$$P50$$Gproquest$$Hfree_for_read</linktohtml><link.rule.ids>780,784,25753,27925,37012,44590</link.rule.ids></links><search><creatorcontrib>Litinski, Daniel</creatorcontrib><title>A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery</title><title>arXiv.org</title><description>Given a quantum gate circuit, how does one execute it in a fault-tolerant architecture with as little overhead as possible? In this paper, we discuss strategies for surface-code quantum computing on small, intermediate and large scales. They are strategies for space-time trade-offs, going from slow computations using few qubits to fast computations using many qubits. Our schemes are based on surface-code patches, which not only feature a low space cost compared to other surface-code schemes, but are also conceptually simple, simple enough that they can be described as a tile-based game with a small set of rules. Therefore, no knowledge of quantum error correction is necessary to understand the schemes in this paper, but only the concepts of qubits and measurements. As an example, assuming a physical error rate of \(10^{-4}\) and a code cycle time of 1 \(\mu\)s, a classically intractable 100-qubit quantum computation with a \(T\) count of \(10^8\) and a \(T\) depth of \(10^6\) can be executed in 4 hours using 55,000 qubits, in 22 minutes using 120,000 qubits, or in 1 second using 330,000,000 qubits.</description><subject>Computation</subject><subject>Cycle time</subject><subject>Error correction</subject><subject>Fault tolerance</subject><subject>Gates (circuits)</subject><subject>Quantum computing</subject><subject>Quantum theory</subject><subject>Qubits (quantum computing)</subject><issn>2331-8422</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2019</creationdate><recordtype>article</recordtype><sourceid>PIMPY</sourceid><recordid>eNotTl1LwzAUDYLgmPsBvgV8br29SZrUtzF0igWR7X3cJmntWNvZpn78ewP6dA6cT8ZuMkilUQruaPxuP9PMgEkBTYEXbIFCZImRiFdsNU1HAMBco1JiwV7WfEud50PNd_NYk_V8Mzg_3fOSxsYnO0snz99m6sPcRak7z6HtG_7VhvdoCaGNiZhs_PhzzS5rOk1-9Y9Ltn982G-ekvJ1-7xZlwkphAQ1oXJWCG1rq8nIyupInHXxbY5RNNIpDVA7YyulqYIqJ1GITAqfkxRLdvtXex6Hj9lP4XAc5rGPiweEArWBTIH4BWtBTdA</recordid><startdate>20190203</startdate><enddate>20190203</enddate><creator>Litinski, Daniel</creator><general>Cornell University Library, arXiv.org</general><scope>8FE</scope><scope>8FG</scope><scope>ABJCF</scope><scope>ABUWG</scope><scope>AFKRA</scope><scope>AZQEC</scope><scope>BENPR</scope><scope>BGLVJ</scope><scope>CCPQU</scope><scope>DWQXO</scope><scope>HCIFZ</scope><scope>L6V</scope><scope>M7S</scope><scope>PIMPY</scope><scope>PQEST</scope><scope>PQQKQ</scope><scope>PQUKI</scope><scope>PRINS</scope><scope>PTHSS</scope></search><sort><creationdate>20190203</creationdate><title>A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery</title><author>Litinski, Daniel</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a520-27a25dc337cfc7a84bc7fc7dcd28962a2584d5700fd8cb57ab0b6a393143e6a43</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2019</creationdate><topic>Computation</topic><topic>Cycle time</topic><topic>Error correction</topic><topic>Fault tolerance</topic><topic>Gates (circuits)</topic><topic>Quantum computing</topic><topic>Quantum theory</topic><topic>Qubits (quantum computing)</topic><toplevel>online_resources</toplevel><creatorcontrib>Litinski, Daniel</creatorcontrib><collection>ProQuest SciTech Collection</collection><collection>ProQuest Technology Collection</collection><collection>Materials Science & Engineering Collection</collection><collection>ProQuest Central (Alumni)</collection><collection>ProQuest Central</collection><collection>ProQuest Central Essentials</collection><collection>AUTh Library subscriptions: ProQuest Central</collection><collection>Technology Collection</collection><collection>ProQuest One Community College</collection><collection>ProQuest Central Korea</collection><collection>SciTech Premium Collection</collection><collection>ProQuest Engineering Collection</collection><collection>Engineering Database</collection><collection>Publicly Available Content Database</collection><collection>ProQuest One Academic Eastern Edition (DO NOT USE)</collection><collection>ProQuest One Academic</collection><collection>ProQuest One Academic UKI Edition</collection><collection>ProQuest Central China</collection><collection>Engineering collection</collection><jtitle>arXiv.org</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Litinski, Daniel</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery</atitle><jtitle>arXiv.org</jtitle><date>2019-02-03</date><risdate>2019</risdate><eissn>2331-8422</eissn><abstract>Given a quantum gate circuit, how does one execute it in a fault-tolerant architecture with as little overhead as possible? In this paper, we discuss strategies for surface-code quantum computing on small, intermediate and large scales. They are strategies for space-time trade-offs, going from slow computations using few qubits to fast computations using many qubits. Our schemes are based on surface-code patches, which not only feature a low space cost compared to other surface-code schemes, but are also conceptually simple, simple enough that they can be described as a tile-based game with a small set of rules. Therefore, no knowledge of quantum error correction is necessary to understand the schemes in this paper, but only the concepts of qubits and measurements. As an example, assuming a physical error rate of \(10^{-4}\) and a code cycle time of 1 \(\mu\)s, a classically intractable 100-qubit quantum computation with a \(T\) count of \(10^8\) and a \(T\) depth of \(10^6\) can be executed in 4 hours using 55,000 qubits, in 22 minutes using 120,000 qubits, or in 1 second using 330,000,000 qubits.</abstract><cop>Ithaca</cop><pub>Cornell University Library, arXiv.org</pub><doi>10.48550/arxiv.1808.02892</doi><oa>free_for_read</oa></addata></record> |
fulltext | fulltext |
identifier | EISSN: 2331-8422 |
ispartof | arXiv.org, 2019-02 |
issn | 2331-8422 |
language | eng |
recordid | cdi_proquest_journals_2092780150 |
source | Publicly Available Content Database |
subjects | Computation Cycle time Error correction Fault tolerance Gates (circuits) Quantum computing Quantum theory Qubits (quantum computing) |
title | A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery |
url | http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-27T18%3A16%3A23IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=A%20Game%20of%20Surface%20Codes:%20Large-Scale%20Quantum%20Computing%20with%20Lattice%20Surgery&rft.jtitle=arXiv.org&rft.au=Litinski,%20Daniel&rft.date=2019-02-03&rft.eissn=2331-8422&rft_id=info:doi/10.48550/arxiv.1808.02892&rft_dat=%3Cproquest%3E2092780150%3C/proquest%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-a520-27a25dc337cfc7a84bc7fc7dcd28962a2584d5700fd8cb57ab0b6a393143e6a43%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_pqid=2092780150&rft_id=info:pmid/&rfr_iscdi=true |