Riverlane’s Post

THE BIG IF. “Alternatively, making the time-reversal of the anticipated computed state and running the same evolution drives the computer back to its initial state if and only if the computer really made a correct computation. The initial state is typically non-entangled and therefore its verification is an easy task.” https://lnkd.in/dk5ibMWs

A key takeaway, for me: "To probe the limits of our error-correction performance, we run repetition codes up to distance-29 and find that logical performance is limited by rare correlated error events occurring approximately once every hour, or 3×10^9 cycles." And "These errors, whose origins are not yet understood, set a current error floor of 10^−10." Is this a hard wall, or a mere speedbump awaiting a technical workaround? Indeed, do such errors of unknown origin occur using other qubit technologies (particularly trapped-ion and neutral-atom or silicon-spin quantum dots), such that high-distance codes might become essential so that any fantasies about the utility of low-distance codes may be sadly misguided? So, read the fine print carefully for any error correction scheme - exactly which error modalities does it detect and correct, and which does it not detect or correct, or at what cost. Another important takeaway, for me, is that there is some brief discussion of defects which cause TLS (two-level systems - the defect acts as if it were another qubit) - "Prior to the repeated runs, we employ a frequency optimization strategy which forecasts defect frequencies of two-level systems (TLS). This helps to avoid qubits coupling to TLSs during the initial calibration as well as over the duration of the experiments." But much more awareness and research of this issue is needed. Do other qubit technologies have a comparable issue or is it peculiar to transmon qubits. Even if trapped-ion and neutral-atom qubits don't have this issue, what about quantum dots and silicon-spin qubits in particular? There is some brief mention of previous work related to large error bursts due to high-energy impact events (cosmic rays, background radiation), but not enough discussion of whether all such errors are detected and corrected, and at what cost. Another big question mark for any error correction scheme. In fact, I wonder what the implications might be for deploying quantum computers or other quantum technologies in outer space. #QuantumErrorCorrection #QEC #LogicalQubits #PracticalQuantumComputing #GoogleQuantum #GoogleQuantumAI #QuantumComputing #QuantumApplications #QuantumAlgorithms #QuantumInformationScience #QIS #QuantumTechnologies #QuantumTech #Quantum

Lessons from the Recent Global outage by Blue Screen of Death (part -1) Obviously, It’s Not Only a Single Issue It is evident that the recent BSOD (Blue Screen of Death) incident is not merely a problem of a single component. This event presents challenges and insights that warrant deep exploration, reflection, and lessons to be learned. From my current understanding, it is likely that multiple issues are at play. Here are some preliminary observations: 1. **Code Logic or Architecture Issues**:   - **Reason**: The global scale of the problem suggests it is not merely a dynamic boundary issue but rather a significant flaw within the code logic or architecture.   - **Analysis**: Specifically, the issue may involve a significant problem within the Falcon sensor's code. One plausible reason could be the adoption of advanced technologies and models. These advanced algorithms might have led to cross-dimensional parameters and features being assigned overly high permissions, thereby disrupting the balance within the existing security framework. This disruption can cause the system to behave unpredictably and fail to handle exceptions properly.   - The BSOD incident may stem from severe defects within the code logic or architecture. The complexity and interdependence of various system components might have led to unforeseen interactions and errors that were not adequately covered in the testing phases. 2. **Detection Sensitivity and Balance**:   - **Reason**: The BSOD was triggered by excessive CPU utilization due to misclassification of events. This misclassification likely stems from feature extraction across dimensions in ML learning, leading to erroneous risk assessments. Although a low probability event, it deviates from the original design principles and framework, causing issues outside the established framework.   - The sensitivity in machine learning models requires dynamic adjustment to balance false positives and false negatives. Implementing adaptive models and online learning mechanisms can effectively address this issue. ...... Sincerely yours,   Xiaowen Kang xiaowenseekjob@gmail.com 2024.7.20.06.25

