Quantum Kolmogorov complexity and quantum correlations in deterministic-control quantum Turing machines

This work presents a study of Kolmogorov complexity for general quantum states from the perspective of deterministic-control quantum Turing Machines (dcq-TM). We extend the dcq-TM model to incorporate mixed state inputs and outputs, and define dcq-computable states as those that can be approximated by a dcq-TM. Moreover, we introduce (conditional) Kolmogorov complexity of quantum states and use it to study three particular aspects of the algorithmic information contained in a quantum state: a comparison of the information in a quantum state with that of its classical representation as an array of real numbers, an exploration of the limits of quantum state copying in the context of algorithmic complexity, and study of the complexity of correlations in quantum systems, resulting in a correlation-aware definition for algorithmic mutual information that satisfies symmetry of information property.


Introduction
Kolmogorov complexity is a mathematical formulation to capture the intuitive idea of the amount of information an individual object (usually a string) has.This notion was independently proposed by Kolmogorov in 1965 [12], Solomonoff in 1964 [30] and Chaitin in 1966 [7].It defines the amount of information of an object as the number of minimal instructions to be given to a machine to reproduce that object.If the object is a string x, and the machine is a Universal Turing machine U, the Kolmogorov complexity of x is the length of the shortest program that running in U as input, outputs x.We refer to the book by Li and Vitányi [14] for a comprehensive reading of this theme.
Several aspects must be considered to extend the notion of complexity to the quantum realm, as, in this context, the objects are quantum states, and the set of potential operations is not discrete.In [35], Vitányi identifies three approaches for the quantitative definition of information in a quantum state.The first one is the description (using classical bits) of the physical apparatus that outputs the given state.In this context, the continuous set of quantum states can be approximated by Cauchy sequences of states that can be directly outputted by the machine.The second approach consist on the qubit description of the quantum machine outputting the state, which upper bounds the information in a given quantum state by the logarithm of the dimension of the associated Hilbert space.The third approach considers the information content in a quantum state to be the classical information content of the list of real numbers involved in a (fixed) mathematical expression for the state.Furthermore, there are additional aspects to consider, including how to handle the distinction between a machine outputting a state or a high fidelity approximation of it; and the issue of directly addressing mixed states, and therefore define the machine through density operators instead of pure states.
In the last few decades, several definitions and approaches have been proposed in the literature that explore all the aforementioned possibilities.Svozil [32], in his pioneer work, defined the quantum Kolmogorov complexity of a state as the length of the minimum classical description in a quantum Turing machine (in the machine model defined in [8]) of that state.In [34], Vitányi proposed the definition of the (quantum) Kolmogorov complexity of a pure quantum state |φ⟩ as the minimum value of the sum of two parts: (i) the length of a classical program computing |ψ⟩, an approximation of |φ⟩, and (ii) the negative log-fidelity of the approximation of |ψ⟩ to |φ⟩.
These two first approaches considered classical descriptions for quantum states.In [6], the authors considered the possibility of using a quantum program (encoded in qubits instead of bits) to define the complexity similarly to Vitányi's.In their work, Berthiaume, van Dam, and Laplante defined the Kolmogorov complexity of a qubit string as the length of the shortest quantum bit string that, given to a quantum universal Turing machine, produces the qubit string with high fidelity.Its properties were further studied in [23,24].
Based on a generalization of the notion of universal semi-measure, Gács [9] proposed to define Kolmogorov complexity based on density matrices.Later, in [21], the Kolmogorov complexity of a pure quantum state |φ⟩ was defined as the length of the shortest description of a quantum circuit capable of producing such state (or an approximation of it).More recently, a new approach to define Kolmogorov complexity based on a particular type of quantum Turing machines, called deterministic controlled Turing machines was proposed [16].In this approach, a description of a quantum state |φ⟩ is given by a sequence of quantum gates, which transforms an initial reference state of the quantum tape into the state |φ⟩.
Although (classical) Kolmogorov complexity has been successfully applied to several fields ranging from security, computational complexity, bio-medicine, etc [1,2,31], corresponding applications of its quantum versions are yet just a few.For example, in [21] the authors establish the ground to characterize quantum entanglement via Kolmogorov complexity.In [22] Mora and Briegel and Kraus studied the application of quantum Kolmogorov complexity to thermodynamics and complexity theory.In [3] and [17] the authors explore the connection between (quantum) Kolmogorov complexity and entropy applied to Brudno's theorem and information-disturbance theorem, respectively.Another example of application is in cryptography, in [18], the authors use (classical) Kolmogorov complexity to derive the security of BB84 quantum key distribution [4].Recently, in [28], algorithmic information theory has been used in genomics applications.
The interconnection between Kolmogorov Complexity Theory and Information Theory is well-known and extensively studied in the literature [10,33].Concepts in one theory can find analogous versions in the other.One of the most important concepts in Information Theory is the notion of mutual information, which captures the inherent dependency of how much information is needed to explain one object having another object as a starting point.One of the most significant characteristics of (classical) mutual information is that it is symmetric, that is, I(X, Y ) = I(Y, X).On the other hand, for algorithmic mutual information such equality holds up to a logarithmic term of the size of the objects [13,33,36].The concept is briefly mentioned in the quantum Kolmogorov case in [34].In the context of quantum Kolmogorov complexity theory, the study of quantum algorithmic mutual information can help understand and quantify the complexity of the correlations between parts of multipartite quantum systems, since these systems can be inherently correlated.It is well-known that the correlations in quantum systems can be stronger than those present in classical systems due to the presence of entanglement [11] or the more general quantum discord [20].Understanding quantum correlations and their relation to algorithmic mutual information measured in terms of a quantum version of Kolmogorov complexity is important, as it opens the possibility of quantifying the amount of manipulation required to create such correlations between two systems.Consequently, this connection can be useful in analyzing complexity in quantum computing, leading to more efficient algorithms, or in relating security and complexity in quantum cryptography protocols, for example.

