├── .gitignore
├── LICENSE.txt
├── README.md
├── bloch_sphere
    ├── __init__.py
    ├── animate_bloch.py
    └── animate_bloch_compare.py
├── examples
    ├── common_gates.md
    ├── hh_gate.gif
    ├── hzh_x_compare.gif
    ├── random_as_zxz.gif
    ├── random_as_zxzxz.gif
    ├── render_examples.py
    ├── ry_gate_arrows.gif
    ├── sqrt_xxxx_gate.gif
    ├── ststs_gate.gif
    ├── synthesize_from_rz_rx_rz.py
    ├── xx_gate.gif
    ├── xyss_gate.gif
    ├── xz_y_compare.gif
    ├── yy_gate.gif
    └── zz_gate.gif
└── setup.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | /dist
 2 | /*.egg-info
 3 | /build
 4 | 
 5 | # Mac files
 6 | .DS_Store
 7 | 
 8 | # cache files
 9 | __pycache__/
10 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | Copyright 2020 Casey Duckering
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Qubit Bloch Sphere Visualization
  2 | 
  3 | A collection of visualization tools for the qubit Bloch sphere.
  4 | The Bloch sphere is a useful representation of the state of a single-qubit quantum computer.
  5 | 
  6 | ![X gate comparison with Hadamard-Z-Hadamard](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/hzh_x_compare.gif)
  7 | 
  8 | * [Animations for many common gates](https://github.com/cduck/bloch_sphere/blob/master/examples/common_gates.md)
  9 | 
 10 | See also: [Feynman path integral visualization](https://github.com/cduck/feynman_path)
 11 | 
 12 | # Install
 13 | 
 14 | bloch\_sphere is available on PyPI:
 15 | 
 16 | ```bash
 17 | python3 -m pip install bloch_sphere
 18 | ```
 19 | 
 20 | ## Prerequisites
 21 | 
 22 | Cairo needs to be installed separately to render videos.
 23 | See platform-specific [instructions for Linux, Windows, and macOS from Cairo](https://www.cairographics.org/download/).
 24 | Below are some examples for installing Cairo on Linux distributions and macOS.
 25 | 
 26 | **Ubuntu**
 27 | 
 28 | ```bash
 29 | sudo apt-get install libcairo2
 30 | ```
 31 | 
 32 | **macOS**
 33 | 
 34 | Using [homebrew](https://brew.sh/):
 35 | 
 36 | ```bash
 37 | brew install cairo
 38 | ```
 39 | 
 40 | # Usage
 41 | 
 42 | This package provides a command line tool to generate animations.
 43 | In your shell, run the following (run `animate_bloch -h` for help).
 44 | ```bash
 45 | animate_bloch hadamard x y s s
 46 | ```
 47 | 
 48 | ```bash
 49 | animate_bloch2 xy_vs_z x,y z
 50 | ```
 51 | 
 52 | With annotations:
 53 | ```bash
 54 | animate_bloch2 xy_vs_z_annotated \
 55 |     x,y z \
 56 |     --circuit '& \gate{X} & \gate{Y} & \qw & \push{=} & & \gate{Z} & \qw' \
 57 |     --equation '$YX\ket{\psi}=Z\ket{\psi}$' \
 58 |     --fps 20 \
 59 |     --mp4
 60 | ```
 61 | 
 62 | Custom gates: `custom;<x-axis>;<y-axis>;<z-axis>;<number half rotations>;<label>`
 63 | ```bash
 64 | animate_bloch2 custom_hzy "custom;0;1;1;1;Hzy" "s,h,inv_s"
 65 | ```
 66 | 
 67 | Alternate drawing styles:
 68 | ```bash
 69 | animate_bloch ry_gate_arrows --style arrows ry,0.666667 ry,0.666667 ry,0.666667
 70 | ```
 71 | 
 72 | ![Ry(2π/3) gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/ry_gate_arrows.gif)
 73 | 
 74 | # Code Examples
 75 | 
 76 | ### Visualize a single Bloch sphere
 77 | 
 78 | ```python
 79 | from bloch_sphere.animate_bloch import do_or_save_animation, AnimState
 80 | 
 81 | @do_or_save_animation('my_animation', save=False, fps=20, preview=True)
 82 | # Or
 83 | #@do_or_save_animation('my_animation', save='gif', fps=20, preview=True)
 84 | #@do_or_save_animation('my_animation', save='mp4', fps=20, preview=False)
 85 | def animate(state: AnimState):
 86 |     state.x_gate()
 87 |     state.y_gate()
 88 |     state.s_gate()
 89 |     state.s_gate()
 90 |     ...
 91 |     state.wait()  # Pause at the end
 92 | ```
 93 | 
 94 | ![Example output animation](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/xyss_gate.gif)
 95 | 
 96 | 
 97 | ### Compare two sequences of gates
 98 | 
 99 | ```python
100 | from bloch_sphere.animate_bloch_compare import main
101 | 
102 | main('hzh_x', 'h,z,h'.split(','), 'x'.split(','),
103 |      r'& \gate{H} & \gate{Z} & \gate{H} & \qw & \push{=} & & \gate{X} & \qw',
104 |      r'$HZH\ket{\psi}=X\ket{\psi}$',
105 |      mp4=False,
106 |      fps=20,
107 |      preview=True,
108 | )
109 | ```
110 | 
111 | Or
112 | 
113 | ```python
114 | import drawsvg as draw
115 | import latextools
116 | from bloch_sphere.animate_bloch_compare import render_animation
117 | 
118 | # Add some extra labels
119 | zero_ket = draw.Group()
120 | zero_ket.draw(latextools.render_snippet('$\ket{0}$', latextools.pkg.qcircuit),
121 |               x=0, y=0, center=True, scale=0.015)
122 | one_ket = draw.Group()
123 | one_ket.draw(latextools.render_snippet('$\ket{1}$', latextools.pkg.qcircuit),
124 |              x=0, y=0, center=True, scale=0.015)
125 | zero_ket_inner = draw.Use(zero_ket, 0, 0, transform='scale(0.75)')
126 | one_ket_inner = draw.Use(one_ket, 0, 0, transform='scale(0.75)')
127 | 
128 | w = 624*2  # Output width
129 | fps = 20
130 | draw_args = dict(
131 |     w = w/2,
132 |     outer_labels=[
133 |         [(0, 0, 1), (-0.15, 0.13), zero_ket],
134 |         [(0, 0, -1), (0.15, -0.13), one_ket],
135 |     ],
136 |     inner_labels=[
137 |         [(0, 0, 0.8), (0, 0), zero_ket_inner],
138 |         [(0, 0, -0.8), (0, 0), one_ket_inner],
139 |     ],
140 | )
141 | 
142 | gates1 = 'h,z,h'.split(',')
143 | gates2 = 'x'.split(',')
144 | def func1(state):
145 |     state.draw_args = dict(draw_args)
146 |     state.draw_args['inner_labels'] = []
147 |     state.sphere_fade_in()
148 |     state.apply_gate_list(gates1, final_wait=False)
149 |     state.wait()
150 |     for _ in gates2:
151 |         state.i_gate()
152 |     state.wait()
153 |     state.wait()
154 |     state.sphere_fade_out()
155 |     state.wait()
156 | def func2(state):
157 |     state.draw_args = dict(draw_args)
158 |     state.draw_args['inner_labels'] = []
159 |     state.sphere_fade_in()
160 |     for _ in gates1:
161 |         state.i_gate()
162 |     state.wait()
163 |     state.apply_gate_list(gates2, final_wait=False)
164 |     state.wait()
165 |     state.wait()
166 |     state.sphere_fade_out()
167 |     state.wait()
168 | render_animation('hzh_x_compare', func1, func2,
169 |                  r'& \gate{H} & \gate{Z} & \gate{H} & \qw & \push{=} & & \gate{X} & \qw',
170 |                  r'$HZH\ket{\psi}=X\ket{\psi}$',
171 |                  save='gif',  # False, 'gif', or 'mp4'
172 |                  fps=fps,
173 |                  preview=True,
174 |                  w=w)
175 | ```
176 | 
177 | ![Example output animation](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/hzh_x_compare.gif)
178 | 
179 | ### Synthesize any gate as Rz, Rx, Rz
180 | 
181 | Any single-qubit gate can be decomposed into a series of three rotations about fixed axes, most commonly as rotations about Z, X, and Z.
182 | See [the example code](https://github.com/cduck/bloch_sphere/blob/master/examples/synthesize_from_rz_rx_rz.py) that generated the below animation.
183 | 
184 | ![Example output animation](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/random_as_zxz.gif)
185 | 
186 | ### Synthesize any gate as Rz, Rx(π/2), Rz, Rx(π/2), Rz
187 | 
188 | Any single-qubit gate can also be decomposed into a series of three Z rotations with fixed X rotations of π/2 (1/4 turn) in between.
189 | See [the example code](https://github.com/cduck/bloch_sphere/blob/master/examples/synthesize_from_rz_rx_rz.py) that generated the below animation.
190 | 
191 | ![Example output animation](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/random_as_zxzxz.gif)
192 | 


--------------------------------------------------------------------------------
/bloch_sphere/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/bloch_sphere/__init__.py


--------------------------------------------------------------------------------
/bloch_sphere/animate_bloch.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | from typing import Any, Dict, List, Optional
  4 | 
  5 | import dataclasses
  6 | import argparse
  7 | import re
  8 | import sys
  9 | import numpy as np
 10 | 
 11 | import drawsvg as draw  # pip install drawsvg
 12 | from hyperbolic import euclid3d  # pip install hyperbolic
 13 | import hyperbolic.euclid as shapes
 14 | 
 15 | 
 16 | @dataclasses.dataclass
 17 | class AnimState:
 18 |     anim: draw.FrameAnimation
 19 |     fps: float = 20
 20 |     speed: float = 1
 21 |     inner_proj: euclid3d.Projection = euclid3d.identity(3)
 22 |     inner_opacity: float = 1
 23 |     extra_opacity: float = 0
 24 |     label: Optional[str] = None
 25 |     axis: Optional[List[float]] = None
 26 |     draw_args: Dict[str, Any] = dataclasses.field(default_factory=dict)
 27 | 
 28 |     @classmethod
 29 |     def _interpolate(cls, x):
 30 |         return (np.sin(x * np.pi + -np.pi/2) + 1)/2
 31 |     def _smooth(self, duration):
 32 |         x = np.linspace(0, 1, int(round(self.fps*duration)))
 33 |         y = self._interpolate(x)
 34 |         return y
 35 |     def _wait(self, duration):
 36 |         return range(int(round(self.fps*duration)))
 37 | 
 38 |     def _draw_frame(self):
 39 |         self.anim.draw_frame(self.inner_proj, label=self.label,
 40 |                              inner_opacity=self.inner_opacity,
 41 |                              extra_opacity=self.extra_opacity,
 42 |                              axis=self.axis,
 43 |                              id_prefix='{}-d'.format(len(self.anim.frames)),
 44 |                              **self.draw_args)
 45 | 
 46 |     def sphere_fade_in(self):
 47 |         for t in self._smooth(0.4):
 48 |             self.inner_opacity = t
 49 |             self._draw_frame()
 50 |         self.inner_opacity = 1
 51 | 
 52 |     def sphere_fade_out(self):
 53 |         for t in self._smooth(0.4):
 54 |             self.inner_opacity = 1-t
 55 |             self._draw_frame()
 56 |         self.inner_opacity = 0
 57 | 
 58 |     def fade_in(self, label, axis):
 59 |         assert self.extra_opacity == 0, 'Unexpected previous state'
 60 |         self.label = label
 61 |         self.axis = axis
 62 |         for t in self._smooth(0.4):
 63 |             self.extra_opacity = t
 64 |             self._draw_frame()
 65 |         self.extra_opacity = 1
 66 | 
 67 |     def fade_out(self):
 68 |         assert self.extra_opacity == 1, 'Unexpected previous state'
 69 |         for t in self._smooth(0.4):
 70 |             self.extra_opacity = 1-t
 71 |             self._draw_frame()
 72 |         self.extra_opacity = 0
 73 | 
 74 |     def rotate(self, rads):
 75 |         start = self.inner_proj
 76 |         for t in self._smooth(2):
 77 |             self.inner_proj = euclid3d.rotation3d(self.axis, rads*t) @ start
 78 |             self._draw_frame()
 79 |         self.inner_proj = euclid3d.rotation3d(self.axis, rads) @ start
 80 | 
 81 |     def wait(self, duration=1):
 82 |         for i in self._wait(duration):
 83 |             self._draw_frame()
 84 | 
 85 |     def i_gate(self):
 86 |         self.wait(2.8)
 87 | 
 88 |     def do_gate(self, label, axis, radians):
 89 |         self.fade_in(label, axis)
 90 |         self.rotate(radians)
 91 |         self.fade_out()
 92 | 
 93 |     def h_gate(self):
 94 |         self.do_gate('H Gate:', (1, 0, 1), np.pi)
 95 |     def x_gate(self):
 96 |         self.do_gate('X Gate:', (1, 0, 0), np.pi)
 97 |     def y_gate(self):
 98 |         self.do_gate('Y Gate:', (0, 1, 0), np.pi)
 99 |     def z_gate(self):
100 |         self.do_gate('Z Gate:', (0, 0, 1), np.pi)
101 |     def sqrt_x_gate(self):
102 |         self.do_gate('√X Gate:', (1, 0, 0), np.pi/2)
103 |     def sqrt_y_gate(self):
104 |         self.do_gate('√Y Gate:', (0, 1, 0), np.pi/2)
105 |     def s_gate(self):
106 |         self.do_gate('S Gate:', (0, 0, 1), np.pi/2)
107 |     def t_gate(self):
108 |         self.do_gate('T Gate:', (0, 0, 1), np.pi/4)
109 |     def inv_h_gate(self):
110 |         self.do_gate('H⁻¹ Gate:', (1, 0, 1), -np.pi)
111 |     def inv_x_gate(self):
112 |         self.do_gate('X⁻¹ Gate:', (1, 0, 0), -np.pi)
113 |     def inv_y_gate(self):
114 |         self.do_gate('Y⁻¹ Gate:', (0, 1, 0), -np.pi)
115 |     def inv_z_gate(self):
116 |         self.do_gate('Z⁻¹ Gate:', (0, 0, 1), -np.pi)
117 |     def inv_sqrt_x_gate(self):
118 |         self.do_gate('√X⁻¹ Gate:', (1, 0, 0), -np.pi/2)
119 |     def inv_sqrt_y_gate(self):
120 |         self.do_gate('√Y⁻¹ Gate:', (0, 1, 0), -np.pi/2)
121 |     def inv_s_gate(self):
122 |         self.do_gate('S⁻¹ Gate:', (0, 0, 1), -np.pi/2)
123 |     def inv_t_gate(self):
124 |         self.do_gate('T⁻¹ Gate:', (0, 0, 1), -np.pi/4)
125 |     def custom_gate(self, x, y, z, r_pi=1, label=None):
126 |         x = float(x)
127 |         y = float(y)
128 |         z = float(z)
129 |         r_pi = float(r_pi)
130 |         if label is None:
131 |             label = f'{r_pi:.3f}π about ({x:.3f}, {y:.3f}, {z:.3f})'
132 |         self.do_gate(label, (x, y, z), np.pi*r_pi)
133 | 
134 |     def apply_gate_list(self, gates, final_wait=True):
135 |         non_gates = {'wait', 'no_wait'}
136 |         block_gates = {'do'}
137 |         no_wait = False
138 |         for gate in gates:
139 |             if gate.startswith('custom,') or gate.startswith('custom;'):
140 |                 try:
141 |                     self.custom_gate(*gate[7:].split(gate[6]))
142 |                 except ValueError:
143 |                     print(f'Error: Custom gate arguments contain invalid '
144 |                           f'floats {gate}.')
145 |                     sys.exit(1)
146 |                     return
147 |                 continue
148 | 
149 |             if re.match('r[x,y,z][,;]', gate[:3].lower()):
150 |                 try:
151 |                     r_pi = float(gate[3:])
152 |                 except ValueError:
153 |                     print('Error: Rx/Ry/Rz gate should have style like '
154 |                           'Rx;{float} or Rx,{float}.')
155 |                     sys.exit(1)
156 |                     return
157 |                 gate_name = 'R' + gate[1].lower()  # Display Rx instead of rx
158 |                 x = int(gate_name[1] == 'x')
159 |                 y = int(gate_name[1] == 'y')
160 |                 z = int(gate_name[1] == 'z')
161 |                 formated_r_pi = f"{r_pi:.3f}".rstrip('0').rstrip('.')
162 |                 label = f"{gate_name}({formated_r_pi}π)"
163 |                 self.custom_gate(x, y, z, r_pi, label=label)
164 |                 continue
165 | 
166 |             gate = gate.replace('-', '_')
167 |             if gate in block_gates:
168 |                 print(f'Error: Invalid gate name "{gate}".')
169 |                 sys.exit(1)
170 |                 return
171 |             if gate == 'no_wait':
172 |                 no_wait = True
173 |             elif gate in non_gates:
174 |                 getattr(self, gate)()
175 |             else:
176 |                 method = getattr(self, gate+'_gate', None)
177 |                 if method is not None:
178 |                     method()
179 |                 else:
180 |                     print(f'Error: Unknown gate name "{gate}".')
181 |                     sys.exit(1)
182 |                     return
183 |         if not no_wait and final_wait:
184 |             self.wait()
185 | 
186 | def do_or_save_animation(name: str, save=False, fps=20, preview=True,
187 |                          style='sphere'):
188 |     def wrapper(func):
189 |         if save == 'mp4':
190 |             with draw.frame_animate_video(
191 |                     f'{name}.mp4', draw_frame, fps=fps, jupyter=preview
192 |                     ) as anim:
193 |                 state = AnimState(anim, fps=fps, draw_args={"style": style})
194 |                 func(state)
195 |         elif save == 'gif' or save is True:
196 |             with draw.frame_animate_video(
197 |                     f'{name}.gif', draw_frame, duration=1/fps, jupyter=preview
198 |                     ) as anim:
199 |                 state = AnimState(anim, fps=fps, draw_args={"style": style})
200 |                 func(state)
201 |         else:
202 |             with draw.frame_animate_jupyter(draw_frame, delay=1/fps) as anim:
203 |                 state = AnimState(anim, fps=fps, draw_args={"style": style})
204 |                 func(state)
205 |         return func
206 |     return wrapper
207 | 
208 | def draw_frame(*args, background='white', id_prefix='d', w=624, h=None,
209 |                **kwargs):
210 |     d = draw.Drawing(5, 3, origin='center', id_prefix=id_prefix)
211 |     d.set_render_size(w=w, h=h)
212 |     if background:
213 |         d.append(draw.Rectangle(-100, -100, 200, 200, fill=background))
214 | 
215 |     g = draw.Group()
216 |     draw_bloch_sphere(g, background=None, *args, **kwargs)
217 |     d.append(g)
218 |     return d
219 | 
220 | def draw_bloch_sphere(d, inner_proj=euclid3d.identity(3), label='', axis=None,
221 |                       rot_proj=None, rot_deg=180,
222 |                       outer_labels=(), inner_labels=(),
223 |                       extra_opacity=1, inner_opacity=1, background='white',
224 |                       style='sphere'):
225 |     spin = euclid3d.rotation(3, 0, 2, 2*np.pi/16/2*1.001)
226 |     tilt = euclid3d.rotation(3, 1, 2, np.pi/8)
227 |     trans = tilt @ spin @ euclid3d.axis_swap((1, 2, 0))
228 |     flip_y = euclid3d.scaling([1, -1, 1])
229 |     proj = flip_y @ euclid3d.perspective3d(np.pi/8, view_size=4) @ trans
230 |     zx = euclid3d.axis_swap((2, 0, 1))
231 |     xy = euclid3d.identity(3)
232 |     yz = euclid3d.axis_swap((1, 2, 0))
233 |     proj_zx = proj @ zx
234 |     proj_xy = proj @ xy
235 |     proj_yz = proj @ yz
236 | 
237 |     if background:
238 |         d.append(draw.Rectangle(-100, -100, 200, 200, fill=background))
239 | 
240 |     def draw_band(proj, trans, r_outer=1, r_inner=0.9, color='black', z_mul=1,
241 |                   opacity=1, divs=4, d=d, **kwargs):
242 |         color = ((color * divs)[:divs] if isinstance(color, list)
243 |                                        else [color] * divs)
244 |         points = np.array([[-1, -1, 1, 1], [-1, 1, 1, -1]]).T
245 |         sqr12 = 0.5**0.5
246 |         overlap = np.pi/500 * (divs != 4)
247 |         start_end_points = [
248 |             np.array([[np.cos(pr-2*np.pi/divs-overlap),
249 |                        np.sin(pr-2*np.pi/divs-overlap)],
250 |                       [np.cos(pr+overlap),  np.sin(pr+overlap)],
251 |                       [np.cos(pr-np.pi/divs), np.sin(pr-np.pi/divs)]])
252 |             for pr in np.linspace(0, 2*np.pi, num=divs, endpoint=False)
253 |         ]
254 |         for i in range(divs):
255 |             p = draw.Path(fill=color[i], stroke='none', stroke_width=0.002,
256 |                           **kwargs, opacity=opacity)
257 |             z = trans.project_point(
258 |                 (r_inner+r_outer)/2*start_end_points[i][2])[2]
259 |             e = shapes.EllipseArc.from_bounding_quad(
260 |                 *proj.project_list(points*r_outer)[:, :2].flatten(),
261 |                 *proj.project_list(start_end_points[i]*r_outer
262 |                                   )[:, :2].flatten(),
263 |             )
264 |             if e: e.draw_to_path(p)
265 |             if r_inner > 0:
266 |                 e = shapes.EllipseArc.from_bounding_quad(
267 |                     *proj.project_list(points*r_inner)[:, :2].flatten(),
268 |                     *proj.project_list(start_end_points[i]*r_inner
269 |                                       )[:, :2].flatten(),
270 |                 )
271 |                 if e:
272 |                     e.reversed().draw_to_path(p, include_l=True)
273 |             p.Z()
274 |             d.append(p, z=z*z_mul)
275 |             if False:
276 |                 d.draw(shapes.EllipseArc.from_bounding_quad(
277 |                     *proj.project_list((r_outer+r_inner)/2*points
278 |                                       )[:, :2].flatten(),
279 |                     *proj.project_list((r_outer+r_inner)/2*start_end_points[i]
280 |                                       )[:, :2].flatten(),
281 |                 ), fill='none', stroke_width=0.02, stroke=color[i], **kwargs,
282 |                 z=z*z_mul)
283 | 
284 |     xycolors = ['#56e', '#239', '#56e', '#56e']
285 |     yzcolors = ['#e1e144', '#909022', '#e1e144', '#e1e144']
286 |     zxcolors = ['#9e2', '#6a1', '#9e2', '#9e2']
287 | 
288 |     draw_band(proj_xy, trans@xy, 1, 0.925, z_mul=10, color=xycolors)
289 |     draw_band(proj_yz, trans@yz, 1, 0.925, z_mul=10, color=yzcolors)
290 |     draw_band(proj_zx, trans@zx, 1, 0.925, z_mul=10, color=zxcolors)
291 | 
292 |     # Inner
293 |     g = draw.Group(opacity=inner_opacity)
294 |     z_center = trans.project_point((0,0,0))[2]
295 |     d.append(g, z=z_center)
296 |     inner_xy = proj@inner_proj@xy
297 | 
298 |     if style == 'arrows':
299 |         # Draw arrowed axis. (Positive half only)
300 |         arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=4, orient='auto')
301 |         arrow.append(draw.Lines(-0.1, -0.5, -0.1, 0.5, 0.9, 0, fill='#9e2',
302 |                                 close=True))
303 |         g.append(draw.Line(*inner_xy.p2(0, 0, 0), *inner_xy.p2(0.6, 0, 0),
304 |                         stroke='#9e2', stroke_width=0.035, marker_end=arrow),
305 |                 z=z_center)
306 |         arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=4, orient='auto')
307 |         arrow.append(draw.Lines(-0.1, -0.5, -0.1, 0.5, 0.9, 0, fill='#e1e144',
308 |                                 close=True))
309 |         g.append(draw.Line(*inner_xy.p2(0, 0, 0), *inner_xy.p2(0, 0.6, 0),
310 |                         stroke='#e1e144', stroke_width=0.035, marker_end=arrow),
311 |                 z=z_center)
312 |         arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=4, orient='auto')
313 |         arrow.append(draw.Lines(-0.1, -0.5, -0.1, 0.5, 0.9, 0, fill='#56e',
314 |                                 close=True))
315 |         g.append(draw.Line(*inner_xy.p2(0, 0, 0), *inner_xy.p2(0, 0, 0.6),
316 |                         stroke='#56e', stroke_width=0.035, marker_end=arrow),
317 |                 z=z_center)
318 |     else:
319 |         # Draw inner bands
320 |         # Darker colors: #34b, #a8a833, #7b2
321 |         draw_band(proj@inner_proj@xy, trans@inner_proj@xy, 0.8, 0.7,
322 |                   color=xycolors, d=g)
323 |         draw_band(proj@inner_proj@yz, trans@inner_proj@yz, 0.8, 0.7,
324 |                   color=yzcolors, divs=4, d=g)
325 |         draw_band(proj@inner_proj@zx, trans@inner_proj@zx, 0.8, 0.7,
326 |                   color=zxcolors, divs=8//2, d=g)
327 |         arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=4, orient='auto')
328 |         arrow.append(draw.Lines(-0.1, -0.5, -0.1, 0.5, 0.9, 0, fill='black',
329 |                                 close=True))
330 |         g.append(draw.Line(*inner_xy.p2(-0.65, 0, 0), *inner_xy.p2(0.6, 0, 0),
331 |                            stroke='black', stroke_width=0.015,
332 |                            marker_end=arrow),
333 |                 z=z_center)
334 |         g.append(draw.Line(*inner_xy.p2(0, -0.65, 0), *inner_xy.p2(0, 0.6, 0),
335 |                            stroke='black', stroke_width=0.015,
336 |                            marker_end=arrow),
337 |                 z=z_center)
338 |         g.append(draw.Line(*inner_xy.p2(0, 0, -0.65), *inner_xy.p2(0, 0, 0.6),
339 |                            stroke='black', stroke_width=0.015,
340 |                            marker_end=arrow),
341 |                 z=z_center)
342 |         for pt, (x_off, y_off), elem in inner_labels:
343 |             x, y = (proj@inner_proj).p2(*pt)
344 |             g.append(draw.Use(elem, x+x_off, y+y_off), z=10000)
345 | 
346 |     elevation_lines = False
347 |     if elevation_lines:
348 |         for elevation in (*np.linspace(0, np.pi/2, 4, True)[1:-1],
349 |                           *np.linspace(-np.pi/2, 0, 3, False)[1:]):
350 |             y = 0.75 * np.sin(elevation)
351 |             r = 0.75 * np.cos(elevation)
352 |             draw_band(proj@inner_proj@xy @ euclid3d.translation((0, 0, y)),
353 |                       trans@inner_proj@xy @ euclid3d.translation((0, 0, y)),
354 |                       r_outer=r-0.01, r_inner=r+0.01, color='#bbb', opacity=1,
355 |                       d=g)
356 | 
357 |     # Outer arrows and text
358 |     arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=4, orient='auto')
359 |     arrow.append(draw.Lines(-0.1, 0.5, -0.1, -0.5, 0.9, 0, fill='black',
360 |                             close=True))
361 |     d.append(draw.Line(*proj_xy.p2(1, 0, 0), *proj_xy.p2(1.2, 0, 0),
362 |                        stroke='black', stroke_width=0.02, marker_end=arrow),
363 |                        z=100)
364 |     d.append(draw.Line(*proj_xy.p2(0, 1, 0), *proj_xy.p2(0, 1.2, 0),
365 |                        stroke='black', stroke_width=0.02, marker_end=arrow),
366 |                        z=100)
367 |     d.append(draw.Line(*proj_xy.p2(0, 0, 1), *proj_xy.p2(0, 0, 1.2),
368 |                        stroke='black', stroke_width=0.02, marker_end=arrow),
369 |                        z=100)
370 |     d.append(draw.Line(*proj_xy.p2(-1, 0, 0), *proj_xy.p2(-1.2, 0, 0),
371 |                        stroke='black', stroke_width=0.02))
372 |     d.append(draw.Line(*proj_xy.p2(0, -1, 0), *proj_xy.p2(0, -1.2, 0),
373 |                        stroke='black', stroke_width=0.02))
374 |     d.append(draw.Line(*proj_xy.p2(0, 0, -1), *proj_xy.p2(0, 0, -1.2),
375 |                        stroke='black', stroke_width=0.02))
376 |     d.append(draw.Text(['X'], 0.2, *proj_xy.p2(1.7, 0, 0), center=True,
377 |                        fill='black'), z=100)
378 |     d.append(draw.Text(['Y'], 0.2, *proj_xy.p2(0, 1.35, 0), center=True,
379 |                        fill='black'), z=100)
380 |     d.append(draw.Text(['Z'], 0.2, *proj_xy.p2(0, 0, 1.4), center=True,
381 |                        fill='black'), z=100)
382 |     for pt, (x_off, y_off), elem in outer_labels:
383 |         x, y = proj.p2(*pt)
384 |         d.append(draw.Use(elem, x+x_off, y-y_off), z=10000)
385 | 
386 |     # Extra annotations
387 |     if label:
388 |         d.append(draw.Text([label], 0.4, -0.6, -1.2, center=True, fill='#c00',
389 |                            text_anchor='end',
390 |                            opacity=extra_opacity))
391 |     if axis:
392 |         g = draw.Group(opacity=extra_opacity)
393 |         axis = np.array(axis, dtype=float)
394 |         axis_len = 1.18
395 |         axis /= np.linalg.norm(axis)
396 |         arrow = draw.Marker(-0.1, -0.5, 0.9, 0.5, scale=3, orient='auto')
397 |         arrow.append(draw.Lines(-0.1, 0.5, -0.1, -0.5, 0.9, 0, fill='#e00',
398 |                                 close=True))
399 |         z = 100
400 |         g.append(draw.Line(*proj_xy.p2(0, 0, 0), *proj_xy.p2(*axis*axis_len),
401 |                            stroke='#e00', stroke_width=0.04, marker_end=arrow))
402 |         d.append(g, z=z)
403 | 
404 |     if rot_proj is not None:
405 |         rot_proj =  inner_proj @ rot_proj
406 |         r_inner, r_outer = 0.1, 0.16
407 |         points = np.array([[-1, -1, 1, 1], [-1, 1, 1, -1]]).T
408 |         start_end_points = np.array([[1, 0], [-1, 0], [0, 1]])
409 |         p = draw.Path(fill='orange', fill_rule='nonzero', opacity=extra_opacity)
410 |         z = 9 * (trans@rot_proj).project_point(start_end_points[2])[2]
411 |         e = shapes.EllipseArc.from_bounding_quad(
412 |             *(proj@rot_proj).project_list(points*r_outer)[:, :2].flatten(),
413 |             *(proj@rot_proj).project_list(start_end_points*r_outer
414 |                                          )[:, :2].flatten(),
415 |         )
416 |         if e: e.reversed().draw_to_path(p)
417 |         e = shapes.EllipseArc.from_bounding_quad(
418 |             *(proj@rot_proj).project_list(points*r_inner)[:, :2].flatten(),
419 |             *(proj@rot_proj).project_list(start_end_points*r_inner
420 |                                          )[:, :2].flatten(),
421 |         )
422 |         if e:
423 |             e.draw_to_path(p, include_l=True)
424 |         sa = 2.5 * (r_outer-r_inner)
425 |         xa = -(r_inner+r_outer)/2
426 |         p.L(*(proj@rot_proj).p2(xa, 0.3*sa))
427 |         p.L(*(proj@rot_proj).p2(xa+0.5*sa, 0.3*sa))
428 |         p.L(*(proj@rot_proj).p2(xa, -0.7*sa))
429 |         p.L(*(proj@rot_proj).p2(xa-0.5*sa, 0.3*sa))
430 |         p.L(*(proj@rot_proj).p2(xa, 0.3*sa))
431 |         p.Z()
432 |         d.append(p, z=z)
433 | 
434 |     return d
435 | 
436 | 
437 | def main(name, gates, mp4=False, fps=20, preview=False, style='sphere'):
438 |     save = 'mp4' if mp4 else 'gif'
439 |     @do_or_save_animation(name, save=save, fps=fps, preview=preview,
440 |                           style=style)
441 |     def animate(state):
442 |         state.apply_gate_list(gates)
443 |     print(f'Saved "{name}.{save}" with gate sequence "{"".join(gates)}"')
444 | 
445 | def run_from_command_line():
446 |     parser = argparse.ArgumentParser(
447 |         description='Renders animations of the Bloch sphere for a sequence of '
448 |                     'single-qubit gates.')
449 |     parser.add_argument('name', type=str, help=
450 |         'The file name to save (excluding file extension)')
451 |     parser.add_argument('gate', type=str, nargs='+', help=
452 |         'List of gates to apply (e.g. h x wait inv_sqrt_y ...)')
453 |     parser.add_argument('--mp4', action='store_true', help=
454 |         'Save an mp4 video instead of a GIF')
455 |     parser.add_argument('--fps', type=float, default=20, help=
456 |         'Sets the animation frame rate')
457 |     parser.add_argument('--style', type=str, choices=['sphere', 'arrows'],
458 |         default='sphere', help='The style to draw the Bloch sphere. E.g. '
459 |         'draw the whole sphere or just draw the axis arrows.')
460 |     args = parser.parse_args()
461 |     main(name=args.name, gates=args.gate, mp4=args.mp4, fps=args.fps,
462 |          style=args.style)
463 | 
464 | if __name__ == '__main__':
465 |     run_from_command_line()
466 | 


--------------------------------------------------------------------------------
/bloch_sphere/animate_bloch_compare.py:
--------------------------------------------------------------------------------
  1 | 
  2 | import argparse
  3 | 
  4 | import drawsvg as draw
  5 | import latextools
  6 | 
  7 | from bloch_sphere import animate_bloch
  8 | 
  9 | 
 10 | def render_animation(name, func1, func2, circuit_qcircuit='', equation_latex='',
 11 |                      save=False, fps=20, preview=True, style='sphere',
 12 |                      **kwargs):
 13 |     with draw.frame_animation.FrameAnimationContext(
 14 |             animate_bloch.draw_frame, jupyter=preview, delay=0) as anim:
 15 |         state = animate_bloch.AnimState(
 16 |                 anim, fps=fps, draw_args={"style": style})
 17 |         func1(state)
 18 |     frames1 = anim.frames
 19 | 
 20 |     with draw.frame_animation.FrameAnimationContext(
 21 |             animate_bloch.draw_frame, jupyter=preview, delay=0) as anim:
 22 |         state = animate_bloch.AnimState(
 23 |                 anim, fps=fps, draw_args={"style": style})
 24 |         func2(state)
 25 |     frames2 = anim.frames
 26 | 
 27 |     g = draw.Group()
 28 |     # Equals sign
 29 |     g.append(draw.Rectangle(-0.4, -0.15, 0.8, 0.075, fill='#000'))
 30 |     g.append(draw.Rectangle(-0.4, 0.075, 0.8, 0.075, fill='#000'))
 31 |     if circuit_qcircuit:
 32 |         circuit_elem = latextools.render_qcircuit(circuit_qcircuit).as_svg()
 33 |         g.draw(circuit_elem, x=0, y=-2, center=True, scale=0.04)
 34 |     if equation_latex:
 35 |         equation_elem = latextools.render_snippet(
 36 |             equation_latex, latextools.pkg.qcircuit).as_svg()
 37 |         g.draw(equation_elem, x=0, y=0.8, center=True, scale=0.03)
 38 |     extra_elements = (g,)
 39 | 
 40 |     save_side_by_side(name, frames1, frames2, extra_elements=extra_elements,
 41 |                       save=save, fps=fps, preview=preview, **kwargs)
 42 | 
 43 | def zip_pad(*iterables):
 44 |     '''Same as the builtin zip but pads shorter iterables with their last
 45 |     value.'''
 46 |     iters = tuple(iter(iterable) for iterable in iterables)
 47 |     last_values = [None] * len(iters)
 48 |     def try_next(i, it):
 49 |         nonlocal end_counter
 50 |         try:
 51 |             val = next(it)
 52 |         except StopIteration:
 53 |             end_counter += 1
 54 |             return last_values[i]
 55 |         last_values[i] = val
 56 |         return val
 57 |     while True:
 58 |         end_counter = 0
 59 |         values = tuple(try_next(i, it) for i, it in enumerate(iters))
 60 |         if end_counter >= len(iters):
 61 |             return
 62 |         yield values
 63 | 
 64 | def save_side_by_side(name: str, frames1, frames2, extra_elements=(),
 65 |                       save=False, fps=20, preview=True, **kwargs):
 66 |     with draw.frame_animation.FrameAnimationContext(
 67 |             draw_whole_frame, jupyter=not save or preview,
 68 |             delay=0 if save else 1/fps) as anim:
 69 |         for f1, f2 in zip_pad(frames1, frames2):
 70 |             anim.draw_frame(f1, f2, background='white',
 71 |                             extra_elements=extra_elements, **kwargs)
 72 |     if save == 'mp4':
 73 |         anim.save_video(f'{name}.mp4', fps=fps)
 74 |     elif save == 'gif' or save is True:
 75 |         anim.save_video(f'{name}.gif', duration=1/fps)
 76 | 
 77 | def draw_whole_frame(f1, f2, background='white', w=624*2, h=None,
 78 |                      extra_elements=()):
 79 |     d = draw.Drawing(10, 4, origin=(-5, -2.5))
 80 |     d.set_render_size(w=w, h=h)
 81 |     if background:
 82 |         d.append(draw.Rectangle(-100, -100, 200, 200, fill=background))
 83 | 
 84 |     d.append(draw.Group([f1.elements[-1]], transform='translate(-2.5)'))
 85 |     d.append(draw.Group([f2.elements[-1]], transform='translate(2.5)'))
 86 | 
 87 |     d.extend(extra_elements)
 88 |     return d
 89 | 
 90 | def main(name, gates1, gates2, circuit_qcircuit='', equation_latex='',
 91 |          mp4=False, fps=20, preview=False, style='sphere'):
 92 |     save = 'mp4' if mp4 else 'gif'
 93 |     def func1(state):
 94 |         state.sphere_fade_in()
 95 |         state.apply_gate_list(gates1, final_wait=False)
 96 |         state.wait()
 97 |         for _ in gates2:
 98 |             state.i_gate()
 99 |         state.wait()
100 |         state.wait()
101 |         state.sphere_fade_out()
102 |         state.wait()
103 |     def func2(state):
104 |         state.sphere_fade_in()
105 |         for _ in gates1:
106 |             state.i_gate()
107 |         state.wait()
108 |         state.apply_gate_list(gates2, final_wait=False)
109 |         state.wait()
110 |         state.wait()
111 |         state.sphere_fade_out()
112 |         state.wait()
113 |     render_animation(name, func1, func2, circuit_qcircuit, equation_latex,
114 |                      save=save, fps=fps, preview=preview, style=style)
115 |     print(f'Saved "{name}.{save}"')
116 | 
117 | def run_from_command_line():
118 |     parser = argparse.ArgumentParser(
119 |         description='Renders animations of the Bloch sphere for a sequence of '
120 |                     'single-qubit gates.')
121 |     parser.add_argument('name', type=str, help=
122 |         'The file name to save (excluding file extension)')
123 |     parser.add_argument('gates1', type=str, help=
124 |         'List of gates to apply on the left (e.g. h,x,wait,inv_sqrt_y,...)')
125 |     parser.add_argument('gates2', type=str, help=
126 |         'List of gates to apply on the right (e.g. h,x,wait,inv_sqrt_y,...)')
127 |     parser.add_argument('--circuit', type=str, help=
128 |         r'Latex code for a qcircuit digram (e.g. \'& \gate{Y} & \gate{Z} & \qw '
129 |         r'& \push{=} & & \gate{X} & \qw\'')
130 |     parser.add_argument('--equation', type=str, help=
131 |         r'Latex code for an equation (e.g. \'$ZY\ket{\psi}=X\ket{\psi}$\'')
132 |     parser.add_argument('--mp4', action='store_true', help=
133 |         'Save an mp4 video instead of a GIF')
134 |     parser.add_argument('--fps', type=float, default=20, help=
135 |         'Sets the animation frame rate')
136 |     parser.add_argument('--style', type=str, choices=['sphere', 'arrows'],
137 |         default='sphere', help='The style to draw the Bloch sphere. E.g. '
138 |         'draw the whole sphere or just draw the axis arrows.')
139 |     args = parser.parse_args()
140 |     main(name=args.name, gates1=args.gates1.split(','),
141 |          gates2=args.gates2.split(','),
142 |          circuit_qcircuit=args.circuit, equation_latex=args.equation,
143 |          mp4=args.mp4, fps=args.fps, style=args.arrow_style)
144 | 
145 | if __name__ == '__main__':
146 |     run_from_command_line()
147 | 


--------------------------------------------------------------------------------
/examples/common_gates.md:
--------------------------------------------------------------------------------
 1 | # Bloch Sphere Visualizations for some Common Quantum Gates
 2 | 
 3 | ### X gate (classical NOT bit flip)
 4 | 
 5 | ![X gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/xx_gate.gif)
 6 | 
 7 | ### Z gate (quantum phase flip)
 8 | 
 9 | ![Z gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/zz_gate.gif)
10 | 
11 | ### Y gate (bit and phase flip)
12 | 
13 | ![Y gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/yy_gate.gif)
14 | 
15 | ### Hadamard gate (Z/X axis swap)
16 | 
17 | ![Hadamard gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/hh_gate.gif)
18 | 
19 | ### 1/2-X gate (square root of NOT)
20 | 
21 | ![Half-X gate](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/sqrt_xxxx_gate.gif)
22 | 
23 | ### S and T gates (1/2-Z and 1/4-Z)
24 | 
25 | ![S and T gates](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/ststs_gate.gif)
26 | 
27 | ### Y gate (bit flip with phase)
28 | 
29 | ![Y gate comparison with XZ](https://raw.githubusercontent.com/cduck/bloch_sphere/master/examples/xz_y_compare.gif)
30 | 


--------------------------------------------------------------------------------
/examples/hh_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/hh_gate.gif


--------------------------------------------------------------------------------
/examples/hzh_x_compare.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/hzh_x_compare.gif


--------------------------------------------------------------------------------
/examples/random_as_zxz.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/random_as_zxz.gif


--------------------------------------------------------------------------------
/examples/random_as_zxzxz.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/random_as_zxzxz.gif


--------------------------------------------------------------------------------
/examples/render_examples.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | import drawsvg as draw
  4 | import latextools
  5 | from bloch_sphere.animate_bloch import do_or_save_animation, AnimState
  6 | from bloch_sphere.animate_bloch_compare import render_animation
  7 | 
  8 | 
  9 | # Add some extra labels
 10 | zero_ket = draw.Group()
 11 | zero_ket.draw(latextools.render_snippet('$\ket{0}$', latextools.pkg.qcircuit),
 12 |               x=0, y=0, center=True, scale=0.015)
 13 | one_ket = draw.Group()
 14 | one_ket.draw(latextools.render_snippet('$\ket{1}$', latextools.pkg.qcircuit),
 15 |              x=0, y=0, center=True, scale=0.015)
 16 | zero_ket_inner = draw.Use(zero_ket, 0, 0, transform='scale(0.75)')
 17 | one_ket_inner = draw.Use(one_ket, 0, 0, transform='scale(0.75)')
 18 | 
 19 | w = 624*2  # Output width
 20 | fps = 20
 21 | draw_args = dict(
 22 |     w = w/2,
 23 |     outer_labels=[
 24 |         [(0, 0, 1), (-0.15, 0.13), zero_ket],
 25 |         [(0, 0, -1), (0.15, -0.13), one_ket],
 26 |     ],
 27 |     inner_labels=[
 28 |         [(0, 0, 0.8), (0, 0), zero_ket_inner],
 29 |         [(0, 0, -0.8), (0, 0), one_ket_inner],
 30 |     ],
 31 | )
 32 | 
 33 | def gate_sequence(gates, compared_to_gates=None, first_sequence=True,
 34 |                   show_inner_labels=True):
 35 |     if isinstance(gates, str):
 36 |         gates = gates.split(',')
 37 |     gates = tuple(gates)
 38 |     if compared_to_gates is not None:
 39 |         if isinstance(compared_to_gates, str):
 40 |             compared_to_gates = compared_to_gates.split(',')
 41 |         compared_to_gates = tuple(compared_to_gates)
 42 | 
 43 |     def regular_func(state):
 44 |         state.draw_args = dict(draw_args, **state.draw_args)
 45 |         if not show_inner_labels:
 46 |             state.draw_args['inner_labels'] = []
 47 |         state.apply_gate_list(gates)
 48 | 
 49 |     def comparison_func(state):
 50 |         state.draw_args = dict(draw_args, **state.draw_args)
 51 |         if not show_inner_labels:
 52 |             state.draw_args['inner_labels'] = []
 53 |         state.sphere_fade_in()
 54 |         if first_sequence:
 55 |             state.apply_gate_list(gates, final_wait=False)
 56 |             state.wait()
 57 |         for _ in compared_to_gates:
 58 |             state.i_gate()
 59 |         state.wait()
 60 |         if not first_sequence:
 61 |             state.apply_gate_list(gates, final_wait=False)
 62 |             state.wait()
 63 |         state.wait()
 64 |         state.sphere_fade_out()
 65 |         state.wait()
 66 | 
 67 |     if compared_to_gates is not None:
 68 |         return comparison_func
 69 |     return regular_func
 70 | 
 71 | 
 72 | print('Rendering hzh_x_compare')
 73 | #$ animate_bloch2 hzh_x_compare h,z,h x --circuit '& \gate{H} & \gate{Z} & \gate{H} & \qw & \push{=} & & \gate{X} & \qw' --equation '$HZH\ket{\psi}=X\ket{\psi}$'
 74 | render_animation('hzh_x_compare',
 75 |                  gate_sequence('h,z,h', 'x', True, False),
 76 |                  gate_sequence('x', 'h,z,h', False, False),
 77 |                  r'& \gate{H} & \gate{Z} & \gate{H} & \qw & \push{=} & & \gate{X} & \qw',
 78 |                  r'$HZH\ket{\psi}=X\ket{\psi}$',
 79 |                  save='gif',  # False, 'gif', or 'mp4'
 80 |                  preview=False,
 81 |                  fps=fps,
 82 |                  w=w)
 83 | 
 84 | print('Rendering ry_gate_arrows')
 85 | #$ animate_bloch ry_gate_arrows --style arrows ry,0.666667 ry,0.666667 ry,0.666667
 86 | do_or_save_animation('ry_gate_arrows', save='gif', fps=fps, preview=False,
 87 |                      style='arrows'
 88 |         )(gate_sequence('ry;0.666667,ry;0.666667,ry;0.666667'))
 89 | 
 90 | print('Rendering xyss_gate')
 91 | #$ animate_bloch xyss_gate x y s s
 92 | do_or_save_animation('xyss_gate', save='gif', fps=fps, preview=False
 93 |         )(gate_sequence('x,y,s,s'))
 94 | 
 95 | print('Rendering xx_gate')
 96 | #$ #animate_bloch xx_gate x x
 97 | do_or_save_animation('xx_gate', save='gif', fps=fps, preview=False
 98 |         )(gate_sequence('x,x'))
 99 | 
100 | print('Rendering yy_gate')
101 | #$ #animate_bloch yy_gate y y
102 | do_or_save_animation('yy_gate', save='gif', fps=fps, preview=False
103 |         )(gate_sequence('y,y'))
104 | 
105 | print('Rendering zz_gate')
106 | #$ animate_bloch zz_gate z z
107 | do_or_save_animation('zz_gate', save='gif', fps=fps, preview=False
108 |         )(gate_sequence('z,z'))
109 | 
110 | print('Rendering hh_gate')
111 | #$ animate_bloch hh_gate h h
112 | do_or_save_animation('hh_gate', save='gif', fps=fps, preview=False
113 |         )(gate_sequence('h,h'))
114 | 
115 | print('Rendering sqrt_xxxx_gate')
116 | #$ animate_bloch sqrt_xxxx_gate sqrt_x sqrt_x sqrt_x sqrt_x
117 | do_or_save_animation('sqrt_xxxx_gate', save='gif', fps=fps, preview=False
118 |         )(gate_sequence('sqrt_x,sqrt_x,sqrt_x,sqrt_x'))
119 | 
120 | print('Rendering ststs_gate')
121 | #$ animate_bloch ststs_gate s t s t s
122 | do_or_save_animation('ststs_gate', save='gif', fps=fps, preview=False
123 |         )(gate_sequence('s,t,s,t,s'))
124 | 
125 | print('Rendering xz_y_compare')
126 | #$ animate_bloch2 xz_y_compare x,z y --circuit '& \gate{X} & \gate{Z} & \qw & \push{=} & & \gate{Y} & \qw' --equation '$ZX\ket{\psi}=Y\ket{\psi}$'
127 | render_animation('xz_y_compare',
128 |                  gate_sequence('x,z', 'y', True, False),
129 |                  gate_sequence('y', 'x,z', False, False),
130 |                  r'& \gate{X} & \gate{Z} & \qw & \push{=} & & \gate{Y} & \qw',
131 |                  r'$ZX\ket{\psi}=Y\ket{\psi}$',
132 |                  save='gif',  # False, 'gif', or 'mp4'
133 |                  preview=False,
134 |                  fps=fps,
135 |                  w=w)
136 | 
137 | print()
138 | print('Please compress the rendered GIFs with https://gifcompressor.com/')
139 | 


--------------------------------------------------------------------------------
/examples/ry_gate_arrows.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/ry_gate_arrows.gif


--------------------------------------------------------------------------------
/examples/sqrt_xxxx_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/sqrt_xxxx_gate.gif


--------------------------------------------------------------------------------
/examples/ststs_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/ststs_gate.gif


--------------------------------------------------------------------------------
/examples/synthesize_from_rz_rx_rz.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | try:
  4 |     import numpy as np
  5 |     import scipy as sp
  6 |     from scipy.stats import unitary_group
  7 |     import cirq
  8 | except ImportError:
  9 |     print('Install extra dependencies:')
 10 |     print('    python3 -m pip install scipy "cirq~=0.10.0"')
 11 |     print()
 12 |     raise
 13 | from bloch_sphere.animate_bloch_compare import main
 14 | 
 15 | # Random unitary gate
 16 | seed = 18
 17 | u = unitary_group.rvs(2, random_state=seed)
 18 | 
 19 | # Compute Bloch rotation axis and angle
 20 | axis_angle = cirq.linalg.axis_angle(u)
 21 | print('Axis angle:', axis_angle)
 22 | #      Axis angle: 0.366*π around -0.233*X+0.831*Y-0.505*Z
 23 | 
 24 | # Decompose into Rz, Ry, Rz
 25 | angles = np.array(
 26 |     cirq.linalg.deconstruct_single_qubit_matrix_into_angles(u))
 27 | # Convert to Rz, Rx, Rz
 28 | angles[0] -= np.pi/2
 29 | angles[2] += np.pi/2
 30 | print('Rz, Rx, Rz angles (radians):', angles)
 31 | #      Rz, Rx, Rz angles (radians): [4.12326921 0.97622252 1.52745046]
 32 | 
 33 | # Show the circuit
 34 | q = cirq.LineQubit(0)
 35 | circuit = cirq.Circuit(
 36 |     cirq.rz(angles[0])(q),
 37 |     cirq.rx(angles[1])(q),
 38 |     cirq.rz(angles[2])(q),
 39 | )
 40 | print(circuit)
 41 | #     0: ───Rz(1.31π)───Rx(0.311π)───Rz(0.486π)───
 42 | 
 43 | # Check circuit
 44 | assert cirq.equal_up_to_global_phase(u, cirq.unitary(circuit))
 45 | 
 46 | # Generate animation
 47 | main('random_as_zxz',
 48 |      # Left gate
 49 |      [f'custom;{axis_angle.axis[0]};{axis_angle.axis[1]};'
 50 |       f'{axis_angle.axis[2]};{axis_angle.angle/np.pi};Random'],
 51 |      # Right gates
 52 |      [f'custom;0;0;1;{angles[0]/np.pi};Rz({angles[0]/np.pi:.3f}π)',
 53 |       f'custom;1;0;0;{angles[1]/np.pi};Rx({angles[1]/np.pi:.3f}π)',
 54 |       f'custom;0;0;1;{angles[2]/np.pi};Rz({angles[2]/np.pi:.3f}π)'],
 55 |      # Circuit diagram
 56 |      r'& \gate{U} & \qw & \push{=} & & \gate{R_Z} & \gate{R_X} & \gate{R_Z} & '
 57 |      r'\qw',
 58 |      # Circuit equation
 59 |      #r'$U\ket{\psi}=R_Z R_X R_Z\ket{\psi}$',
 60 |      mp4=False,
 61 |      fps=20,
 62 |      preview=False,
 63 | )
 64 | 
 65 | 
 66 | ################################################################################
 67 | ### Now synthesize an alternative with only parameterized Rz gates and fixed Rx
 68 | ### Rz, Rx(π/2), Rz, Rx(π/2), Rz
 69 | 
 70 | z_angles = angles.copy()
 71 | # Convert back to Rz, Ry, Rz
 72 | z_angles[0] += np.pi/2
 73 | z_angles[2] -= np.pi/2
 74 | # Turn the Ry into Rx(π/2), Rz, Rx(π/2)
 75 | z_angles[0] += np.pi
 76 | z_angles[1] = np.pi - z_angles[1]
 77 | # Restrict angles to [-pi, +pi)
 78 | z_angles = (z_angles + np.pi) % (2*np.pi) - np.pi
 79 | 
 80 | # Show the circuit
 81 | q = cirq.LineQubit(0)
 82 | z_circuit = cirq.Circuit(
 83 |     cirq.rz(z_angles[0])(q),
 84 |     cirq.rx(np.pi/2)(q),
 85 |     cirq.rz(z_angles[1])(q),
 86 |     cirq.rx(np.pi/2)(q),
 87 |     cirq.rz(z_angles[2])(q),
 88 | )
 89 | print(z_circuit)
 90 | #     0: ───Rz(-0.371π)───Rx(0.5π)───Rz(0.265π)───Rx(0.5π)───Rz(0.099π)───
 91 | 
 92 | # Check circuit
 93 | assert cirq.equal_up_to_global_phase(u, cirq.unitary(z_circuit))
 94 | 
 95 | # Generate animation
 96 | main('random_as_zxzxz',
 97 |      # Left gate
 98 |      [f'custom;{axis_angle.axis[0]};{axis_angle.axis[1]};'
 99 |       f'{axis_angle.axis[2]};{axis_angle.angle/np.pi};Random'],
100 |      # Right gates
101 |      [f'custom;0;0;1;{z_angles[0]/np.pi};Rz({z_angles[0]/np.pi:.3f}π)',
102 |       f'custom;1;0;0;0.5;Rx(π/2)',
103 |       f'custom;0;0;1;{z_angles[1]/np.pi};Rz({z_angles[1]/np.pi:.3f}π)',
104 |       f'custom;1;0;0;0.5;Rx(π/2)',
105 |       f'custom;0;0;1;{z_angles[2]/np.pi};Rz({z_angles[2]/np.pi:.3f}π)'],
106 |      # Circuit diagram
107 |      r'& \gate{U} & \qw & \push{=} & & \gate{R_Z} & \gate{\sqrt{X}} & \gate{R_Z} & \gate{\sqrt{X}} & \gate{R_Z} & '
108 |      r'\qw',
109 |      # Circuit equation
110 |      #r'$U\ket{\psi}=R_Z R_X R_Z\ket{\psi}$',
111 |      mp4=False,
112 |      fps=20,
113 |      preview=False,
114 | )
115 | 


--------------------------------------------------------------------------------
/examples/xx_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/xx_gate.gif


--------------------------------------------------------------------------------
/examples/xyss_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/xyss_gate.gif


--------------------------------------------------------------------------------
/examples/xz_y_compare.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/xz_y_compare.gif


--------------------------------------------------------------------------------
/examples/yy_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/yy_gate.gif


--------------------------------------------------------------------------------
/examples/zz_gate.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cduck/bloch_sphere/93bafb97f813949f50df9466ce1b3e927f2eed75/examples/zz_gate.gif


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | import logging
 3 | logger = logging.getLogger(__name__)
 4 | 
 5 | name = 'bloch_sphere'
 6 | package_name = 'bloch_sphere'
 7 | version = '0.5.0'
 8 | 
 9 | try:
10 |     with open('README.md', 'r') as f:
11 |         long_desc = f.read()
12 | except:
13 |     logger.warning('Could not open README.md.  long_description will be set to None.')
14 |     long_desc = None
15 | 
16 | setup(
17 |     name = package_name,
18 |     packages = find_packages(),
19 |     entry_points = {
20 |         'console_scripts': [
21 |             'animate_bloch=bloch_sphere.animate_bloch:run_from_command_line',
22 |             'animate_bloch2=bloch_sphere.animate_bloch_compare:run_from_command_line',
23 |         ]},
24 |     version = version,
25 |     description = 'Visualization tools for the qubit Bloch sphere',
26 |     long_description = long_desc,
27 |     long_description_content_type = 'text/markdown',
28 |     author = 'Casey Duckering',
29 |     #author_email = '',
30 |     url = f'https://github.com/cduck/{name}',
31 |     download_url = f'https://github.com/cduck/{name}/archive/{version}.tar.gz',
32 |     keywords = ['quantum computing', 'qubit', 'jupyter'],
33 |     classifiers = [
34 |         'License :: OSI Approved :: MIT License',
35 |         'Development Status :: 3 - Alpha',
36 |         'Programming Language :: Python :: 3',
37 |         'Framework :: IPython',
38 |         'Framework :: Jupyter',
39 |     ],
40 |     install_requires = [
41 |         'numpy',
42 |         'drawSvg~=2.0',
43 |         'hyperbolic~=2.0',
44 |         'latextools~=0.5.0',
45 |     ],
46 | )
47 | 
48 | 


--------------------------------------------------------------------------------