          Agree & Join LinkedIn
        
  By clicking Continue to join or sign in, you agree to LinkedIn’s User Agreement, Privacy Policy, and Cookie Policy.
🚀 Excited to share that our paper 𝑸𝒖𝒂𝒏𝒕𝒖𝒎 𝑺𝒒𝒖𝒆𝒆𝒛𝒊𝒏𝒆𝒔𝒔: 𝑰𝒏𝒇𝒐𝒓𝒎𝒂𝒕𝒊𝒐𝒏-𝑻𝒉𝒆𝒐𝒓𝒆𝒕𝒊𝒄 𝑭𝒐𝒖𝒏𝒅𝒂𝒕𝒊𝒐𝒏𝒔 𝒐𝒇 𝑸𝒖𝒂𝒏𝒕𝒖𝒎 𝑺𝒐𝒇𝒕𝒘𝒂𝒓𝒆 𝑻𝒆𝒔𝒕𝒂𝒃𝒊𝒍𝒊𝒕𝒚 received a 𝐬𝐭𝐫𝐚𝐢𝐠𝐡𝐭 𝐚𝐜𝐜𝐞𝐩𝐭𝐚𝐧𝐜𝐞 𝐚𝐭 𝐀𝐒𝐄 2026!

Software testability has been a foundational concept in software engineering for decades, shaping how we reason about fault detection, debugging, and software quality. Yet, despite rapid advances in quantum computing, there has been no formal notion of testability for quantum software.

In this work, we take a first step toward closing that gap by introducing the 𝐟𝐢𝐫𝐬𝐭 𝐟𝐨𝐫𝐦𝐚𝐥𝐢𝐬𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 𝐪𝐮𝐚𝐧𝐭𝐮𝐦 𝐬𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐭𝐞𝐬𝐭𝐚𝐛𝐢𝐥𝐢𝐭𝐲. Building on classical software engineering and quantum information theory, we define 𝑸𝒖𝒂𝒏𝒕𝒖𝒎 𝑺𝒒𝒖𝒆𝒆𝒛𝒊𝒏𝒆𝒔𝒔—an information-theoretic measure that captures how much information about a fault is lost as it propagates through a quantum program.

The key idea is simple: if faults are masked before they reach observable outcomes, the software becomes harder to test. Quantum Squeeziness quantifies this phenomenon, providing a rigorous foundation for reasoning about fault propagation, observability, and test effectiveness in quantum systems. Across 50,000+ mutants, we show that higher squeeziness strongly predicts lower fault detectability, while our optimized 𝑭𝒂𝒔𝒕𝑺𝒒𝒖𝒆𝒆𝒛𝒊𝒏𝒆𝒔𝒔 technique achieves a 16.9× speedup with 95% accuracy.

Beyond testing and debugging, we believe this opens new research directions at the intersection of software engineering, quantum information theory, and quantum reliability, with potential applications in 𝐞𝐫𝐫𝐨𝐫 𝐦𝐢𝐭𝐢𝐠𝐚𝐭𝐢𝐨𝐧, 𝐟𝐚𝐮𝐥𝐭 𝐭𝐨𝐥𝐞𝐫𝐚𝐧𝐜𝐞, 𝐚𝐧𝐝 𝐝𝐞𝐬𝐢𝐠𝐧-𝐟𝐨𝐫-𝐭𝐞𝐬𝐭𝐚𝐛𝐢𝐥𝐢𝐭𝐲 𝐨𝐟 𝐟𝐮𝐭𝐮𝐫𝐞 𝐪𝐮𝐚𝐧𝐭𝐮𝐦 𝐬𝐨𝐟𝐭𝐰𝐚𝐫𝐞.

Very proud of this contribution and grateful to my co-authors and collaborators throughout the journey.

See you in Munich for ASE 2026! 🇩🇪 Congratulations Héctor Menéndez and Mohammad Reza Mousavi!Fantastic 🎉 congratulations, Avner Bensoussan 👏👏Congratulations Avner! 🥳 To view or add a comment, sign in 🚀 Our paper has been accepted at the 19th IEEE International Conference on Software Testing, Verification and Validation (ICST 2026).

