pqcprep.phase_tools

  1"""
  2Collection of functions relating to phase extraction. 
  3"""
  4import numpy as np
  5from qiskit import QuantumCircuit, QuantumRegister
  6from .pqc_tools import generate_network, A_generate_network, get_state_vec 
  7
  8def extract_phase(n):
  9    r"""
 10
 11    Constructs an operator that extracts the phase associated with a given computational basis state:
 12    $ \ket{k} \mapsto e^{2 \pi k} \ket{k}$. 
 13
 14    This is based on a sequence of single-qubit Rz rotations, as shown in Eqs. (13)-(15) in [Hayes 2023](https://arxiv.org/pdf/2306.11073). 
 15    Unsigned magnitude encoding is assumed. 
 16
 17    Arguments: 
 18    ---
 19    - **n** : *int* 
 20
 21        Number of qubits in the system. 
 22
 23    Returns:
 24    ---
 25    - **circuit** : *QuantumCircuit* 
 26
 27        Implementation of the gate as a qiskit `QuantumCircuit`.       
 28
 29    """
 30    qc = QuantumCircuit(n, name="Extract Phase")
 31    qubits = list(range(n))
 32    
 33    for k in np.arange(0,n):
 34        lam = 2.*np.pi*(2.**(k-n))
 35        qubit = k
 36        qc.p(lam,qubits[qubit]) 
 37      
 38    # package as instruction
 39    qc_inst = qc.to_instruction()
 40    circuit = QuantumCircuit(n)
 41    circuit.append(qc_inst, qubits)    
 42
 43    return circuit 
 44
 45def full_encode(n,m, weights_A_str, weights_p_str,L_A,L_p, real_p, repeat_params=None, state_vec_file=None, save=False, full_state_vec=False, no_UA=False,operators="QRQ"):
 46    """
 47    
 48    Execute the quantum state preparation protocol using pre-trained QCNN weights. 
 49
 50    Arguments:
 51    ---
 52    - **n** : *int* 
 53
 54        Number of qubits in the input register. 
 55
 56    - **m** : *int* 
 57
 58        Number of qubits in the target register. 
 59
 60    - **weights_A_str** : *str*
 61
 62        File path to storage location of amplitude encoding QCNN weights. 
 63
 64    - **weights_p_str** : *str*
 65
 66        File path to storage location of phase encoding QCNN weights.    
 67
 68    - **L_A** : *int* 
 69
 70        Number of layers in the amplitude encoding QCNN.     
 71
 72    - **L_p** : *int* 
 73
 74        Number of layers in the phase encoding QCNN. 
 75
 76    - **real_p** : *boolean* 
 77
 78        Value of the `real` argument of the phase encoding QCNN. See `pqcprep.pqc_tools.generate_network()` for details. 
 79
 80    - **repeat_params** : *boolean*
 81
 82        Value of the `repeat_params` argument of the phase encoding QCNN. See `pqcprep.pqc_tools.generate_network()` for details. Default is False. 
 83
 84    - **state_vec_file** : *str*, *optional* 
 85
 86        File path to store output state vector. 
 87
 88    - **save** : *boolean* 
 89
 90        If True, output statevector is saved at `state_vec_file`. Default is False.      
 91
 92    - **full_state_vec** : *boolean* 
 93
 94        If True, the full statevector is additionally returned, including non-cleared ancilla states. Default is False. 
 95
 96    - **no_UA** : *boolean* 
 97
 98        If True, do not apply the amplitude encoding gate $\hat{U}_A$ and instead apply a Hadamard transform on the input register. Default is False.         
 99
100    - **operators** : *str* 
101
102        Which operators to apply to the registers. Options are `'QRQ'` for full phase extraction, `'RQ'` for partial phase extraction, and `'Q'` for function 
103        evaluation only. Default is `'QRQ'`.  
104
105    Returns:
106    ---
107    - **state_v** : *array_like* 
108
109        Array representing the statevector of the input register, assuming a cleared target register. 
110
111    - **state_v_full** : *array_like*, *optional* 
112
113        Array representing the statevector of the input register for the various target register configurations.    
114        Only returned if `full_state_vec` is True. 
115
116    """
117
118    # set up registers 
119    input_register = QuantumRegister(n, "input")
120    target_register = QuantumRegister(m, "target")
121    circuit = QuantumCircuit(input_register, target_register) 
122
123    # load weights 
124    if type(weights_p_str) !=str:
125        weights_p=weights_p_str
126    else:    
127        weights_p = np.load(weights_p_str)
128    
129    if no_UA:
130        circuit.h(input_register)
131    else:    
132        weights_A = np.load(weights_A_str)
133        # encode amplitudes 
134        circuit.compose(A_generate_network(n, L_A), input_register, inplace=True)
135        circuit = circuit.assign_parameters(weights_A)
136
137    # evaluate function
138    qc = generate_network(n,m, L_p, real=real_p,repeat_params=repeat_params)
139    qc = qc.assign_parameters(weights_p)
140    inv_qc = qc.inverse()
141    circuit.compose(qc, [*input_register,*target_register], inplace=True) 
142    
143    if operators=="QRQ" or operators=="RQ":
144        # extract phases 
145        circuit.compose(extract_phase(m),target_register, inplace=True) 
146    elif operators != "Q":
147        raise ValueError("Unexpected value for 'operators'. Should be 'QRQ', 'RQ', or 'Q'.")    
148
149    if operators=="QRQ":
150        # clear ancilla register 
151        circuit.compose(inv_qc, [*input_register,*target_register], inplace=True) 
152 
153    # get resulting statevector 
154    state_vector = get_state_vec(circuit).reshape((2**m,2**n))
155
156    state_v = state_vector[0,:].flatten()
157
158    if save:
159        if state_vec_file==None: raise ValueError("Must provide file path to save output.")
160        
161        # save to file 
162        np.save(state_vec_file, state_v)
163        if full_state_vec:
164            np.save(state_vec_file+"full", state_vector)
165
166        return 0
167    else:
168        if full_state_vec:
169            return state_v, state_vector 
170        else:
171            return state_v
172
173def phase_from_state(state_vec):
174    r"""
175    Extracts the phase, reduced to the interval $[0, 2 \pi]$, from a statevector. 
176
177    Phases corresponding to near-zero amplitudes are set to zero ("phase blanking").
178
179    Arguments:
180    ---
181    - **state_vec** : *array_like*
182
183        The complex state vector. 
184
185
186    Returns:
187    ----
188    - **phase** : *array_like* 
189
190        The corresponding phase.      
191    """
192    amplitude = np.abs(state_vec)
193    phase = np.angle(state_vec) + 2* np.pi * (np.angle(state_vec) < 0).astype(int)
194    phase = np.angle(state_vec) - 2* np.pi * (np.angle(state_vec) > 2*np.pi).astype(int)
195    phase *= (amplitude > 1e-15).astype(float)  
196
197    return phase