Glossary

Accuracy is the proportion of correctly predicted examples (both true positives and true negatives) out of all examples. It’s calculated as correct predictions divided by total predictions. It works well when classes are balanced, but can be misleading if one class dominates.

Adam is an optimization algorithm that updates model weights using both the average of past gradients (momentum) and the average of past squared gradients (adaptive learning rates). This combination helps it converge faster and more stably than vanilla stochastic gradient descent. It adjusts each parameter’s learning rate individually, making it effective for sparse or noisy data.

In mathematics, the adjoint of a matrix (or operator) is its conjugate transpose: take the transpose and then replace each entry with its conjugate. For a matrix , the adjoint is written ). It generalizes the transpose to complex spaces and is central in defining Hermitian and unitary operators.

In quantum computing an amplitude is a complex number that describes the weight of a basis state in a quantum superposition. The squared magnitude of an amplitude gives the probability of measuring that basis state. Amplitudes can interfere, this means adding or canceling, allowing quantum algorithms to bias outcomes toward correct solutions.

Amplitude amplification is a quantum algorithmic technique that increases the probability of measuring desired outcomes by repeatedly applying a specific operator that amplifies their amplitude. It generalizes Grover’s search algorithm, working for any algorithm with a known success amplitude. After iterations, where is the original success probability, the target state's amplitude approaches , making it much more likely to be measured.

Amplitude encoding represents classical data as the amplitudes of a quantum state's basis vectors. If you have a normalized data vector , it’s encoded into an -qubit state . This allows data values to be stored in only qubits, but preparing the quantum state can be computationally expensive.

An ancilla qubit is an extra qubit introduced into a quantum circuit to assist with computation, often initialized in a known state like is a basis state.
Learn more about . It is used as temporary workspace for tasks such as error correction, implementing quantum gates or extracting information without disturbing the main data qubits. After use, ancilla qubits are typically uncomputed, measured or reset so they don’t carry unintended information forward.

Angle encoding is a method of loading classical data into a quantum state by mapping data values to rotation angles of qubits (e.g., using quantum gates like Rx Gate, Ry Gate, or Rz Gate) Each feature of the data is represented as the angle of the quantum state vector’s rotation, which changes its probability amplitudes. This allows continuous classical values to be embedded in qQuantum states for use in quantum algorithms or quantum circuits.

An Ansatz is a chosen form or structure of a quantum state (often parameterized) used as a starting point for algorithms like the Variational Quantum Eigensolver. It defines how qubits are entangled and rotated, and its parameters are optimized to approximate the solution to a problem. The quality of the Ansatz directly affects the accuracy and efficiency of the computation.

Artificial Intelligence is the field of creating systems that perform tasks requiring human-like reasoning, learning, or decision-making.

The bandwagon effect is a cognitive bias where people adopt beliefs, behaviors, or trends mainly because many others are doing the same. It’s driven by social pressure and the assumption that popular choices must be correct or desirable. This often leads to herd behavior and poor independent judgment.

The barren plateau problem in quantum computing refers to regions in a quantum circuit’s parameter space where the **gradient of the cost function becomes exponentially small** as the number of qubits increases. This makes training variational quantum algorithms (like VQEs or QNNs) extremely difficult because optimization algorithms receive almost no useful signal to guide updates. It’s primarily caused by random circuit initialization and high circuit depth, leading to near-random output states.

Basis encoding represents classical data by mapping each possible data value to a distinct computational basis state of qubits. For example, an ( n )-bit binary string ( x ) is encoded as the quantum state (|x\rangle) among the (2^n) basis states. It’s a direct, one-to-one encoding—no superposition or amplitude manipulation is used.

A basis state in quantum computing is one of the fundamental states that form the building blocks of a quantum system’s state space. For a single qubit, the basis states are and ; any other qubit state is a superposition of these. In systems with multiple qubits, basis states are all possible combinations of s and s (e.g., , , , and ), forming an orthonormal basis for the system’s Hilbert space.

Bayes’ theorem describes how to update the probability of a hypothesis after observing new evidence. It states that the posterior probability equals the prior probability multiplied by the likelihood , divided by the overall probability of the evidence . In short, it quantifies how evidence should change our belief in a hypothesis.

A Bayesian Network is a directed acyclic graph where nodes represent random variables and edges represent conditional dependencies between them. Each node has a probability distribution that quantifies how it depends on its parent nodes. The network allows efficient computation of joint, conditional, and marginal probabilities by exploiting these dependencies.

A **Bell state** is one of four specific quantum states in which two qubits are **maximally entangled**, meaning their measurement outcomes are perfectly correlated no matter how far apart they are. Each Bell state represents a different pattern of correlation between the qubits. These states are fundamental in quantum information for testing **nonlocality** (violations of Bell’s inequality) and for protocols like **quantum teleportation**.

A Bernoulli distribution models a random experiment with exactly two possible outcomes: success (1) with probability (p) and failure (0) with probability (1 - p). It’s the simplest discrete probability distribution and serves as the basis for the binomial distribution. The mean is (p) and the variance is (p(1 - p)).

Bias is a systematic deviation from truth or fairness in judgment, data, or outcomes. It occurs when certain perspectives, groups, or results are favored—consciously or unconsciously—over others. In statistics or AI, bias means consistent error introduced by flawed assumptions or unbalanced data.

A bit (short for “binary digit”) is the smallest unit of data in computing, representing a value of either 0 or 1. It’s the fundamental building block of all digital information. Multiple bits combine to form larger units like bytes (8 bits) and encode more complex data such as numbers, text, or images.

bipartite refers to a system divided into two parts (subsystems), like two qubits or two groups of qubits. Each part can be studied on its own, but they may also share quantum correlations or entanglement. This setup is key for analyzing how information or entanglement is distributed between two parts of a quantum system.

The Bloch sphere is a geometric representation of a single qubit’s quantum state as a point on or inside a unit sphere. The north and south poles represent the classical states |0⟩ and |1⟩, while any other point corresponds to a superposition of them. Its position encodes the qubit’s relative phase and probability amplitudes, making it a visual tool for understanding quantum state evolution.

Block encoding is a quantum computing method for representing a classical or quantum matrix (A) as a submatrix of a larger unitary matrix (U). Specifically, (U) is built so that (A = \alpha (\langle 0^k | \otimes I) U (|0^k\rangle \otimes I)) for some scaling factor (\alpha) and number of ancilla qubits (k). This lets quantum algorithms access (A) efficiently using unitary operations, enabling tasks like Hamiltonian simulation or matrix inversion.

A Boltzmann Machine is a type of stochastic (randomized) neural network that learns to represent complex data distributions by adjusting the weights between interconnected neurons. Each neuron has a binary state (on/off), and learning happens by minimizing the difference between observed data patterns and the network’s internal predictions using a probabilistic energy function. It’s mainly used as a building block for deeper models like Restricted Boltzmann Machines and Deep Belief Networks.

A **Born Machine** is a quantum-inspired probabilistic model that generates data by sampling from a probability distribution defined by a quantum wavefunction. The probabilities come from the **Born rule**, which states that the likelihood of an outcome equals the squared magnitude of the wavefunction’s amplitude. In practice, it uses quantum states or their simulations to model complex data distributions that are difficult for classical systems to represent.

The Born Rule states that the probability of finding a quantum system in a particular state is given by the square of the amplitude of its wavefunction, (|\psi|^2). In other words, it connects the abstract wavefunction to measurable outcomes. This is what allows quantum mechanics to make statistical predictions about experimental results.