Overview of results
The main results of this work can be summarized as follows: • We present a natural generalization of the deterministic-control quantum Turing machine (dcq-TM) model, originally introduced in [16], to allow for mixed state inputs and outputs.
• We define the set of dcq-computable states as the set of states which can be approximated with arbitrary precision using a dcq-TM.
• We define the (conditional) Kolmogorov complexity K of quantum states in the dcq-TM model and show that it is machine independent up to a constant.
• Using the concept of classical representation of a quantum state to refer the array of real numbers describing its density matrix in the computational basis, we show that the defined set of dcq-computable states coincides with the set of states with computable classical representations.Moreover, we note that the algorithmic complexity of a quantum state and that of its classical representation are equal up to a constant.
• To contrast with the above result, we compare the properties of quantum states and their classical representations when used as a resource.In this context, we show that the representation contains more descriptive information when used as a resource for computation.We then further explore this difference by reducing the problem of computing an n-qubit state ρ to the problem of computing a duplicate of ρ given access to one copy of it, resulting in a relation between the information in a single copy of a quantum state versus the information in two copies of itself.We conclude that for the majority of quantum states, cloning them is essentially as hard as to create them.The result can be interpreted as an algorithmic information version of the no-cloning theorem.
• Finally, we explore the concept of algorithmic mutual information for dcq-computable states.We show that the analogous version of the classical chain rule is not satisfied for general bipartite states and interpret this discrepancy to be caused by the presence of correlations among the two subsystems.We propose an alternative generalization of the chain rule for quantum systems and show that it is indeed satisfied under our definition of K. Using this result, we present a correlationaccounting definition for algorithmic mutual information and show that it satisfies the symmetry of information property.
This paper is organized as follows: In Section 2, we briefly go through some important definitions on classical Kolmogorov complexity and computability of real numbers.In Section 3, we describe the dcq-TM machine model and present definitions for classical representations of quantum states, as well as classical simulators for quantum machines.In Section 4, we define the concept of computable quantum states and compare it to the set of states with computable classical representations.In Section 5, we define the concept of Kolmogorov complexity in the dcq-TM model and study some comparisons with the complexity of the associated classical representations, culminating in a dcq-TM version of nocloning theorem.Later, in Section 6 we study potential definitions of algorithmic mutual information with the intent of quantifying quantum correlations, resulting in a generalization of the chain rule and an alternative definition for mutual information.Finally, in Section 7, we summarize and discuss the results, as well as point to further research directions on the topic.

Kolmogorov complexity
In this subsection we briefly review some basic properties of the standard classical algorithmic complexity K in order to better motivate the definitions in the following sections.Classically, the Kolmogorov complexity of a string x is defined as the length of the shortest program that produces x when given to a classical universal Turing machine. 1 We refer the reader to the book of Li and Vitányi [14] for a complete study on this topic.

