Factoring a quantum state

Question

I'm looking for algorithms that take an arbitrary quantum state made up of a sum of weighted classical states made up of bits, like this:

|0000>/2 - |0011>/2 + |0100>/2 - |0111>/2

and factor it into a more compact form using tensor products, like this:

|0> x (|0> + |1>) x (|00> - |11>) / 2

I want to use the algorithm as a way of visualizing/simplifying the state of a (simulated) quantum circuit.

For individual qubits I know I can just pair all the states with the state where the bit is flipped and check that every pair has the same x:y relation between the states. In the example above, flipping the second bit always gives you a state with a 1:1 weighting, so the second bit factors out as (1|0> + 1|1>).

But extending that approach to detect entangled bits (like the third and fourth in the example) causes it to take at least Ω(n^c) time (probably more, I haven't thought it all the way through), where n is the number of states and c is the number of entangled bits. Since n is already growing exponentially with the number of bits that's... not ideal.

Are there better algorithms? Representations easier to factor from/to? How useful is changing the basis? Links to papers would be great.

Buckeye

#2267646 – Redo

This has nothing to do with integer factorization. – Cobelligerent

@Redo That is an algorithm to factor integers into primes. What I want is more analogous to polynomial factorization, though still different. – Buckeye

Should this algorithm be implemented using a quantum programming language, or should it be implemented using a traditional programming language? – Carmelinacarmelita

@AndersonGreen A normal programming language. I want to use it to visualize the state of a quantum computation, but since I don't have a quantum computer it would not be useful for the factoring algorithm itself to be quantum. – Buckeye

@Strilanc See also: #4595656 – Carmelinacarmelita

@AndersonGreen Thanks. I have already written a very basic simulator ( jsfiddle.net/xkCLq/24/embedded/result ), but before I work on the massive lack of optimizations I want to work on visualizing the state better. – Buckeye

Isn't the running time of your approach asymptotic to 4^b, where b is the number of qubits? The loop structure looks to me like, for each subset of qubits (2^b), for each setting of those qubits (2^c where c is the size of the subset), compute the conditional state of the other qubits (2^(b-c) coefficients) and compare. – Prophet

@DavidEisenstat Sounds about right. Like I said, n^c, which is (2^b)^c, was just a half-thought lower bound that was already bad and likely to be worse. – Buckeye

Ah, so n is the number of qubits, not the number of classical states. – Prophet

@DavidEisenstat Yes, but the exact opposite. – Buckeye

@Craig: Can you give me a hint why "that is an algorithm to factor integers"? – Pentachlorophenol

@Craig: How did you finally solve the problem? – Pentachlorophenol

@HansStricker Since the full problem was NP-hard, I focused on "is a specific contiguous set of qubits indicated by the user separable from the rest?". You can see it in action in Quirk's amplitude displays. – Buckeye

Answer 1

It looks like an efficient algorithm is going to be hard:

From wikipedia:

The problem of deciding whether a state is separable in general is sometimes called the separability problem in quantum information theory. It is considered to be a difficult problem. It has been shown to be NP-hard.

Gurvits, L., Classical deterministic complexity of Edmonds’ problem and quantum entanglement, in Proceedings of the 35th ACM Symposium on Theory of Computing, ACM Press, New York, 2003.

Sevag Gharibian, Strong NP-Hardness of the Quantum Separability Problem, Quantum Information and Computation, Vol. 10, No. 3&4, pp. 343-360, 2010. arXiv:0810.4507

Scarecrow