Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

The Orthogonality Filter: Gram–Schmidt Projection in a Complex State Space

P. K. Majumdar

Published Aug 28, 2026• 0 citations
Publisher

Abstract

This Python/NumPy program generates a reproducible, normalised random quantum state and constructs its rank-one projection operator. It then generates a second complex state and applies the Gram–Schmidt procedure to remove every component parallel to the first state, producing a normalised orthogonal vector. The program verifies the inner-product orthogonality, confirms that the projector is Hermitian and idempotent, and demonstrates that applying the projector to the orthogonal state produces a vector whose norm is numerically zero within a declared floating-point tolerance. This illustrates, computationally, how a projector completely filters out a state that lies in its orthogonal complement.

DOI
10.5281/zenodo.22134802

Related papers

Constructing and Validating Quantum Projection Operators with NumPy

P. K. Majumdar

This program constructs a projection operator from a normalised complex state vector and verifies its Hermiticity, idempotence, trace and eigenvalues. It also generates the complementary projector, confirms that the two outcome projectors resolve the identity, and calculates measurement probabilities for an example input state. Numerical tolerances are used to accommodate floating-point arithmetic.

•Aug 25, 2026•0 citations

The State Measurement Engine: Validating and Applying a Quantum Projector

P. K. Majumdar

This Python/NumPy program implements an ideal projective measurement for a single-qubit state. It verifies that the supplied state is normalised and that the measurement operator is both Hermitian and idempotent. It then applies the Born rule to calculate the probability of the selected outcome. When the probability is non-zero, the program constructs and normalises the conditional post-measurement state; when the probability is zero within the specified numerical tolerance, it reports that the outcome cannot occur and avoids invalid normalisation of the zero vector. Two worked examples demonstrate both a possible and an impossible measurement outcome.

•Aug 28, 2026•0 citations

Orthogonality Check

P. K. Majumdar

This Jupyter Notebook provides a reproducible implementation for determining whether two complex quantum state vectors are orthogonal The notebook accompanies Chapter 2 of Quantum Computing Preliminaries and demonstrates how orthogonality is tested using the absolute value of the complex inner product The Python function accepts normalised or unnormalised state vectors and normalises them automatically before calculating their overlap The implementation validates that both inputs are finite nonempty one dimensional and equal in size It also rejects the zero vector because the zero vector cannot be normalised The calculation uses the NumPy vdot function to apply complex conjugation to the first vector correctly A numerical tolerance is used to determine whether the absolute overlap is sufficiently close to zero The function returns True when the states are orthogonal and False otherwise The notebook includes examples involving the computational zero state the computational one state the plus state and two unnormalised complex vectors The examples confirm that the computational zero and one states are orthogonal while the computational zero and plus states are not orthogonal The unnormalised complex example also demonstrates a pair of states that are not orthogonal Numerical assertions verify all calculated results The notebook requires Python 3 Jupyter Notebook or JupyterLab and NumPy No external datasets internet connection quantum computing framework or physical quantum hardware are required

•Aug 11, 2026•0 citations

Representing Quantum States using NumPy

P. K. Majumdar

This example demonstrates 1. Complex vectors 2. Scalar multiplication 3. Vector addition 4. Linear combinations 5. Vector space closure 6. Vector norms 7. State normalisation 8. Inner products 9. Orthogonality

•Aug 1, 2026•0 citations

Quantum Gram-Schmidt processes and their application to efficient state readout for quantum algorithms

Kaining Zhang, Min-Hsiu Hsieh, Liu Liu +1 more

Many quantum algorithms that claim speedup over their classical counterparts only generates quantum states as solutions instead of their final classical description. The additional step to decode quantum states into classical vectors normally will destroy the quantum advantage in most scenarios because all existing tomographic methods require runtime that is polynomial with respect to the state dimension. In this work, we present an efficient readout protocol that yields the classical vector form of the generated state, so it will achieve the end-to-end advantage for those quantum algorithms. Our protocol suits the case in which the output state lies in the row space of the input matrix, of rank $r$, that is stored in the quantum random access memory. The quantum resources for decoding the state in ${\ensuremath{\ell}}^{2}$ norm with $\ensuremath{\epsilon}$ error require $\mathrm{poly}(r,1/\ensuremath{\epsilon})$ copies of the output state and $\mathrm{poly}(r,{\ensuremath{\kappa}}^{r},1/\ensuremath{\epsilon})$ queries to the input oracles, where $\ensuremath{\kappa}$ is the condition number of the input matrix. With our readout protocol, we completely characterize the end-to-end resources for quantum linear equation solvers and quantum singular value decomposition. One of our technical tools is an efficient quantum algorithm for performing the Gram-Schmidt orthonormal procedure, which we believe will be of independent interest.

arXiv:2004.06421•Physical Review Research•Nov 1, 2021•12 citations

Qubit measurement probabilities with the Born rule

P. K. Majumdar