Bra–ket notation is a compact way to describe quantum states and their inner products. A **ket** (|ψ⟩) represents a column vector describing a quantum state, while a **bra** (⟨φ|) represents its conjugate transpose (a row vector). The inner product ⟨φ|ψ⟩ gives a complex number (like an overlap or probability amplitude), and the outer product |ψ⟩⟨φ| gives an operator.

Circuit depth in quantum computing is the number of layers of quantum gates that must be applied sequentially, where gates acting on different qubits in parallel count as one layer. It measures how long a quantum computation takes, assuming gates in the same layer happen simultaneously. Lower depth is crucial because qubits lose coherence over time, so deep circuits are more error-prone.

Classical preprocessing in quantum computing refers to the use of classical algorithms to prepare data, parameters, or problem instances before they’re fed into a quantum algorithm. It often involves tasks like encoding input data into quantum states or reducing a problem’s complexity so the quantum part can focus on what it does best. Essentially, it’s the classical setup work that makes the quantum computation efficient and meaningful.

Clean code is code that is easy to read, understand, and modify because it’s well-organized, consistent, and free of unnecessary complexity. It uses clear names, simple logic, and minimal duplication. The goal is for any competent developer to quickly grasp what the code does and safely change it without breaking things.

A **closed quantum system** is one that does not exchange energy, matter, or information with its surroundings. Its evolution is fully determined by the **Schrödinger equation**, meaning it remains in a **pure state** that changes only through unitary (reversible) time evolution. In practice, true closed systems don’t exist, but they are an idealization used to model isolated quantum behavior.

The commutative property means that changing the order of numbers in an operation doesn’t change the result. It applies to addition and multiplication: and . It does not apply to subtraction or division.

The complex conjugate of a Complex NumberA complex number is a number that has two parts: a real part and an imaginary part, written as , where . The real part behaves like ordinary numbers, while the imaginary part represents a direction perpendicular to the real axis on the complex plane. Complex numbers let us represent and calculate quantities involving square roots of negative numbers.
Learn more about Complex Number , where and , is defined as . So you flip the sign of the imaginary part and leave the real part unchanged.

A complex number is a number that has two parts: a real part and an imaginary part, written as , where . The real part behaves like ordinary numbers, while the imaginary part represents a direction perpendicular to the real axis on the complex plane. Complex numbers let us represent and calculate quantities involving square roots of negative numbers.

The computational basis is the standard set of basis states used to describe qubits in quantum computing. These are typically and for a single qubit. For multi-qubit systems all possible combinations of basis states denote the computational basis, like , , , and . These states correspond to classical bit strings and form an orthonormal basis for the system's Hilbert space. Any quantum state can be expressed as a superposition of these computational basis states.

Computational complexity in quantum computing studies how the resources (like time or number of qubits) needed to solve a problem scale with input size on a quantum computer. It classifies problems into complexity classes (e.g., BQP, QMA) that describe what quantum computers can efficiently solve or verify. The goal is to compare these classes with classical ones (like P or NP) to understand whether quantum computers offer real computational advantages.

Conditional probability is the probability that an event occurs given that another event has already occurred. It’s written as , assuming . It measures how likely is when we know has happened, narrowing the sample space to cases where is true.

A controlled-NOT (CNOT) gate is a two-QubitA qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.
Learn more about Quantum Bit Quantum GateA quantum gate is a basic operation that changes the state of one or more qubits, similar to how a logic gate operates on bits in classical computing. It uses unitary transformations, meaning it preserves the total probability (the state’s length in complex space). Quantum gates enable superposition and entanglement, allowing quantum computers to perform computations that classical ones cannot efficiently replicate.
Learn more about Quantum Gate where the first QubitA qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.
Learn more about Quantum Bit (control) determines whether the second QubitA qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.
Learn more about Quantum Bit (target) is flipped on the -axis. If the control QubitA qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.
Learn more about Quantum Bit is in state is a basis state.
Learn more about , the target Qubit'sA qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.
Learn more about Quantum Bit Quantum StateA quantum state is the complete mathematical description of a quantum system, containing all the information needed to predict measurement outcomes. It’s usually represented by a wavefunction or a state vector in a Hilbert space. The state defines probabilities, not certainties, for observable quantities like position, momentum, or spin.
Learn more about Quantum State is inverted . If the control is is a basis state.
Learn more about , the target is unchanged. It’s essential for creating entanglement, since applying aCNOT to a superposed control qubit links the states of both qubits.

A **controlled operator** is a quantum operation that acts on a target qubit (or system) **only if** one or more control qubits are in a specific state (usually (|1\rangle)). It’s represented as ( C(U) ), where (U) is the operator applied conditionally. For example, the **CNOT gate** is a controlled-(X) operator: it flips the target qubit only when the control qubit is (|1\rangle).

A controlled-Z (CZ) gate is a two-qubit quantum gate that flips the phase of the second qubit (adds a minus sign) only if the first qubit is in the state . In matrix form, it leaves , , and unchanged, but turns into . It’s mainly used to create entanglement between qubits, just like the CNOT gate but with a phase flip instead of a bit flip.

The CNOT (Controlled-NOT) operator is a two-qubit quantum gate that flips the **target qubit** (applies an X gate) only if the **control qubit** is in the state (|1⟩). In matrix form, it leaves (|00⟩) and (|01⟩) unchanged, but swaps (|10⟩) and (|11⟩). It’s essential for creating entanglement between qubits.

A **cost function** measures how far a model’s predictions are from the actual outcomes by assigning a numerical “error” value. The goal of training is to **minimize this cost**, meaning the model’s predictions get closer to reality. Different cost functions (e.g., mean squared error, cross-entropy) are used depending on the type of prediction problem.

Debugging is the process of finding and fixing errors or unexpected behavior in a program’s code. It involves identifying the source of the problem, understanding why it occurs, and correcting it so the program runs as intended. Tools like debuggers or print statements help track program execution to locate issues efficiently.

A **decision boundary** is the line or surface that separates different classes in a classification problem. It represents where a model is equally uncertain between two or more classes (e.g., where predicted probabilities are 0.5 vs. 0.5). Points on one side of the boundary are classified as one class, and points on the other side as another.

Decoherence is the process by which a quantum system loses its quantum behavior—like superposition—because it interacts with its surrounding environment. These interactions cause the system’s quantum states to become entangled with the environment, effectively destroying the system’s coherent phase relationships. As a result, the system starts to behave classically rather than quantum mechanically.

Deep learning is a branch of machine learning that uses multi-layered neural networks to automatically learn complex patterns from data. Each layer transforms raw input into increasingly abstract representations, allowing the system to perform tasks like image recognition or language understanding without explicit feature engineering. It relies heavily on large datasets and high computational power for training.

Design Science Research (DSR) is a research approach focused on creating and evaluating practical artifacts—such as models, methods, or systems—to solve real-world problems. It combines building these artifacts with rigorous evaluation to generate scientific knowledge. The goal is both to improve practice and to contribute to theory through the design process itself.

The diffusion operator (also called the Grover diffusion operator) is a unitary operation that inverts the amplitude of each state about the average amplitude. It’s used in Grover’s search algorithm to amplify the probability of the marked (target) state. Mathematically, it’s represented as , where is the uniform superposition state.

Don’t Repeat Yourself (DRY) is a software design principle that says every piece of knowledge or logic should exist in only one place in a codebase. Repetition creates multiple sources of truth, which increases the risk of inconsistencies and maintenance errors. Following DRY means refactoring duplicate code into reusable functions, modules, or abstractions.

