How to put the tensor product of two operators onto two variables?

Question

I am trying to make an intuitive Mathemtaica program to show the principle of quantum walking. The idea of quantum walking is very simple and direct, but when I try to transfer it into Mathemitca codes, I meet several difficulties.

The principle of quantum walk is introduced here http://susan-stepney.blogspot.jp/2014/02/mathjax.html and here http://xxx.tau.ac.il/abs/quant-ph/0303081

There are two operations in one step:

1. Coin operation (Hadamard coin H)

2. Step operation (S)

With these two operations, bellow shows the first three steps of a quantum walk

I hope to express this process in an intuitive Mathematica codes.

The result of one step can be expressed as

The two operators, H and S, are put on these two variables

I do not know how to realize such a tensor product in Mathemcatica.

,

where S and H are two operators; x and y are two variables; x is an array; y is an integer.

But I guess this equation is correct, because similar equation is shown in wiki( http://en.wikipedia.org/wiki/Tensor_product)

To realize this equation in Mathematica, I test an example first, as shown below .

My expected result is

But I cannot obtain this result.

My questions are:

1. How can I realize in Mathematica？

2. How to intuitively express the first three steps of quantum walk using Mathematica codes?

I have tried to solve this problem for several days, but made no progress. Any help or suggestion will be highly appreciated,

Answer 1

You can implement your "quantum walk" states and operators as follows:

Represent the basis state in the form state[spin, index], where spin is either "↑" or "↓".

Define how the H and S operators act on basis states.

H[state[spin : ("↑" | "↓"), index_]] := 
  1/Sqrt[2] state["↑", index] + 
  1/Sqrt[2] If[spin == "↑", 1, -1] state["↓", index];

S[state[spin : ("↑" | "↓"), index_]] := 
  state[spin, index + If[spin == "↑", 1, -1]];

Define simplification rules for the operators, which reduces any operation to one in which operators act only on basis states.

H[u_ + v_] := H[u] + H[v];
S[u_ + v_] := S[u] + S[v];

H[u_?(FreeQ[#, state] &) v_] := u H[v];
S[u_?(FreeQ[#, state] &) v_] := u S[v];

Evaluate the random walk example at the top of your question.

state["↓", 0]
H[%]
S[%]
H[%]
S[%]
H[%]
S[%] // Simplify

I have used Simplify on the final result to rearrange it into a more concise form, which is

(-state["↓", -3] - 2 state["↓", -1] + 
  state["↓", 1] + state["↑", -1] + 
  state["↑", 3])/(2 Sqrt[2])

You can use the Notation package to make state[spin, index] display in a nicer way. For instance, after loading the Notation package, you could use the Notation palette to define the following notation

Notation[\[LeftBracketingBar]spin_〉⊗\[LeftBracketingBar]index_〉 ⟺ state[spin_,index_]]

and then re-evaluate the above random walk to obtain a "prettified" version of the output.