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)