# Three Approaches to the Quantitative Definition of Information in an Individual Pure Quantum State

## 1 Introduction

While Kolmogorov complexity is the accepted absolute measure of information content in a classical individual finite object, a similar absolute notion is needed for the information content of a pure quantum state. <sup>1</sup><sup>1</sup>1 For definitions and theory of Kolmogorov complexity consult , and for quantum theory consult .  Quantum theory assumes that every complex vector, except the null vector, represents a realizable pure quantum state.<sup>2</sup><sup>2</sup>2That is, every complex vector that can be normalized to unit length. This leaves open the question of how to design the equipment that prepares such a pure state. While there are continuously many pure states in a finite-dimensional complex vector space—corresponding to all vectors of unit length—we can finitely describe only a countable subset. Imposing effectiveness on such descriptions leads to constructive procedures. The most general such procedures satisfying universally agreed-upon logical principles of effectiveness are quantum Turing machines, . To define quantum Kolmogorov complexity by way of quantum Turing machines leaves essentially two options:

1. We want to describe every quantum superposition exactly; or
2. we want to take into account the number of bits/qubits in the specification as well the accuracy of the quantum state produced.

We have to deal with three problems:

* There are continuously many quantum Turing machines;
* There are continously many pure quantum states;
* There are continuously many qubit descriptions.

There are uncountably many quantum Turing machines only if we allow arbitrary real rotations in the definition of machines. Then, a quantum Turing machine can only be universal in the sense that it can approximate the computation of an arbitrary machine, . In descriptions using universal quantum Turing machines we would have to account for the closeness of approximation, the number of steps required to get this precision, and the like. In contrast, if we fix the rotation of all contemplated machines to a single primitive rotation $`\theta `$ with $`\mathrm{cos}\theta =3/5`$ and $`\mathrm{sin}\theta =4/5`$ then there are only countably many Turing machines and the universal machine simulates the others exactly . Every quantum Turing machine computation using arbitrary real rotations can be approximated to any precision by machines with fixed rotation $`\theta `$ but in general cannot be simulated exactly—just like in the case of the simulation of arbitrary quantum Turing machines by a universal quantum Turing machine. Since exact simulation is impossible by a fixed universal quantum Turing machine anyhow, but arbitrarily close approximations are possible by Turing machines using a fixed rotation like $`\theta `$, we are motivated to fix $`Q_1,Q_2,\mathrm{}`$ as a standard enumeration of quantum Turing machines using only rotation $`\theta `$.

Our next question is whether we want programs (descriptions) to be in classical bits or in qubits? The intuitive notion of computability requires the programs to be classical. Namely, to prepare a quantum state requires a physical apparatus that “computes” this quantum state from classical specifications. Since such specifications have effective descriptions, every quantum state that can be prepared can be described effectively in descriptions consisting of classical bits. Descriptions consisting of arbitrary pure quantum states allows noncomputable (or hard to compute) information to be hidden in the bits of the amplitudes. In Definition 2 we call a pure quantum state directly computable if there is a (classical) program such that the universal quantum Turing machine computes that state from the program and then halts in an appropriate fashion. In a computational setting we naturally require that directly computable pure quantum states can be prepared. By repeating the preparation we can obtain arbitrarily many copies of the pure quantum state. <sup>3</sup><sup>3</sup>3See the discussion in , pp. 49–51. If descriptions are not effective then we are not going to use them in our algorithms except possibly on inputs from an “unprepared” origin. Every quantum state used in a quantum computation arises from some classically preparation or is possibly captured from some unknown origin. If the latter, then we can consume it as conditional side-information or an oracle. Restricting ourselves to an effective enumeration of quantum Turing machines and classical descriptions to describe by approximation continuously many pure quantum states is reminiscent of the construction of continuously many real numbers from Cauchy sequences of rational numbers, the rationals being effectively enumerable.

The second approach considers the shortest effective qubit description of a pure quantum state. This can also be properly formulated in terms of the conditional version of the first approach. An advantage of this version is that the upper bound on the complexity of a pure quantum state is immediately given by the number of qubits involved in the literal description of that pure quantum state. The status of incompressibility and degree of uncomputability is as yet unknown and potentially a source of problems with this approach.

The third approach is to give programs for the $`2^{n+1}`$ real numbers involved in the precise description of the $`n`$-qubit state. Then the question reduces to the problem of describing lists of real numbers.

In the classical situation there are also several variants of Kolmogorov complexity that are very meaningful in their respective settings: plain Kolmogorov complexity, prefix complexity, monotone complexity, uniform complexity, negative logarithm of universal measure, and so on . It is therefore not surprising that in the more complicated situation of quantum information several different choices of complexity can be meaningful and unavoidable in different settings.