The double-slit experiment shows that light and particles like electrons act as both waves and particles. When they pass through two slits, they create an interference pattern on a screen—evidence of wave behavior. But if you measure which slit each particle goes through, the interference disappears, revealing particle-like behavior instead.

An **eigenstate** is a quantum state that remains unchanged except for a scaling factor when a specific observable (like energy or momentum) is measured. Mathematically, it satisfies , where is the operator and is the eigenvalue (the measurable result). In that state, the observable has a definite value — measuring it will always give .

An eigenvalue is a number that indicates how much a linear transformation stretches or compresses a vector that doesn’t change direction under that transformation (called an eigenvector). Mathematically, it satisfies ( A v = \lambda v ), where ( A ) is a square matrix, ( v ) is the eigenvector, and ( \lambda ) is the eigenvalue. In essence, it measures the scaling factor applied to certain special directions of a transformation.

An eigenvector of a square matrix is a nonzero vector whose direction doesn’t change when the matrix is applied to it—it only gets scaled by a factor called the eigenvalue. In equation form: , where is the matrix, the eigenvector, and the eigenvalue. Eigenvectors show the “principal directions” in which a linear transformation acts by simple stretching or compressing.

An embedding is a numerical representation of data (like words, images, or documents) in a continuous vector space where similar items are close together. It captures semantic or structural relationships by encoding features into dense vectors. Embeddings are used in machine learning to make non-numeric data comparable and computable.

Encoding is the process of converting information from one form into another, usually so it can be stored, transmitted, or processed more efficiently. For example, text can be encoded into binary for computers to handle, or sounds into digital signals for transmission. The key idea is that encoding changes the representation, not the meaning, of the data.

Entanglement is a quantum phenomenon where two or more particles become correlated so that measuring one instantly determines the state of the other, no matter how far apart they are. This correlation arises because their quantum states are linked as a single system, not as independent parts. It doesn’t allow faster-than-light communication but shows that quantum systems can share information in ways classical physics can’t explain.

An **entanglement operator** is a quantum operation (a unitary or measurement-based transformation) that creates or modifies **quantum entanglement** between particles or subsystems. It acts on multiple qubits so their states become correlated in a way that can’t be described independently. Common examples include two-qubit gates like the **CNOT** or **CZ** gates, which generate entangled Bell states from separable inputs.

In machine learning, *error* measures how far a model’s predictions deviate from the true values. It’s typically split into **training error** (how well the model fits the data it was trained on) and **generalization error** (how well it performs on unseen data). High error indicates poor model accuracy, often due to underfitting, overfitting, or noise in the data.

Error correction in quantum computing protects fragile quantum information from noise and decoherence by encoding one logical qubit into multiple physical qubits. It uses specially designed quantum codes that can detect and correct certain types of errors (like bit-flips or phase-flips) without directly measuring and collapsing the quantum state. This allows reliable computation even on imperfect hardware.

Error-syndrome extraction is the process in quantum error correction where measurements are used to detect which type of error (bit-flip, phase-flip, or both) has affected the encoded qubits, without collapsing their logical state. The outcome of these measurements—called the *syndrome*—indicates which correction operation is needed. Essentially, it identifies the error pattern while preserving the encoded quantum information.

Execution in quantum computing is the process of running a quantum circuit on qubits to perform a computation. It involves applying a sequence of quantum gates (unitary operations) followed by measurement, which collapses the qubits’ superpositions into classical outcomes. Because quantum states are probabilistic, repeated executions (shots) are used to estimate the result distribution accurately.

The expectation value is the average result you'd get if you repeated a measurement of a quantity many times under identical conditions. Mathematically, it’s the weighted average of all possible outcomes, where each outcome is weighted by its probability. In quantum mechanics, it represents the average value of an observable calculated from the wavefunction.

Expressiveness in quantum computing refers to how effectively a quantum model (like a variational circuit) can represent complex functions or quantum states. A more expressive model can capture richer correlations and solve more complex problems, but may also be harder to train. It’s roughly analogous to the “capacity” or “model complexity” in classical machine learning.

A **fault-tolerant quantum computer** is a system designed to keep performing correct quantum computations even when some qubits or operations fail due to noise or errors. It achieves this by encoding logical qubits across many physical qubits using **quantum error correction**. The system detects and corrects errors continuously without collapsing the quantum information.

Feature space is the multidimensional space where each dimension represents one feature (or variable) used to describe data. Each data point in this space corresponds to an object characterized by its feature values. The structure and distance between points in this space determine similarity, clustering, and classification behavior in machine learning models.

The Fourier basis is a set of sine and cosine functions that can represent any periodic signal as a weighted sum of these functions. Each basis function corresponds to a specific frequency, capturing how much of that frequency is present in the signal. In essence, it’s the coordinate system for expressing signals in terms of their frequency components instead of time.

The Fourier Transform converts a signal from the time domain into the frequency domain, showing which frequencies make up the signal and with what amplitudes. It expresses any time-based function as a sum of sine and cosine waves. In essence, it decomposes complex signals into their basic frequency components.

Generalization in machine learning is the model’s ability to perform well on new, unseen data, not just the data it was trained on. It measures how well the model captures the underlying patterns rather than memorizing the training examples. Poor generalization usually means overfitting—when a model learns noise or details specific to the training set instead of general rules.

Generative Artificial Intelligence refers to systems that can create new content—such as text, images, audio, or code—based on patterns learned from large datasets. Unlike traditional AI that only classifies or predicts, generative AI produces original outputs that resemble human-created data. It works by modeling the probability distributions of data and sampling from them to generate new, coherent examples.

A global phase is a complex phase factor (like multiplying the whole quantum state by ) that changes how the state looks mathematically but not how it behaves physically. Since measurement probabilities depend only on relative phases between components, a global phase has no observable effect. So, the global phase doesn't change outcomes. It's physically meaningless and can be ignored.

A **gradient** is a vector that shows the direction and rate of the steepest increase of a function. Each component of the gradient is the **partial derivative** of the function with respect to one input variable. In optimization, it tells you how to adjust inputs to increase or decrease the function’s output most efficiently.

The **ground state** is the lowest possible energy state of a physical system, such as an atom or molecule. In this state, all particles occupy the lowest available energy levels allowed by quantum mechanics. Any higher-energy state is called an excited state.

Grover iteration is the core step in Grover’s search algorithm that amplifies the probability of the correct answer in a quantum superposition. It consists of two operations: first, the *oracle* flips the phase of the target state; second, the *diffusion operator* (or inversion about the mean) increases the amplitude of that marked state while decreasing others. Repeating this process about √N times makes the correct state most likely to be measured.

Grover’s algorithm is a quantum search algorithm that finds a target item in an unsorted database of elements in roughly steps, offering a quadratic speedup over classical search. It works by repeatedly amplifying the probability amplitude of the correct answer using an “oracle” that marks the desired item. After enough iterations, measuring the quantum state yields the correct result with high probability.

The Hadamard operator, often denoted H, is a single-qubit quantum gate that creates an equal superposition of and . In other words, It turns the states of the computational basis and into the states of the Fourier basis and .

The Hamiltonian operator () in quantum mechanics represents the total energy of a system — both kinetic and potential. It acts on a wavefunction to determine how the system evolves over time, according to the Schrödinger equation. Mathematically, , where is the kinetic energy operator and is the potential energy operator.

Hamiltonian simulation is the process of using a quantum computer to mimic the time evolution of a quantum system governed by a Hamiltonian , typically by approximating . It allows prediction of how a quantum state changes over time without physically realizing the system. This is fundamental to quantum algorithms for chemistry, materials science, and physics because it efficiently reproduces complex quantum dynamics that are intractable for classical computers.