Definition 2.1. (Kolmogorov complexity)
Let x, y ∈ {0, 1} * be two strings and U a classical universal Turing machine.The Kolmogorov complexity of x given y is defined as: The default value for y, the auxiliary input for the program p, is the empty string.In order to avoid overloaded notation, in those cases we typically drop this argument in the notation.Notice that Kolmogorov complexity is machine independent in the sense that we can fix a universal Turing machine U whose program size is at most a constant additive term worst than any other machine, and the running time is, at most, a logarithmic multiplicative factor slower than in any other machine (see Theorem 7.1.1from [14]).
In information theory, one of the fundamental quantities is mutual information.There is an analogous version for Kolmogorov complexity that we will call algorithmic mutual information, and is given by ( In contrast with standard (Shannon) mutual information, this quantity is independent of any probability distribution and is concerned only with how much of the information in the string y can be used to describe x.In information theory, one useful result is the chain rule, which allows us to express the entropy of a joint distribution in terms of its conditional and marginal distributions.For Kolmogorov complexity we have,

Property 2.1. (Chain rule 1)
For all strings x and y in {0, 1} * , Using Equation (3) in combination with Equation ( 2) leads to a result called symmetry of information, which states that I K (x, y) = I The chain rule also allows us to relate I (1) K with another quantity, which can also be understood as a measure of mutual descriptive information Analogous expressions for I K and I K exist in classical information theory for random variables X, Y by replacing the Kolmogorov complexity K by the Shannon entropy function H.In classical information theory those quantities are proven to be equivalent [29].In the case of algorithmic information theory, they are related by Let n = |x| + |y|, by noting that K(x, y) ≤ K(xy) + O(log(n)) we can slightly modify the chain rule to a form that will be later more suitable for generalizing to the quantum case [14]:

(Chain rule 2)
For all strings x and y in {0, 1} * with n = |x| + |y|, Even though Eq. (8) is the simplest form of the classical chain rule, we want to highlight Eq. (7) because it will allow us to better compare it with its quantum counterpart later on.

Computability of real numbers
In this section, we briefly review the notions associated with the computability and algorithmic complexity of real numbers.Throughout the paper, we shall need to encode tuples of strings into a single string.Therefore, we denote by [x 1 , . . ., x m ] the encoding of the m-tuple (x 1 , . . ., x m ) of binary strings into a single binary string.Fix a one-to-one encoding of natural numbers in strings and encoding of rational numbers by assigning the information of sign, numerator, and denominator to the different components of a tuple.Definition 2.2.A real number r is said to be computable if there exists a (classical) Turing machine T which on any input k ∈ N outputs q k ∈ Q, such that In this case, we say that T computes r.
Computable real numbers can be encoded effectively in natural numbers.Given an enumeration of the set of Turing machines, we will consider that a computable real number is encoded by any index that represents a Turing machine that will output the approximation of it according to Def. 2.2.A tuple of real numbers (r 1 , . . ., r n ) ∈ R n is computable if all its components r i are computable.This encompasses complex numbers (ordered pairs of real numbers) and, notably, density matrices (arrays of complex numbers).We can proceed now to define the Kolmogorov complexity of a real number by identifying it with the length of a program that produces a sequence that converges to it according to Equation (9): Definition 2.3.Let r be a real number and U a universal classical Turing machine.The Kolmogorov complexity of r is given by where U p (x) = U(p, x).
The notion Kolmogorov complexity generalizes straightforwardly to arrays of real numbers and matrices as expected.
Remark.Since the set of computable numbers contains N, some ambiguity may arise when talking about the complexity of a natural number, as both Def.2.1 and Def.2.3 may apply (depending on the chosen encoding), but they in general do not coincide.In this document, unless stated otherwise, whenever a number x is understood to take values only in N (index in an enumeration, counter in a for loop, etc.) we assume that K(x) is given by Def.2.1.Otherwise, we assume its complexity is given by Def.2.3.
3 Definition of the machine

Deterministic control quantum Turing machine (dcq-TM)
A dcq-TM is a completely deterministic machine in the sense that the flow of computation is entirely classically controlled, but it is also capable of having quantum states as inputs and outputs.The following description of a dcq-TM is based on the one defined in [16] with the added feature that the machine is also able to handle general mixed states, and not just pure states.The machine is understood as having at least two infinite tapes, one classical and one quantum, with their respective classical and a quantum heads 2 .The distinctive feature of the machine is that it has a deterministic control over the computation happening on the quantum tape -this control is only dependent on the set of internal states (Q) of the dcq-TM, which are classical, and the contents of the classical tape.Thus, the set of internal states and the classical input specify the dcq-TM's computational dynamics entirely, and the quantum tape is a "work only" tape whose contents do not influence the computation.The quantum tape is effectively an infinite quantum memory, composed by quantum cells, each associated with a two dimensional (qubit) Hilbert space C 2 .The classical control of the dcq-TM commands the quantum head in a deterministic way.It chooses where the quantum head moves to and picks, from a pre-chosen universal set U (which without loss of generality is assumed to be finite), which unitary gates to apply and to which cells of the quantum tape to apply them to.It is important to stress that the unitary transformations in U must be described only with computable complex numbers, otherwise the machine would compute super-Turing distribution/functions.The machine is rigorously defined as follows, Definition 3.1.A deterministic-control Quantum Turing machine or dcq-TM is defined by the pair, (Q, δ), where Q and δ are, respectively, the finite set of control states containing at least the two distinct states q s (starting state) and q h (halting state) and the transition function of the computation.The transition function is, where A = {0, 1, 2} is the alphabet of the classical tape, U is a universal set of unitary operators that can be applied to the quantum tape, and D = {L, N, R} is set of possible head displacements (left, none, right).

Anchor cell and input/output schemes
In order to have the quantum and classical inputs/outputs properly defined in the dcq-TM we introduce the concept of an anchor cell.The anchor cell serves the purpose of specifying a global reference point for each tape, in order to identify unambiguously the inputs and outputs of the machine.For a given tape, we specify the anchor cell (on that tape) to be the first cell before the input starts i.e if we index the input cells with positive numbers i > 0, the anchor cell will always be the cell with index i = 0.
The input and the output schemes of the dcq-TM presented here are slightly different from the ones in the definition of [16], where there is no anchor cell defined, and the machine is not aware of the size of its quantum input/output.In the spirit of generalizing the model for general mixed states and more naturally defining inputs and outputs that may start or end with |0⟩ states.We introduce this alternative definition from which it is straightforward to recover all the results already established regarding the dcq-TM.
Inputs -We say the machine received as input the pair (x; ρ ⟨1,n⟩ ) if its internal state is q s , its classical and quantum heads are parked in their respective anchor cells, and the tapes' contents are as shown in Figure 1.The classical input x is the string written between the anchor and the first blank after the anchor.At the end of the classical input, we insert a blank cell to distinguish strings x and n, where the latter specifies the quantum input in the quantum tape.The quantum input ρ ⟨1,n⟩ is the physical quantum state present in the set of cells between the anchor and the cell specified by string n.Outputs -We say the machine produced as output, (y; σ ⟨1,s⟩ ), if the machine is in the halting state q h and the classical and quantum tapes are in the configuration shown in Figure 2. The classical output y is defined as the string written in the set of cells that are between the anchor and first blank to the right of the anchor.The quantum output specification m is defined as the string between the first and the second blanks appearing after the anchor.Finally, the quantum output is defined as the physical quantum state present in the set of cells between the anchor and the cell specified by string m.
Although there are many ways to evaluate functions that have multiple classical inputs/outputs using the above configuration, for the purposes of the examples of this paper it is convenient to have a unified encoding to use whenever we refer to algorithms that use a single string x to encode a tuple (x 1 , . . ., x k ) of strings.We use the following encoding where ℓ(x i ) = 1 |xi| is a string of 1s of length |x i |.Using this encoding, each input x i adds 2|x i | + 1 bits to the input string, except the last one, which only adds |x i |; that is Multiple quantum inputs/outputs can be defined by encoding the tuple of sizes (number of qubits) of the different systems in the same way described above.

Symbolic notation for dcq-TM computations
Thus, an input on the dcq-TM of the form (x; ρ ⟨1,n⟩ ), specifies the following representation of the tapes, where If a specific dcq-TM machine, T, on input (x; ρ in ) produces output (y; ρ out ) we represent the computation symbolically as, for the overall output, and for the classical and quantum outputs.To represent empty inputs/outputs we use the symbols 2 for the classical tape, and ϵ for the quantum one.Note that ϵ is used to denote quantum input/outputs of size zero.We call the reader's attention to the fact that ϵ is not a density operator acting on a Hilbert space, since a zero size input/output does not refer to any system in the quantum tape; we use it to refer to the cases where there may not be a quantum input/output.The computability properties of dcq-TM may be dependent on the chosen set U of basic quantum operations, namely the states that can be prepared exactly by the machine.On this work, we will focus on dcq-TM based on the universal set U = {1, H, S, π 8 , Sw, c-Not} commonly used in the circuit model for quantum computation.This set is important because it is associated with the capabilities of practical quantum computers.It is also important to remark that the transition function of a dcq-TM depends only on the contents of the classical tape, this is the reason the model is denoted as deterministic control.In [16], the universality of this model was proven and, moreover, it was also shown that the dcq-TM model could simulate a special type of quantum circuit called a seesaw circuit.A polynomial translatability theorem was proven which states that any general quantum circuit can be simulated by one such seesaw circuit with a polynomially bounded overhead on the number of gates, showing that the dcq-TM can solve in a bounded polynomial-time the same problems that the regular quantum circuit model can, therefore, the BQP complexity class coincides with the analogous dcBQP class defined for the dcq-TM model.We also know that there is a universal dcq-TM, T U , that can simulate every other dcq-TM on any arbitrary input.As such, without loss of generality, The previous expression represents symbolically the equivalence between the computation taken on a specific input in the dcq-TM model, and it is implementation of the seesaw circuit C * x that gives the same output.From now on, whenever we refer to a universal dcq-TM, we mean a universal dcq-TM machine fulfilling the s-m-n property.
Sometimes, we may want to refer to an instance of a universal dcq-TM U, simulating some other dcq-TM T. From the s-m-n property, we know that there is a string t ∈ {0, 1} * such that, for any input (x; ρ in ) we have that U (t, x); ρ in = T(x; ρ in ).In these cases we say that the machine U runs the program t on input (x; ρ in ), denoted symbolically by:

Classical quantum state encoding and simulators
In this work we are interested in comparing the complexity aspects of two related, but fundamentally different types of objects.The first are the quantum states themselves, understood as density operators acting on a given Hilbert space, encoded in the physical states of the cells of the quantum tape, and are denoted by standard Greek letters ρ, σ, etc.The second are the classical representations of the quantum states, which are understood as arrays of complex numbers describing the respective density matrices in the computational basis, encoded by strings of symbols in the classical alphabet A according to an appropriate rule (as described in Section 2.2), and denoted by bolded Greek letters ρ, σ, etc.In the context of inputs and outputs of dcq-TMs, a statement of the form is interpreted as follows: "Upon classical input of any string encoding the computational-basis matrix associated to the state ρ in and no quantum input, the dcq-TM T outputs a string encoding the respective matrix for the state ρ out without a quantum output".Finally, for simplicity, following the relation between the states and their matrix representations, for every function f of quantum states ρ, σ, . . ., we define f (ρ, σ, . . . ) ≡ f (ρ, σ, . . .).Before moving on to discuss directly dcq-computable and (plain) dcq-computable quantum states, we establish a notation for the classical simulators of these machines.For any dcq-TM T, consider a "classical" machine T (a dcq-TM that does not interact with the quantum tape and whose quantum output is ϵ for any input), defined constructively from T, which appropriately approximates the matrix operations associated with the logic gates applied during the execution of T such that whenever the respective string encodings ρ in and ρ out exist (that is, whenever the matrices ρ in and ρ out are computable).
The set of directly dcq-computable states is denoted by DCOMP q .
Denote by T(x; σ)↓ t a particular (defined constructively from T and t) dcq-TM that simulates T(x; σ), except that if at the step t it has not halted, if forces it to halt, then outputs the output of the simulated machine (according to the rules specified in Section 3).T (C) (x; σ)↓ t and T (Q) (x; σ)↓ t are defined analogously.Consider now Algorithm 1 which, given a universal dcq-TM U, uses Cantor's zig-zag method to assign to each non-negative integer s a different directly dcq-computable state associated with running U for some combination of input and number of steps, which is different for every value of s.Because the output of a dcq-TM is well defined for any state of its tapes, each value of s is uniquely associated with a directly dcq-computable state through Algorithm 1.Additionally, because every directly dcq-computable state ρ is associated with U running some program for some number of steps, we know that there exists a value of s for which Algorithm 1 outputs ρ.This means that the set of states that can be returned by Algorithm 1 coincides set of directly dcq-computable states.For a fixed reference universal dcq-TM, the quantum output of Algorithm 1 defines a surjective function Π 1 (s) from the set of non-negative integers to DCOMP q , that is, an enumeration of it.We denote the set of all dcq-computable quantum states by COMP q .
Consider the set COMP c of quantum states for which their density matrix representation, when written in the computational basis, has computable complex numbers as components.This set is relevant because it represents the set of quantum states that can be written in a classical computer.Let us state a pair of algorithms that will be useful in finding relationships between quantum states and their representation in the context of the dcq-TM model.Since our machine model is controlled by classical programs, we would expect that COMP q , the set of computable states as defined by Def.4.2 and the set COMP c coincide.This is indeed the case as shown below.(COMP q ⊆ COMP c ): Let ρ ∈ COMP q , and {σ i } i a sequence which satisfies Def.4.2.From the definition of COMP c , to show that ρ ∈ COMP c we must show that ρ is computable.Note that the set U consists on matrices with computable components.It follows that the associated sequence of matrices {σ i } i is computable since, for any dcq-TM T such that T(k; ϵ) = (2; σ k ), the classical machine T simulates the evolution of the initial state though the quantum circuit specified by T and computes the components σ n .By recalling that the limit of any classically computable sequence is computable, it follows that lim n→∞ σ n = ρ is computable and thus, ρ ∈ COMP c .
(COMP c ⊆ COMP q ): Let ρ be a density matrix with computable components.From the definition of computability of real numbers, this means that there exists a set f k rs r,s,k , of computable functions over N such that the sequence of matrices σ k = (g rs (k)), where Parameters: Universal dcq-TM U ; Algorithm 2: Given a density matrix σ and integer k, finds a directly dcq-computable state that is closer to σ than 1/(2k).
We want to use {σ k } to construct a (computable) sequence {σ ′ k } of states associated with directly dcq-computable states that satisfy Def.4.2.Consider the following construction for σ ′ k : Fix a universal dcq-TM U and run Algorithm 2 with input ((k, σ 2k ); ϵ) and define σ ′ k as its quantum output.We know that Algorithm 2 will always find such state because the set of gates that a dcq-TM has access is universal, and hence the set of directly dcq-computable states is dense in the set of quantum states.To prove that ρ ∈ COMP q it only remains to show that the sequence {σ i } satisfies Def.4.2 (2).Indeed, we have that 5 Algorithmic complexity in the dcq-TM model Having defined the features of the dcq-TM, we proceed to introduce two (non-equivalent) notions of the concept of Kolmogorov complexity.The first one is a generalization of the one proposed in [16] for general directly dcq-computable states: Definition 5.1.Let ρ be a directly dcq-computable quantum state and T be a dcq-TM.The basic algorithmic complexity of ρ is This definition is limited in that it is only applicable to directly dcq-computable states (denoted by the superscript d), which are dependent on the specific chosen universal set of gates U in Def.3.1.We are interested in extending the concept of algorithmic complexity for dcq-computable states.

Definition 5.2. Let ρ be a quantum state and T be a dcq-TM. The algorithmic complexity of ρ is given by
Definition 5.3.Let x be a binary string, ρ, σ be two quantum states, and T be a dcq-TM.The conditional algorithmic complexity of ρ given the pair (x; σ) is In other words, we define the complexity of a quantum state as the infimum length of the classical description of the sequence that converges to such a state.Note that, because Equation (25) considers the infimum of the set, states that are not dcq-computable are assigned infinite complexity.This definition is analogous to the standard classical complexity for real numbers (see Def. 2.3) and it is machine independent in the following sense: Property 5.1.Let T and T ′ be universal dcq-TM, then for any string x and quantum states ρ, σ it holds that Proof.Let s be a map that translates T ′ -programs to T-programs and c ∈ N be such that |s(p)| ≤ |p| + c for every p ∈ {0, 1} * .Then, By a symmetric argument, since T ′ is also assumed to enjoy the s-m-n property, there is c ′ ∈ N such that: Remark.From Property 5.1 we can talk about the machine independent algorithmic complexity K (without subscript) and consider complexities that are equal up to an additive constant to be equivalent.
We can turn our attention now into exploring the relationship between the complexity of a quantum state and its respective classical representation.As the following theorem states, they turn out to be same.

Theorem 5.2. For every dcq-TM T and quantum state ρ it holds that
Proof.The result follows directly from the algorithms in the proof of Theorem 4.1, with the constant term being the length of each algorithm's specification.
An immediate implication of Theorem 5.2 is that, since the components of a density matrix can have arbitrarily high complexity even for single qubit quantum systems, there is no upper bound for the complexity of an n-qubit quantum state.This is in contrast to the complexity of n-bit strings, which is upper bounded by n. 3Does Theorem 5.2 mean that the information value of the state of a quantum system exactly coincides with that of the numbers in its density matrix?The reason the two quantities in Equation ( 30) coincide is because we are quantifying the complexity of a quantum system using a classical string (the description of the program).Note that having access to the description of a program that computes a given quantum state is not the same as having a copy of the quantum state itself.To get a little better insight about how these two types of objects differ we need to consider their use in the role of a resource.

Conditional complexity and state cloning
Let us continue by evidencing a consequence of the no-cloning theorem.Since the machine receives a specification of the size of its quantum input, we know that for any state ρ it holds that K(ρ|2; ρ) = 0, as the program that outputs the quantum input has constant length.On the other hand K(ρ ⊗ ρ | 2; ρ) ̸ = 0, as there is not a single machine that can copy arbitrary quantum states.In the worst case scenario, such machine would construct the second copy of ρ from scratch, which means that the complexity of duplicating a physical state is upper bounded by the complexity of the state itself: This is in contrast to the case in which one would want to copy a classical input, in which case it is always possible to output twice the input.If one had a priori access to the classical description of the state, it is possible to run Algorithm 2 repeatedly to compute several copies of ρ.Therefore, copying a quantum state given its associated density matrix ρ has constant complexity: This exercise suggests that the classical description of a quantum state contains "more" descriptive information that the physical state itself, and thus we can conclude that Property 5.3.For any dcq-computable quantum states ρ, σ it holds that We now turn our attention to answering if, for arbitrary quantum states, the complexity of copying the state is the same as computing it.In other words, we want to know if the converse of Equation (31) holds.Intuitively, this would mean that any machine that computes the duplicate of a state ρ would necessarily have the descriptive information of that state somehow encoded within it.In order to tackle this question, let us first state a couple of lemmas, the proofs of which can be found in the Appendix.Recall that the fidelity between two quantum states ρ and σ is defined as Lemma 5.4.Let T : D(H) → D(H ⊗2 ) be a CPTP map, i.e., a completely positive and trace-preserving map.Define the copying error CE T of the transformation T on the state ρ ∈ D(H) as Lemma 5.5.Let H be an N -dimensional Hilbert space and A = {ρ i ∈ D(H)} be a set of density operators such that for i ̸ = j: Then, A cannot have more than N elements.

Lemma 5.6. For any CPTP map T : D(H) → D H
Theorem 5.7.For any n-qubit quantum state ρ it holds that Proof.To prove the result, we construct a family of algorithms (See Algorithm.3) with three parameters: a program index t, a qubit number n, and a list index m.Then show that, given an n-qubit state ρ, there exist t, m ∈ N satisfying: where c is a constant independent of n, such that the program specified by Algorithm 3 with the parameters (t, n, m) computes ρ.We can see Algorithm 3 as a program that computes ρ from ϵ using a program that computes ρ ⊗ ρ from ρ as a subroutine.
Parameters: Universal dcq-TM U. Integers t, n, m; Input: Integer k; (List preparation phase) while The size of the list k0 then ρ out ← σ; else s ← s + 1; end end return (2; ρ out = Π 1 (s)); Algorithm 3: Approximation of an n-qubit state given a subroutine that is known to be able to duplicate it and a specification index m ≤ log(n).
Let U be a reference universal dcq-TM.For any t, k ∈ N define the family of CPTP maps T t,k : C 2 n → C 2 2n as: That is, T t,k represents the transformation (understood as going from the quantum input space to the quantum output space) applied by the machine U running the program t on classical input k.
Let us now gain a little intuition on the two phases of Algorithm 3. The list preparation phase goes through the set of directly dcq-computable states looking for states that are "close" to being copied by T t,k0 .Whenever it finds one such state, it adds it to the list L if it is "far" from all the other states already in the list.The phase ends when the m-th element is added to the list this way and assigns ρ 0 to be equal to the last state added.On the other hand, the output preparation phase goes again through the set of directly dcq-computable states, now looking for a state that is both close to the state ρ 0 obtained from the first phase and "close enough" to being copied by T t,kout .To show that the proposed algorithm satisfies the desired properties, we break down the proof into two parts.We want to show that: i) If U t computes ρ ⊗ ρ from ρ and for large enough m, the list preparation phase will always add a matrix ρ 0 for which and such matrix will be found before the list exceeds 2 n elements ii) On input k, if ρ 0 satisfies Equation (42) then the output state ρ out (k) will satisfy Once these properties are proven, the bound in Equation (39) follows by noting that the minimal size program t ′ that computes ρ ⊗ ρ from ρ can be specified by using bits, and the values of m ≤ 2 n and n can be specified with n and log(n) bits, respectively.
• Proof of statement i) Note that whenever a matrix σ gets added to L it satisfies by Lemma 5.6(1) and the definition of dcq-computability invoking Lemma 5.4 we get that and substituting k 0 in terms of δ 0 (2 n ) Depending on the transformation T t,k0 , the loop inside the while statement of the list preparation phase will add some amount of elements to the list before there are no more states that satisfy the stated conditions.Let l max be the maximum amount of elements that can be added to L in this way.From Lemma 5.5 we know that the l max ≤ 2 n because the largest size of a set {σ i } that satisfies . Recall now that the set of n-qubit directly dcq-computable states is dense in the set of n-qubit quantum states and the fact that the function Π1 (s) will eventually output every directly dcq-computable state.Let s ′ be the smallest integer such that using Lemma 5.6(2) and the fact that and from Lemma 5.6(1) we get Suppose the loop reaches s ′ without finding σ satisfying Equation (42).Then, as shown in Equation (50), at s = s ′ the matrix ρ ′ = Π1 (s ′ ) will satisfy the first condition in the check to be added to L. Additionally, for every σ already in L at that point, it will hold that (see Lemma 1 from [27]) and hence which satisfies the second condition to be added to L. Therefore, for large enough m, the list L will always have an element that satisfies Equation (42).Particularly, there is a value of m ≤ l max ≤ 2 n for which the cycle ends when such element is added and sets it to be ρ 0 .
• Proof of statement ii) Suppose ρ 0 satisfies Equation (42).We proceed to show that any density matrix σ that holds both of the conditions in the if statement of the output preparation phase must also satisfy Analogously to Equations ( 44) and ( 45), whenever a matrix σ is found that satisfies and In other words, such σ is either "very close" to ρ or "very far" from it.Consider the case where left part of Eq (55) is true, we have that (noting that and therefore which means that such σ cannot satisfy the second condition of the if statement.We conclude that for any σ that satisfies both conditions (and hence also for ρ out ), it holds that Finally, translating into trace distance we get One way to interpret Theorem 5.7 along with Equation (32) is that, for the task of describing ρ ⊗ ρ, the advantage of having prior access to a single copy of ρ as compared to not having any prior resource state is at most 2n + 2 log(n) bits (up to an additive constant).This means that for complex quantum states, for which K(ρ) ≫ n, having access to a copy of ρ gives effectively no advantage for describing ρ ⊗ ρ.This is in contrast with classical strings, where having a copy of the string gives all the information needed to compute its duplicate, and can be understood as an algorithmic information version of the no-cloning theorem.

On the chain rule and complexity of quantum correlations
One feature of quantum multipartite states is that, in general, they contain correlations between their parts.One way to quantify correlations is through the notion of mutual information.In this section we use the dcq-TM model to generalize the chain rule and extend the concept of algorithmic mutual information to quantum states.Let us first define the concept of prefix for quantum states.

Definition 6.1. (Prefix of a quantum state)
We can make use of quantum prefixes to study the behaviour of K when considering systems split into two (or more) parts.Note that an n-qubit state has n possible prefixes, which are manifestly defined by the layout of the cells in the quantum tape.When we want to stress the number m of qubits of a prefix we will refer to it as the "m-prefix".To make the separation more explicit in some of the following definitions we will denote the larger n-qubit space as H AB and the m-qubit prefix space as H A so we can write a quantum state and its prefix as ρ AB and ρ A , respectively.
By analogy with the classical algorithmic information theory, it seems natural to begin our exploration of mutual information by considering the straightforward generalization of two (classically) related quantities:

Definition 6.2. (Algorithmic mutual information 1)
Let ρ A and ρ B be two quantum states.Define the mutual information of ρ A respect to ρ B by: (61) Definition 6.

(Algorithmic mutual information 2)
Let ρ AB be a bipartite quantum state.Define the mutual information between the partial states ρ A and ρ B by: Definition 6.2 compares the algorithmic complexity of the state ρ A assuming the machine starts with the all zero state in its classical and quantum tapes, versus its complexity assuming the machine has the description of the state ρ B given as a classical input.The choice of giving the classical description instead the state itself will become clearer as we study its potential in the context of correlations.Evidently K(ρ A |ρ B ) is upper bounded by K(ρ A ), and hence I (1) is non-negative.On the other hand, Def.6.3 considers the difference between computing the states ρ A and ρ B separately as opposed to computing the (potentially correlated) single state ρ AB .The main conceptual difference between I (1) and I (2) is whether to consider the states ρ A and ρ B to exist independently or as a part of a greater joint state.Under the classical definition of Kolmogorov complexity, the analogous expressions to (61) and (62) for mutual information turn out to be connected through the chain rule as shown by Equation (7).To explore what is the connection between these two quantities, we may ask ourselves how would a quantum version of the chain rule look like?A straightforward generalization of Equation ( 7) would be to replace the string xy with a bipartite state ρ AB leading to an expression of the form: but as Theorem 6.1 states, the above equality does not hold for arbitrary joint states.
Theorem 6.1.There exist no constant g such that for every natural number n and n-qubit quantum bipartite state ρ AB . Proof.
j=1 β i |j⟩⟨j| be the spectral decomposition of the reduced systems ρ A and ρ B .Assume that the Inequality (64) holds for some ρ AB for which ρ A and ρ B are proper mixed states and some constant g.We show that there exists then a ρAB for which the inequality does not hold.Hence, there is no g that satisfies Equation ( 64) for all bipartite mixed states.
Note that since ρ A and ρ B are proper mixed states, there exist r, r ′ and s, s ′ such that r ̸ = r ′ , s ̸ = s ′ , and α r , α r ′ , βs, βs ′ are all non-zero.Define the set of states where α i β j |i, j⟩⟨i, j|, and where γ = √ α r α r ′ β s β s ′ .Note that σ AB and ρ A ⊗ ρ B are strictly different density operators and, since the partial traces on the second term of σ AB both vanish, we have that for any 0 and similarly ρλ B = ρ B .Notice also that, since ρ A and ρ B are assumed to be dcq-computable, it follows from Theorem 4.1 all of the ρλ AB are dcq-computable quantum states.Let us denote the value g 0 = K(ρ A ) + K(ρ B | ρ A ).We can write the inequality (64) as: Define now the set Note that for all m, the set C m is finite (of size at most 2 m ), whereas the set C is infinite (its size is equal to the set of computable real numbers between 0 an 1), this means that for any m, there exists In other words, given a bipartite state ρ AB with mixed partial traces, there are an infinite number of states ρ ′ AB that share its partial traces and have larger quantum Kolmogorov complexity under the dcq-TM model.Additionally, for any n, g, g 0 we have that Therefore, there is an m 0 such that m ′ − glog(nm ′ ) − g 0 > 0 for any m ′ ≥ m 0 .The result follows by noting that, from the above argument, there exists λ such that K(ρ λ AB ) ≥ m 0 , and hence To understand better relation between Def. 6.2 and Def 6.3, we have to consider the role of correlations in the description of bipartite states.In the Shannon approach, the notion of information is based on the knowledge of system's state: the more we are uncertain of the state of the system, the more we increase our knowledge (i.e., information) upon learning that state.Thus, mutual information between two systems is manifestly linked to correlations between them.In the original Kolmogorov approach, the notion of information is based on our ability to compute a given string.Consequently, mutual information between two strings tells us how much knowing one helps in computing the other.When generalizing to the quantum domain, we see that part of this intuition holds for Def.6.2 as well.In other words, algorithmic mutual information is quantifying the similarity between the descriptions of two states, complexity wise, and says noting about the correlations in their joint state.Indeed, the quantities on the right hand side of Equation (61) do not depend on the joint state ρ AB at all.On the other hand, Def.6.3 effectively compares the complexity of computing a (generally) correlated state with its individual parts.One problem with Def.6.3 as a measure of complexity is that, following Theorem 6.1, the quantity is unbounded from below.
At this point we can ask ourselves: is there a version of the chain rule that holds for quantum states?Such expression would help us motivate an alternative definition for algorithmic mutual information that satisfies a form of symmetry, as well as give us insight into the complexity of correlations in quantum systems.Theorem 6.2 provides a relatively straightforward generalization of Equation ( 7) by introducing a direct dependence on the joint state, as well as requiring a classical description of the prefix (as opposed to a copy of the state).Theorem 6.2.Let n, m be integers such that 1 < m ≤ n, and ρ be an n-qubit quantum state.For any m-prefix σ of ρ it holds that Proof.Let U be a reference universal dcq-TM: (≤): We specify an algorithm to compute ρ given as input two parameters: the specifications t 1 , t 2 of two programs that compute σ and ρ|σ, respectively.The algorithm works as follows: on input k, simulates the action of Ũt1 (2k; ε) to obtain σ k , then simulate U t2 ((2k, σ k ); ε) to obtain ρ ′ k .Let ρ k = U t2 ((2k, σ); ε), using the triangle inequality and the contractive property of the trace distance we get that So the algorithm correctly computes ρ.Specifying t 1 , t 2 can be done using K(σ) + K(ρ|σ) bits.Since this is a two-input program, a specification of the length of one of the inputs must be added, which is of size at least min{log(K(σ)), log(K(ρ|σ))} ≤ log(K(ρ)) + log(m).We can conclude then that (≥): By reductio ad absurdum, assume that for every positive real number c there exist an integer n > 1, an n-qubit quantum state ρ, and a prefix σ of ρ such that Let (c, ρ, σ) be such that they satisfy Equation (75) with ρ, σ being n and m ≤ n qubit states, respectively.Furthermore, let t ρ be such that U tρ computes ρ and |t ρ | = K(ρ) + O(1).In the following treatment, it will be useful to have a shorthand notation for the prefixes of the quantum output of programs.Let η(t, x) denote the m-prefix of U Q t (x; ε).For any positive integer s consider now the following sets: halts with a quantum output of at least m qubits (76) Recall that a set A is computably enumerable if there exists a bijective function E A : {1, . . ., |A|} → A and a machine T A such that T A (i; ε) = (E A (i); ε) for every i = {1, . . ., |A|}.To see that the set P η s is computably enumerable given s, m, |t ρ |, and η, consider a machine that classically simulates instances of all programs up to length |t ρ | running with all inputs x ∈ {1, . . ., s} in parallel, keeping track of their simulated outputs as they halt, and outputting the i-th program found to satisfy the conditions in Equation (77).Denote the enumeration of P η s defined by this machine as E s,m,|tρ|,η .We want to use the set P σ s to find an upper bound for K(ρ|σ).Because we know that t ρ ∈ P σ s for any s, fix s = s 0 and let j be the index assigned to t ρ by E s0,m,|tρ|,σ .We can compute ρ|σ as follows: consider a machine that on input (k; σ) outputs the values of |t ρ |, m, and j, then finds the value of t ρ = E s0,m,|tρ|,σ (j) and outputs the simulated quantum output of U tρ (k).By recalling that |m| ≤ log(n) we get that Using Equation ( 75) we can obtain a bound for the size of which is independent of the value of s 0 .To arrive to a contradiction, we will proceed to show that the bound found in Equation ( 79) is "too big", in the sense that it allows for a very short description of σ.
To do this, we will use the fact that we can compute σ by simulating a program that computes ρ and then outputting only the first m qubits of its quantum output.In general, for input k, we do not really need to run a program that computes ρ, instead we can run any program that outputs a state "close enough" to the output of U tρ (ak) for some natural number a ≥ 2. We want to construct a small set of programs that are candidates to approximate σ in this way for a given k and then specify one of them by giving its index in an enumeration of that set.First, consider a slightly relaxed version of the P η s family of sets by noting that where we used the fact that the considered sets 2 P η(t,5k) 5k are disjoint.Equation (85) in turn gives us a bound for the complexity of σ We arrive to the contradiction by noting that the last expression on Equation (88) is negative for large enough c.
By applying Theorem 6.2 to a bipartite state ρ AB we get our new version of the chain rule where the second equality comes from the fact that the state ρ AB and the state obtained by swapping the order of the subsystems A and B are related by a log(n) overhead, which gets absorbed by the last term in Equation (72).Notably, Equation (89) recovers the form of the classical chain rule Equation (7) when the two subsystems are uncorrelated, that is Equipped by this result, we can define a correlation-accounting version of mutual information by quantifying by "how much" a state deviates from the classical chain rule, we call this quantity complexity of correlations: Definition 6.4.(Complexity of quantum correlations) Let ρ AB be a bipartite quantum state.Define the complexity of correlations in the subsystem A respect to B by: where Because ρ B has the information of the dimension of the space H B , it is straightforward to see that C(A : B) is non-negative (up to a constant).Note that the quantity I (Q) (A : B) should not be interpreted as an information measure because it can be negative.In fact, it is generically negative, reaching its maximum zero value for product states ρ A ⊗ρ B (we denote the quantity by I (Q) to highlight its analogous formal mathematical expression to I (1) ).From Equations (89) and (90) we know that C also satisfies symmetry of information: for an n-qubit state ρ AB it holds that (93)

Discussion
In this work, we have laid the foundations of a quantum algorithmic complexity theory based on the dcq-TM model.We started by expanding the definition of the machine to allow it to work with mixed states as inputs/outputs and defined the set of computable quantum states.The choice of our machine model is motivated by two of its main properties: a) the set of machines is naturally discrete and shown to be Turing-complete, and b) there is a single, well defined, halting state for every machine.We mention this properties in contrast to quantum-controlled type of machine models whose description may be parameterized by the set of quantum states associated to a given Hilbert space.If the set of machines is described by a continuous set of states, it can lead to super-Turing capabilities. 4This issue can be solved by allowing only some discrete subset of states (chosen adequately to output approximations of quantum states within a desired accuracy), as described in [6].Another, more difficult to solve issue, is that machines running quantum programs do not always have a single, well defined, halting state.Instead, due to the unitary evolution principle of quantum mechanics, they are generally in a superposition of halting and working states, which makes defining computability difficult.This issue has been openly discussed (see, for instance [5,15,19,25]).We make the observation that, in practical scenarios, for adequately modeling real-life quantum computers, we see ourselves as classical users interacting with the quantum machine, which is in line with the dcq-TM model.Another advantage of the dcq-TM model is that, by having explicitly separated classical and quantum tapes, it lends naturally to comparing two of the approaches mentioned in [35].That is, it lets us work with quantum states by inputting them as the physical state of the cells of the quantum tape, or alternatively, we can input their classical representation by encoding the corresponding density matrix as a string in the classical tape.We defined the algorithmic complexity of a state ρ as the size of the description of the shortest computable sequence of "outputtable" states that approximates ρ, and showed that it is machine independent.We also showed that any program that computes ρ can be transformed into one that computes ρ, and vice-versa; which means that the resulting complexities K(ρ) and K(ρ) are equivalent.Nevertheless, we found that the conditional complexities K(σ|ρ) and K(σ|ρ) are, in general, not the same.Instead, the classical representations contain more descriptive information than the physical system when used as a resource.This led us to study the behaviour of complexity for quantum state copying.By combining Equations (31) and (39) we can obtain the relation which can be seen as a statement of how much of an advantage having a copy of a state gives when computing two copies.For any qubit number n and value k of complexity, there is a finite number of quantum states for which K(ρ) ≤ k, and an infinite number of states for which K(ρ) > k.It follows that for any n ∈ N and integer function k(n) ∈ O(n), there is an infinite number of n-qubit states ρ for which K(ρ) ≫ k(n).Therefore, for almost all quantum states, having access to a copy of the state gives no significant advantage for computing its duplicate.Finally, we considered notions of quantum algorithmic mutual information, and found that two classically equivalent definitions are no longer equivalent for the quantum case.We noted that the property that connects these two quantities in the classical case, namely the chain rule, does not hold for general bipartite quantum states.We interpreted this discrepancy to be caused by the presence of quantum correlations.To compute a quantum multipartite state it is not enough to be able to compute each of its parts individually, but one must also describe the inherent correlations present in the joint state.Taking this into account, we developed a generalization of the chain rule for quantum states in the dcq-TM model.This new property let us to propose a candidate for a measure of the algorithmic complexity of correlations in quantum systems, which is symmetric up to a logarithmic term in the complexity of the joint state times the number of qubits.
Potential future work directions include the study of the relationship between quantum Kolmogorov complexity and Von Neumann entropy, one way to approach this is through generalization of Brudno's Theorem, which relates the complexity rate with the entropy rate for stationary, ergodic sources.Such analysis has already been done in [3] for Deutsch's machine model [8], which is quantum-controlled.Additionally, further properties of complexity of correlations can be explored and a potential theory of algorithmic complexity of multipartite correlations can be developed.and using the following identities/inequalities (derived from the contractive property of the Bures angle and the squaring property of fidelity) we can bound the right hand side of Equation (100) and write it in terms of fidelity: Substituting the inequalities (101) and (103) in the left and right hand sides of Equation (100), respectively, we get: where the last step holds because , then the solutions of the quadratic inequality in the interval [0, 1] satisfy 8.2 Proof of Lemma 5.5 Lemma 5.5 is a generalization of the basic property which states that for a finite dimensional Hilbert space H, any set {ρ i } of orthogonal states can have at most dim(H) elements.The lemma states that this property holds even if the states are not quite orthogonal, but instead have pair-wise fidelities upper bounded by δ 0 (H).To prove this result we will start by proving a restricted version of the main lemma, which is then used to prove the more general statement.First, we restrict the sets to consist only of pure states, then we build upon that version removing the requirement of the states to be pure.

