def set_relationship(self,
                         relationships,
                         qubit0,
                         qubit1,
                         fraction=1,
                         update=True):
        '''
        Rotates the given pair of qubits towards the given target expectation values.
        
        Args:
            target_state: Target expectation values.
            qubit0, qubit1: Qubits on which the operation is applied
            fraction: fraction of the rotation toward the target state to apply.
            update: whether to update the tomography after the rotation is added to the circuit.
        '''
        zero = 0.001

        def inner(vec1, vec2):
            inner = 0
            for j in range(len(vec1)):
                inner += conj(vec1[j]) * vec2[j]
            return inner

        def normalize(vec):
            renorm = sqrt(inner(vec, vec))
            if abs((renorm * conj(renorm))) > zero:
                return np.copy(vec) / renorm
            else:
                return [nan for amp in vec]

        def random_vector(ortho_vecs=[]):
            vec = np.array([2 * random() - 1 for _ in range(4)],
                           dtype='complex')
            vec[0] = abs(vec[0])
            for ortho_vec in ortho_vecs:
                vec -= inner(ortho_vec, vec) * ortho_vec
            return normalize(vec)

        def get_rho(qubit0, qubit1):
            if type(self.backend) == ExpectationValue:
                rel = self.get_relationship(qubit0, qubit1)
                b0 = self.get_bloch(qubit0)
                b1 = self.get_bloch(qubit1)
                rho = np.identity(4, dtype='complex128')
                for pauli in ['X', 'Y', 'Z']:
                    rho += b0[pauli] * matrices[pauli + 'I']
                    rho += b1[pauli] * matrices['I' + pauli]
                for pauli in [
                        'XX', 'XY', 'XZ', 'YX', 'YY', 'YZ', 'ZX', 'ZY', 'ZZ'
                ]:
                    rho += rel[pauli] * matrices[pauli]
                return rho / 4
            else:
                (q0, q1) = sorted([qubit0, qubit1])
                return self.tomography.fit(output='density_matrix',
                                           pairs_list=[(q0, q1)])[q0, q1]

        raw_vals, raw_vecs = la.eigh(get_rho(qubit0, qubit1))
        vals = sorted([(val, k) for k, val in enumerate(raw_vals)],
                      reverse=True)
        vecs = [[raw_vecs[j][k] for j in range(4)] for (val, k) in vals]

        Pup = np.identity(4, dtype='complex')
        for (pauli, sign) in relationships.items():
            Pup = dot(Pup, (matrices['II'] + sign * matrices[pauli]) / 2)
        Pdown = (matrices['II'] - Pup)

        new_vecs = [[nan for _ in range(4)] for _ in range(4)]
        valid = [False for _ in range(4)]

        # the first new vector comes from projecting the first eigenvector
        vec = np.copy(vecs[0])
        while not valid[0]:
            new_vecs[0] = normalize(dot(Pup, vec))
            valid[0] = True not in [isnan(new_vecs[0][j]) for j in range(4)]
            # if that doesn't work, a random vector is projected instead
            vec = random_vector()

        # the second is found by similarly projecting the second eigenvector
        # and then finding the component orthogonal to new_vecs[0]
        vec = dot(Pup, vecs[1])
        while not valid[1]:
            new_vecs[1] = vec - inner(new_vecs[0], vec) * new_vecs[0]
            new_vecs[1] = normalize(new_vecs[1])
            valid[1] = True not in [isnan(new_vecs[1][j]) for j in range(4)]
            # if that doesn't work, start with a random one instead
            vec = random_vector()

        # the third is the projection of the third eigenvector to the subpace orthogonal to the first two
        vec = np.copy(vecs[2])
        for j in range(2):
            vec -= inner(new_vecs[j], vec) * new_vecs[j]
        while not valid[2]:
            new_vecs[2] = normalize(vec)
            valid[2] = True not in [isnan(new_vecs[2][j]) for j in range(4)]
            # if that doesn't work, use a random vector orthogonal to the first two
            vec = random_vector(ortho_vecs=[new_vecs[0], new_vecs[1]])

        # the last is just orthogonal to the rest
        vec = normalize(dot(Pdown, vecs[3]))
        while not valid[3]:
            new_vecs[3] = random_vector(
                ortho_vecs=[new_vecs[0], new_vecs[1], new_vecs[2]])
            valid[3] = True not in [isnan(new_vecs[3][j]) for j in range(4)]

        # a unitary is then constructed to rotate the old basis into the new
        U = [[0 for _ in range(4)] for _ in range(4)]
        for j in range(4):
            U += outer(new_vecs[j], conj(vecs[j]))

        if fraction != 1:
            U = pwr(U, fraction)

        try:
            circuit = two_qubit_cnot_decompose(U)
            gate = circuit.to_instruction()
            done = True
        except Exception as e:
            print(e)
            gate = None

        if gate:
            self.qc.append(gate, [qubit0, qubit1])

        if update:
            self.update_tomography()

        return gate
    def set_bloch(self, target_expect, qubit, fraction=1, update=True):
        '''
        Rotates the given qubit towards the given target state.
        
        Args:
            target_state: Expectation values of the target state.
            qubit: Qubit on which the operation is applied
            fraction: fraction of the rotation toward the target state to apply.
            update: whether to update the tomography after the rotation is added to the circuit.
        '''
        def basis_change(pole, basis, qubit, dagger=False):
            '''
            Returns the circuit required to change from the Z basis to the eigenbasis
            of a particular Pauli. The opposite is done when `dagger=True`.
            '''
            if pole == '+' and dagger == True:
                self.qc.x(qubit)

            if basis == 'X':
                self.qc.h(qubit)
            elif basis == 'Y':
                if dagger:
                    self.qc.rx(-pi / 2, qubit)
                else:
                    self.qc.rx(pi / 2, qubit)

            if pole == '+' and dagger == False:
                self.qc.x(qubit)

        def normalize(expect):
            '''
            Returns the given expectation values after normalization.
            '''
            R = sqrt(expect['X']**2 + expect['Y']**2 + expect['Z']**2)
            return {pauli: expect[pauli] / R for pauli in expect}

        def get_basis(expect):
            '''
            Get the eigenbasis of the density matrix for a the given expectation values.
            '''
            normalized_expect = normalize(expect)

            theta = arccos(normalized_expect['Z'])
            phi = arctan2(normalized_expect['Y'], normalized_expect['X'])

            state0 = [cos(theta / 2), exp(1j * phi) * sin(theta / 2)]
            state1 = [conj(state0[1]), -conj(state0[0])]

            return [state0, state1]

        # add in missing zeros
        for pauli in ['X', 'Y', 'Z']:
            if pauli not in target_expect:
                target_expect[pauli] = 0

        # determine the unitary which rotates as close to the target state as possible
        current_basis = get_basis(self.get_bloch(qubit))
        target_basis = get_basis(target_expect)
        U = array([[0 for _ in range(2)] for _ in range(2)], dtype=complex)
        for i in range(2):
            for j in range(2):
                for k in range(2):
                    U[j][k] += target_basis[i][j] * conj(current_basis[i][k])

        # get the unitary for the desired fraction of the rotation
        if fraction != 1:
            U = pwr(U, fraction)

        # apply the corresponding gate
        the, phi, lam = OneQubitEulerDecomposer().angles(U)
        self.qc.u3(the, phi, lam, qubit)

        if update:
            self.update_tomography()