📄 𝘛𝘰𝘸𝘢𝘳𝘥 𝘓𝘪𝘷𝘦 𝘕𝘰𝘪𝘴𝘦 𝘍𝘪𝘯𝘨𝘦𝘳𝘱𝘳𝘪𝘯𝘵𝘪𝘯𝘨 𝘧𝘰𝘳 𝘋𝘪𝘴𝘤𝘳𝘦𝘱𝘢𝘯𝘤𝘺 𝘈𝘯𝘢𝘭𝘺𝘴𝘪𝘴 𝘪𝘯 𝘘𝘶𝘢𝘯𝘵𝘶𝘮 𝘚𝘰𝘧𝘵𝘸𝘢𝘳𝘦 𝘌𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘪𝘯𝘨 🔗 https://lnkd.in/ehw2Mskw

Noise remains a fundamental obstacle to reliable quantum software — yet current models are often static, coarse, and misaligned with real system behaviour.

In this work, we introduce 𝒍𝒊𝒗𝒆 𝒏𝒐𝒊𝒔𝒆 𝒇𝒊𝒏𝒈𝒆𝒓𝒑𝒓𝒊𝒏𝒕𝒊𝒏𝒈, a lightweight and empirical approach to characterising noisy quantum systems.

Our key idea: → leverage 𝒄𝒍𝒂𝒔𝒔𝒊𝒄𝒂𝒍 𝒔𝒉𝒂𝒅𝒐𝒘 𝒕𝒆𝒄𝒉𝒏𝒊𝒒𝒖𝒆𝒔 to build compact, updatable fingerprints of noise → enable efficient comparison of quantum states and platforms (e.g., Qiskit vs Cirq) → support practical workflows for 𝒕𝒆𝒔𝒕𝒊𝒏𝒈, 𝒅𝒆𝒃𝒖𝒈𝒈𝒊𝒏𝒈, and 𝒄𝒓𝒐𝒔𝒔-𝒑𝒍𝒂𝒕𝒇𝒐𝒓𝒎 𝒗𝒂𝒍𝒊𝒅𝒂𝒕𝒊𝒐𝒏

We implement this vision in SIMSHADOW, showing that fingerprints: • capture structured, interpretable noise patterns • reveal systematic cross-platform discrepancies • correlate with observable divergences in program outputs

More broadly, this work bridges 𝒒𝒖𝒂𝒏𝒕𝒖𝒎 𝒊𝒏𝒇𝒐𝒓𝒎𝒂𝒕𝒊𝒐𝒏 𝒕𝒉𝒆𝒐𝒓𝒚 and 𝒔𝒐𝒇𝒕𝒘𝒂𝒓𝒆 𝒕𝒆𝒔𝒕𝒊𝒏𝒈, moving toward more reliable and portable quantum software systems. To view or add a comment, sign in Some time ago, I read a quantum error correction paper that really caught my attention. It focused on a specific adaptive syndrome measurement protocol, but the broader takeaway was what got me excited: classical feedforward can be used to drastically reduce logical errors.

It also forced me to rethink a lot of what I knew about decoding. Specifically, decoding hypergraphs (which are used alongside the syndrome to accurately correct errors) could no longer be built ahead of time. They had to be assembled just-in-time. Otherwise, memory requirements scale exponentially, making static setups completely impractical for most real-world systems.

Of course, many of us rely on Stim to generate detector error models and compile decoding hypergraphs. But its execution latency is simply too high for online, just-in-time generation, even on “slow-clock” platforms like neutral atom and trapped ion systems.

In our recent paper, we propose a parallel formulation of Stim’s backtracking algorithm and implement it in a new GPU-accelerated compiler called GreenPeas. On select benchmarks, it achieves a geometric mean speedup of 13.2× over Stim, enabling adaptive circuit simulations and deployments that were previously impractical.

Example: we circuit-level decoded [[4, 2, 2]]-concatenated surface codes with adaptive syndrome measurements by building decoding hypergraphs on-the-fly with GreenPeas. The result: 6.7× fewer logical errors and 4.5× faster decoding relative to prior phenomenological approaches.

GreenPeas is fully open-source. If you know C (and some of the good parts of C++), please consider contributing.

Paper: https://lnkd.in/dU3EC3zC Code: https://lnkd.in/d8JcGDVf To view or add a comment, sign in It’s (a)live ! Designing Quantum Error Correcting Codes to fit decoders via Reinforcement Learning https://lnkd.in/ez3MExu4