Theorem 8.2. (Gram-Schmidt orthogonalization)
Let H be a Hilbert space and {|ψ i ⟩ ∈ H} k i=1 a normalized, linearly independent set.For i = 1, 2, . . ., k define and The set {|e i ⟩} k i=1 is an orthonormal set.The following properties refer directly to the sets defined in Theorem 8.2: Lemma 8.3.Let H be an N -dimensional Hilbert space, 0 ≤ δ ≤ 1, and {|ψ i ⟩ ∈ H} a normalized, linearly independent set such that for i ̸ = j |⟨ψ i |ψ j ⟩| 2 ≤ δ. (108) The non-normalized Gram-Schmidt vectors {|ẽ i ⟩} k i=1 satisfy for j < i where Proof.We proceed by induction over the index j.Note that for j = 1 and any i > 1 we have that Assume now that for some i and j < i − 1 it holds that for all 1 < i ′ ≤ i, 1 ≤ j ′ ≤ j and j ′ < i ′  (120) Then A cannot have more than N elements.
Proof.We intend to show that for δ pure 0 (N ) defined as in Equation (120), the set A must be linearly independent.Let A ′ = {|ϕ i ⟩} M i=1 ⊆ A be a maximal linearly independent subset of A and A ′′ = A ∖ A ′ .We proceed to prove that any other state belonging to the Hilbert space H ′ = Span(A) = Span(A ′ ) cannot satisfy Equation (119), and thus A ′′ must be the empty set.
Let {|e i ⟩} M i=1 be the set obtained from A ′ through the Gram-Schmidt process.Because the |e i ⟩ form an orthonormal basis for H ′ , it holds that for any | φ⟩ ∈ A ′′ ⊆ H ′ there exists k such that writing the trace distances in terms of inner products we obtain We can now use the inequalities (114) and (121) to get which we can solve for ⟨ φ|ϕ k ⟩ 2 as follows All that remains now is to show that the right side of Equation ( 125) is strictly greater than δ pure Proof.To prove the result we will proceed as follows: for each ρ i ∈ A we will define an associated pure state such that if A satisfies Equation (128) then the associated set I of pure states satisfies Equation (119), which in turn by lemma 8.5 implies that |I| = |A| ≤ N .Let M = |A|.Following the spectral decomposition theorem; for i = 1, . . ., M , let {|ψ k i ⟩} N k=1 be a set of orthogonal states and {λ k i } N k=1 a set of non-negative real numbers such that Furthermore, it is easy to check that for i, j = 1, . . ., M the following is an orthonormal set: We intend now to use the Uhlmann's theorem to find a bound for inner products ⟨ψ s j |ψ k i ⟩ in terms of δ 0 (N ).Recall that any state of the form is a purification of ρ i in H ⊗ H ′ for any orthogonal basis {|ϕ k i ⟩ ∈ H ′ }, where H ′ is an ancilliary Hilbert space isomorphic to H. Now, from Ulhmann's theorem: where the maximum is taken over all purifications Ψ i , Ψ j of ρ i , ρ j , respectively.Since all terms in the last summation are positive numbers we can conclude that for any k, s = 1, . . ., N : Define now the sets notice that the set I must have at least M elements because every density operator acting on an Ndimensional space must have at least one eigenvalue greater or equal to

