Unitary operators
4 Feb 2019

...Back to page 3

A unitary operator is also a rotation of the computational sphere about an axis. But whereas hermitian unitary operators represent half-rotations of the sphere only, general unitary operators represent rotations by any amount (0 < theta < 180 degrees), in either direction. The evolution of a state or set of states over time is usually given by the sum of a series of infinitesimal rotations of the sphere about a constant or changing axis. These are all unitary operations and usually combine to form circles (great and not) on the sphere, although in principle they can form any continuous path, closed or otherwise.

Consider a two-node network where the output of each node is connected to the input of the other node, with weight 1. Each node also applies a hermitian operator. Consider two hermitian operators with axes that are almost the same, but which have a small angle between them (in yellow below, in the equatorial plane of the sphere), and an initial point (1-bit state) on the sphere at H ("horizontal polarization"). The action of the first operator is to rotate the computational sphere half-way about that axis, which doesn't move the initial point very far. When the second operator is applied, the point is returned almost to its starting position, but not quite: it is rotated by an amount equal to twice the angle between the axes of the two operators, about a third axis that is perpendicular to both. Repeated applications of the two operators continue to rotate the point first one way and then the other, at alternating steps:



By combining an appropriate pair of hermitian operators in the correct order, any 1-bit unitary operator can be created. Reversing the order of the hermitian operators reverses the direction of the unitary rotation. For a given unitary axis and rotation angle, there are an infinite number of pairs of hermitian operators that will produce that unitary operation: any two hermitian operators with axes located on the equator of the unitary operator, which are also half the rotation angle apart.

Two operators are required to rotate a point. In the example shown above, a single value flows through the network, so that half of the time each node is "idle". However, this loop structure provides a simple mechanism for parallel processing: the loop can be initialized with two different points (one to each node), so that during each computational step both points are partially updated by one of the operators (half of the loop). In this way both the left and the right points move at the same time, and their traces are intermixed in the plots below (since both flow through each node on alternate steps). If the loop was bigger, more independent points could be processed in parallel. Here is another network of 2 nodes, with different hermitian operator axes, in which 2 unrelated points are moved each step:


If the second point is initialized properly, it will "fill in the gaps" created every other step by the first point, and the resulting motion will be a more continuous sequence of points at twice the resolution. In this case, the second point exactly interpolates the path of the first, and the net rotation per step is now equal to the angle between the two hermitian operator axes, rather than twice this angle:


If the 2-node loop of this network is duplicated, additional points can be processed simultaneously. Each loop is initialized with appropriate values to create two trails: a given point rotating about a specific axis, and its counter-rotating twin:



For any axis and angle of rotation, any set of 1-bit states can be propagated around the sphere by hermitian operators in this way. Only the odd-numbered node values are shown below, so there is only one rotating figure:


The demonstrations shown above use 1-bit states and operators. Similar dynamics are expected for multi-bit states (objects with more than 2 complex numbers) and operators, but with larger loops containing more nodes. For example, I expect that 2-bit states (4 complex numbers) will require 4 hermitian operators to create a unitary operator, and that 4-bit states (16 complex numbers) will require 16 hermitian operators for each unitary operator, etc...

The screenshots above are of the Linux version of this software. The image below shows the corresponding Mac version, which operates identically:


You can see some of these ideas put into use via analog electronics at the following site:

Next time, two-bit states and operators.


©Sky Coyote 2018-2019