## 2 Classical Descriptions

The complex quantity $`x|z`$ is the inner product of vectors $`|x`$ and $`|z`$. Since pure quantum states $`|x,|z`$ have unit length, $`|x|z|=|\mathrm{cos}\theta |`$ where $`\theta `$ is the angle between vectors $`|x`$ and $`|z`$ and $`|x|z|^2`$ is the probability of outcome $`|x`$ being measured from state $`|z`$, . The idea is as follows. A von Neumann measurement is a decomposition of the Hilbert space into subspaces that are mutually orthogonal, for example an orthonormal basis is an observable. Physicists like to specify observables as Hermitian matrices, where the understanding is that the eigenspaces of the matrices (which will always be orthogonal) are the actual subspaces. When a measurement is performed, the state is projected into one of the subspaces (with probability equal to the square of the projection). So the subspaces correspond to the possible outcomes of a measurement. In the above case we project $`|z`$ on outcome $`|x`$ using projection $`|xx|`$ resulting in $`x|z`$$`|x`$.

Our model of computation is a quantum Turing machine with classical binary program $`p`$ on the input tape and a quantum auxiliary input on a special conditional input facility. We think of this auxiliary input as being given as a pure quantum state $`|y`$ (in which case it can be used only once), as a mixture density matrix $`\rho `$, or (perhaps partially) as a classical program from which it can be computed. In the last case, the classical program can of course be used indefinitely often.<sup>4</sup><sup>4</sup>4We can even allow that the conditional information $`y`$ is infinite or noncomputable, or an oracle. But we will not need this in the present paper.  It is therefore not only important what information is given conditionally, but also how it is described—like this is the sometimes the case in the classical version of Kolmogorov complexity for other reasons that would additionally hold in the quantum case. We impose the condition that the set of halting programs $`𝒫_y=\{p:T(p|y)<\mathrm{}\}`$ is prefix-free: no program in $`𝒫_y`$ is a proper prefix of another program in $`𝒫_y`$. Put differently, the Turing machine scans all of a halting program $`p`$ but never scans the bit following the last bit of $`p`$: it is self-delimiting. <sup>5</sup><sup>5</sup>5One can also use a model were the input $`p`$ is delimited by distinguished markers. Then the Turing machine always knows where the input ends. In the self-delimiting case the endmarker must be implicit in the halting program $`p`$ itself. This encoding of the endmarker carries an inherent penalty in the form of increased length: typically a prefix code of an $`n`$-length binary string has length about $`n+\mathrm{log}n+2\mathrm{log}\mathrm{log}n`$ bits, . <sup>6</sup><sup>6</sup>6 There are two possible interpretations for the computation relation $`Q(p,y)=|x`$. In the narrow interpretation we require that $`Q`$ with $`p`$ on the input tape and $`y`$ on the conditional tape halts with $`|x`$ on the output tape. In the wide interpretation we can define pure quantum states by requiring that for every precision $`\delta >0`$ the computation of $`Q`$ with $`p`$ on the input tape and $`y`$ on the conditional tape and $`\delta `$ on a tape where the precision is to be supplied halts with $`|x^{}`$ on the output tape and $`|x|x^{}|^21\delta `$. Such a notion of “computable” or “recursive” pure quantum states is similar to Turing’s notion of “computable numbers.” In the remainder of this section we use the narrow interpretation. 

###### Definition 1

The (self-delimiting) complexity of $`|x`$ with respect to quantum Turing machine $`Q`$ with $`y`$ as conditional input given for free is

$$K_Q(|x|y):=\underset{p}{\mathrm{min}}\{l(p)+\mathrm{log}(|z|x|^2):Q(p,y)=|z\}$$

where $`l(p)`$ is the number of bits in the specification $`p`$, $`y`$ is an input quantum state and $`|z`$ is the quantum state produced by the computation $`Q(p,y)`$, and $`|x`$ is the target state that one is trying to describe.

###### Theorem 1

There is a universal machine <sup>7</sup><sup>7</sup>7 We use “$`U`$” to denote a universal (quantum) Turing machine rather than a unitary matrix. $`U`$ such that for all machines $`Q`$ there is a constant $`c_Q`$ (the length of the description of the index of $`Q`$ in the enumeration) such that for all quantum states $`|x`$ we have $`K_U(|x|y)K_Q(|x|y)+c_Q`$.

Proof. There is a universal quantum Turing machine $`U`$ in the standard enumeration $`Q_1,Q_2,\mathrm{}`$ such that for every quantum Turing machine $`Q`$ in the enumeration there is a self-delimiting program $`i_Q`$ (the index of $`Q`$) and $`U(i_Qp,y)=Q(p,y)`$ for all $`p,y`$. Setting $`c_Q=l(i_Q)`$ proves the theorem. $`\mathrm{}`$