We turn the workflow of designing a code than evaluating it around: fix the decoder architecture first, then train a PPO agent to generate Bivariate Bicycle (BB) codes that maximise that decoder’s performance under a depolarising noise model. What comes out is a generative model for codes, conditioned on the decoder you actually intend to deploy.

As a byproduct we accumulated a (growing) dataset of codes, for those who are interested using them for supervised learning. #QuantumComputing #QuantumErrorCorrection #ReinforcementLearning #qLDPC To view or add a comment, sign in Isn’t superdense coding weird? In general, a qubit can only encode one bit of information (due to Holevo’s Theorem). So, if Alice wants to send 2 classical bits of information to Bob using qubits, she must send 2 of them. But let’s consider superdense coding for a moment. Superdense coding is a protocol in quantum information that allows Alice to send 2 classical bits by sending one qubit, provided that they both already share an EPR pair (i.e. a maximally entangled pair of qubits). I’ll link a more complete explanation of superdense coding in the comments.

This seems pretty straightforward, and makes intuitive sense: Alice effectively sends 2 qubits to Bob, so in terms of capacity, it is no wonder she can “exchange” these 2 qubits with two bits.

But what happens if we look at the same protocol a bit differently? What if instead of Alice preparing the initial EPR pair, Bob produces it, and then sends one qubit to Alice. The protocol is still exactly the same, since our pre-condition is that Alice and Bob share an EPR pair. However, this time, Alice only ever sends one qubit to Bob, but still manages to transmit 2 bits of information!

Of course, this doesn’t violate Holevo’s Theorem - since Alice and Bob do share an EPR pair to begin with, which assists in increasing the classical capacity.

This perspective was first brought to my attention by my supervisor, Michael Ben-Or, and it is one of those cool examples where entanglement kind of “breaks” the classical intuition. To view or add a comment, sign in Our latest paper was accepted for ICST short papers, vision and emerging result track! 🥳

“Towards Live Noise Fingerprinting for Discrepancy Analysis in Quantum Software Engineering”

            PhD Candidate | Hybrid Quantum–Classical Architectures | Quantum Software Testability | King’s College London
        🚀 Our paper has been accepted at the 19th IEEE International Conference on Software Testing, Verification and Validation (ICST 2026).

Noise remains a fundamental obstacle to reliable quantum software — yet current models are often static, coarse, and misaligned with real system behaviour.

More broadly, this work bridges 𝒒𝒖𝒂𝒏𝒕𝒖𝒎 𝒊𝒏𝒇𝒐𝒓𝒎𝒂𝒕𝒊𝒐𝒏 𝒕𝒉𝒆𝒐𝒓𝒚 and 𝒔𝒐𝒇𝒕𝒘𝒂𝒓𝒆 𝒕𝒆𝒔𝒕𝒊𝒏𝒈, moving toward more reliable and portable quantum software systems. To view or add a comment, sign in 🚀𝗦𝗶𝗺𝘂𝗹𝗮𝘁𝗶𝗻𝗴 𝗤-𝗖𝗧𝗥𝗟’𝘀 𝗘𝘅𝗽𝗲𝗿𝗶𝗺𝗲𝗻𝘁𝘀 𝘄𝗶𝘁𝗵 𝗠𝗣𝗢-𝗕𝗮𝘀𝗲𝗱 𝗖𝗹𝗮𝘀𝘀𝗶𝗰𝗮𝗹 𝗦𝗶𝗺𝘂𝗹𝗮𝘁𝗶𝗼𝗻

