pyGSTi 0.9.12.1__cp310-cp310-win_amd64.whl → 0.9.13__cp310-cp310-win_amd64.whl

pygsti/algorithms/mirroring.py

@@ -21,92 +21,6 @@ from pygsti.tools import compilationtools as _comp
 
 from . import randomcircuit as _rc
 
-# ### TODO: THIS IS TIMS OLD CODE WHICH SHOULD PERHAPS ALSO BE AN OPTION IN THE `CREATE_MIRROR_CIRCUIT` FUNCTION
-# def create_mirror_circuit(circ, pspec, circtype='Clifford+Gzr', pauli_labels=None, pluspi_prob=0.):
-#     """
-#     *****************************************************************
-#     Function currently has the following limitations that need fixing:
-
-#        - A layer contains only Clifford or Gzr gates on ALL the qubits.
-#        - all of the Clifford gates are self inverse
-#        - The qubits are labelled "Q0" through "Qn-1" -- THIS SHOULD NOW BE FIXED!
-#        - Pauli's are labelled by "Gi", "Gxpi", "Gypi" and "Gzpi".
-#        - There's no option for randomized prep/meas
-#        - There's no option for randomly adding +/-pi to the Z rotation angles.
-#        - There's no option for adding "barriers"
-#        - There's no test that the 'Gzr' gate has the "correct" convention for a rotation angle
-#          (a rotation by pi must be a Z gate) or that it's a rotation around Z.
-#     *****************************************************************
-#     """
-#     assert(circtype == 'Clifford+Gzr' or circtype == 'Clifford')
-#     n = circ.width
-#     d = circ.depth
-#     if pauli_labels is None: pauli_labels = ['Gi', 'Gxpi', 'Gypi', 'Gzpi']
-#     qubits = circ.line_labels
-#     identity = _np.identity(2 * n, _np.int64)
-#     zrotname = 'Gzr'
-#     # qubit_labels = ['G{}'.format(i) for i in range(n)]
-
-#     _, gate_inverse = pspec.compute_one_qubit_gate_relations()
-#     gate_inverse.update(pspec.compute_multiqubit_inversion_relations())  # add multiQ inverses
-
-#     quasi_inverse_circ = []
-#     central_pauli_circ = _cir.Circuit([[_lbl.Label(pauli_labels[_np.random.randint(0, 4)], q) for q in qubits]])
-#     #telescoping_pauli = central_pauli_layer.copy()
-#     # The telescoping Pauli in the symplectic rep.
-#     telp_s, telp_p = _symp.symplectic_rep_of_clifford_circuit(central_pauli_circ, pspec=pspec)
-#     assert(_np.sum(_np.abs(telp_s - identity)) <= 1e-8)  # Check that it's a Pauli.
-
-#     for d_ind in range(d):
-#         layer = circ.layer(d - d_ind - 1)
-#         if layer[0].name == zrotname:
-#             quasi_inverse_layer = []
-#             for gate in layer:
-
-#                 q_int = qubits.index(gate.qubits[0])
-#                 angle = float(gate.args[0])
-
-#                 if telp_p[n + q_int] == 0: rotation_sign = -1.  # If the Pauli is Z or I.
-#                 else: rotation_sign = +1  # If the Pauli is X or Y.
-
-#                 # Sets the quasi inversion angle to + or - the original angle, depending on the Paul
-#                 quasi_inverse_angle = rotation_sign * angle
-#                 # Decides whether to add with to add +/- pi to the rotation angle.
-#                 if _np.random.binomial(1, pluspi_prob) == 1:
-#                     quasi_inverse_angle += _np.pi * (-1)**_np.random.binomial(1, 0.5)
-#                     quasi_inverse_angle = _comp.mod_2pi(quasi_inverse_angle)
-#                     # Updates the telescoping Pauli (in the symplectic rep_, to include this added pi-rotation,
-#                     # as we need to include it as we keep collapsing the circuit down.
-#                     telp_p[q_int] = (telp_p[q_int] + 2) % 4
-#                 # Constructs the quasi-inverse gate.
-#                 quasi_inverse_gate = _lbl.Label(zrotname, gate.qubits, args=(str(quasi_inverse_angle),))
-#                 quasi_inverse_layer.append(quasi_inverse_gate)
-
-#             # We don't have to update the telescoping Pauli as it's unchanged, but when we update
-#             # this it'll need to change.
-#             #telp_p = telp_p
-
-#         else:
-#             quasi_inverse_layer = [_lbl.Label(gate_inverse[gate.name], gate.qubits) for gate in layer]
-#             telp_layer = _symp.find_pauli_layer(telp_p, pauli_labels, qubits)
-#             conjugation_circ = _cir.Circuit([layer, telp_layer, quasi_inverse_layer])
-#             # We calculate what the new telescoping Pauli is, in the symplectic rep.
-#             telp_s, telp_p = _symp.symplectic_rep_of_clifford_circuit(conjugation_circ, pspec=pspec)
-
-#         # Check that the layer -- pauli -- quasi-inverse circuit implements a Pauli.
-#         assert(_np.sum(_np.abs(telp_s - identity)) <= 1e-10)
-#         # Add the quasi inverse layer that we've constructed to the end of the quasi inverse circuit.
-#         quasi_inverse_circ.append(quasi_inverse_layer)
-
-#     # now that we've completed the quasi inverse circuit we convert it to a Circuit object
-#     quasi_inverse_circ = _cir.Circuit(quasi_inverse_circ)
-
-#     # Calculate the bit string that this mirror circuit should output, from the final telescoped Pauli.
-#     target_bitstring = ''.join(['1' if p == 2 else '0' for p in telp_p[n:]])
-#     mirror_circuit = circ + central_pauli_circ + quasi_inverse_circ
-
-#     return mirror_circuit, target_bitstring
-
 
 def create_mirror_circuit(circ, pspec, circ_type='clifford+zxzxz'):
     """
@@ -313,305 +227,3 @@ def create_mirror_circuit(circ, pspec, circ_type='clifford+zxzxz'):
     mirror_circuit = _cir.Circuit(mc, line_labels=circ.line_labels)
 
     return mirror_circuit, target_bitstring
-
-
-# #generate mirror circuits with pauli frame randomization. no random +pi needed
-# #as we construct the quasi-inverse, we generate random pauli layers, and compile them into the unitaries
-# #we'll need to recompute the angles needed for the z rotations
-
-# def create_nc_mirror_circuit(circ, pspec, circtype='Clifford+Gzr'):
-
-#     assert(circtype == 'Clifford+Gzr' or circtype == 'Clifford')
-#     n = circ.width
-#     d = circ.depth
-#     pauli_labels = ['I', 'X', 'Y', 'Z']
-#     qubits = circ.line_labels
-#     identity = _np.identity(2 * n, _np.int64)
-#     zrotname = 'Gzr'
-#     # qubit_labels = ['G{}'.format(i) for i in range(n)]
-
-#     _, gate_inverse = pspec.compute_one_qubit_gate_relations()
-#     gate_inverse.update(pspec.compute_multiqubit_inversion_relations())  # add multiQ inverses
-#     #for gname in pspec.gate_names:
-#     #    assert(gname in gate_inverse), \
-#     #        "%s gate does not have an inverse in the gate-set! MRB is not possible!" % gname
-
-#     quasi_inverse_circ = []
-
-#     Xpi2layer = [_lbl.Label('Gc16', qubits[t]) for t in range(n)]
-#     c = circ.copy(editable=True)
-
-#    #build the inverse
-#     d_ind = 0
-#     while d_ind<d:
-#         layer = circ.layer(d - d_ind - 1)
-#         if layer[0].name == zrotname: #ask if it's a Zrot layer. It's necessary for the whole layer to have Zrot gates
-
-#             current_layers = circ[d-d_ind-5:d-d_ind]
-#             #recompile inverse of current layer
-#             for i in range(n):
-#                 #print((i, float(current_layers[0][i].args[0]), float(current_layers[2][i].args[0]),
-#                 # float(current_layers[4][i].args[0])))
-#                 if n==1:
-#                     old_params = [(float(current_layers[0].args[0]), float(current_layers[2].args[0]),
-#                                    float(current_layers[4].args[0])) for i in range(n)]
-#                 else:
-#                     old_params = [(float(current_layers[0][i].args[0]), float(current_layers[2][i].args[0]),
-#                                    float(current_layers[4][i].args[0])) for i in range(n)]
-#                 layer_new_params = [_comp.inv_recompile_unitary(*p) for p in old_params] #need to write this function
-#                 theta1_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][0]),))
-#                                 for i in range(len(layer_new_params))]
-#                 theta2_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][1]),))
-#                                 for i in range(len(layer_new_params))]
-#                 theta3_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][2]),))
-#                                 for i in range(len(layer_new_params))]
-
-#             #add to mirror circuit
-#             c.append_circuit_inplace(_cir.Circuit([theta3_layer]))
-#             c.append_circuit_inplace(_cir.Circuit([Xpi2layer]))
-#             c.append_circuit_inplace(_cir.Circuit([theta2_layer]))
-#             c.append_circuit_inplace(_cir.Circuit([Xpi2layer]))
-#             c.append_circuit_inplace(_cir.Circuit([theta1_layer]))
-#             d_ind += 5
-
-#         else:
-#             inverse_layer = [_lbl.Label(gate_inverse[gate.name], gate.qubits) for gate in layer]
-#             #create quasi-inverse. Right now, it's ust inverting every gate in the original layer, so a simple inverse
-#             # Add the inverse layer that we've constructed to the end of the circuit
-#             c.append_circuit_inplace(_cir.Circuit([inverse_layer]))
-#             d_ind += 1
-#         #now that we've built the simple mirror circuit, let's add pauli frame randomization
-#     d_ind = 0
-#     mc = []
-#     net_paulis = [0 for q in qubits]
-#     d = c.depth
-
-
-#     srep_dict = _symp.compute_internal_gate_symplectic_representations(gllist=['I', 'X', 'Y', 'Z'])
-#     # the `callable` part is a workaround to remove gates with args, defined by functions.
-#     srep_dict.update(pspec.compute_clifford_symplectic_reps([gn for gn, u in pspec.gate_unitaries.items()
-#                      if not callable(u)]))
-
-#     while d_ind<d:
-#         layer = c.layer(d_ind)
-#         if layer[0].name == zrotname: #ask if it's a Zrot layer. It's necessary for the whole layer to have Zrot gates
-#             #if the layer is 1Q unitaries, pauli randomize
-#             current_layers = c[d_ind:d_ind+5]
-#             #generate random pauli
-#             new_paulis = [_np.random.randint(0, 4) for q in qubits]
-#             new_paulis_as_layer = [_lbl.Label(pauli_labels[new_paulis[i]], qubits[i]) for i in range(n)]
-#             #compute new net pauli based on previous pauli
-#             net_paulis_as_layer = [_lbl.Label(pauli_labels[net_paulis[i]], qubits[i]) for i in range(n)]
-#             net_paulis = _symp.find_pauli_number(_symp.symplectic_rep_of_clifford_circuit(_cir.Circuit(
-#                                                  new_paulis_as_layer+net_paulis_as_layer), srep_dict=srep_dict)[1])
-#             #depending on what the net pauli before the U gate is, might need to change parameters on the U gate to
-#             # commute the pauli through
-#             #recompile current layer to account for this and recompile with these paulis
-#             if n == 1:
-#                 old_params_and_paulis = [(float(current_layers[0].args[0]), float(current_layers[2].args[0]),
-#                                           float(current_layers[4].args[0]), net_paulis[i], new_paulis[i])
-#                                          for i in range(n)]
-#             else:
-#                 old_params_and_paulis = [(float(current_layers[0][i].args[0]), float(current_layers[2][i].args[0]),
-#                                           float(current_layers[4][i].args[0]), net_paulis[i], new_paulis[i])
-#                                           for i in range(n)]
-#             layer_new_params = [_comp.pauli_frame_randomize_unitary(*p) for p in old_params_and_paulis]
-#             theta1_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][0]),))
-#                             for i in range(len(layer_new_params))]
-#             theta2_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][1]),))
-#                             for i in range(len(layer_new_params))]
-#             theta3_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][2]),))
-#                             for i in range(len(layer_new_params))]
-
-#             #add to mirror circuit
-#             mc.append([theta1_layer])
-#             mc.append([Xpi2layer])
-#             mc.append([theta2_layer])
-#             mc.append([Xpi2layer])
-#             mc.append([theta3_layer])
-
-#             d_ind += 5
-
-#         else:
-#             net_paulis_as_layer = [_lbl.Label(pauli_labels[net_paulis[i]], qubits[i]) for i in range(n)]
-#             net_paulis = _symp.find_pauli_number(_symp.symplectic_rep_of_clifford_circuit(_cir.Circuit([layer
-#                                                  , net_paulis_as_layer, layer]), srep_dict=srep_dict)[1])
-#             mc.append(layer)
-#             #we need to account for how the net pauli changes when it gets passed through the clifford layers
-#             d_ind += 1
-
-#     #update the target pauli
-#     pauli_layer = [_lbl.Label(pauli_labels[net_paulis[i]], qubits[i]) for i in range(len(qubits))]
-#     conjugation_circ = _cir.Circuit([pauli_layer])
-#     telp_s, telp_p = _symp.symplectic_rep_of_clifford_circuit(conjugation_circ, srep_dict=srep_dict)
-
-#     # Calculate the bit string that this mirror circuit should output, from the final telescoped Pauli.
-#     target_bitstring = ''.join(['1' if p == 2 else '0' for p in telp_p[n:]])
-
-#     mirror_circuit = _cir.Circuit(mc)
-
-#     return mirror_circuit, target_bitstring
-
-# #
-# def create_cz_mirror_circuit(circ, pspec, circtype='GCzr+Gzr', pauli_labels=None):
-#     '''
-#     Makes a mirror circuit with Pauli frame randomization from a forward circuits consisting of only Haar-random 1Q
-#     unitary layers and CZRot layers
-#     The 1Q unitaries must be decomposed as Zr-Xpi/2-Zr-Xpi/2-Zr
-#     The CZRot layers must contain only Gc0/Gi and Gczr gates
-#     '''
-
-#     assert(circtype == 'GCzr+Gzr')
-#     n = circ.width
-#     d = circ.depth
-#     if pauli_labels is None: pauli_labels = ['Gc0', 'Gc3', 'Gc6', 'Gc9']
-#     qubits = circ.line_labels
-#     zrotname = 'Gzr'
-#     czrotname = 'Gczr'
-
-#     Xpi2layer = [_lbl.Label('Gc16', q) for q in qubits]
-
-#     #make an editable copy of the circuit to add the inverse on to
-#     c = circ.copy(editable=True)
-#    #build the inverse
-#     d_ind = 0
-#     while d_ind<d:
-#         layer = circ.layer(d - d_ind - 1)
-#         if layer[0].name == zrotname: #ask if it's a Zrot layer. It's necessary for the whole layer to have Zrot gates
-#             #get the entire arbitrary 1q unitaries: Zrot-Xpi/2-Zrot-Xpi/2-Zrot
-#             current_layers = circ[d-d_ind-5:d-d_ind]
-#             #recompile inverse of current layer
-#             for i in range(n):
-#                 if n==1:
-#                     old_params = [(float(current_layers[0].args[0]), float(current_layers[2].args[0]),
-#                                    float(current_layers[4].args[0])) for i in range(n)]
-#                 else:
-#                     old_params = [(float(current_layers[0][i].args[0]), float(current_layers[2][i].args[0]),
-#                                    float(current_layers[4][i].args[0])) for i in range(n)]
-#                 layer_new_params = [_comp.inv_recompile_unitary(*p) for p in old_params] #generates parameters for
-#                 # the inverse of this layer
-#                 theta1_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][0]),))
-#                                 for i in range(len(layer_new_params))]
-#                 theta2_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][1]),))
-#                                 for i in range(len(layer_new_params))]
-#                 theta3_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][2]),))
-#                                 for i in range(len(layer_new_params))]
-
-#             #add to mirror circuit
-#             c.append_circuit_inplace(_cir.Circuit([theta3_layer]))
-#             c.append_circuit_inplace(_cir.Circuit([Xpi2layer]))
-#             c.append_circuit_inplace(_cir.Circuit([theta2_layer]))
-#             c.append_circuit_inplace(_cir.Circuit([Xpi2layer]))
-#             c.append_circuit_inplace(_cir.Circuit([theta1_layer]))
-
-#             d_ind += 5
-
-#         if layer[0].name == czrotname or layer[0].name == 'Gc0':
-#             invlayer = []
-#             for g in layer:
-#                 if g.name == czrotname:
-#                     gate_qubits = g.qubits
-#                     #get gate args
-#                     theta = float(g.args[0])
-#                     invlayer.append(_lbl.Label(czrotname, gate_qubits, args=(str(-1*theta),)))
-#                 else:
-#                     invlayer.append(g)
-#             c.append_circuit_inplace(_cir.Circuit([invlayer]))
-#             d_ind += 1
-
-#     #now that we've built the simple mirror circuit, let's add pauli frame randomization
-#     d_ind = 0
-#     mc = []
-#     net_paulis = {q:0 for q in qubits} #dictionary keeping track of the random paulis
-#     d = c.depth
-#     correction_angles = {q: 0 for q in qubits}
-
-#     while d_ind<d:
-#         layer = c.layer(d_ind)
-#         if layer[0].name == zrotname:
-#             #if the layer is 1Q unitaries, pauli randomize
-#             current_layers = c[d_ind:d_ind+5]
-
-#             #generate random pauli
-#             new_paulis = {q: _np.random.randint(0, 4) for q in qubits}
-#             new_paulis_as_layer = [_lbl.Label(pauli_labels[new_paulis[q]], q) for q in qubits]
-
-#             #compute new net pauli based on previous pauli
-#             net_paulis_as_layer = [_lbl.Label(pauli_labels[net_paulis[q]], q) for q in qubits]
-
-#             net_pauli_numbers = _symp.find_pauli_number(_symp.symplectic_rep_of_clifford_circuit(_cir.Circuit(
-#                                    new_paulis_as_layer+net_paulis_as_layer), pspec=pspec)[1])
-#             net_paulis = {qubits[i]: net_pauli_numbers[i] for i in range(n)}
-
-#             #depending on what the net pauli before the U gate is, might need to change parameters on the U gate to
-#             # commute the pauli through
-#             #recompile current layer to account for this and recompile with these paulis
-#             if n == 1:
-#                 old_params_and_paulis = [(float(current_layers[0].args[0]), float(current_layers[2].args[0]),
-#                    float(current_layers[4].args[0]), net_paulis[qubits[i]], new_paulis[qubits[i]]) for i in range(n)]
-#             else:
-#                 #problem:ordering of qubits in the layer isn't always consistent
-#                 old_params_and_paulis = [(float(current_layers[0][i].args[0]), float(current_layers[2][i].args[0]),
-#                    float(current_layers[4][i].args[0]), net_paulis[qubits[i]],
-#                    new_paulis[qubits[i]]) for i in range(n)]
-
-#             layer_new_params = [_comp.pauli_frame_randomize_unitary(*p) for p in old_params_and_paulis] #need to write
-#             # this function
-#             #recompile any zrotation corrections from the previous Czr into the first zr of this layer
-#             theta1_layer = [_lbl.Label(zrotname, qubits[i],
-#               args=(str(layer_new_params[i][0]+correction_angles[qubits[i]]),)) for i in range(len(layer_new_params))]
-#             theta2_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][1]),))
-#                             for i in range(len(layer_new_params))]
-#             theta3_layer = [_lbl.Label(zrotname, qubits[i], args=(str(layer_new_params[i][2]),))
-#                             for i in range(len(layer_new_params))]
-#             #add to mirror circuit
-#             mc.append([theta1_layer])
-#             mc.append([Xpi2layer])
-#             mc.append([theta2_layer])
-#             mc.append([Xpi2layer])
-#             mc.append([theta3_layer])
-
-#             correction_angles = {q: 0 for q in qubits}
-#             d_ind += 5
-
-#         if layer[0].name == czrotname or layer[0].name == 'Gc0':
-#             quasi_inv_layer = []
-
-#             #recompile layer taking into acount paulis
-#             for g in layer:
-#                 if g.name == czrotname:
-#                     #get the qubits, figure out net pauli on those qubits
-#                     gate_qubits = g.qubits
-#                     net_paulis_for_gate = (net_paulis[gate_qubits[0]], net_paulis[gate_qubits[1]])
-#                     theta = float(g.args[0])
-#                     if ((net_paulis_for_gate[0] % 3 != 0 and net_paulis_for_gate[1] % 3 == 0)
-#                        or (net_paulis_for_gate[0] % 3 == 0 and net_paulis_for_gate[1] % 3 != 0)):
-#                         theta *= -1
-#                     quasi_inv_layer.append(_lbl.Label(czrotname, gate_qubits, args=(str(theta),)))
-#                     #for each X or Y, do a Zrotation by -theta on the other qubit after the 2Q gate.
-#                     for q in gate_qubits:
-#                         if net_paulis[q] == 1 or net_paulis[q] == 2:
-#                             for q2 in gate_qubits:
-#                                 if q2 != q:
-#                                     correction_angles[q2] += -1*theta
-#                 else:
-#                     gate_qubit = g.qubits
-#                     quasi_inv_layer.append(_lbl.Label('Gc0', gate_qubit))
-#             #add to circuit
-#             mc.append([quasi_inv_layer])
-
-#             #increment position in circuit
-#             d_ind += 1
-
-#     #update the target pauli
-#     pauli_layer = [_lbl.Label(pauli_labels[net_paulis[q]], q) for q in qubits]
-#     conjugation_circ = _cir.Circuit([pauli_layer]) #conjugation_circ = _cir.Circuit([random_stateprep_layer,
-#                             pauli_layer, random_meas_layer])
-#     telp_s, telp_p = _symp.symplectic_rep_of_clifford_circuit(conjugation_circ, pspec=pspec)
-
-#     # Calculate the bit string that this mirror circuit should output, from the final Pauli.
-#     target_bitstring = ''.join(['1' if p == 2 else '0' for p in telp_p[n:]])
-
-#     mirror_circuit = _cir.Circuit(mc)
-
-#     return mirror_circuit, target_bitstring