We fix once and for all a reference universal quantum Turing machine $`U`$ and define the quantum Kolmogorov complexity as

$`K(|x|y):=K_U(|x|y),`$   
$`K(|x):=K_U(|x|ϵ),`$   
where $`ϵ`$ denotes the absence of any conditional information. The definition is continuous: If two quantum states are very close then their quantum Kolmogorov complexities are very close. Furthermore, since we can approximate every (pure quantum) state $`|x`$ to arbitrary closeness, , in particular, for every constant $`ϵ>0`$ we can compute a (pure quantum) state $`|z`$ such that $`|z|x|^2>1ϵ`$. <sup>8</sup><sup>8</sup>8We can view this as the probability of the possibly noncomputable outcome $`|x`$ when executing projection $`|xx|`$ on $`|z`$ and measuring outcome $`|x`$. For this definition to be useful it should satisfy: 

* The complexity of a pure state that can be directly computed should be the length of the shortest program that computes that state. (If the complexity is less then this may lead to discontinuities when we restrict quantum Kolmogorov complexity to the domain of classical objects.)
* The quantum Kolmogorov complexity of a classical object should equal the classical Kolmogorov complexity of that object (up to a constant additive term).
* The quantum Kolmogorov complexity of a quantum object should have an upper bound. (This is necessary for the complexity to be approximable from above, even if the quantum object is available in as many copies as we require.)
* Most objects should be “incompressible” in terms of quantum Kolmogorov complexity.
* In a probabilistic ensemble the expected quantum Kolmogorov complexity should be about equal (or have another meaningful relation) to the von Neumann entropy. <sup>9</sup><sup>9</sup>9In the classical case the average self-delimiting Kolmogorov complexity equals the Shannon entropy up to an additive constant depending on the complexity of the distribution concerned.

For a quantum system $`|z`$ the quantity $`P(x):=|z|x|^2`$ is the probability that the system passes a test for $`|x`$, and vice versa. The term $`\mathrm{log}(|z|x|^2)`$ can be viewed as the code word length to redescribe $`|x`$ given $`|z`$ and an orthonormal basis with $`|x`$ as one of the basis vectors using the well-known Shannon-Fano prefix code. This works as follows: For every state $`|z`$ in $`N:=2^n`$-dimensional Hilbert space with basis vectors $`=\{|e_0,\mathrm{},|e_{N1}\}`$ we have $`_{i=0}^{N1}|e_i|z|^2=1`$. If the basis has $`|x`$ as one of the basis vectors, then we can consider $`|z`$ as a random variable that assumes value $`|x`$ with probability $`|x|z|^2`$. The Shannon-Fano code word for $`|x`$ in the probabilistic ensemble $`,(|e_i|z|^2)_i`$ is based on the probability $`|x|z|^2`$ of $`|x`$ given $`|z`$ and has length $`\mathrm{log}(|x|z|^2)`$. Considering a canonical method of constructing an orthonormal basis $`=|e_0,\mathrm{},|e_{N1}`$ from a given basis vector, we can choose $``$ such that $`K()=\mathrm{min}_i\{K(|e_i)\}+O(1)`$. The Shannon-Fano code is appropriate for our purpose since it is optimal in that it achieves the least expected code word length—the expectation taken over the probability of the source words—up to 1 bit by Shannon’s Noiseless Coding Theorem.

### 2.1 Consistency with Classical Complexity

Our proposal would not be useful if it were the case that for a directly computable object the complexity is less than the shortest program to compute that object. This would imply that the code corresponding to the probabilistic component in the description is possibly shorter than the difference in program lengths for programs for an approximation of the object and the object itself. This would penalize definite description compared to probabilistic description and in case of classical objects would make quantum Kolmogorov complexity less than classical Kolmogorov complexity.

###### Theorem 2

Let $`U`$ be the reference universal quantum Turing machine and let $`|x`$ be a basis vector in a directly computable orthonormal basis $``$ given $`y`$: there is a program $`p`$ such that $`U(p,y)=|x`$. Then $`K(|x|y)=\mathrm{min}_p\{l(p):U(p,y)=|x\}`$ up to $`K(|y)+O(1)`$.

Proof. Let $`|z`$ be such that

$$K(|x|y)=\underset{q}{\mathrm{min}}\{l(q)+\mathrm{log}(|z|x|^2):U(q,y)=|z\}.$$

Denote the program $`q`$ that minimizes the righthand side by $`q_{\mathrm{min}}`$ and the program $`p`$ that minimizes the expression in the statement of the theorem by $`p_{\mathrm{min}}`$.