The HHL algorithm (Harrow–Hassidim–Lloyd) is a quantum algorithm for solving systems of linear equations exponentially faster than the best known classical methods, under certain conditions. It encodes the solution vector as a quantum state using phase estimation and controlled rotations based on the eigenvalues of . However, it only provides a quantum state proportional to , not its classical components, and its speedup depends on properties like sparsity and condition number of .

A Hermitian matrix (or operator) is one that equals its own conjugate transpose — mathematically, . This means each element satisfies . Hermitian matrices always have real eigenvalues and orthogonal eigenvectors, which makes them central in quantum mechanics and linear algebra.

A heuristic is a simplified rule or mental shortcut used to make decisions or solve problems quickly when a full analysis would be too slow or complex. It sacrifices some accuracy or optimality for efficiency and practicality. In computing and AI, heuristics guide algorithms toward good-enough solutions when exact methods are too costly.

A Hilbert space is a complete vector space equipped with an inner product, which allows for measuring angles and lengths between vectors. "Complete" means that every Cauchy sequence of vectors converges to a vector within the space. It generalizes the idea of Euclidean space to possibly infinite dimensions and forms the foundation for quantum mechanics and functional analysis.

The HZH routine means applying a Hadamard gate (H), then a Pauli-Z gate (Z), then another Hadamard (H). This sequence effectively turns the Z operation into a Not (X) operation because . In other words, it flips the qubit’s state from to by rotating the Z-axis operation into the X-axis basis.

An identity matrix is a square matrix with 1s on the main diagonal and 0s everywhere else. It acts as the multiplicative identity in matrix algebra, meaning ( A \times I = I \times A = A ) for any compatible matrix ( A ). Essentially, multiplying by it leaves a matrix unchanged.

An inner product is a mathematical operation that takes two vectors and returns a single number measuring how similar or aligned they are. In Euclidean space, it’s the sum of the products of corresponding components (e.g., ). It generalizes the dot product and defines geometric concepts likelength and angle in vector spaces.

Interference in quantum computing refers to the way probability amplitudes of quantum states combine—sometimes reinforcing each other (constructive interference) or canceling out (destructive interference). Quantum algorithms exploit this to amplify the probability of correct answers while suppressing incorrect ones. It’s a key mechanism that gives quantum computers their computational advantage.

In math, an *inverse* undoes the effect of an operation or function. For a number, the inverse under addition is its opposite (e.g., the inverse of 5 is −5), and under multiplication it’s its reciprocal (e.g., the inverse of 5 is 1/5). For a function ( f(x) ), the inverse ( f^(x) ) reverses its action so that ( f(f^(x)) = x ).

A **joint distribution** describes the probability of two or more random variables occurring together. It shows how the outcomes of one variable relate to the outcomes of another, either as a table (for discrete variables) or a function (for continuous ones). From it, you can derive marginal and conditional distributions by summing or integrating over specific variables.

Joint probability is the likelihood that two (or more) events happen at the same time. For example, if is it rains and is you carry an umbrella, the joint probability is the chance that both rain and carrying an umbrella occur together. Mathematically, .

In machine learning, a **kernel** is a function that computes the similarity between data points in a higher-dimensional space without explicitly transforming the data there. This allows algorithms like Support Vector Machines to learn complex, nonlinear relationships efficiently. Essentially, it replaces inner products in feature space with a simpler computation in the original space.

A ket (written as |ψ⟩) represents a vector in a complex Hilbert space, describing the state of a quantum system. It encodes all measurable information about that system. In linear algebra terms, it’s a column vector, while the corresponding bra (⟨ψ|) is its conjugate transpose (a row vector).

Linear algebra is the branch of mathematics that studies vectors, vector spaces, and linear transformations between them. It provides tools for solving systems of linear equations and understanding geometric operations like rotations, projections, and scaling. Its core objects—matrices and vectors—form the basis for much of modern computation, physics, and machine learning.

Linear Combination of Unitaries (LCU) is a quantum computing method for implementing an operator that can be written as a weighted sum of unitary matrices. Instead of directly applying a non-unitary operator, the algorithm probabilistically combines unitaries using ancilla qubits and amplitude amplification. This enables simulation of general linear operators (like Hamiltonians) on a quantum computer while keeping operations physically realizable.

A logical operator is a symbol or word used to combine or modify Boolean (true/false) values in logic or programming. The main ones are **AND (&&)**, **OR (||)**, and **NOT (!)**. They determine the truth of a compound statement — for example, “A AND B” is true only if both A and B are true.

A **logical qubit** is a qubit made from many **physical qubits** working together to protect quantum information from errors. Instead of storing data in a single unstable qubit, error-correcting codes distribute it across several, allowing detection and correction of mistakes. It’s the fundamental unit of computation in a **fault-tolerant quantum computer**.

A loss function measures how far a model’s predictions are from the actual target values. It assigns a numerical value to this difference—lower values mean better performance. During training, the model adjusts its parameters to minimize this loss.

Machine Learning is an approach on solving problems by deriving the rules from data instead of explicitly programming.

A machine learning pipeline is a structured sequence of steps that takes raw data through preprocessing, model training, evaluation, and deployment to produce actionable outputs in a repeatable way.

Marginal probability is the probability of a single event occurring, regardless of the outcomes of other variables. It’s found by summing or integrating joint probabilities over all possible values of the other variables. For example, ( P(A) = \sum_B P(A, B) ) gives the marginal probability of (A) from the joint distribution of (A) and (B).

Markov Chain Monte Carlo (MCMC) is a method for sampling from complex probability distributions when direct sampling is difficult. It builds a Markov chain whose long-run behavior matches the target distribution. By running the chain long enough, the collected samples approximate the true distribution, allowing estimation of expectations or probabilities.

Matrix density is the ratio of nonzero elements to the total number of elements in a matrix. It measures how “filled” the matrix is, with higher density meaning fewer zeros. A dense matrix has most entries nonzero, while a sparse matrix has mostly zeros.

Matrix diagonalization is the process of rewriting a square matrix ( A ) as ( A = PDP^ ), where ( D ) is a diagonal matrix and ( P ) contains the eigenvectors of ( A ). This is only possible if ( A ) has enough linearly independent eigenvectors. Diagonalization simplifies many computations, such as raising ( A ) to a power, because powers of ( D ) are easy to compute.

Matrix inversion is the process of finding a matrix ( A^ ) such that ( A \times A^ = I ), where ( I ) is the identity matrix. It’s only possible for square, non-singular matrices (those with a nonzero determinant). The inverse effectively “undoes” the transformation represented by ( A ), similar to dividing by a number in regular arithmetic.

Matrix multiplication combines two matrices by taking the dot product of rows from the first matrix with columns from the second. Each entry in the result is the sum of elementwise products between a row of the first and a column of the second. It only works when the number of columns in the first matrix equals the number of rows in the second.

In quantum computing, measurement is the process of extracting classical information from a quantum state. It collapses a qubit’s superposition into one of its basis states (usually or ), with probabilities determined by the amplitudes of those states. After measurement, the qubit’s state becomes definite, destroying the original superposition.

A **model** in machine learning is a mathematical representation of patterns learned from data. It takes **inputs** (features) and produces **outputs** (predictions or classifications) based on relationships it has identified during training. Essentially, it’s a function that generalizes from examples to make decisions or predictions on new data.

