def circuit_status(self, handle: ResultHandle) -> CircuitStatus: self._check_handle_type(handle) jobid = handle[0] message = "" measure_permutations = json.loads(handle[1]) # type: ignore if self._MACHINE_DEBUG: n_qubits, n_shots = literal_eval( jobid[len(_DEBUG_HANDLE_PREFIX):]) # type: ignore empty_ar = OutcomeArray.from_ints([0] * n_shots, n_qubits, big_endian=True) self._cache[handle].update( {"result": BackendResult(shots=empty_ar)}) statenum = StatusEnum.COMPLETED else: data = put(self._url, data={ "id": jobid }, headers=self._header).json() status = data["status"] if "ERROR" in data: message = data["ERROR"] statenum = _STATUS_MAP.get(status, StatusEnum.ERROR) if statenum is StatusEnum.COMPLETED: shots = OutcomeArray.from_ints(data["samples"], data["no_qubits"], big_endian=True) shots = shots.choose_indices(measure_permutations) self._cache[handle].update( {"result": BackendResult(shots=shots)}) return CircuitStatus(statenum, message)
def process_circuits( self, circuits: Iterable[Circuit], n_shots: Optional[int] = None, valid_check: bool = True, **kwargs: KwargTypes, ) -> List[ResultHandle]: circuit_list = list(circuits) if valid_check: self._check_all_circuits(circuit_list, nomeasure_warn=(n_shots is not None)) handle_list = [] for circuit in circuit_list: qulacs_state = self._sim(circuit.n_qubits) qulacs_state.set_zero_state() qulacs_circ = tk_to_qulacs(circuit) qulacs_circ.update_quantum_state(qulacs_state) state = qulacs_state.get_vector() qubits = sorted(circuit.qubits, reverse=True) shots = None bits = None if n_shots: bits2index = list((com.bits[0], qubits.index(com.qubits[0])) for com in circuit if com.op.type == OpType.Measure) if len(bits2index) == 0: bits = circuit.bits shots = OutcomeArray.from_ints([0] * n_shots, len(bits)) else: bits, choose_indices = zip(*bits2index) samples = qulacs_state.sampling(n_shots) shots = OutcomeArray.from_ints(samples, circuit.n_qubits) shots = shots.choose_indices(choose_indices) try: phase = float(circuit.phase) coeff = np.exp(phase * np.pi * 1j) state *= coeff except TypeError: warning( "Global phase is dependent on a symbolic parameter, so cannot " "adjust for phase") implicit_perm = circuit.implicit_qubit_permutation() qubits = [implicit_perm[qb] for qb in qubits] handle = ResultHandle(str(uuid4())) self._cache[handle] = { "result": BackendResult(state=state, shots=shots, c_bits=bits, q_bits=qubits) } handle_list.append(handle) del qulacs_state del qulacs_circ return handle_list
def circuit_status(self, handle: ResultHandle) -> CircuitStatus: self._check_handle_type(handle) jobid = str(handle[0]) n_shots = cast(int, handle[1]) if self._MACHINE_DEBUG: n_qubits: int = literal_eval(jobid[len(_DEBUG_HANDLE_PREFIX):]) zero_counts: Counter = Counter() zero_array = OutcomeArray.from_ints( ints=[0], width=n_qubits, big_endian=False, ) zero_counts[zero_array] = n_shots if handle in self._cache: self._cache[handle].update( {"result": BackendResult(counts=zero_counts)}) else: self._cache[handle] = { "result": BackendResult(counts=zero_counts) } statenum = StatusEnum.COMPLETED else: measure_permutations = json.loads(str(handle[2])) url = self._url + str(jobid) resp = get(url, headers=self._header).json() status = resp["status"] statenum = _STATUS_MAP.get(status) # type: ignore if statenum is StatusEnum.COMPLETED: ionq_counts = resp["data"]["histogram"] tket_counts: Counter = Counter() # reverse engineer counts. Imprecise, due to rounding. max_counts = 0 max_array = None for outcome_key, prob in ionq_counts.items(): array = OutcomeArray.from_ints( ints=[int(outcome_key)], width=int(resp["qubits"]), big_endian=False, ) array = array.choose_indices(measure_permutations) array_counts = round(n_shots * float(prob)) tket_counts[array] = array_counts if array_counts > max_counts: max_counts = array_counts max_array = array # account for rounding error sum_counts = sum(tket_counts.values()) diff = n_shots - sum_counts tket_counts[max_array] += diff if handle in self._cache: self._cache[handle].update( {"result": BackendResult(counts=tket_counts)}) else: self._cache[handle] = { "result": BackendResult(counts=tket_counts) } return CircuitStatus(statenum)
def circuit_status(self, handle: ResultHandle) -> CircuitStatus: self._check_handle_type(handle) jobid = cast(str, handle[0]) message = "" n_shots = cast(int, handle[1]) if self._MACHINE_DEBUG: n_bits = literal_eval(jobid[len(_DEBUG_HANDLE_PREFIX) :]) empty_ar = OutcomeArray.from_ints([0] * n_shots, n_bits, big_endian=True) self._cache[handle].update({"result": BackendResult(shots=empty_ar)}) statenum = StatusEnum.COMPLETED else: job = qsharp.azure.status(jobid) status = job.status.lower() statenum = _STATUS_MAP.get(status, StatusEnum.ERROR) message = repr(job) if statenum is StatusEnum.COMPLETED: output = qsharp.azure.output(jobid) self._cache[handle].update({"result": _convert_result(output, n_shots)}) return CircuitStatus(statenum, message)
def _hex_to_outar(hexes: Sequence[str], width: int) -> OutcomeArray: ints = [int(hexst, 16) for hexst in hexes] return OutcomeArray.from_ints(ints, width)