This Jupyter Notebook provides a reproducible numerical demonstration of the Born rule for projective measurements of a single qubit. It explains how a complex inner product is converted into a physically meaningful measurement probability. Using Python and NumPy, the notebook defines a validated function that calculates the probability amplitude between an initial quantum state and a measurement state. It then calculates the transition probability by taking the squared absolute value of that amplitude. The implementation checks that both state vectors are finite, one dimensional, equal in size and correctly normalised. It uses the NumPy vdot function to apply complex conjugation to the measurement state correctly. In the worked example, the qubit is prepared in the computational zero state and measured in the Pauli X basis. The calculation shows that the probabilities of obtaining the plus and minus outcomes are both 0.5. It also confirms that the two probabilities sum to 1. The numerical result is compared with the corresponding Bloch sphere prediction. The notebook verifies that the vector calculation and the geometric calculation both produce a transition probability of 0.5. Numerical consistency checks confirm agreement between the two calculation methods and verify probability conservation. The notebook requires Python 3, Jupyter Notebook or JupyterLab, and NumPy. It does not require a quantum computing framework or access to physical quantum hardware.

•Aug 11, 2026•0 citations
This Python/NumPy program generates a reproducible, normalised random quantum state and constructs its rank-one projection operator. It then generates a second complex state and applies the Gram–Schmidt procedure to remove every component parallel to the first state, producing a normalised orthogonal vector. The program verifies the inner-product orthogonality, confirms that the projector is Hermitian and idempotent, and demonstrates that applying the projector to the orthogonal state produces a vector whose norm is numerically zero within a declared floating-point tolerance. This illustrates, computationally, how a projector completely filters out a state that lies in its orthogonal complement.
This Python/NumPy program implements an ideal projective measurement for a single-qubit state. It verifies that the supplied state is normalised and that the measurement operator is both Hermitian and idempotent. It then applies the Born rule to calculate the probability of the selected outcome. When the probability is non-zero, the program constructs and normalises the conditional post-measurement state; when the probability is zero within the specified numerical tolerance, it reports that the outcome cannot occur and avoids invalid normalisation of the zero vector. Two worked examples demonstrate both a possible and an impossible measurement outcome.
This Jupyter Notebook provides a reproducible implementation for determining whether two complex quantum state vectors are orthogonal The notebook accompanies Chapter 2 of Quantum Computing Preliminaries and demonstrates how orthogonality is tested using the absolute value of the complex inner product The Python function accepts normalised or unnormalised state vectors and normalises them automatically before calculating their overlap The implementation validates that both inputs are finite nonempty one dimensional and equal in size It also rejects the zero vector because the zero vector cannot be normalised The calculation uses the NumPy vdot function to apply complex conjugation to the first vector correctly A numerical tolerance is used to determine whether the absolute overlap is sufficiently close to zero The function returns True when the states are orthogonal and False otherwise The notebook includes examples involving the computational zero state the computational one state the plus state and two unnormalised complex vectors The examples confirm that the computational zero and one states are orthogonal while the computational zero and plus states are not orthogonal The unnormalised complex example also demonstrates a pair of states that are not orthogonal Numerical assertions verify all calculated results The notebook requires Python 3 Jupyter Notebook or JupyterLab and NumPy No external datasets internet connection quantum computing framework or physical quantum hardware are required
Many quantum algorithms that claim speedup over their classical counterparts only generates quantum states as solutions instead of their final classical description. The additional step to decode quantum states into classical vectors normally will destroy the quantum advantage in most scenarios because all existing tomographic methods require runtime that is polynomial with respect to the state dimension. In this work, we present an efficient readout protocol that yields the classical vector form of the generated state, so it will achieve the end-to-end advantage for those quantum algorithms. Our protocol suits the case in which the output state lies in the row space of the input matrix, of rank rrr, that is stored in the quantum random access memory. The quantum resources for decoding the state in ${\ensuremath{\ell}}^{2}$ norm with $\ensuremath{\epsilon}$ error require $\mathrm{poly}(r,1/\ensuremath{\epsilon})$ copies of the output state and $\mathrm{poly}(r,{\ensuremath{\kappa}}^{r},1/\ensuremath{\epsilon})$ queries to the input oracles, where $\ensuremath{\kappa}$ is the condition number of the input matrix. With our readout protocol, we completely characterize the end-to-end resources for quantum linear equation solvers and quantum singular value decomposition. One of our technical tools is an efficient quantum algorithm for performing the Gram-Schmidt orthonormal procedure, which we believe will be of independent interest.
This Jupyter Notebook provides a reproducible numerical demonstration of the Born rule for projective measurements of a single qubit. It explains how a complex inner product is converted into a physically meaningful measurement probability. Using Python and NumPy, the notebook defines a validated function that calculates the probability amplitude between an initial quantum state and a measurement state. It then calculates the transition probability by taking the squared absolute value of that amplitude. The implementation checks that both state vectors are finite, one dimensional, equal in size and correctly normalised. It uses the NumPy vdot function to apply complex conjugation to the measurement state correctly. In the worked example, the qubit is prepared in the computational zero state and measured in the Pauli X basis. The calculation shows that the probabilities of obtaining the plus and minus outcomes are both 0.5. It also confirms that the two probabilities sum to 1. The numerical result is compared with the corresponding Bloch sphere prediction. The notebook verifies that the vector calculation and the geometric calculation both produce a transition probability of 0.5. Numerical consistency checks confirm agreement between the two calculation methods and verify probability conservation. The notebook requires Python 3, Jupyter Notebook or JupyterLab, and NumPy. It does not require a quantum computing framework or access to physical quantum hardware.