The most significant bit (MSB) is the bit in a binary number with the highest place value—it represents the largest power of two. In an 8-bit number, it’s the leftmost bit. For signed integers, the MSB often indicates the sign: 0 for positive and 1 for negative (in two’s complement representation).

A **multi-qubit gate** is a quantum operation that acts on two or more qubits simultaneously, allowing them to become **entangled** and enabling interactions that single-qubit gates cannot produce. These gates manipulate the **joint state** of the qubits, not just each one independently. Examples include the **CNOT** and **Toffoli** gates, which are essential for performing complex quantum algorithms.

A multi-controlled gate is a quantum logic gate that performs an operation on a target qubit only when several control qubits are all in a specific state (usually ). It generalizes the controlled-NOT (CNOT) gate, which has one control and one target. For example, a Toffoli gate is a 2-controlled NOT—it flips the target qubit only if both controls are 1.

An artificial neural network is a computational model of interconnected nodes inspired by biological neurons, used to approximate functions and recognize patterns.

Noise

Noisy Intermediate-Scale Quantum refers to the current generation of quantum devices that have enough qubits to run non-trivial algorithms but are still small and error-prone, limiting their reliability and scalability.

Non-locality in quantum computing refers to the way entangled quantum states exhibit correlations that can’t be explained by local hidden variables—meaning changes to one qubit’s state can instantaneously affect another, even at a distance. This doesn’t allow faster-than-light communication but shows that quantum systems share information in a fundamentally non-classical way. It’s what enables quantum phenomena like teleportation and certain computational speedups.

Normalization in quantum computing means that the total probability of all possible outcomes of a quantum state must equal 1. Mathematically, if a quantum state is written as a vector of complex amplitudes, the sum of the squares of their magnitudes must be 1. This ensures that when the quantum state is measured, one of the possible outcomes will definitely occur.

In quantum computing, the NOT gate (also called the **X gate**) flips the state of a qubit: it changes to and to . Mathematically, it’s represented by the Pauli-X matrix . On the Bloch sphere, it corresponds to a rotation around the X-axis.

In quantum computing, the NOT operation (also called the **X gate**) flips the state of a qubit: it turns (|0⟩) into (|1⟩) and (|1⟩) into (|0⟩). Mathematically, it’s represented by the Pauli-X matrix, which swaps the probability amplitudes of these basis states. On the Bloch sphere, it corresponds to a 180° rotation around the X-axis.

In quantum computing, an **observable** is a physical quantity (like energy, spin, or position) that can be **measured** from a quantum state. Mathematically, it’s represented by a **Hermitian operator**, whose eigenvalues correspond to the possible measurement outcomes. When you measure an observable, the quantum state **collapses** into one of its eigenstates, yielding one of those eigenvalues as the result.

Optimization is the process of finding the best possible solution to a problem within given constraints. It involves adjusting variables to minimize or maximize an objective function, such as cost, time, or efficiency. In simple terms, it’s about achieving the most effective outcome with the least waste or effort.

An oracle is a black-box function that encodes information about a problem—typically deciding whether a given input satisfies some condition. It’s implemented as a quantum operation that can be queried in superposition, allowing a quantum algorithm to extract global properties of the function more efficiently than classical methods. Oracles are central to algorithms like Grover’s and Deutsch–Jozsa, where they guide the computation without revealing internal details.

Order effect refers to how the sequence in which information or tasks are presented influences responses or outcomes. For example, people may remember or rate items differently depending on whether they appear first (primacy effect) or last (recency effect) in a list. It’s a form of bias that affects perception, memory, and decision-making.

Orthogonal means independent. In geometry, two lines or vectors are orthogonal if they meet at a angle. In math or data science, it means two things don’t influence each other, like variables or directions that are completely uncorrelated. In quantum computing, orthogonal states are quantum states that are completely distinct. Their inner product is zero, meaning they can be perfectly told apart when measured. For example, the basis states and are orthogonal. This property ensures they can represent different, non-overlapping pieces of information in a quantum system.

Orthonormal states are perfectly distinct and normalized, which makes them reliable building blocks for quantum algorithms. Two quantum states are orthonormal if they’re at right angles in Hilbert space (their inner product is zero) and each has length 1. This guarantees the states don’t overlap and can be cleanly distinguished when measuring a quantum system.

A **Parameterized Quantum Circuit (PQC)** is a quantum circuit where certain gate operations depend on adjustable parameters—typically real numbers representing rotation angles. These parameters are tuned (often by classical optimization) to perform a specific task, such as minimizing a cost function. PQCs are central to **variational quantum algorithms**, where quantum computation provides state preparation and measurement, and a classical computer optimizes the parameters.

A Pauli operator is one of three 2×2 complex matrices — **σₓ, σᵧ, σ_z** — that represent the basic quantum spin operations on a single qubit. They correspond to rotations or measurements along the x, y, and z axes of the Bloch sphere. Together with the identity matrix, they form a basis for all single-qubit operations in quantum mechanics.

Periodicity refers to the repeating pattern in the values of a function evaluated over a quantum superposition of inputs. Algorithms like Shor’s exploit this by using the Quantum Fourier Transform (QFT) to detect the period efficiently, something classical methods can’t do quickly. Identifying this period is key to solving problems such as integer factorization and discrete logarithms.

Phase encoding in quantum computing stores information in the *phase* of a qubit’s quantum state rather than its amplitude. The qubit’s phase determines how it interferes with other states during computation, enabling quantum algorithms to exploit interference for speedups. This is used in algorithms like Quantum Fourier Transform, where phase differences represent encoded data or computational results.

Phase kickback is a quantum phenomenon where a phase shift applied to a *target* qubit in a controlled operation gets "kicked back" onto the *control* qubit instead. It happens because the control qubit’s superposition interacts with the target’s phase, effectively transferring that phase information to the control. This mechanism is fundamental in algorithms like phase estimation and the quantum Fourier transform.

A phase shift changes the relative phase of a qubit’s quantum state without altering its probability amplitudes. This means it rotates the qubit’s state around the z-axis of the Bloch sphere, multiplying the is a basis state.
Learn more about component by a complex phase . Phase shifts are key for interference effects and form the basis of many quantum gates like the S, T, and controlled-phase gates.

The **Polynomial Hierarchy (PH)** is a layered generalization of NP and co-NP that organizes decision problems by how many alternating quantifiers (∃ and ∀) are needed in their logical definitions. Each level, denoted Σₖᴾ or Πₖᴾ, represents problems solvable by a polynomial-time machine with access to an oracle for the previous level. If any two adjacent levels collapse (e.g., Σₖᴾ = Πₖᴾ), the entire hierarchy collapses to that level.

Probabilistic Pattern Recognition is the classification of patterns based on probability models, where decisions are made by estimating class-conditional probabilities and applying Bayes' rule.

A probabilistic system is one where outcomes are not fixed but occur with certain probabilities due to inherent randomness or uncertainty. Instead of producing a single deterministic result, it describes possible states and their likelihoods. Such systems are modeled using probability theory to predict behavior and quantify uncertainty.

A probability distribution describes how the probabilities of different possible outcomes of a random variable are spread out. It shows which values are more or less likely to occur, either as a list (for discrete variables) or a curve (for continuous ones). Essentially, it’s a complete mathematical summary of a random variable’s behavior.

A probability model is a mathematical framework that describes all possible outcomes of a random process and assigns a probability to each one. It consists of a sample space (the set of all outcomes) and a probability rule (how likely each outcome is). The probabilities must be nonnegative and sum to 1 across all possible outcomes.

