# How to create simple (tensor) product spaces?

Is it possible to work with simple tensor product spaces, like multiplying product states from quantum mechanics?

I basically have a simple two dimensional vector space, whose elements are represented by two dimensional vectors: $$(1,0)$$ and $$(0,1)$$ are the basis vectors. And I have $$2\times 2$$ matrices acting on them.

What I want to do is to combine two or more of such vector space to a bigger one, so that I get states like this: $$(1,0)\otimes (1,0)$$, $$(1,0)\otimes (0,1)$$, $$(0,1)\otimes (1,0)$$ and $$(0,1)\otimes (0,1)$$ are the basis states of the combined vector space. Matrices should combine similarly like: $$((1,2),(3,4))\otimes((1,2),(3,4))$$

I tried different ways to achieve this, using the \[CircleTimes] or the \[TensorProduct] symbols to combine them, but in the end I do not get anything to work.

• KroneckerProduct Mar 22, 2016 at 14:56
• This does not work, it created incompatible shapes, when trying to multiply two combined matrices: KroneckerProduct[{{1,2},{3,4}},{{1,2},{3,4}}] with the combined vector: KroneckerProduct[{1,0},{0,1}] Mar 22, 2016 at 15:17
• Flatten the second one. Mar 22, 2016 at 15:58

Here is the basic method, illustrated with the combination of two spin-1/2 particles. (Hopefully, the physics language is familiar or accessible; I don't really have an idea of where else this kind of construction is useful.)

sigmaZ = {{1, 0}, {0, -1}}
id = IdentityMatrix
(* {{1, 0}, {0, -1}} *)
(* {{1, 0}, {0, 1}} *)


Let's suppose we want to compute the $z$ component of the total spin of two particles. The individual operators and the sum are

(sz = KroneckerProduct[sigmaZ, id]) // MatrixForm
(sz = KroneckerProduct[id, sigmaZ]) // MatrixForm
(sz[1, 2] = sz + sz) // MatrixForm Now, we can make single-particle states (written in the eigenbasis of sigmaZ) using

state = {s, s[-1]}
state = {s, s[-1]}
(* {s, s[-1]} *)
(* {s, s[-1]} *)


(I am using this abstract indexing in order to keep track of the states and particles that each amplitude is associated with: s[-1], for instance, stands for the amplitude of particle 2 to be in the "down" state.)

Then, we can take the tensor product of these two states to form the two-particle state

state[1, 2] = KroneckerProduct[state, state] // Flatten
(* {s s, s s[-1], s[-1] s, s[-1] s[-1]} *)


(Below, I will present an alternative to Flattening, but this is the way I prefer to do this). Note the ordering of the two-particle basis:

Particle 1, up; Particle 2 up

Particle 1, up; Particle 2 down

Particle 1, down; Particle 2 up

Particle 1, down; Particle 2 down

We can see by direct matrix multiplication that this is consistent with the ordering used in KroneckerProduct when constructing the two-particle operators:

sz.state[1, 2]
sz.state[1, 2]
(* {s s, s s[-1], -s[-1] s, -s[-1] s[-1]} *)
(* {s s, -s s[-1], s[-1] s, -s[-1] s[-1]} *)


We can see that when Particle 1 is in the down state, the amplitude gets multiplied by -1 when being acted on by sz, and so on. Note that we can also do

state[1, 2].sz


with no problems.

Finally, we can construct our states in alternative ways. The ordering in Mathematica is consistent with many different ways of constructing the states. For instance,

Table[state[i, j], {i, 1, -1, -2}, {j, 1, -1, -2}] // Flatten
state @@@ Tuples[{1, -1}, 2]
(* {state[1, 1], state[1, -1], state[-1, 1], state[-1, -1]} *)
(* {state[1, 1], state[1, -1], state[-1, 1], state[-1, -1]} *)


Here, the first and second positions in the argument of state are, respectively, the spin of particle 1 and 2, and we can see that the ordering of the basis is respected.

Alternative to Flattening

If we feel like making column vectors and row vectors separately, then do the following:

columnState[1, 2] = KroneckerProduct[state, List /@ state]
rowState[1, 2] = KroneckerProduct[List@state, state]
columnState[1, 2] // MatrixForm
rowState[1, 2] // MatrixForm
(* {{s s}, {s s[-1]}, {s[-1] s}, {s[-1] s[-1]}} *)
(* {{s s, s s[-1], s[-1] s, s[-1] s[-1]}} *) And of course,

rowState[1, 2] == Transpose@columnState[1, 2]
(* True *)


Now, Dotting the matrix with the vectors can only be done one way, and Mathematica will complain if we try to do things in the wrong order.

sz.columnState[1, 2] // MatrixForm
rowState[1, 2].sz // MatrixForm 