#OurNewAddition #PublishedArticle #CongratulationsVinayUpInHaven!!! Optimizing Network Convergence for Efficient Data Transmission in Server-to-Client Environments: A Comparative Analysis of Dynamic Routing Protocols Using OPNET Simulation https://lnkd.in/gc85YJMq

New preprint! We consider transfer of Gaussian states through complex networks. Even in a relatively formless network external users coupling to a node in the network are not equal as transfer fidelity depends on the degree of the node. If the network has a community structure, meaning that it can be decomposed into subnetworks with higher link density, it can support multiple independent transfers; what we here call routing. Finally, we present results suggesting that networks of sufficient complexity may have subtle features giving them an edge over superficially simular random networks. Warmest thanks to our collaborators and friends at Algorithmiq! https://lnkd.in/dkAMFwNH #complexnetworks #quantummechanics

Interesting paper - Using Big Data with Quantum by reducing the dataset needed while incurring some additional error. "Big data applications on small quantum computers" https://lnkd.in/e5SZRuYV coresets - technique allows a large collection of data X to be replaced (to within an error ϵ) by a weighted data set (X′ , w) with a significantly reduced size.

qLDPC codes reduce space overhead for fault tolerance, but logical computations with them often require serialized operations, increasing time costs. Looking for more efficient logical operations? Check out this new work from University of Chicago, Harvard University and QuEra Computing Inc. Fast and Parallelizable Logical Computation with Homological Product Codes https://hubs.ly/Q02J_L6Q0

New paper with David Aasen and Parsa Bonderson up on arXiv: "A fault-tolerant pairwise measurement-based code on eight qubits", https://lnkd.in/gtvnaQw6 To our knowledge, this is the smallest fault-tolerantly error correcting Floquet code so far -- if anyone constructs one on less than eight qubits, or proves that it would be impossible to do so, please let me know! :)

Without error correction, a quantum computer outputs random answers... but so does a quantum computer WITH error correction! So, what's the difference? Is there "good" and "bad" randomness? Well, there is. Random doesn't mean fully unpredictable. For example, when you play at the lottery, the outcome is random, but it is still fairly predictable that you're going to lose money. In other words, you lose money with a high probability. Similarly, quantum algorithms are designed to yield useful results with a high probability. But not every time. This means that even on an error-free quantum computer, there's always a chance you'll get a bad result. Let's take an example illustrated by the graphs below. We run Grover's search algorithm and try to retrieve one of three states: 000, 011 or 101. The algorithm succeeds if the result is one of these three values, it fails otherwise. On the left, we use a noiseless emulator ("good" random). On the right, we use a noisy emulator ("bad" random). As you can see, even when there are no errors, the algorithm sometimes fails and returns a bad result. This is by design, and a consequence of pure randomness. But when there are errors, the algorithm fails more often. In this example, we picked a tuning which doesn't completely kill good results, but higher noise levels would cause good results to simply vanish. This example was made using the logical qubit emulator of Felis, featuring tunable noise levels. Check out the sample notebook in the comments: will you manage to make the results so bad that the good solutions no longer stand out?

I have been experimenting with various Post Quantum Digital Signature schemes. The first 2 are Falcon, and Sphincs+. Falcon is a Lattice based algorythim, while Sphincs+ uses a hash based system. It seems that most of the (proposed) Post Quantum algoryhims use Lattices, so it makes sense in my mind that Sphincs+(being hash-based) is a good choice for Digital Signatures, effectively load balancing some of that risk. In order to use these algorithims I had to write it all in C++( as the PQC libraries, mainly liboqs, are available only for C++) Anyway, I've signed this post with using Sphincs+. The keys produced by liboqs library are binary. So I've converted these into Bas64( as is general convention with DER > PEM, which I expect will continue to get used) Public Key: dEvnX2rxIak41IRsmx6Qp4xZXmdBj1ndzDUFSsrPC0c= Signature: ( it's too large to post, but it's here on GH: https://lnkd.in/e6UtVXZt)