Python is a high-level, interpreted programming language known for its simple syntax and readability. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Its extensive standard library and large ecosystem make it useful for tasks ranging from web development to data science and automation.

Qiskit is an open-source Python framework for programming and simulating quantum computers. It lets users create quantum circuits, run them on real quantum hardware or simulators, and analyze the results. Essentially, it bridges high-level quantum algorithms with low-level hardware execution.

Qiskit Aer is a high-performance simulator framework for quantum circuits within Qiskit. It lets users run and test quantum algorithms on classical hardware by accurately emulating noise, decoherence, and other quantum effects. This allows developers to validate and optimize quantum programs before executing them on real quantum computers.

Quantum advantage is the point where a quantum computer performs a specific task faster or more efficiently than the best possible classical computer. It doesn’t mean quantum computers are universally better—just that they outperform classical ones for that task. The first demonstrations (e.g., Google’s 2019 Sycamore experiment) showed speedups for highly specialized problems, not yet for practical applications.

A quantum algorithm is a step-by-step computational procedure designed to run on a quantum computer, exploiting quantum phenomena such as superposition, entanglement, and interference to solve certain problems more efficiently than classical algorithms.

A Quantum Bayesian Network (QBN) is a generalization of a classical Bayesian network where probabilities are replaced by quantum probability amplitudes represented as density matrices. It models dependencies between quantum systems using quantum conditional probabilities instead of classical ones. This allows reasoning about quantum uncertainty and entanglement in a structured, graph-based way similar to how Bayesian networks represent classical uncertainty.

A qubit is the basic unit of quantum information, representing a superposition of 0 and 1 states.

A **Quantum Boltzmann Machine (QBM)** is a type of probabilistic neural network that uses **quantum states** instead of classical bits to represent and sample from probability distributions. It extends the **classical Boltzmann Machine** by exploiting **quantum superposition and tunneling** to explore the energy landscape more efficiently. In theory, this allows it to learn complex correlations between variables that are difficult for classical models to capture.

A **Quantum Causal Model (QCM)** generalizes classical causal models (like Bayesian networks) to describe cause–effect relationships between quantum systems. Instead of using probabilities over classical variables, it uses **quantum states and quantum operations** to represent how interventions and influences propagate. This framework captures both **quantum correlations** (like entanglement) and **causal structure**, distinguishing true causation from mere quantum correlation.

A **quantum channel** is a mathematical model that describes how a quantum state changes when it’s transmitted or interacts with its environment. It represents any physical process affecting qubits, including noise, measurement, or decoherence. Formally, it’s a **completely positive, trace-preserving (CPTP) map** acting on density matrices.

A quantum circuit is a sequence of quantum gates applied to qubits, representing the operations in a quantum computation. Each gate changes the qubits’ state using quantum mechanics principles like superposition and entanglement. The final qubit states, when measured, yield the circuit’s computational result probabilistically.

A quantum computer is typically a large, highly controlled system kept at near-absolute-zero temperatures to preserve quantum behavior. It contains a processor with qubits—often made from superconducting circuits, trapped ions, or photons—manipulated by microwaves, lasers, or magnetic fields. Surrounding systems handle cooling, error correction, and control electronics to maintain quantum coherence and read out results.

Quantum Computing is a different kind of computation that builds upon the phenomena of Quantum Mechanics.

A use case is a description of how a user interacts with a system to achieve a specific goal.

Quantum Error Correction (QEC) protects quantum information from decoherence and operational errors by encoding one logical qubit into multiple physical qubits. It detects and corrects errors without directly measuring the qubit’s quantum state, preserving superposition and entanglement. QEC relies on redundant encoding and stabilizer measurements to identify and reverse errors before they accumulate.

A **Quantum Feature Map** is a process that converts classical input data into a **quantum state** using a parameterized quantum circuit. This transformation encodes data into the **high-dimensional Hilbert space** of a quantum system, allowing quantum algorithms to exploit complex correlations not easily captured classically. Essentially, it’s the quantum analogue of feature mapping in machine learning, used to make data more separable for classification or regression tasks.

The Quantum Fourier Transform (QFT) is the quantum analog of the discrete Fourier transform, mapping quantum states from the computational basis to the frequency domain using quantum superposition and interference. It transforms amplitudes so that periodic patterns in the input become phase differences in the output. The QFT is exponentially faster than the classical Fourier transform, making it central to algorithms like Shor’s factoring algorithm.

A quantum gate is a basic operation that changes the state of one or more qubits, similar to how a logic gate operates on bits in classical computing. It uses unitary transformations, meaning it preserves the total probability (the state’s length in complex space). Quantum gates enable superposition and entanglement, allowing quantum computers to perform computations that classical ones cannot efficiently replicate.

Quantum hardware is the physical technology that builds and runs quantum computers, using quantum bits (qubits) instead of classical bits. These qubits exploit quantum properties like superposition and entanglement to process information in fundamentally different ways. The hardware can be based on systems such as superconducting circuits, trapped ions, or photons, each requiring extreme control and isolation to maintain quantum coherence.

Quantum information is the study of how information is represented, processed, and transmitted using quantum systems. Essentially, data is stored in quantum bits (qubits) that exist in superpositions of its basis states and . This allows to create fundamentally different algorithms than classical systems support.

A **quantum kernel** is a function that measures the similarity between data points by mapping them into a **quantum feature space** using a quantum circuit. It’s used in **quantum machine learning** to compute inner products between these quantum states, capturing complex relationships that may be hard for classical kernels to represent. In short, it lets quantum systems generate richer feature mappings for kernel-based algorithms like SVMs.

Quantum Machine Learning is the field of research that combines principles from quantum computing with traditional machine learning to solve complex problems more efficiently than classical approaches.

Quantum mechanics is the branch of physics that describes the behavior of matter and energy at atomic and subatomic scales.

A quantum neural network is a computational model that combines quantum computing principles with neural network structures to process information and learn patterns.

Quantum noise is the random fluctuation in a measurement caused by the inherent uncertainty of quantum systems, not by technical imperfections. It arises because quantities like position and momentum, or phase and amplitude of light, cannot both be precisely known or measured simultaneously (Heisenberg uncertainty principle). This sets a fundamental limit on the precision of quantum measurements and devices such as lasers or sensors.

A quantum operator is a mathematical object that represents a physical action or measurement on a quantum state. It transforms one quantum state into another, often expressed as a matrix acting on a vector in Hilbert space. In quantum computing, operators correspond to quantum gates, which manipulate qubits according to the rules of linear algebra and quantum mechanics.

A **quantum phase** is the angle component of a particle’s wavefunction that determines how its probability amplitude interferes with others. It doesn’t affect observable probabilities directly but becomes crucial when comparing two or more states, as phase differences lead to interference effects. Essentially, it encodes the relative timing or “alignment” of quantum waves.

Quantum Phase Estimation (QPE) is a quantum algorithm that determines the phase in an eigenvalue equation for a given unitary U and its eigenvector . It does this by encoding into the amplitudes of qubits using controlled applications of U and then extracting via the inverse quantum Fourier transform. QPE is a core subroutine in many quantum algorithms, such as Shor’s factoring algorithm and quantum simulations.

Quantum Random Access Memory (QRAM) is a theoretical type of memory that allows a quantum computer to access multiple memory locations simultaneously in superposition. Instead of retrieving one data element at a time, QRAM can query all relevant addresses in parallel, with the amplitudes encoding probabilities. It’s crucial for algorithms needing fast data lookup in quantum superposition, but no scalable physical implementation yet exists.