Recent impressive experiments by Q-CTRL on IBM Heron r3 used a rescaling-based, 𝗵𝗲𝘂𝗿𝗶𝘀𝘁𝗶𝗰 𝗲𝗿𝗿𝗼𝗿-𝗺𝗶𝘁𝗶𝗴𝗮𝘁𝗶𝗼𝗻 𝗺𝗲𝘁𝗵𝗼𝗱 to simulate quench dynamics in the 1D half-filled Fermi-Hubbard model. They reported a ~3000× runtime advantage over their classical simulation benchmark. We think the key lesson is more nuanced. The many-body state generated by these circuits may indeed be demanding to evolve accurately with standard Schrödinger-picture classical MPS methods (the benchmark used in this paper). However, for these circuits, Heisenberg-picture classical simulation methods appear to be much more effective for computing expectation values. A standard classical simulation method for one-dimensional quantum dynamics is based on matrix-product operators. QEDMA’s Application Team Lead, Ori Alberton, used an MPO-based Heisenberg evolution of the relevant observables, implemented with the widely used open-source ITensors.jl library, to reproduce the reported dynamics to an 𝗮𝗰𝗰𝘂𝗿𝗮𝗰𝘆 𝗯𝗲𝘁𝘁𝗲𝗿 𝘁𝗵𝗮𝗻 𝟬.𝟬𝟭. The simulation ran on a 𝗹𝗮𝗽𝘁𝗼𝗽 (𝗠𝟮 𝗠𝗮𝗰𝗯𝗼𝗼𝗸 𝗽𝗿𝗼) in about 𝗳𝗶𝘃𝗲 𝗺𝗶𝗻𝘂𝘁𝗲𝘀. This is consistent with the broader point also highlighted by Algorithmiq’s Majorana propagation and BlueQubit’s Pauli propagation results. The fact that the simple rescaling-based error mitigation method performed well for these specific circuits is interesting. This is probably due to the fact that for this specific circuit, the effect of hardware noise on the results seems to be small compared to generic circuits with the same volume. This is also the reason for the low overhead in terms of extra shots that were required to obtain the error-mitigated result with a small statistical error. It would be interesting to further understand whether there is a correlation between the low complexity required for the classical simulation and the low overhead for applying error mitigation. The MPO simulation is based on the Heisenberg evolution of the observable of interest. Notably, if one wants to compute multiple observables, this task is straightforwardly parallelizable, so the wall-clock time for computing a single observable and multiple observables is the same. Our conclusion: Demonstrating quantum advantage requires advanced error mitigation methods.

            532 followers
        ✨ Join QIP 2026 and don’t miss the opportunity to attend Dorit Aharonov's tutorial!  ✨Dorit Aharonov is a professor of computer science at the Hebrew University of Jerusalem and co-founder and CSO of QEDMA Quantum Computing. She co-proved the quantum fault-tolerance theorem and has made pioneering contributions in quantum algorithms, Hamiltonian complexity, and quantum cryptography.   🔹 Noise and errors remain the main barrier to practical quantum computation. While recent demonstrations of small-scale fault-tolerant computations validate the long-term promise of error correction, the large qubit overheads and limited qubit counts in current devices delay its practical impact. Error mitigation is an approach to quantum error reduction that trades qubit overhead for additional quantum processing time, enabling larger circuits on today’s hardware. It has thus become the leading strategy toward near term quantum advantage.   This tutorial will survey major error mitigation methods, including probabilistic error cancellation, zero-noise extrapolation (ZNE) and other advanced methods. Dorit Aharonov will present experimental results on large circuits and, on the other hand, discuss theoretical limits on error mitigation at large scales. Finally she will outline how error mitigation can be combined with error correction in a hybrid manner, to optimize the use of time and qubit resources, accelerate the path to quantum advantage, and provide significant benefits even when full fledged fault tolerant quantum computers are available.

📅 The tutorial will take place on Sunday, 25 January, 2026 🔗 Learn more about QIP 2026: https://qip2026.lu.lv To view or add a comment, sign in What does it mean for an answer to become “stronger” in a quantum algorithm? Quantum Computing Series - Post #11

In the last post, we talked about waves and interference. We said that the goal of a quantum algorithm is to make useful answers “stronger” and useless answers fade, before measurement. But what does “stronger” actually mean?

In quantum computing, we do not directly see all the possible answers. When we measure, we only get one result. So “stronger” does not mean the answer is visible during the computation. It means that a useful answer becomes more likely to appear when we measure.

This is where interference becomes important. During the computation, the quantum state evolves. Different possible evolutions of the quantum state can interfere with each other. Some possible states reinforce certain outcomes, making them more likely to appear when we measure.

A good quantum algorithm that exploits interference is designed so that, by the end: • useful answers have higher probability • less useful answers have lower probability Then we measure. And if the algorithm works as intended, the result is more likely to be the correct answer.

This is very different from a classical algorithm. A classical algorithm usually tries to identify the answer step by step. A quantum algorithm shapes the probabilities before the final measurement.

So again, quantum algorithms are not about “trying all answers at once”. They are about carefully guiding interference to make useful answers more likely.

