1
$\begingroup$

Has anyone used or considered color-space and color superposition for Qutrit work?

A classical color-sphere has black and white at its poles, a grey scale as its axis, pure spectral colors as a color-wheel around its equator, and every possible mixed color inside or on the surface of this color space. This is a qutrit-like space analogous to a Bloch Sphere as a qubit space.

enter image description here

Research validating superposition of colors as a Qubit (if not a Qutrit) Computing basis-

https://physics.aps.org/articles/v9/135

$\endgroup$
  • $\begingroup$ I think, you wanted to visit, for example, ux.stackexchange.com . $\endgroup$ – peterh says reinstate Monica Nov 30 at 11:58
  • $\begingroup$ This is more than a human interface idea. Colors are well known to be added (superposed) or subtracted. Thus further operations are possible with colored light. I'll edit the question to bring out the "physical realization" aspect more. $\endgroup$ – wave Dec 1 at 3:34
2
$\begingroup$

Let me for starters address your last comment:

Research validating superposition of colors as a Qubit (if not a Qutrit) Computing basis- https://physics.aps.org/articles/v9/135

This has absolutely nothing to do with the problem at hand. That paper talks about how to generate photons with two frequencies, it has nothing to do with how states can be represented with colour encoding.


You can use RGB encoding to map elements of $\mathbb R^3$ to a single color. This can be useful if for example you are dealing with a state in which you have a two-dimensional system (a qubit) interacting with an high-dimensional one. An example of such a system are vector vortex beams, which are states of light in which the polarization is entangled with the orbital angular momentum, and therefore the polarization state depends on the position in the transverse propagation plane (unfortunately, the only example of this kind of RGB encoding actually being used that I know of is as of yet unpublished).

Regarding using this kind of thing to represent the state of a qutrit, I guess you can do it, but I don't know how useful it would be. The idea is that given a qutrit state of the form $$|\psi\rangle=\alpha|0\rangle+\beta|1\rangle+\gamma|2\rangle$$ you can represent it as a Bloch sphere attached to each element of another Bloch sphere. One way to do this (other choices are possible) is to have the first Bloch sphere represent the state of the qubit in the space spanned by $|0\rangle$ and the projector onto the two remaining modes, and the second Bloch sphere represent the state you get after post-selecting on the $|2\rangle,|3\rangle$ modes.