By running $`U`$ on all binary strings (candidate programs) simultaneously dovetailed-fashion <sup>10</sup><sup>10</sup>10A dovetailed computation is a method related to Cantor’s diagonalization to run all programs alternatingly in such a way that every program eventually makes progress. On an list of programs $`p_1,p_2,\mathrm{}`$ one divides the overall computation into stages $`k:=1,2,\mathrm{}`$. In stage $`k`$ of the overall computation one executes the $`i`$th computation step of every program $`p_{ki+1}`$ for $`i:=1,\mathrm{},k`$. one can enumerate all objects that are directly computable given $`y`$ in order of their halting programs. Assume that $`U`$ is also given a $`K(|y)`$ length program $`b`$ to compute $``$—that is, enumerate the basis vectors in $``$. This way $`q_{\mathrm{min}}`$ computes $`|z`$, the program $`b`$ computes $``$. Now since the vectors of $``$ are mutually orthogonal

$$\underset{|e}{}|z|e|^2=1.$$

Since $`|x`$ is one of the basis vectors we have $`\mathrm{log}|z|x|^2`$ is the length of a prefix code (the Shannon-Fano code) to compute $`|x`$ from $`|z`$ and $``$. Denoting this code by $`r`$ we have that the concatenation $`q_{\mathrm{min}}br`$ is a program to compute $`|x`$: parse it into $`q_{\mathrm{min}},b,`$ and $`r`$ using the self-delimiting property of $`q_{\mathrm{min}}`$ and $`b`$. Use $`q_{\mathrm{min}}`$ to compute $`|z`$ and use $`b`$ to compute $``$, determine the probabilities $`|z|e|^2`$ for all basis vectors $`|e`$ in $``$. Determine the Shannon-Fano code words for all the basis vectors from these probabilities. Since $`r`$ is the code word for $`|x`$ we can now decode $`|x`$. Therefore,

$$l(q_{\mathrm{min}})+\mathrm{log}(|z|x|^2)l(p_{\mathrm{min}})K(|y)O(1)$$

which was what we had to prove. $`\mathrm{}`$

###### Corollary 1

On classical objects (that is, the natural numbers or finite binary strings that are all directly computable) the quantum Kolmogorov complexity coincides up to a fixed additional constant with the self-delimiting Kolmogorov complexity since $`K(|n)=O(1)`$ for the standard classical basis $`=\{0,1\}^n`$. <sup>11</sup><sup>11</sup>11 This proof does not show that it coincide up to an additive constant term with the original plain complexity defined by Kolmogorov, , based on Turing machines where the input is delited by distinguished markers. The same proof for the plain Kolmogorov complexity shows that it coincides up to a logarithmic additive term.  (We assume that the information about the dimensionality of the Hilbert space is given conditionally.)

###### Remark 1

Fixed additional constants are no problem since the complexity also varies by fixed additional constants due to the choice of reference universal Turing machine. $`\mathrm{}`$

### 2.2 Upper Bound on Complexity

A priori, in the worst case $`K(|x|n)`$ is possibly $`\mathrm{}`$. We show that the worst-case has a $`2n`$ upper bound.

###### Lemma 1

For all $`n`$-qubit quantum states $`|x`$ we have $`K(|x|n)2n+O(1)`$.

Proof. For every state $`|x`$ in $`N:=2^n`$-dimensional Hilbert space with basis vectors $`|e_0,\mathrm{},|e_{N1}`$ we have $`_{i=0}^{N1}|e_i|x|^2=1`$. Hence there is an $`i`$ such that $`|e_i|x|^21/N`$. Let $`p`$ be a $`K(i|n)+O(1)`$-bit program to construct a basis state $`|e_i`$ given $`n`$. Then $`l(p)n+O(1)`$. Then $`K(|x|n)l(p)\mathrm{log}(1/N)2n+O(1)`$. $`\mathrm{}`$

### 2.3 Computability

In the classical case Kolmogorov complexity is not computable but can be approximated from above by a computable process. The non-cloning property prevents us from copying an unknown pure quantum state given to us. Therefore, an approximation from above that requires checking every output state against the target state destroys the latter. To overcome the fragility of the pure quantum target state one has to postulate that it is available as an outcome in a measurement.

###### Theorem 3

Let $`|x`$ be the pure quantum state we want to describe.

(i) The quantum Kolmogorov complexity $`K(|x)`$ is not computable.

(ii) If we can repeatedly execute the projection $`|xx|`$ and perform a measurement with outcome $`|x`$, then the quantum Kolmogorov complexity $`K(|x)`$ can be approximated from above by a computable process with arbitrarily small probability of error $`\alpha `$ of giving a too small value.

