@quantum_jim/

QuantumProgrammingTutorial

Python

No description

fork
loading
Files
  • main.py
  • Engine.py
  • Levels.py
  • License

This Plugin Crashed!

Error: Error: must not create an existing file {"type":"CREATE_FILE","wid":"0.47053716702190473","path":"main.py","file":{"path":"main.py","content":{"asEncoding":{"base64":"#  Created by James Wootton
#  Copyright © 2017 University of Basel. All rights reserved.

import math

def ColouredString (message,colour) :
  #  DESCRIPTION:
  #      Prints in a colour specified by the colour in ["r","b","p"] and then sets what follows back to white

  # first the colour
  coloured_message = ""
  if colour=="r": # red
    coloured_message += "\x1b[1;31m"
  elif colour=="g": # green
    coloured_message += "\x1b[1;32m"
  elif colour=="b": # blue
    coloured_message += "\x1b[1;34m" 
  elif colour=="p": # purple
    coloured_message += "\x1b[1;35m"
  else: # black (which should actually be the default text colour)
    coloured_message += "\x1b[0m"
  
  # then the message
  coloured_message += message

  # and back to black
  coloured_message += "\x1b[0m"
  
  return coloured_message

def  Expect2Prob ( expect ) :
  #  DESCRIPTION:
  #      Converts expectation value to a probability of getting the outcome 1.
  return (1-expect)/2
  
def Expect2Polar ( boxes ) :
  #  DESCRIPTION:
  #      Takes the contents of an X and Z box and turns it into polar coordinates for the Bloch circle.
  #  INPUT:
  #      {String: Float}    boxes       Should have entries for "X" and "Z", which serve as the horizontal and vertical boxes respectively.
  #  OUTPUT:
  #      [Float]            [ degrees, radius ]     degrees is between 0 and 1. It is the angle clockwise from the top as a fraction of 2*Pi. Radius is how far out the point is. Will be 1 for pure states and 0 for maximally mixed.
 
  radius = math.sqrt( boxes["X"]**2 + boxes["Z"]**2)
  degrees = 0 # default value of 0
  if radius>0.0:
    degrees = math.acos( -boxes["Z"] / radius ) / (2*math.pi)
    if boxes["X"]>=0.0:
      degrees = 1 - degrees

    return [ degrees, radius ]

def Polar2Expect ( polar_coords ) :
  #  DESCRIPTION:
  #      As Boxes2Polar, but with inputs and outputs reversed
  boxes = {}
  boxes["X"] = -polar_coords[1] * sin( 2*math.pi*polar_coords[0])
  boxes["Z"] = -polar_coords[1] * cos( 2*math.pi*polar_coords[0])
  return boxes
    
def ExchangeBoxes ( state, box1, box2 ) :
  #  DESCRIPTION:
  #      Given a state and two of its boxes, the values for these boxes are exchanged
  output_state = state
  temp = output_state[box1]
  output_state[box1] = output_state[box2]
  output_state[box2] = temp
  return output_state
    
def ApplyGate ( state, gate, qubit ) :
  #  DESCRIPTION:
  #      Transforms the given state according to the given gate.
  #  INPUT:
  #      {String: Float}    state       Full two qubit state. Needs entries for XI, ZI, IZ, IX, XX, XZ, ZX, ZZ and YY
  #      String              gate        QISKit style str to specify a gate (can be x, z, h, q, qdg, or cz)
  #      Int                 qubit       Qubit on which single qubit gate is applied. Unused for CZ.
  #  OUTPUT:
  #      {String: Float}    state       Transformed version of input state.
  
  # We begin constructing the output state by copying the input state.
  output_state = state
  
  # Single qubit gates require special treatment, so we deal with these separately.
  if gate in ["x","z","h","q","qdg"] :
    # Single qubit gates act on pairs of boxes. These are the pairs that form Bloch circles.
    # For qubit 0, these pairs are  (XI, ZI), (XX,ZX) and (XZ,ZZ).
    # For qubit 2 they are (IX, IZ), (XX,XZ) and (ZX,ZZ).
    # Here we loop over and construct the three pairs, which in each case will be (p[0],p[1]).
    for rc in ["I","X","Z"] :
            
      box_name = {"X":rc,"Z":rc}
      for p in ["X","Z"] :
        if qubit=="0" :
          box_name[p] = p + box_name[p]
        else :
          box_name[p] = box_name[p] + p
          
      
      
      # What we do to the pairs depends on the gate we apply.
      if gate=="x": # invert Z box and invert YY
        output_state[box_name["Z"]] = -output_state[box_name["Z"]]
        output_state["YY"] = -output_state["YY"]
      elif gate=="z" :# invert X box and invert YY
        output_state[box_name["X"]] = -output_state[box_name["X"]]
        output_state["YY"] = -output_state["YY"]
      elif gate=="h" : # exchange X and Z boxes and invert YY
        output_state = ExchangeBoxes( output_state, box_name["X"], box_name["Z"])
        output_state["YY"] = -output_state["YY"]
      elif gate in ["q","qdg"] :
        polar_coords = Expect2Polar( { "X":output_state[box_name["X"]], "Z":output_state[box_name["Z"]] } ) # convert to polar coords
        if gate=="q" : # change angle according to the rotation
          polar_coords[0] += 1/8
        else :
          polar_coords[0] -= 1/8
          
        # convert back to boxes
        output_boxes = Polar2Expect(polar_coords)
        for p in ["X","Z"] :
          output_state[box_name[p]] = output_boxes[p]
      else :
        print("Error: Unknown single qubit gate")

  # Now for the two qubit gates
  elif gate=="cz" :
    # exchange contents of XI and XZ
    output_state = ExchangeBoxes( output_state, "XI", "XZ")
    # exchange contents of IX and ZX
    output_state = ExchangeBoxes( output_state, "IX", "ZX")
    # exchange contents of XX and YY
    output_state = ExchangeBoxes( output_state, "XX", "YY")
  elif gate=="cx" :
    if qubit=="1" :
      # exchange contents of XI and XX
      output_state = ExchangeBoxes( output_state, "XI", "XX")
      # exchange contents of IZ and ZZ
      output_state = ExchangeBoxes( output_state, "IZ", "ZZ")
      # exchange contents of XZ and YY
      output_state = ExchangeBoxes( output_state, "XZ", "YY")
      # invert XZ
      output_state["XZ"] = -output_state["XZ"]
    elif qubit=="0" :
      # exchange contents of ZI and ZZ
      output_state = ExchangeBoxes( output_state, "ZI", "ZZ")
      # exchange contents of IX and XX
      output_state = ExchangeBoxes( output_state, "IX", "XX")
      # exchange contents of ZX and YY
      output_state = ExchangeBoxes( output_state, "ZX", "YY")
      # invert ZX
      output_state["ZX"] = -output_state["ZX"]
      output_state["YY"] = -output_state["YY"] # invert YY
    else :
      print("Error: Unknown gate")
  
  
  return output_state
  
def MakeInitial ( target_state, inverse_solution ) :
  #  DESCRIPTION:
  #      Constructs an initial state such that the target state and solution are as specified by the input
  #      Note that the inverse of the desired solution must be supplied here
  #      Put simply, this means that the first gate should be on the right, and the substition q <-> qdg should be used
    
  state = target_state
  for gate in inverse_solution :
      state = ApplyGate( state, gate[0], gate[1] )
  return state
  
def MakeCell ( cell_state ) :
  #  DESCRIPTION:
  #      Prints a single box or Bloch circle, depending on the input state.
  #  INPUT:
  #      {String: Float}    cell_state  With key "X", value is the expectation value for horizontal red box.
  #                                      Similarly for "Z" and the vertical blue box, and "Y" for a diagonal purple box.
  #                                      Note that a cell that uses "Y" will correspond to XZ or ZZ boxes. Not a Y box.
  #  OUTPUT:
  #      [String]            lines       List of 12 lines, which when printed sequentially will display the cell.
  #  PROCESS:
  #      When a single key is supplied, the corresponding box is printed.
  #      When both "X" and "Z" are supplied, the boxes are combined into a Bloch circle.
  #      In all cases, the level on the box is first converted from the expectation value to the probability.
  
  reso = {"X":17, "Z":9, "Y":13} # number of characters used for each type of box (including center)

  bottom = "───────────────────────" # bottom border
  right = "|" # right border

  # The 8 points around the circle and one in the middle. Default to a dot
  c = []
  c.append("˙")
  c.append(".")
  c.append("·")
  c.append("˙")
  c.append(".")
  c.append("˙")
  c.append("·")
  c.append(".")
  c.append(" ")
  
  # When a Bloch sphere is displayed, the point corresponding to the state is denoted by "*"
  # This is displayed only for pretty mixed states (radius <0.25) and pretty pure ones (radius>0.75)
  if ( "X" in cell_state.keys() and "Z" in cell_state.keys() ) : # both X  and Z boxes need to be present in the cell
    if ( Expect2Polar( cell_state )[1]<0.25 ) : # if state is pretty mixed, point is shown in the center
      c[8] = "*"
    elif Expect2Polar( cell_state )[1]>0.75 : # if state is pretty pure, it is one of the 8 around the edge
      point = 0
      degree = Expect2Polar( cell_state )[0]
      for eighth in range(1,8) :
        if degree>(float(eighth)/8 - 1.0/16) and degree<=(float(eighth)/8 + 1.0/16 ) :
          point = eighth
      if point in [1,4,7] :
        c[ point ] = "⁎"
      else :
        c[ point ] = "*"


  # Strings for the three boxes. Blank if unused, but filled with █ and ░ if used to represent how 'filled' they are.
  b = {"X":[], "Z":[], "Y":[] }
  for box in [ "X", "Z", "Y" ] :
    this_b = []
    if box not in cell_state.keys() :
      for _ in range(1,reso[box]+1) :
        this_b.append(" ")
    else :
      prob = Expect2Prob( cell_state[box] ) # convert from expectation value to prob of a 1 outcome
      fill = int( float(reso[box]) * prob )
      
      if (prob>0.5 and fill != reso[box]) : # if over half filled, but not completely filled, round up (for clear visuals)
          fill += 1
      for _ in range(fill) :
        if box == "X" :
          this_b.append( ColouredString( "█" , "r" ) )
        elif box == "Z" :
          this_b.append( ColouredString( "█" , "b" ) )
        elif box == "Y" :
          this_b.append( ColouredString( "█" , "p" ) )

      for _ in range(fill,reso[box]) :
        if box == "X" :
          this_b.append( ColouredString( "░" , "r" ) )
        elif box == "Z" :
          this_b.append( ColouredString( "░" , "b" ) )
        elif box == "Y" :
          this_b.append( ColouredString( "░" , "p" ) )
    b[box] = this_b
  
  # center is X with the colour of the cell, unless the cell is empty
  if "Y" in cell_state.keys() :
    c[8] = ColouredString( b["Y"][int(reso["Y"]/2)], "p" )
  elif "X" in cell_state.keys() :
    c[8] = ColouredString( b["X"][int(reso["X"]/2)], "r" )
  elif "Z" in cell_state.keys() :
    c[8] = ColouredString( b["Z"][int(reso["Z"]/2)], "b" )
  
  b["X"][int(reso["X"]/2)] = c[8] # The center will be the ninth element of c instead

  # Declare and construct the lines.
  lines = []
  if cell_state==[] :
    for _ in range(11) :
      lines.append( "                       "+right )
  else :
    lines.append( "      .·  "+c[0]+"  ·.        "+right )
    lines.append( "   "+c[7]+"˙     "+b["Z"][8]+"     ˙"+c[1]+"     "+right )
    lines.append( "  ·       "+b["Z"][7]+"    "+b["Y"][11]+b["Y"][12]+" ·    "+right )
    lines.append( " ·        "+b["Z"][6]+"  "+b["Y"][9]+b["Y"][10]+"    ·   "+right )
    lines.append( "          "+b["Z"][5]+""+b["Y"][7]+b["Y"][8]+"          "+right )
    lines.append( ""+c[6]+" "+"".join(b["X"])+" "+c[2]+"  "+right )
    lines.append( "        "+b["Y"][4]+b["Y"][5]+""+b["Z"][3]+"            "+right )
    lines.append( " ˙    "+b["Y"][2]+b["Y"][3]+"  "+b["Z"][2]+"        ˙   "+right )
    lines.append( "  · "+b["Y"][0]+b["Y"][1]+"    "+b["Z"][1]+"       ·    "+right )
    lines.append( "   "+c[5]+".     "+b["Z"][0]+"     ."+c[3]+"     "+right )
    lines.append( "      ˙·  "+c[4]+"  ·˙        "+right )
  lines.append( bottom + right )
  
  return lines

def MakeGrid ( state, shown_qubit, active_qubit, bloch ) :

  #  DESCRIPTION:
  #      The inputs describe what the grid is doing. This function puts all that information together to actually make the grid.
  #  INPUT:
  #      {String: Float}    state   Full two qubit state. Needs entries for XI, ZI, IZ, IX, XX, XZ, ZX, ZZ and YY
  #      Int     shown_qubit     If this is 0 or 1, only the two boxes of that qubit are shown. Otherwise, all are shown.
  #      Int     active_qubit	If this is 0 or 1, the diagonals are straightened according to their function for this qubit. Otherwise they remain diagonal.
  # Bool    bloch       	Whether or not to display Bloch circles for the qubit specified above
  #  OUTPUT:
  #      [String]    grid_lines   An array of strs that represent the grid
  
  cells = { "XI":[], "ZI":[], "XX":[],"XZ":[],"ZX":[],"ZZ":[],"YY":[],"II":[], "IX":[], "IZ":[] }
  
  # determine which cells behave in which way (I is blank, B is Bloch circle, X and Z are horizontal and vertical boxes and Y are diagonal)
  grid_lines = []
  cell_types = {}
  if bloch :
    if shown_qubit==0 :
      cell_types = {"I":["II","ZI","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":[],"Y":[],"Z":[],"B":["XI"]} # shown_qubit is used as active qubit
    elif shown_qubit==1 :
      cell_types = {"I":["II","XI","ZI","XX","XZ","ZX","ZZ","YY","IZ"],"X":[],"Y":[],"Z":[],"B":["IX"]} # shown_qubit is used as active qubit
    else :
      if active_qubit==0 :
        cell_types = {"I":["II","ZI","ZX","ZZ"],"X":["IX"],"Y":[],"Z":["IZ"],"B":["XI","XX","XZ"]}
      elif active_qubit==1 :
        cell_types = {"I":["II","IZ","XZ","ZZ"],"X":["XI"],"Y":[],"Z":["ZI"],"B":["IX","XX","ZX"]} # these are the same as above but with strs reversed
      else :
        print("Error: A valid qubit must be chosen to display a Bloch circle")
  else :
    if shown_qubit==0 :
      cell_types = {"I":["II","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":["XI"],"Y":[],"Z":["ZI"],"B":[]}
    elif shown_qubit==1 :
      cell_types = {"I":["II","XI","ZI","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":["IX"],"Y":[],"Z":["IZ"],"B":[]}
    else :
      # Y for diagonal boxes, since there is no active qubit
      cell_types = {"I":["II"],"X":["XI","IX","XX"],"Y":["XZ","ZX"],"Z":["ZI","IZ","ZZ"],"B":[]}

  # make blank cell
  for cell in cell_types["I"] :
      cells[cell] = MakeCell( {} )

  # make cells with horizontal and vertical boxes
  for cell_type in ["X","Z"] :
      for cell in cell_types[cell_type] :
          cells[cell] = MakeCell( { cell_type: state[cell] } )




######################

  # make cells with diagonal boxes
  for cell in cell_types["Y"] :
    if active_qubit in [0,1] :
      index = active_qubit
      cells[cell] = MakeCell( { str(cell[index]):state[cell] } ) # qubit dependent cell type is used
    else :
      cells[cell] = MakeCell( { "Y":state[cell] } ) # same as in X,Z loop above

  # make cells with Bloch circle
  for cell in cell_types["B"] :
  	index = (1-active_qubit)
  	if active_qubit==0 :
  	  cells[cell] = MakeCell( { "X":state["X"+str(cell[index])], "Z":state["Z"+str(cell[index])] } )
  	else :
  	  cells[cell] = MakeCell( { "X":state[str(cell[index])+"X"], "Z":state[str(cell[index])+"Z"] } )
  
  for l in range(12) :
      grid_lines.append( cells["II"][l] + cells["ZI"][l] + cells["XI"][l] )
  for l in range(12) :
      grid_lines.append( cells["IZ"][l] + cells["ZZ"][l] + cells["XZ"][l] )
  for l in range(12) :
      grid_lines.append( cells["IX"][l] + cells["ZX"][l] + cells["XX"][l] )

  return grid_lines

 
print(ColouredString("hello","r"))
print(ColouredString("hello","g"))
print(ColouredString("hello","b"))
print(ColouredString("hello","p"))
print(ColouredString("hello","s"))

  
grid_lines = MakeGrid ( ApplyGate({"XI":0.0, "ZI":1.0,
                        "XX":0.0,"XZ":0.0,"ZX":0.0,"ZZ":0.0,"YY":0.0,
                        "IX":0.0, "IZ":0.0},"cz","0"), 2, 2, False )
for line in grid_lines :
  print(line)


    
    "},"asBuffer":null},"loaded":true}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
#  Created by James Wootton
#  Copyright © 2017 University of Basel. All rights reserved.

import math

def ColouredString (message,colour) :
  #  DESCRIPTION:
  #      Prints in a colour specified by the colour in ["r","b","p"] and then sets what follows back to white

  # first the colour
  coloured_message = ""
  if colour=="r": # red
    coloured_message += "\x1b[1;31m"
  elif colour=="g": # green
    coloured_message += "\x1b[1;32m"
  elif colour=="b": # blue
    coloured_message += "\x1b[1;34m" 
  elif colour=="p": # purple
    coloured_message += "\x1b[1;35m"
  else: # black (which should actually be the default text colour)
    coloured_message += "\x1b[0m"
  
  # then the message
  coloured_message += message

  # and back to black
  coloured_message += "\x1b[0m"
  
  return coloured_message

def  Expect2Prob ( expect ) :
  #  DESCRIPTION:
  #      Converts expectation value to a probability of getting the outcome 1.
  return (1-expect)/2
  
def Expect2Polar ( boxes ) :
  #  DESCRIPTION:
  #      Takes the contents of an X and Z box and turns it into polar coordinates for the Bloch circle.
  #  INPUT:
  #      {String: Float}    boxes       Should have entries for "X" and "Z", which serve as the horizontal and vertical boxes respectively.
  #  OUTPUT:
  #      [Float]            [ degrees, radius ]     degrees is between 0 and 1. It is the angle clockwise from the top as a fraction of 2*Pi. Radius is how far out the point is. Will be 1 for pure states and 0 for maximally mixed.
 
  radius = math.sqrt( boxes["X"]**2 + boxes["Z"]**2)
  degrees = 0 # default value of 0
  if radius>0.0:
    degrees = math.acos( -boxes["Z"] / radius ) / (2*math.pi)
    if boxes["X"]>=0.0:
      degrees = 1 - degrees

    return [ degrees, radius ]

def Polar2Expect ( polar_coords ) :
  #  DESCRIPTION:
  #      As Boxes2Polar, but with inputs and outputs reversed
  boxes = {}
  boxes["X"] = -polar_coords[1] * sin( 2*math.pi*polar_coords[0])
  boxes["Z"] = -polar_coords[1] * cos( 2*math.pi*polar_coords[0])
  return boxes
    
def ExchangeBoxes ( state, box1, box2 ) :
  #  DESCRIPTION:
  #      Given a state and two of its boxes, the values for these boxes are exchanged
  output_state = state
  temp = output_state[box1]
  output_state[box1] = output_state[box2]
  output_state[box2] = temp
  return output_state
    
def ApplyGate ( state, gate, qubit ) :
  #  DESCRIPTION:
  #      Transforms the given state according to the given gate.
  #  INPUT:
  #      {String: Float}    state       Full two qubit state. Needs entries for XI, ZI, IZ, IX, XX, XZ, ZX, ZZ and YY
  #      String              gate        QISKit style str to specify a gate (can be x, z, h, q, qdg, or cz)
  #      Int                 qubit       Qubit on which single qubit gate is applied. Unused for CZ.
  #  OUTPUT:
  #      {String: Float}    state       Transformed version of input state.
  
  # We begin constructing the output state by copying the input state.
  output_state = state
  
  # Single qubit gates require special treatment, so we deal with these separately.
  if gate in ["x","z","h","q","qdg"] :
    # Single qubit gates act on pairs of boxes. These are the pairs that form Bloch circles.
    # For qubit 0, these pairs are  (XI, ZI), (XX,ZX) and (XZ,ZZ).
    # For qubit 2 they are (IX, IZ), (XX,XZ) and (ZX,ZZ).
    # Here we loop over and construct the three pairs, which in each case will be (p[0],p[1]).
    for rc in ["I","X","Z"] :
            
      box_name = {"X":rc,"Z":rc}
      for p in ["X","Z"] :
        if qubit=="0" :
          box_name[p] = p + box_name[p]
        else :
          box_name[p] = box_name[p] + p
          
      
      
      # What we do to the pairs depends on the gate we apply.
      if gate=="x": # invert Z box and invert YY
        output_state[box_name["Z"]] = -output_state[box_name["Z"]]
        output_state["YY"] = -output_state["YY"]
      elif gate=="z" :# invert X box and invert YY
        output_state[box_name["X"]] = -output_state[box_name["X"]]
        output_state["YY"] = -output_state["YY"]
      elif gate=="h" : # exchange X and Z boxes and invert YY
        output_state = ExchangeBoxes( output_state, box_name["X"], box_name["Z"])
        output_state["YY"] = -output_state["YY"]
      elif gate in ["q","qdg"] :
        polar_coords = Expect2Polar( { "X":output_state[box_name["X"]], "Z":output_state[box_name["Z"]] } ) # convert to polar coords
        if gate=="q" : # change angle according to the rotation
          polar_coords[0] += 1/8
        else :
          polar_coords[0] -= 1/8
          
        # convert back to boxes
        output_boxes = Polar2Expect(polar_coords)
        for p in ["X","Z"] :
          output_state[box_name[p]] = output_boxes[p]
      else :
        print("Error: Unknown single qubit gate")

  # Now for the two qubit gates
  elif gate=="cz" :
    # exchange contents of XI and XZ
    output_state = ExchangeBoxes( output_state, "XI", "XZ")
    # exchange contents of IX and ZX
    output_state = ExchangeBoxes( output_state, "IX", "ZX")
    # exchange contents of XX and YY
    output_state = ExchangeBoxes( output_state, "XX", "YY")
  elif gate=="cx" :
    if qubit=="1" :
      # exchange contents of XI and XX
      output_state = ExchangeBoxes( output_state, "XI", "XX")
      # exchange contents of IZ and ZZ
      output_state = ExchangeBoxes( output_state, "IZ", "ZZ")
      # exchange contents of XZ and YY
      output_state = ExchangeBoxes( output_state, "XZ", "YY")
      # invert XZ
      output_state["XZ"] = -output_state["XZ"]
    elif qubit=="0" :
      # exchange contents of ZI and ZZ
      output_state = ExchangeBoxes( output_state, "ZI", "ZZ")
      # exchange contents of IX and XX
      output_state = ExchangeBoxes( output_state, "IX", "XX")
      # exchange contents of ZX and YY
      output_state = ExchangeBoxes( output_state, "ZX", "YY")
      # invert ZX
      output_state["ZX"] = -output_state["ZX"]
      output_state["YY"] = -output_state["YY"] # invert YY
    else :
      print("Error: Unknown gate")
  
  
  return output_state
  
def MakeInitial ( target_state, inverse_solution ) :
  #  DESCRIPTION:
  #      Constructs an initial state such that the target state and solution are as specified by the input
  #      Note that the inverse of the desired solution must be supplied here
  #      Put simply, this means that the first gate should be on the right, and the substition q <-> qdg should be used
    
  state = target_state
  for gate in inverse_solution :
      state = ApplyGate( state, gate[0], gate[1] )
  return state
  
def MakeCell ( cell_state ) :
  #  DESCRIPTION:
  #      Prints a single box or Bloch circle, depending on the input state.
  #  INPUT:
  #      {String: Float}    cell_state  With key "X", value is the expectation value for horizontal red box.
  #                                      Similarly for "Z" and the vertical blue box, and "Y" for a diagonal purple box.
  #                                      Note that a cell that uses "Y" will correspond to XZ or ZZ boxes. Not a Y box.
  #  OUTPUT:
  #      [String]            lines       List of 12 lines, which when printed sequentially will display the cell.
  #  PROCESS:
  #      When a single key is supplied, the corresponding box is printed.
  #      When both "X" and "Z" are supplied, the boxes are combined into a Bloch circle.
  #      In all cases, the level on the box is first converted from the expectation value to the probability.
  
  reso = {"X":17, "Z":9, "Y":13} # number of characters used for each type of box (including center)

  bottom = "───────────────────────" # bottom border
  right = "|" # right border

  # The 8 points around the circle and one in the middle. Default to a dot
  c = []
  c.append("˙")
  c.append(".")
  c.append("·")
  c.append("˙")
  c.append(".")
  c.append("˙")
  c.append("·")
  c.append(".")
  c.append(" ")
  
  # When a Bloch sphere is displayed, the point corresponding to the state is denoted by "*"
  # This is displayed only for pretty mixed states (radius <0.25) and pretty pure ones (radius>0.75)
  if ( "X" in cell_state.keys() and "Z" in cell_state.keys() ) : # both X  and Z boxes need to be present in the cell
    if ( Expect2Polar( cell_state )[1]<0.25 ) : # if state is pretty mixed, point is shown in the center
      c[8] = "*"
    elif Expect2Polar( cell_state )[1]>0.75 : # if state is pretty pure, it is one of the 8 around the edge
      point = 0
      degree = Expect2Polar( cell_state )[0]
      for eighth in range(1,8) :
        if degree>(float(eighth)/8 - 1.0/16) and degree<=(float(eighth)/8 + 1.0/16 ) :
          point = eighth
      if point in [1,4,7] :
        c[ point ] = "⁎"
      else :
        c[ point ] = "*"


  # Strings for the three boxes. Blank if unused, but filled with █ and ░ if used to represent how 'filled' they are.
  b = {"X":[], "Z":[], "Y":[] }
  for box in [ "X", "Z", "Y" ] :
    this_b = []
    if box not in cell_state.keys() :
      for _ in range(1,reso[box]+1) :
        this_b.append(" ")
    else :
      prob = Expect2Prob( cell_state[box] ) # convert from expectation value to prob of a 1 outcome
      fill = int( float(reso[box]) * prob )
      
      if (prob>0.5 and fill != reso[box]) : # if over half filled, but not completely filled, round up (for clear visuals)
          fill += 1
      for _ in range(fill) :
        if box == "X" :
          this_b.append( ColouredString( "█" , "r" ) )
        elif box == "Z" :
          this_b.append( ColouredString( "█" , "b" ) )
        elif box == "Y" :
          this_b.append( ColouredString( "█" , "p" ) )

      for _ in range(fill,reso[box]) :
        if box == "X" :
          this_b.append( ColouredString( "░" , "r" ) )
        elif box == "Z" :
          this_b.append( ColouredString( "░" , "b" ) )
        elif box == "Y" :
          this_b.append( ColouredString( "░" , "p" ) )
    b[box] = this_b
  
  # center is X with the colour of the cell, unless the cell is empty
  if "Y" in cell_state.keys() :
    c[8] = ColouredString( b["Y"][int(reso["Y"]/2)], "p" )
  elif "X" in cell_state.keys() :
    c[8] = ColouredString( b["X"][int(reso["X"]/2)], "r" )
  elif "Z" in cell_state.keys() :
    c[8] = ColouredString( b["Z"][int(reso["Z"]/2)], "b" )
  
  b["X"][int(reso["X"]/2)] = c[8] # The center will be the ninth element of c instead

  # Declare and construct the lines.
  lines = []
  if cell_state==[] :
    for _ in range(11) :
      lines.append( "                       "+right )
  else :
    lines.append( "      .·  "+c[0]+"  ·.        "+right )
    lines.append( "   "+c[7]+"˙     "+b["Z"][8]+"     ˙"+c[1]+"     "+right )
    lines.append( "  ·       "+b["Z"][7]+"    "+b["Y"][11]+b["Y"][12]+" ·    "+right )
    lines.append( " ·        "+b["Z"][6]+"  "+b["Y"][9]+b["Y"][10]+"    ·   "+right )
    lines.append( "          "+b["Z"][5]+""+b["Y"][7]+b["Y"][8]+"          "+right )
    lines.append( ""+c[6]+" "+"".join(b["X"])+" "+c[2]+"  "+right )
    lines.append( "        "+b["Y"][4]+b["Y"][5]+""+b["Z"][3]+"            "+right )
    lines.append( " ˙    "+b["Y"][2]+b["Y"][3]+"  "+b["Z"][2]+"        ˙   "+right )
    lines.append( "  · "+b["Y"][0]+b["Y"][1]+"    "+b["Z"][1]+"       ·    "+right )
    lines.append( "   "+c[5]+".     "+b["Z"][0]+"     ."+c[3]+"     "+right )
    lines.append( "      ˙·  "+c[4]+"  ·˙        "+right )
  lines.append( bottom + right )
  
  return lines

def MakeGrid ( state, shown_qubit, active_qubit, bloch ) :

  #  DESCRIPTION:
  #      The inputs describe what the grid is doing. This function puts all that information together to actually make the grid.
  #  INPUT:
  #      {String: Float}    state   Full two qubit state. Needs entries for XI, ZI, IZ, IX, XX, XZ, ZX, ZZ and YY
  #      Int     shown_qubit     If this is 0 or 1, only the two boxes of that qubit are shown. Otherwise, all are shown.
  #      Int     active_qubit	If this is 0 or 1, the diagonals are straightened according to their function for this qubit. Otherwise they remain diagonal.
  # Bool    bloch       	Whether or not to display Bloch circles for the qubit specified above
  #  OUTPUT:
  #      [String]    grid_lines   An array of strs that represent the grid
  
  cells = { "XI":[], "ZI":[], "XX":[],"XZ":[],"ZX":[],"ZZ":[],"YY":[],"II":[], "IX":[], "IZ":[] }
  
  # determine which cells behave in which way (I is blank, B is Bloch circle, X and Z are horizontal and vertical boxes and Y are diagonal)
  grid_lines = []
  cell_types = {}
  if bloch :
    if shown_qubit==0 :
      cell_types = {"I":["II","ZI","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":[],"Y":[],"Z":[],"B":["XI"]} # shown_qubit is used as active qubit
    elif shown_qubit==1 :
      cell_types = {"I":["II","XI","ZI","XX","XZ","ZX","ZZ","YY","IZ"],"X":[],"Y":[],"Z":[],"B":["IX"]} # shown_qubit is used as active qubit
    else :
      if active_qubit==0 :
        cell_types = {"I":["II","ZI","ZX","ZZ"],"X":["IX"],"Y":[],"Z":["IZ"],"B":["XI","XX","XZ"]}
      elif active_qubit==1 :
        cell_types = {"I":["II","IZ","XZ","ZZ"],"X":["XI"],"Y":[],"Z":["ZI"],"B":["IX","XX","ZX"]} # these are the same as above but with strs reversed
      else :
        print("Error: A valid qubit must be chosen to display a Bloch circle")
  else :
    if shown_qubit==0 :
      cell_types = {"I":["II","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":["XI"],"Y":[],"Z":["ZI"],"B":[]}
    elif shown_qubit==1 :
      cell_types = {"I":["II","XI","ZI","XX","XZ","ZX","ZZ","YY","IX","IZ"],"X":["IX"],"Y":[],"Z":["IZ"],"B":[]}
    else :
      # Y for diagonal boxes, since there is no active qubit
      cell_types = {"I":["II"],"X":["XI","IX","XX"],"Y":["XZ","ZX"],"Z":["ZI","IZ","ZZ"],"B":[]}

  # make blank cell
  for cell in cell_types["I"] :
      cells[cell] = MakeCell( {} )

  # make cells with horizontal and vertical boxes
  for cell_type in ["X","Z"] :
      for cell in cell_types[cell_type] :
          cells[cell] = MakeCell( { cell_type: state[cell] } )




######################

  # make cells with diagonal boxes
  for cell in cell_types["Y"] :
    if active_qubit in [0,1] :
      index = active_qubit
      cells[cell] = MakeCell( { str(cell[index]):state[cell] } ) # qubit dependent cell type is used
    else :
      cells[cell] = MakeCell( { "Y":state[cell] } ) # same as in X,Z loop above

  # make cells with Bloch circle
  for cell in cell_types["B"] :
  	index = (1-active_qubit)
  	if active_qubit==0 :
  	  cells[cell] = MakeCell( { "X":state["X"+str(cell[index])], "Z":state["Z"+str(cell[index])] } )
  	else :
  	  cells[cell] = MakeCell( { "X":state[str(cell[index])+"X"], "Z":state[str(cell[index])+"Z"] } )
  
  for l in range(12) :
      grid_lines.append( cells["II"][l] + cells["ZI"][l] + cells["XI"][l] )
  for l in range(12) :
      grid_lines.append( cells["IZ"][l] + cells["ZZ"][l] + cells["XZ"][l] )
  for l in range(12) :
      grid_lines.append( cells["IX"][l] + cells["ZX"][l] + cells["XX"][l] )

  return grid_lines

 
print(ColouredString("hello","r"))
print(ColouredString("hello","g"))
print(ColouredString("hello","b"))
print(ColouredString("hello","p"))
print(ColouredString("hello","s"))

  
grid_lines = MakeGrid ( ApplyGate({"XI":0.0, "ZI":1.0,
                        "XX":0.0,"XZ":0.0,"ZX":0.0,"ZZ":0.0,"YY":0.0,
                        "IX":0.0, "IZ":0.0},"cz","0"), 2, 2, False )
for line in grid_lines :
  print(line)