In other words, this means that you are rewriting the state as $$|\psi\rangle = \alpha |0\rangle + \left(\sqrt{|\beta|^2+|\gamma|^2}\right) e^{i\arg\beta} \left[ \underbrace{\frac{|\beta|}{\sqrt{|\beta|^2+|\gamma|^2}}}_{\equiv \beta'}|1\rangle + \underbrace{\frac{\gamma e^{-i\arg \beta}}{\sqrt{|\beta|^2+|\gamma|^2}}}_{\equiv \gamma'}|2\rangle \right]. $$ We then use $c_0\equiv \alpha$ and $c_1\equiv\sqrt{|\beta|^2+|\gamma|^2}e^{i\arg\beta}$ as amplitudes of our "first qubit", and $\beta',\gamma'$ as amplitudes of the "second qubit". It should be noticed that there are some caveat in doing this. For example, when $\alpha=1$, the amplitudes in the second sphere are undefined (although this is not that much of a problem, as it's quite common to have this sort of situation when using nonlinear coordinates). Intuitively, the first Bloch sphere encodes the probability of the state being found in the $|0\rangle$ state and the relative phase between $|0\rangle$ and $|1\rangle$, while the second Bloch sphere encodes the relative probability of finding $|1\rangle$ and $|2\rangle$ and their relative phase.

Once you do this, you can represent the state as a pair of Bloch spheres, one attached to the point on the first one. If you represent the point on the second Bloch sphere with an RGB encoding, this amounts to representing the state of the qutrit as a coloured point on a sphere. Just for fun, I implemented this in Mathematica to see what would come out. If you evaluate the following code (which requires MaTeX to be installed on your system, but if you don't the only thing you lose are the labels on the Bloch sphere):

fromSphericalCoordinates[{rr_, \[Theta]\[Theta]_, \[Phi]\[Phi]_}] := 
  With[{r = Abs@rr, \[Theta] = Abs@\[Theta]\[Theta], \[Phi] = 
     Abs@\[Phi]\[Phi]}, Which[
    \[Theta] == 0, {0, 0, 1},
    \[Theta] == Pi, {0, 0, -1},
    Not[0 < \[Theta] < \[Pi]], 
    fromSphericalCoordinates[{r, Mod[\[Theta], Pi], \[Phi]}],
    True, FromSphericalCoordinates[{r, \[Theta], \[Phi]}]
    ]];
colorizePointOnSphere[pt_] := RGBColor[(pt + 1)/2];

stateToBlochCoordinates[ket_List] := {
   2 Re[Conjugate@ket[[1]]*ket[[2]]],
   2 Im[Conjugate@ket[[1]]*ket[[2]]],
   Abs[ket[[1]]]^2 - Abs[ket[[2]]]^2
   };

qutritStateToDoubleSpherePoints[ket_List] := 
  With[{normalizedState = 
     Chop[# E^(-I Arg@First@#)] &@Normalize@ket},
   With[{
     firstQubit = {normalizedState[[1]], 
       Sqrt[1 - normalizedState[[1]]^2] E^(
        I Arg@normalizedState[[2]])},
     secondQubit = # E^(-I Arg@First@#) &@
        Normalize@normalizedState[[{2, 3}]] // Chop
     },
    {stateToBlochCoordinates@firstQubit, 
     stateToBlochCoordinates@secondQubit}
    ]];


qutritStateToColouredSphere[ket_List] := 
  With[{pts = qutritStateToDoubleSpherePoints@ket},
   Graphics3D[{PointSize@0.05,
     colorizePointOnSphere@Last@pts,
     Point@First@pts
     }]
   ];

Get["https://raw.githubusercontent.com/lucainnocenti/QM/master/\
BlochSphere.m"]
Manipulate[
 Column@{qutritStateToDoubleSpherePoints@{Cos[\[Theta]1], 
       Sin[\[Theta]1] Cos[\[Theta]2] E^(I \[Phi]1), 
       Sin[\[Theta]1] Sin[\[Theta]2] E^(
        I (\[Phi]1 + \[Phi]2))}, #} &@
  Show[{
    Graphics3D[{QBlochSphere[]}, ImageSize -> 600],
    qutritStateToColouredSphere@{Cos[\[Theta]1], 
      Sin[\[Theta]1] Cos[\[Theta]2] E^(I \[Phi]1), 
      Sin[\[Theta]1] Sin[\[Theta]2] E^(I (\[Phi]1 + \[Phi]2))}
    }, Axes -> True, AxesLabel -> {x, y, z}, Boxed -> False],
 {{\[Theta]1, 0}, 0, Pi/2.001, 0.001, Appearance -> "Labeled"},
 {{\[Theta]2, 0}, 0, Pi/2.001, 0.001, Appearance -> "Labeled"},
 {{\[Phi]1, 0}, -Pi, Pi, 0.001, Appearance -> "Labeled"},
 {{\[Phi]2, 0}, -Pi, Pi, 0.001, Appearance -> "Labeled"}, 
 ControlPlacement -> Right
 ]

This will give you the following interactive interface to explore how different qutrits would be represented:

enter image description here

I don't think that this would be a particularly useful way to represent states. Directly showing a small Bloch sphere at every point of the big Bloch sphere would probably be a better idea.

$\endgroup$
  • $\begingroup$ Thank you for the very helpful answer. I am in fact also asking about physical color addition and subtraction as a photonic computing basis, for which color-space is a direct visual representation. There are of course many other domains where color representation can stand-in for non-color data. It does seem to me that a Bloch Sphere surface model can naturally be extended to its interior volume by a distance-from-center dimension, with embedded spheres then necessary to add further dimensions. $\endgroup$ – wave Dec 2 at 17:37
  • $\begingroup$ @wave the two things are totally unrelated. "physical color addition and subtraction as a photonic computing basis" would be extremely hard to achieve, as it would amount to nonlinear operations mixing different frequencies of light. Some operations between different frequencies can be achieved, but I don't know of any work that implements reliably gates of this sort. The main problem is always the same: photons don't interact with each other. Regarding extending the Bloch sphere to consider its interior, that is already the case for the normal Bloch sphere when you use density matrices $\endgroup$ – glS Dec 2 at 17:40
  • $\begingroup$ Yes, colored light processing would be very hard to directly implement today, but maybe not someday. The photons could be combined by a common interaction with another quantum object. It will be far easier to start with classical emulation by adding and subtracting RGB virtual qutrits with basic graphics algorithms. $\endgroup$ – wave Dec 2 at 21:00

Not the answer you're looking for? Browse other questions tagged or ask your own question.