Proof. The uncomputability follows a fortiori from the classical case. The semicomputability follows because we have established an upper bound on the quantum Kolmogorov complexity, and we can simply enumerate all halting classical programs up to that length by running their computations dovetailed fashion. The idea is as follows: Let the target state be $`|x`$ of $`n`$ qubits. Then, $`K(|x|n)2n+O(1)`$. (The unconditional case $`K(|x)`$ is similar with $`2n`$ replaced by $`2(n+\mathrm{log}n)`$.) We want to identify a program $`x^{}`$ such that $`p:=x^{}`$ minimizes $`l(p)\mathrm{log}|x|U(p,n)|^2`$ among all candidate programs. To identify it in the limit, for some fixed $`k`$ satisfying (2) below for given $`n,\alpha ,ϵ`$, repeat the computation of every halting program $`p`$ with $`l(p)2n+O(1)`$ at least $`k`$ times and perform the assumed projection and measurement. For every halting program $`p`$ in the dovetailing process we estimate the probability $`q:=|x|U(p,n)|^2`$ from the fraction $`m/k`$: the fraction of $`m`$ positive outcomes out of $`k`$ measurements. The probability that the estimate $`m/k`$ is off from the real value $`q`$ by more than an $`ϵq`$ is given by Chernoff’s bound: for $`0ϵ1`$,

$$P(|mqk|>ϵqk)2e^{ϵ^2qk/3}.$$
(1)   
This means that the probability that the deviation $`|m/kq|`$ exceeds $`ϵq`$ vanishes exponentially with growing $`k`$. Every candidate program $`p`$ satisfies (1) with its own $`q`$ or $`1q`$. There are $`O(2^{2n})`$ candidate programs $`p`$ and hence also $`O(2^{2n})`$ outcomes $`U(p,n)`$ with halting computations. We use this estimate to upper bound the probability of error $`\alpha `$. For given $`k`$, the probability that some halting candidate program $`p`$ satisfies $`|mqk|>ϵqk`$ is at most $`\alpha `$ with

$$\alpha \underset{U(p,n)<\mathrm{}}{}2e^{ϵ^2qk/3}.$$

The probability that no halting program does so is at least $`1\alpha `$. That is, with probability at least $`1\alpha `$ we have

$$(1ϵ)q\frac{m}{k}(1+ϵ)q$$

for every halting program $`p`$. It is convenient to restrict attention to the case that all $`q`$’s are large. Without loss of generality, if $`q<\frac{1}{2}`$ then consider $`1q`$ instead of $`q`$. Then,

$$\mathrm{log}\alpha 2n(ϵ^2k\mathrm{log}e)/6+O(1).$$
(2)   
The approximation algorithm is as follows:

Step 0: Set the required degree of approximation $`ϵ<1/2`$ and the number of trials $`k`$ to achieve the required probability of error $`\alpha `$.

Step 1: Dovetail the running of all candidate programs until the next halting program is enumerated. Repeat the computation of the new halting program $`k`$ times

Step 2: If there is more than one program $`p`$ that achieves the current minimum then choose the program with the smaller length (and hence least number of successfull observations). If $`p`$ is the selected program with $`m`$ successes out of $`k`$ trials then set the current approximation of $`K(|x)`$ to

$$l(p)\mathrm{log}\frac{m}{(1+ϵ)k}.$$

This exceeds the proper value of the approximation based on the real $`q`$ instead of $`m/k`$ by at most 1 bit for all $`ϵ<1`$.

Step 3: Goto Step 1. $`\mathrm{}`$

### 2.4 Incompressibility

###### Definition 2

A pure quantum state $`|x`$ is computable if $`K(|x)<\mathrm{}`$. Hence all finite-dimensional pure quantum states are computable. We call a pure quantum state directly computable if there is a program $`p`$ such that $`U(p)=|x`$.

The standard orthonormal basis—consisting of all $`n`$-bit strings—of the $`2^n`$-dimensional Hilbert space $`_N`$ has at least $`2^n(12^c)`$ basis vectors $`|e_i`$ that satisfy $`K(|e_i|n)nc`$. This is the standard counting argument in . But what about nonclassical orthonormal bases?

###### Lemma 2

There is a (possibly nonclassical) orthonormal basis of the $`2^n`$-dimensional Hilbert space $`_N`$ such that at least $`2^n(12^c)`$ basis vectors $`|e_i`$ satisfy $`K(|e_i|n)nc`$.

