master-thesis-code/cutqc/evaluator.py at master · mar-be/master-thesis-code · GitHub

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
import itertools, copy
import numpy as np
from time import time
from termcolor import colored
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit.circuit.library.standard_gates import HGate, SGate, SdgGate, XGate

from qiskit_helper_functions.non_ibmq_functions import read_dict, find_process_jobs, evaluate_circ

def generate_subcircuit_instances(subcircuits,complete_path_map):
    circ_dict = {}
    all_indexed_combinations = {}
    for subcircuit_idx, subcircuit in enumerate(subcircuits):
        O_qubits, rho_qubits = find_subcircuit_O_rho_qubits(complete_path_map=complete_path_map,subcircuit_idx=subcircuit_idx)
        combinations, indexed_combinations = find_all_combinations(O_qubits, rho_qubits, subcircuit.qubits)
        circ_dict.update(get_subcircuit_instance(subcircuit_idx=subcircuit_idx,subcircuit=subcircuit, combinations=combinations))
        all_indexed_combinations[subcircuit_idx] = indexed_combinations
    return circ_dict, all_indexed_combinations

def find_subcircuit_O_rho_qubits(complete_path_map,subcircuit_idx):
    O_qubits = []
    rho_qubits = []
    for input_qubit in complete_path_map:
        path = complete_path_map[input_qubit]
        if len(path)>1:
            for q in path[:-1]:
                if q['subcircuit_idx'] == subcircuit_idx:
                    O_qubits.append(q)
            for q in path[1:]:
                if q['subcircuit_idx'] == subcircuit_idx:
                    rho_qubits.append(q)
    return O_qubits, rho_qubits

def find_all_combinations(O_qubits, rho_qubits, qubits):
    measurement_basis = ['I','X','Y']
    init_states = ['zero','one','plus','plusI']
    # print('\u03C1 qubits :',rho_qubits)
    all_inits = list(itertools.product(init_states,repeat=len(rho_qubits)))
    complete_inits = []
    for init in all_inits:
        complete_init = ['zero' for i in range(len(qubits))]
        for i in range(len(init)):
            complete_init[qubits.index(rho_qubits[i]['subcircuit_qubit'])] = init[i]
        complete_inits.append(complete_init)
    # print('initializations:',complete_inits)

    # print('O qubits:',O_qubits)
    all_meas = list(itertools.product(measurement_basis,repeat=len(O_qubits)))
    complete_meas = []
    for meas in all_meas:
        complete_m = ['comp' for i in range(len(qubits))]
        for i in range(len(meas)):
            complete_m[qubits.index(O_qubits[i]['subcircuit_qubit'])] = meas[i]
        complete_meas.append(complete_m)
    # print('measurement basis:',complete_meas)

    combinations = list(itertools.product(complete_inits,complete_meas))

    indexed_combinations = {}
    ctr = 0
    for combination in combinations:
        inits, meas = combination
        mutated_meas = mutate_measurement_basis(meas)
        for meas in mutated_meas:
            indexed_combinations[(tuple(inits),tuple(meas))] = ctr
            ctr+=1
    return combinations, indexed_combinations

def mutate_measurement_basis(meas):
    if all(x!='I' for x in meas):
        return [meas]
    else:
        mutated_meas = []
        for x in meas:
            if x != 'I':
                mutated_meas.append([x])
            else:
                mutated_meas.append(['I','Z'])
        mutated_meas = list(itertools.product(*mutated_meas))
        return mutated_meas