A **Quantum Routine** is a defined sequence of quantum operations—such as applying gates, measurements, and state preparations—executed on qubits to perform a specific computational task. It’s analogous to a subroutine in classical programming but operates under quantum mechanics principles like superposition and entanglement. In practice, it’s the building block used to design and run quantum algorithms on hardware or simulators.

Quantum Signal Processing (QSP) is a method for implementing precise polynomial transformations of a quantum system’s eigenvalues using a sequence of single-qubit rotations and controlled unitaries. It lets quantum algorithms manipulate amplitudes or phases efficiently, enabling tasks like Hamiltonian simulation and eigenvalue transformation. Essentially, QSP translates a desired mathematical function into a short, structured sequence of quantum gates.

Quantum simulation uses controllable quantum systems (like qubits or cold atoms) to model and study other quantum systems that are too complex for classical computers to calculate. It exploits quantum mechanics directly—superposition and entanglement—to replicate a target system’s behavior. This allows scientists to investigate materials, chemical reactions, or quantum phenomena that would otherwise be computationally intractable.

Quantum Singular Value Transformation (QSVT) is a quantum algorithmic framework that applies a polynomial function to the singular values of a given matrix, using a sequence of controlled unitary operations. It generalizes many quantum algorithms (like amplitude amplification and HHL) under a single formalism. In essence, QSVT lets you manipulate matrix spectra directly on a quantum computer without explicitly diagonalizing the matrix.

Quantum spectral algorithms are quantum computing methods that analyze the spectrum (eigenvalues and eigenvectors) of large matrices or operators.

A quantum state is the complete mathematical description of a quantum system, containing all the information needed to predict measurement outcomes. It’s usually represented by a wavefunction or a state vector in a Hilbert space. The state defines probabilities, not certainties, for observable quantities like position, momentum, or spin.

Quantum state overlap measures how similar two quantum states are. Mathematically, it’s the absolute square of their inner product: ( |\langle \psi | \phi \rangle|^2 ), which ranges from 0 (completely different) to 1 (identical). It represents the probability that one state would be found if the system were measured in the other state’s basis.

Quantum state preparation is the process of configuring a quantum system into a specific, desired quantum state before computation or measurement. It involves applying controlled operations (like gates, pulses, or interactions) to initialize qubits from a known starting state, typically (), into a target superposition or entangled state. Accurate state preparation is essential, since errors here propagate through the entire quantum algorithm.

A quantum state vector is a mathematical object (usually denoted |ψ⟩) that fully describes the state of a quantum system. Its components give the probability amplitudes for finding the system in each possible basis state. The squared magnitude of each component gives the probability of measuring that corresponding outcome.

A quantum system is any physical system that is subject to the laws of quantum mechanics, whereby quantities such as energy or spin can only assume discrete (quantized) values. Its behavior is described by a wave function that encodes the probabilities of possible measurement results.

Qubitization is a quantum algorithmic technique that represents a complex operator (like a Hamiltonian) as a unitary transformation acting on an extended Hilbert space, enabling efficient simulation of its dynamics. It constructs a “walk operator” whose eigenphases directly encode the eigenvalues of the target operator. This allows algorithms such as quantum phase estimation to extract those eigenvalues with optimal asymptotic scaling in precision.

A real number is any number that can represent a distance along a continuous line, including all rational numbers (like fractions and integers) and irrational numbers (like or ). In other words, it’s any number that can appear on the number line. Real numbers exclude imaginary numbers, which involve .

A **Reproducing Kernel Hilbert Space (RKHS)** is a Hilbert space of functions where evaluating a function at any point can be done via an inner product with a special function called the **kernel**. This kernel encodes similarity between inputs and ensures all evaluation functionals are continuous. RKHSs are central to kernel methods (e.g., SVMs, Gaussian processes) because they let algorithms operate implicitly in high-dimensional feature spaces.

Robustness means a quantum system’s ability to maintain correct behavior despite errors from noise, decoherence, or imperfect control. A robust quantum algorithm or qubit setup resists or corrects these disturbances without losing information. It’s a key factor in making quantum computers reliable for real-world computation.

In quantum computing, a rotation operator is a unitary matrix that rotates a qubit’s state vector on the Bloch sphere by a specific angle around a chosen axis (X, Y, or Z). These are denoted ( R_x(\theta) ), ( R_y(\theta) ), and ( R_z(\theta) ), where ( \theta ) is the rotation angle. They generalize Pauli gates and are fundamental for creating arbitrary single-qubit operations.

The **Rx gate** is a single-qubit quantum gate that performs a rotation around the **x-axis** of the Bloch sphere by a specified angle . Mathematically, it’s represented as , where is the Pauli-X matrix. It changes the qubit’s state by mixing the amplitudes of and while keeping their probabilities dependent on the rotation angle.

The **Ry gate** is a single-qubit quantum gate that rotates a qubit’s state around the **Y-axis** of the Bloch sphere by a specified angle . Mathematically, it’s represented as . It changes the probabilities (amplitudes) of measuring 0 or 1 without altering their relative phase.

The Rz gate is a single-qubit rotation gate that rotates the qubit’s state around the Z-axis of the Bloch sphere by an angle . Its matrix form is . It changes the relative phase between and without altering their probabilities.

Sample complexity is the number of measurements (or repetitions of a quantum experiment) needed to estimate a property of a quantum state or circuit to a desired accuracy. Because quantum measurements destroy the state, multiple copies or runs are required. Lower sample complexity means fewer measurements are needed to achieve reliable results.

Schrödinger’s equation describes how the quantum state (wavefunction) of a physical system changes over time. It’s the fundamental equation of quantum mechanics, playing a role similar to Newton’s laws in classical physics. The equation links the wavefunction’s curvature (its spatial behavior) to the system’s energy, determining the probabilities of measurable outcomes.

Shor’s Algorithm is a quantum algorithm for factoring large integers efficiently—something classical computers can only do very slowly. It works by using quantum parallelism and the Quantum Fourier Transform to find the period of a modular exponentiation function, which reveals the factors. Its efficiency threatens current cryptographic systems like RSA that rely on the hardness of factoring.

Simultaneous Perturbation Stochastic Approximation (SPSA) is an optimization method that estimates the gradient of an objective function using only two function evaluations per iteration, regardless of the problem’s dimension. It does this by randomly perturbing all parameters simultaneously and using the difference in the resulting function values to approximate the gradient. SPSA is efficient for noisy or high-dimensional problems where computing exact or finite-difference gradients is costly.

A **single-qubit gate** is a quantum operation that changes the state of one qubit by rotating its position on the Bloch sphere. Mathematically, it’s represented by a 2×2 unitary matrix that preserves quantum probabilities. Examples include the **Pauli gates (X, Y, Z)** and the **Hadamard gate (H)**, which create superpositions or flip quantum states.

Singular Value Transformation (SVT) is a framework for applying a desired function to the singular values of a matrix using quantum operations. It generalizes many quantum algorithms by expressing them as specific transformations of singular values through polynomial functions. Essentially, it provides a unified way to perform tasks like matrix inversion, projection, or amplification within quantum computation.

In quantum computing, sparsity refers to how many elements in a matrix or operator (such as a Hamiltonian or unitary) are nonzero compared to the total possible elements. A sparse matrix has relatively few nonzero entries, which makes certain quantum algorithms (like Hamiltonian simulation or linear systems solvers) more efficient because only those entries need to be processed. Exploiting sparsity reduces computational complexity and resource requirements.

Spectral analysis is a method for examining how the power or energy of a signal is distributed across different frequencies. It decomposes a complex signal into its frequency components using tools like the Fourier transform. This helps identify dominant frequencies, periodicities, or noise characteristics in data such as sound, vibration, or time series signals.