Proof. Every orthonormal basis of $`_N`$ has $`2^n`$ basis vectors and there are at most $`m_{i=0}^{nc1}2^i=2^{nc}1`$ programs of length less than $`nc`$. Hence there are at most $`m`$ programs available to approximate the basis vectors. We construct an orthonormal basis satisfying the lemma: The set of directly computed pure quantum states $`|x_0,\mathrm{},|x_{m1}`$ span an $`m^{}`$-dimensional subspace $`𝒜`$ with $`m^{}m`$ in the $`2^n`$-dimensional Hilbert space $`_N`$ such that $`_N=𝒜𝒜^{}`$. Here $`𝒜^{}`$ is a $`(2^nm^{})`$-dimensional subspace of $`_N`$ such that every vector in it is perpendicular to every vector in $`𝒜`$. We can write every element $`|x_N`$ as

$$\underset{i=0}{\overset{m^{}1}{}}\alpha _i|a_i+\underset{i=0}{\overset{2^nm^{}1}{}}\beta _i|b_i$$

where the $`|a_i`$’s form an orthonormal basis of $`𝒜`$ and the $`|b_i`$’s form an orthonormal basis of $`𝒜^{}`$ so that the $`|a_i`$’s and $`|b_i`$’s form an orthonormal basis $`K`$ for $`_N`$. For every directly computable state $`|x_j𝒜`$ and basis vector $`|b_iA^{}`$ we have $`|x_j|b_i|^2=0`$ implying that $`K(|x_j|n)\mathrm{log}|x_j|b_i|^2=\mathrm{}`$ and therefore $`K(|b_i|n)>nc`$ ($`0j<m,0i<2^nm^{}`$). This proves the lemma. $`\mathrm{}`$

We generalize this lemma to arbitrary bases:

###### Theorem 4

Every orthonormal basis $`|e_0,\mathrm{},|e_{2^n1}`$ of the $`2^n`$-dimensional Hilbert space $`_N`$ has at least $`2^n(12^c)`$ basis vectors $`|e_i`$ that satisfy $`K(|e_i|n)nc`$.

Proof. Use the notation of the proof of Lemma 2. Assume to the contrary that there are $`>2^{nc}`$ basis vectors $`|e_i`$ with $`K(|e_i|n)<nc`$. Then at least two of them, say $`|e_0`$ and $`|e_1`$ and some pure quantum state $`|x`$ directly computed from a $`<(nc)`$-length program satisfy

$$K(|e_i|n)=K(|x|n)+\mathrm{log}|e_i|x|^2.$$
(3)   
($`i=0,1`$). This means that $`K(|x|n)<nc1`$ since not both $`|e_0`$ and $`|e_1`$ can be equal to $`|x`$. Hence for every directly computed pure quantum state of complexity $`nc1`$ there is at most one basis state of the same complexity (in fact only if that basis state is identical with the directly computed state.) Now eliminate all directly computed pure quantum states $`|x`$ of complexity $`nc1`$ together with the basis states $`|e`$ that stand in relation Equation 3. We are now left with $`>2^{nc1}`$ basis states that stand in relation of Equation 3 with the remaining at most $`2^{nc1}1`$ remaining directly computable pure quantum states of complexity $`nc2`$. Repeating the same argument we end up with $`>1`$ basis vector that stand in relation of Equation 3 with 0 directly computable pure quantum states of complexity $`0`$ which is impossible. $`\mathrm{}`$

###### Corollary 2

The uniform probability $`\mathrm{Pr}\{|x:K(|x|n)nc\}11/2^c`$.

###### Example 1

We elucidate the role of the $`\mathrm{log}|x|z|^2`$ term. Let $`x`$ be a random classical string with $`K(x)l(x)`$ and let $`y`$ be a string obtained from $`x`$ by complementing one bit. It is known (Exercise 2.2.8 in ) that for every such $`x`$ of length $`n`$ there is such a $`y`$ with complexity $`K(y|n)=n\mathrm{log}n+O(1)`$. Now let $`|z`$ be a pure quantum state which has classical bits except the difference bit between $`x`$ and $`y`$ that has equal probabilities of being observed as “1” and as “0.” We can prepare $`|z`$ by giving $`y`$ and the position of the difference bit (in $`\mathrm{log}n`$ bits) and therefore $`K(|z|n)n+O(1)`$. Since from $`|z`$ we have probability $`\frac{1}{2}`$ of obtaining $`x`$ by observing the particular bit in superposition and $`K(x|n)n`$ it follows $`K(|z|n)n+O(1)`$ and therefore $`K(|z|n)=n+O(1)`$. From $`|z`$ we have probability $`\frac{1}{2}`$ of obtaining $`y`$ by observing the particular bit in superposition which (correctly) yields that $`K(y|n)n+O(1)`$. $`\mathrm{}`$

### 2.5 Conditional Complexity

We have used the conditional complexity $`K(|x|y)`$ to mean the minimum sum of the length of a classical program to compute $`|z`$ plus the negative logarithm of the probability of outcome $`|x`$ when executing projection $`|xx|`$ on $`|z`$ and measuring, given the pure quantum state $`y`$ as input on a separate input tape. In the quantum situation the notion of inputs consisting of pure quantum states is subject to very special rules.

