def test_gate_compilation_matches_expected_max_infidelity(tabulation, target):
result = tabulation.compile_two_qubit_gate(target)
assert result.success
max_error = tabulation.max_expected_infidelity
assert 1 - unitary_entanglement_fidelity(target,
result.actual_gate) < max_error
def test_gate_compilation_on_base_gate_standard(tabulation):
base_gate = tabulation.base_gate
result = tabulation.compile_two_qubit_gate(base_gate)
assert len(result.local_unitaries) == 2
assert result.success
fidelity = unitary_entanglement_fidelity(result.actual_gate, base_gate)
assert fidelity > 0.99999
def test_gate_compilation_on_base_gate_identity():
tabulation = gate_product_tabulation(np.eye(4), 0.25)
base_gate = tabulation.base_gate
result = tabulation.compile_two_qubit_gate(base_gate)
assert len(result.local_unitaries) == 2
assert result.success
fidelity = unitary_entanglement_fidelity(result.actual_gate, base_gate)
assert fidelity > 0.99999
def main(samples: int = 1000, max_infidelity: float = 0.01):
"""Demonstration of the usage of the GateTabulation gate compiler.
Args:
samples: Number of random 2-qubit unitary samples to compile.
max_infidelity: Maximum allowed infidelity between randomly generated
gate and the gate compilation used to generate it. The example
runtime scales as max_infidelity^{-2}.
"""
# Define a base gate for compilation
theta = np.pi / 4
phi = np.pi / 24
base = unitary(FSimGate(theta, phi))
# The GateTabulation object is essentially a tabulation of many randomly
# generated gate products (of the form A k A or A k A k A), along with their
# associate KAK vectors. The parameter max_infidelity determines the
# approximate "density" of the tabulated gates. Specifically, it bounds the
# typical distance between an arbitrary two-qubit gate and the nearest
# tabulated gate.
start = time()
tabulation = gate_product_tabulation(base, max_infidelity)
print(tabulation.summary)
print(f'Gate tabulation time : {time() - start} seconds.')
# Generate many random two-qubit gates, then attempt to compile them using
# the tabulation.
unitaries = [random_special_unitary(4) for _ in range(samples)]
infidelities = []
failed_infidelities = []
start = time()
for target in unitaries:
# result.actual_gate is the compiled gate product intended to match the
# target. result.success denotes is the actual gate is expected to be
# within the desired fidelity to the target. It can be False if the
# base gate cannot "fill" the Weyl chamber using at most 3 products.
# result.local_unitaries stores the local unitaries required to
# compile the target unitary from the base unitary.
result = tabulation.compile_two_qubit_gate(target)
infidelity = 1 - unitary_entanglement_fidelity(target,
result.actual_gate)
if result.success:
infidelities.append(infidelity)
else:
failed_infidelities.append(infidelity) # coverage: ignore
t_comp = time() - start
print(f'Gate compilation time : {t_comp:.3f} seconds '
f'({t_comp / samples:.4f} s per gate)')
infidelities = np.array(infidelities)
failed_infidelities = np.array(failed_infidelities)
if np.size(failed_infidelities):
# coverage: ignore
print(f'Number of "failed" compilations:'
f' {np.size(failed_infidelities)}.')
print(f'Maximum infidelity of "failed" compilation: '
f'{np.max(failed_infidelities)}')
plt.figure()
plt.hist(infidelities, bins=25, range=[0, max_infidelity * 1.1])
ylim = plt.ylim()
plt.plot([max_infidelity] * 2,
ylim,
'--',
label='Maximum tabulation infidelity')
plt.xlabel('Compiled gate infidelity vs target')
plt.ylabel('Counts')
plt.legend()
plt.title(f'Base FSim(theta={theta:.4f}, phi={phi:.4f})')
plt.show()