def get_subcircuit_instance(subcircuit_idx, subcircuit, combinations):
    circ_dict = {}
    for combination_ctr, combination in enumerate(combinations):
        # print('combination %d/%d :'%(combination_ctr,len(combinations)),combination)
        subcircuit_dag = circuit_to_dag(subcircuit)
        inits, meas = combination
        for i,x in enumerate(inits):
            q = subcircuit.qubits[i]
            if x == 'zero':
                continue
            elif x == 'one':
                subcircuit_dag.apply_operation_front(op=XGate(),qargs=[q],cargs=[])
            elif x == 'plus':
                subcircuit_dag.apply_operation_front(op=HGate(),qargs=[q],cargs=[])
            elif x == 'minus':
                subcircuit_dag.apply_operation_front(op=HGate(),qargs=[q],cargs=[])
                subcircuit_dag.apply_operation_front(op=XGate(),qargs=[q],cargs=[])
            elif x == 'plusI':
                subcircuit_dag.apply_operation_front(op=SGate(),qargs=[q],cargs=[])
                subcircuit_dag.apply_operation_front(op=HGate(),qargs=[q],cargs=[])
            elif x == 'minusI':
                subcircuit_dag.apply_operation_front(op=SGate(),qargs=[q],cargs=[])
                subcircuit_dag.apply_operation_front(op=HGate(),qargs=[q],cargs=[])
                subcircuit_dag.apply_operation_front(op=XGate(),qargs=[q],cargs=[])
            else:
                raise Exception('Illegal initialization : ',x)
        for i,x in enumerate(meas):
            q = subcircuit.qubits[i]
            if x == 'I' or x == 'comp':
                continue
            elif x == 'X':
                subcircuit_dag.apply_operation_back(op=HGate(),qargs=[q],cargs=[])
            elif x == 'Y':
                subcircuit_dag.apply_operation_back(op=SdgGate(),qargs=[q],cargs=[])
                subcircuit_dag.apply_operation_back(op=HGate(),qargs=[q],cargs=[])
            else:
                raise Exception('Illegal measurement basis:',x)
        subcircuit_inst = dag_to_circuit(subcircuit_dag)
        # NOTE: Adjust subcircuit shots here
        num_shots = max(8192,int(2**subcircuit_inst.num_qubits))
        num_shots = min(8192*10,num_shots)
        circ_dict[(subcircuit_idx,tuple(inits),tuple(meas))] = {'circuit':subcircuit_inst,'shots':num_shots}
    return circ_dict

def simulate_subcircuit(key,circuit,eval_mode,eval_folder,counter):
    if eval_mode=='sv':
        subcircuit_inst_prob = evaluate_circ(circuit=circuit,backend='statevector_simulator')
    elif eval_mode=='runtime':
        uniform_p = 1/2**circuit.num_qubits
        subcircuit_inst_prob = uniform_p
    write_subcircuit(key=key,eval_folder=eval_folder,counter=counter,subcircuit_inst_prob=subcircuit_inst_prob,eval_mode=eval_mode)

def write_subcircuit(key,eval_folder,counter,subcircuit_inst_prob,eval_mode):
    all_indexed_combinations = read_dict('%s/all_indexed_combinations.pckl'%(eval_folder))
    subcircuit_idx, inits, meas = key

    mutated_meas = mutate_measurement_basis(meas)
    for meas in mutated_meas:
        index = all_indexed_combinations[subcircuit_idx][(tuple(inits),tuple(meas))]
        if eval_mode=='runtime':
            eval_file_name = '%s/raw_%d_0.txt'%(eval_folder,subcircuit_idx)
        else:
            eval_file_name = '%s/raw_%d_%d.txt'%(eval_folder,subcircuit_idx,index)
        # print('writting',eval_file_name)
        eval_file = open(eval_file_name,'w')
        eval_file.write('d=%d effective=%d\n'%(counter[subcircuit_idx]['d'],counter[subcircuit_idx]['effective']))
        [eval_file.write('%s '%x) for x in inits]
        eval_file.write('\n')
        [eval_file.write('%s '%x) for x in meas]
        eval_file.write('\n')
        [eval_file.write('%e '%x) for x in subcircuit_inst_prob] if type(subcircuit_inst_prob)==np.ndarray else eval_file.write('%e '%subcircuit_inst_prob)
        eval_file.close()
        if eval_mode=='runtime':
            break