Firstly, if we are given an unknown pure quantum state $`|y`$ as input it can be used only once, that is, it is irrevocably consumed and lost in the computation. It cannot be copied or cloned without destroying the original . This phenomenon is subject to the so-called no-cloning theorem and means that there is a profound difference between giving a directly computable pure quantum state as a classical program or giving it literally. Given as a classical program we can prepare and use arbitrarily many copies of it. Given as an (unknown) pure quantum state in superposition it can be used as start of a computation only once—unless of course we deal with an identity computation in which the input state is simply transported to the output state. This latter computation nonetheless destroys the input state.

If an unknown state $`|y`$ is given as input (in the conditional for example) then the no-cloning theorem of quantum computing says it can be used only once. Thus, for a non-classical pure quantum state $`|x`$ we have

$$K(|x,|x||x)K(|x)+O(1)$$

rather than $`K(x,x|x)=O(1)`$ as in the case for classical objects $`x`$. This holds even if $`|x`$ is directly computable but is given in the conditional in the form of an unknown pure quantum state. However, if $`|x`$ is directly computable and the conditional is a classical program to compute this directly computable state, then that program can be used over and over again.

In the previous example, if the conditional $`|x`$ is directly computable, for example by a classical program $`p`$, then we have both $`K(|x|p)=O(1)`$ and $`K(|x,|x|p)=O(1)`$. In particular, for a classical program $`p`$ that computes a directly computable state $`|x`$ we have

$$K(|x,|x|p)=O(1).$$

It is important here to notice that a classical program for computing a directly computable quantum state carries more information than the directly computable quantum state itself—much like a shortest program for a classical object carries more information than the object itself. In the latter case it consists in partial information about the halting problem. In the quantum case of a directly computable pure state we have the additional information that the state is directly computable and in case of a shortest classical program additional information about the halting problem.

### 2.6 Sub-Additivity

Quantum Kolmogorov complexity of directly computable pure quantum states in simple orthonormal bases is sub-additive:

###### Lemma 3

For directly computable $`|x,|y`$ both of which belong to (possibly different) orthonormal bases of Kolmogorov complexity $`O(1)`$ we have

$$K(|x,|y)K(|x||y)+K(|y)$$

up to an additive constant term.

Proof. By Theorem 2 we there is a program $`p_y`$ to compute $`|y`$ with $`l(p)=K(|y)`$ and a program $`p_{yx}`$ to compute $`|x`$ from $`|y`$ with $`l(p_{yx})=K(|x||y)`$ up to additional constants. Use $`p_y`$ to construct two copies of $`|y`$ and $`p_{yx}`$ to construct $`|x`$ from one of the copies of $`|y`$. The separation between these concatenated binary programs is taken care of by the self-delimiting property of the subprograms. The additional constant term takes care of the couple of $`O(1)`$-bit programs that are required. $`\mathrm{}`$

###### Remark 2

In the classical case we have equality in the theorem (up to an additive logarithmic term). The proof of the remaining inequality, as given in the classical case, doesn’t hold directly for the quantum case. It would require a decision procedure that establishes equality between two pure quantum states without error. While the sub-additivity property holds in case of directly computable states, is easy to see that for the general case of pure states the subadditivity property fails due to the “non-cloning” property. For example for pure states $`|x`$ that are not “clonable” we have:

$$K(|x,|x)>K(|x||x)+K(|x)=K(|x)+O(1).$$

$`\mathrm{}`$

We additionally note:

###### Lemma 4

For all directly computable pure states $`|x`$ and $`|y`$ we have $`K(|x,|y)K(|y)\mathrm{log}|x|y|^2`$ up to an additive logarithmic term.

Proof. $`K(|x||y)\mathrm{log}|x|y|^2`$ by the proof of Theorem 2. Then, the lemma follows by Lemma 3. $`\mathrm{}`$

## 3 Qubit Descriptions

One way to avoid two-part descriptions as we used above is to allow qubit programs as input. This leads to the following definitions, results, and problems.

###### Definition 3

The qubit complexity of $`|x`$ with respect to quantum Turing machine $`Q`$ with $`y`$ as conditional input given for free is

$$KQ_Q(|x|y):=\underset{p}{\mathrm{min}}\{l(|p):Q(|p,y)=|x\}$$

where $`l(|p)`$ is the number of qubits in the qubit specification $`|p`$, $`|p`$ is an input quantum state, $`y`$ is given conditionally, and $`|x`$ is the quantum state produced by the computation $`Q(|p,y)`$: the target state that one describes.