Figure 1 :Figure 2 :
Figure 1: Starting configuration of the dcq-Turing machine with a classical and quantum input.x = x1 • x2 • • • x k is the classical input, while ρ ⟨1,n⟩ is the quantum input "written" on n cells of the quantum tape, where ρi is the local state of the i−th cell, represented by ρi = Tr (1,...,i−1,i+1,...,n) [ρ ⟨1,n⟩ ].The string x2n is surrounded by blank symbols extending to infinity in both directions.The quantum input is surrounded by cells in the local zero state |0⟩⟨0| extending to infinity in both directions.
The set Σ s is computably enumerable as shown by Algorithm 5 (see Appendix).Because we know that t ρ ∈ Σ s can be used to approximate σ (given the value of m), we can think of the Σ s ⊆ P s as a subset of candidates for programs to compute σ.Unfortunately, it is not straightforward to find a bound for |Σ s |.Instead, define Σ * s as the set of states that can be outputted by Algorithm 4, which constructs a list of programs in Σ s that are all at least 4 s -distant from each other.The set Σ * s is computably enumerable by construction and satisfies the following properties: 1.For any distinct t, t ′ ∈ Σ * s it holds that the associated 2 P Universal dcq-TM U, enumeration E Σ s,m,|tρ| of the set Σ s given s, m, |t ρ |, ℓ ; Input: Integers i, s, m, |t ρ |, ℓ; L ← (), j ← 1; Enumeration of the set Σ * s .This means that we can compute σ as follows.On input k, let j be the index of a program τ that satisfies Equation (84) for the set Σ * 5k .Directly compute the values of m, |t ρ |, and ℓ; then run Algorithm 4 on input (j, 5k, m, |t ρ |, ℓ) to obtain τ , and finally output the m-prefix of U Q τ (5k; ϵ), which by Equation (84) is at most 1 k -distant from σ.The size of the index j ≤ |Σ * 5k | can be bounded by |⟨ψ i ′ |ẽ j ′ ⟩| ≤ a j ′ −1 |ẽ j+1 ⟩| = ⟨ψ i |ψ j+1 ⟩ − k≤j ⟨ẽ k |ψ j+1 ⟩⟨ψ i |ẽ k ⟩ ≤ ⟨ψ i |ψ j+1 ⟩ Under the assumptions of Lemma 8.3, with δ ≤ 2 −3 N |⟨ψ i |e i ⟩| ≥ 1 − 2 3 NRecalling that the two terms on the right side are mutually orthogonal and that ||ψ i ⟩| = 1, it follows that ||ẽ i ⟩| ≤ 1 and therefore|⟨ψ i |e j ⟩| ≥ |⟨ψ i |ẽ j ⟩|.(116)On the other hand, we can bound the sequence defined in Equation (114) by the doubly exponential sequencea j+1 = a 2 j + a j ≤ 2a 2 j ≤ 2 3 j , (117)and hence, by Lemma 8.3|⟨ψ i |e i ⟩| ≥ |⟨ψ i |ẽ i ⟩| ≥ 1 − δ (114)Proof.From Equation (106) we know that|ψ i ⟩ = |ẽ i ⟩ + j<i ⟨ẽ j |ψ i ⟩|ẽ j ⟩. (115) j<i |⟨ẽ j |ψ i ⟩| 2 1 N .Substituting |ψ k i ⟩ ∈ I i and |ψ s j ⟩ ∈ I j for i ̸ = j in Equation (134) we obtain This means that the set I satisfies the conditions of lemma 8.5 and hence may have at most N elements.