Spectral filtering is the process of modifying a signal or image by selectively amplifying or suppressing certain frequency components in its spectrum. It typically involves transforming the data (e.g., via Fourier or Laplace transform), applying a filter function in the frequency domain, then converting it back to the original domain. This allows control over features like noise, smoothness, or specific patterns based on their spectral content.

**Stabilizer propagation** is a method used in quantum computing to efficiently simulate how *stabilizer states* evolve under *Clifford operations*. Instead of tracking full quantum states, it tracks how the stabilizer generators (Pauli operators that define the state) transform through the circuit. This works because Clifford gates map Pauli operators to Pauli operators, keeping the stabilizer structure intact and making simulation polynomial-time efficient.

Stochastic Gradient Descent (SGD) is an optimization algorithm that updates model parameters using the gradient from a single (or small batch of) randomly chosen training sample(s) rather than the full dataset. This makes updates faster but noisier, which can help escape local minima. It iteratively moves parameters in the direction that reduces the loss function until convergence.

Superposition in quantum computing means a quantum bit (qubit) can exist in multiple states (0 and 1) at the same time, rather than being limited to one like a classical bit. Mathematically, it’s a linear combination of basis states with complex probability amplitudes. This allows quantum computers to process many possible inputs simultaneously, enabling exponential speedups for certain problems.

Symmetry refers to transformations of a quantum system that leave its physical properties or outcomes unchanged. Exploiting these symmetries helps simplify computations by reducing the number of distinct quantum states that need to be considered. This allows more efficient simulation of physical systems and optimization of quantum algorithms.

A tensor product combines two vector spaces (or matrices) into a new, larger space that encodes all possible pairwise combinations of their elements. If one space has dimension *m* and the other *n*, the tensor product space has dimension *m × n*. In matrix terms, it generalizes the outer product, producing a block matrix that represents how elements from one space interact with elements of another.

In quantum computing, *trainability* refers to how effectively a quantum machine learning model (like a variational quantum circuit) can be optimized to minimize its loss function. It depends on whether small parameter changes produce meaningful gradients rather than vanishing ones. Poor trainability—often caused by issues like barren plateaus—means the model can’t learn efficiently because gradients become too small to guide improvement.

A **training loop** in quantum computing is the iterative process used to optimize parameters in a hybrid quantum-classical algorithm, such as a variational quantum circuit. The quantum computer evaluates a cost function by running the circuit and measuring outputs, while a classical optimizer updates the circuit parameters to minimize (or maximize) that cost. This loop repeats until the model converges to an optimal or near-optimal solution.

In quantum computing, a **Transformer** refers to an adaptation of the classical Transformer neural network architecture for **quantum data or quantum circuits**. It uses quantum operations (like parameterized quantum gates) to process information in **Hilbert space**, enabling the model to capture quantum correlations that classical Transformers can’t. Essentially, it’s a **quantum analog of attention-based models**, designed to learn from or simulate quantum states and dynamics.

In quantum computing, **transpilation** is the process of converting a high-level quantum circuit (written for an ideal model) into an optimized version that can run on a specific quantum device. It adjusts the circuit to match the device’s available gate set, connectivity, and error characteristics. The goal is to preserve the computation’s logic while minimizing errors and resource use.

A **transpose** of a matrix is formed by flipping it over its diagonal — rows become columns and columns become rows. Mathematically, the element at position ( (i, j) ) in the original matrix moves to ( (j, i) ) in the transposed matrix. It’s often denoted as ( A^T ) or ( A' ).

The Trotter–Suzuki decomposition approximates the exponential of a sum of non-commuting operators—like a quantum Hamiltonian—by breaking it into a product of exponentials of the individual terms. This allows simulation of complex quantum evolutions using simpler, implementable operations. The approximation becomes exact in the limit of infinitesimally small time steps, with higher-order Suzuki formulas improving accuracy at the cost of more operations.

Trotterization is a method to approximate the evolution of a quantum system whose Hamiltonian is a sum of non-commuting parts. It breaks the total evolution into a sequence of smaller steps , which can be implemented with available quantum gates. The smaller the time step , the closer the approximation is to the true evolution.

Unitary evolution is the rule that describes how a closed quantum system changes over time according to the Schrödinger equation. The system’s state vector is transformed by a *unitary operator*, meaning probabilities (the total norm) are exactly preserved. This ensures quantum evolution is reversible and information is never lost.

A **unitary operator** is a linear operator ( U ) on a complex vector space that satisfies ( U^\dagger U = UU^\dagger = I ), meaning it preserves inner products. In simpler terms, it preserves the **length** and **angle** between vectors—so it represents a **reversible, norm-preserving transformation**. In quantum mechanics, unitary operators describe the evolution of isolated systems because they conserve probability.

A unitary transformation is a mathematical operation that preserves the length (or norm) of vectors, meaning it doesn’t change probabilities or total energy in quantum systems. Formally, a matrix is unitary if , where is its conjugate transpose. In essence, it represents a rotation or change of basis in complex vector space that keeps inner products unchanged.

A Variational Quantum Algorithm is a hybrid quantum–classical algorithm in which a quantum circuit is paramterized by a classical routine. This means, it usually computes the values for rotation angles used inside this parameterized quantum circuit during a classical pre-processing step. Additionally, the measurement results are interpreted during a classical post-processing.

The Variational Quantum Eigensolver (VQE) is a hybrid quantum-classical algorithm used to find the lowest energy (ground state) of a quantum system. It prepares a parameterized quantum state on a quantum computer, measures its energy, and uses a classical optimizer to adjust the parameters to minimize that energy. This approach reduces quantum hardware requirements by offloading the optimization loop to classical computation.

A vector is a mathematical object that has both magnitude (size) and direction. It’s often represented as an arrow or as an ordered list of numbers (components) that describe its position in space, such as . Vectors are used to represent quantities like velocity, force, or displacement.

A vector space is a set of objects called **vectors** that can be **added together** and **scaled by numbers** (called scalars) while still staying in the same set. The addition and scaling follow specific algebraic rules (like associativity, distributivity, and the existence of a zero vector). Examples include geometric vectors in 2D or 3D space, or functions that can be added and multiplied by numbers.

In quantum computing, a wavefunction describes the complete quantum state of a system. Essentially it encodes all possible outcomes and their probabilities. It’s a mathematical object (usually a complex-valued vector) that evolves according to the Schrödinger equation. Measuring the system collapses the wavefunction to one outcome, destroying the superposition of states.

The X-Gate flips a qubit's probability amplitudes between its two basis states, effectively exchanging their roles. It doesn’t just turn into , but rotates any quantum state halfway around the x-axis of the Bloch sphere. This means it inverts the qubit's orientation while preserving the overall shape of its state on the sphere.

Y Gate

The Y-Rotation Operator () turns the quantum state vector of a single qubit around the -axis.

The Z-gate changes the phase of the state by (or radians) while leaving the state unchanged. This means the amplitude of gains a negative sign, effectively flipping its phase. It's a phase-flip operation that rotates the quantum state vector a half turn around the Z-axis of the Bloch sphere.

Zero Noise Extrapolation (ZNE) is an error mitigation technique where a quantum circuit is run multiple times at different, artificially increased noise levels. The results are then extrapolated back to the “zero-noise” limit using a mathematical fit (often linear or polynomial). This provides an estimate of what the circuit’s outcome would be if there were no hardware noise, without requiring full quantum error correction.