Note that here too there are two possible interpretations for the computation relation $`Q(|p,y)=|x`$. In the narrow interpretation we require that $`Q`$ with $`|p`$ on the input tape and $`y`$ on the conditional tape halts with $`|x`$ on the output tape. In the wide interpretation we require that for every precision $`\delta >0`$ the computation of $`Q`$ with $`|p`$ on the input tape and $`y`$ on the conditional tape and $`\delta `$ on a tape where the precision is to be supplied halts with $`|x^{}`$ on the output tape and $`|x|x^{}|^21\delta `$. Additionally one can require that the approximation finishes in a certain time, say, polynomial in $`l(|x)`$ and $`1/\delta `$. In the remainder of this section we can allow either interpretation (note that the “narrow” complexity will always be at least as large as the “wide” complexity). Fix an enumeration of quantum Turing machines like in Theorem 1, this time with Turing machines that use qubit programs. Just like before it is now straightforward to derive an Invariance Theorem:

###### Theorem 5

There is a universal machine $`U`$ such that for all machines $`Q`$ there is a constant $`c`$ (the length of a self-delimiting encoding of the index of $`Q`$ in the enumeration) such that for all quantum states $`|x`$ we have $`KQ_U(|x|y)KQ_Q(|x|y)+c`$.

We fix once and for all a reference universal quantum Turing machine $`U`$ and express the qubit quantum Kolmogorov complexity as

$`KQ(|x|y):=KQ_U(|x|y),`$   
$`KQ(|x):=KQ_U(|x|ϵ),`$   
where $`ϵ`$ indicates the absence of conditional information (the conditional tape contains the “quantum state” with 0 qubits). We now have immediately:

###### Lemma 5

$`KQ(|x)l(|x)+O(1)`$.

Proof. Give the reference universal machine $`|1^n0|x`$ as input where $`n`$ is the index of the identity quantum Turing machine that transports the attached pure quantum state $`|x`$ to the output. $`\mathrm{}`$

It is possible to define unconditional $`KQ`$-complexity in terms of conditional $`K`$-complexity as follows: Even for pure quantum states that are not directly computable from effective descriptions we have $`K(|x||x)=O(1)`$. This naturaly gives:

###### Lemma 6

The qubit quantum Kolmogorov complexity of $`|x`$ satisfies

$$KQ(|x)=\underset{p}{\mathrm{min}}\{l(|p):K(|x||p)\}+O(1),$$

where $`l(|p)`$ denotes the number of qubits in $`|p`$.

Proof. Transfer the conditional $`|p`$ to the input using an $`O(1)`$-bit program. $`\mathrm{}`$

We can generalize this definition to obtain conditional $`KQ`$-complexity.

### 3.1 Potential Problems of Qubit Complexity

While it is clear that (just as with the previous aproach) the qubit complexity is not computable, it is unknown to the author whether one can approximate the qubit complexity from above by a computable process in any meaningful sense. In particular, the dovetailing approach we used in the first approach now doesn’t seem applicable due to the non-countability of the potentential qubit program candidates. While it is clear that the qubit complexity of a pure quantum state is at least 1, why would it need to be more than one qubit since the probability amplitude can be any complex number? In case the target pure quantum state is a classical binary string, as observed by Harry Buhrman, Holevo’s theorem  tells us that on average one cannot transmit more than $`n`$ bits of classical information by $`n`$-qubit messages (without using entangled qubits on the side). This suggests that for every $`n`$ there exist classical binary strings of length $`n`$ that have qubit complexity at least $`n`$. This of course leaves open the case of the non-classical pure quantum states—a set of measure one—and of how to prove incompressibility of the overwhelming majority of states. These matters have since been investigated by A. Berthiaume, S. Laplante, and W. van Dam (paper in preparation).

## 4 Real Descriptions

A final version of quantum Kolmogorov complexity uses computable real parameters to describe the pure quantum state with complex probability amplitudes. This requires two reals per complex probability amplitude, that is, for $`n`$ qubits one requires $`2^{n+1}`$ real numbers in the worst case. Since every computable real number may require a separate program, a computable $`n`$ qubit state may require $`2^{n+1}`$ finite programs. While this approach does not allow the development of a clean theory in the sense of the previous approaches, it can be directly developed in terms of algorithmic thermodynamics—an extension of Kolmogorov complexity to randomness of infinite sequences (such as binary expansions of real numbers) in terms of coarse-graining and sequential Martin-Löff tests, completely analogous to Peter Gács theory .

## Acknowledgement

The ideas presented in this paper were developed from 1995 through early 1998. Other interests prevented me from earlier publication. I thank Harry Buhrman, Richard Cleve, Wim van Dam, Barbara Terhal, John Tromp, and Ronald de Wolf for discussions and comments on QKC.