Until next time: Grover’s algorithm - a first example of quantum speedup. To view or add a comment, sign in If you need to know better your landscape, the influence of parameters, a detection of barren plateaus, or other geometric caracterization, this is the tool you need!! 5,136 followers 🌄 Introducing Landscape Tools, our new open-source Python library for variational quantum algorithms

Understanding why a quantum model fails to train is one of the hardest challenges in quantum machine learning. That’s exactly what Landscape Tools is built to solve. We’ve been developing this library to give researchers a clear, hands-on way to visualize and analyze the loss landscapes of variational quantum circuits, and we’re excited to share it.

What it does: 🔍 1D, 2D & 3D loss scans across parameter space 📉 PCA-based landscape projections 🛤️ Optimization trajectory visualization 🎛️ Parameter-sensitivity analysis directly on quantum circuits 📊 Barren plateau diagnostics via variance-based scaling analyses (circuit depth, qubit count, observables, Pauli-string padding)

Whether you’re debugging a trainability issue or exploring how your ansatz behaves across parameter space, Landscape Tools gives you the interpretability layer that’s often missing in QML workflows.

Built with quantum ML experiments in mind. Designed to help you stop guessing, and start understanding. 🔗 Learn more about it here : https://lnkd.in/eHEj8XkV

#QuantumComputing #GitHub #opensource Paolo Fittipaldi, Gabriel Legros To view or add a comment, sign in I’m sharing a full open-source implementation of a 𝗤𝘂𝗮𝗻𝘁𝘂𝗺 𝗜𝗻𝘁𝗲𝗿𝗶𝗼𝗿 𝗣𝗼𝗶𝗻𝘁 𝗠𝗲𝘁𝗵𝗼𝗱 algorithm for continuous and constrained portfolio optimization in Qiskit, based on “Quantum Algorithms for Portfolio Optimization” by Iordanis Kerenidis, Anupam Prakash & Daniel Szilagyi.

The algorithm supports continuous portfolio allocation with realistic nonlinear constraints.

Reusable quantum building blocks. HHL solver, Hermitian dilation, SOCP reformulation, and the short-step IPM loop extracted into clean, flexible modules.

𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵/𝗾𝘂𝗮𝗻𝘁𝘂𝗺_𝗶𝗽𝗺_𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵.𝗶𝗽𝘆𝗻𝗯

The full implementation. Runs on 12 real assets, live market data via yfinance, Qiskit Aer simulator, and every run logger to JSON. A toy model by quantum hardware standards, but a paper-faithful implementation.

𝘄𝗼𝗿𝗸𝘀𝗵𝗼𝗽/𝗾𝘂𝗮𝗻𝘁𝘂𝗺_𝗽𝗼𝗿𝘁𝗳𝗼𝗹𝗶𝗼_𝘁𝘂𝘁𝗼𝗿𝗶𝗮𝗹.𝗶𝗽𝘆𝗻𝗯

A 60 min self-contained tutorial. Three pipelines, one story: a classical IPM baseline, a plain HHL run on equality constraints only as QIPM motivation, and the full Quantum IPM with HHL as the Newton-step subroutine. Includes student/instructor toggle tasks. A bonus Classiq version is also available.

Quantum hardware and HHL-based algorithms still have a way to go before they meet in practice. But what I found fascinating is the structure.

The algorithm keeps the classical optimization framework, while asking whether one of its computationally heavy steps, the linear-system solution, could be replaced by a quantum linear-system solver under suitable assumptions.

This is where practical questions arise: conditioning, sparsity, block encoding, approximation error, readout limitations, and the integration of nonlinear constraints. When does it make sense, and when not?

I find it compelling in Quantum Applications to identify the computational bottleneck, understand its assumptions, and assess where a quantum algorithm can realistically fit.

Thanks to PD Dr. Jeanette Lorenz for the opportunity to dive deep into both theory and practice through the Applications of Quantum Computing course at Ludwig-Maximilians-Universität München.

Drop a comment if quantum optimization, linear-system solvers, or quantitative finance is on your mind. Feel free to star/fork and further collaborate on the project through GitHub.

#QuantumComputing #Qiskit #PortfolioOptimization #OpenSource #LMU To view or add a comment, sign in

        1,195 followers
      
                  Create your free account or sign in to continue your search
                
                  or
                
                New to LinkedIn? Join now
              
  By clicking Continue to join or sign in, you agree to LinkedIn’s User Agreement, Privacy Policy, and Cookie Policy.