def test_compare_internal_edge(self, simulator, config) -> None:
# Given
first_vertex = QuantumRegister(2, 'first')
second_vertex = QuantumRegister(2, 'second')
target = QuantumRegister(1, 'target')
first_vertex_measure = ClassicalRegister(2, 'first-vertex-measure')
second_vertex_measure = ClassicalRegister(2, 'second-vertex-measure')
target_measure = ClassicalRegister(1, 'target-measure')
qc = QuantumCircuit(first_vertex,
second_vertex,
target,
first_vertex_measure,
second_vertex_measure,
target_measure,
name="test-circuit")
# Mix states and measure to obtain random test cases
qc.h(first_vertex)
qc.h(second_vertex)
qc.measure(first_vertex, first_vertex_measure)
qc.measure(second_vertex, second_vertex_measure)
# Compare edges
_compare_internal_edge(qc, first_vertex, second_vertex, target[0])
# Measure result
qc.measure(target, target_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Then
# Expected Results are strings 'first second target'
expected_results: Dict[str, float] = {
'0 00 00': 0.0625,
'0 01 01': 0.0625,
'0 10 10': 0.0625,
'0 11 11': 0.0625,
'1 00 01': 0.0625,
'1 00 10': 0.0625,
'1 00 11': 0.0625,
'1 01 00': 0.0625,
'1 01 10': 0.0625,
'1 01 11': 0.0625,
'1 10 00': 0.0625,
'1 10 01': 0.0625,
'1 10 11': 0.0625,
'1 11 00': 0.0625,
'1 11 01': 0.0625,
'1 11 10': 0.0625
}
assert result == approx(expected_results, abs=config['absolute_error'])
assert calc_total_costs(qc) - 4 == 129
def test_and_4(self, simulator: BaseBackend, config: Dict[str,
Any]) -> None:
# Given
input = QuantumRegister(4, 'input')
ancillas = QuantumRegister(2, 'ancilla')
output = QuantumRegister(1, 'output')
input_measure = ClassicalRegister(4, 'input-measure')
output_measure = ClassicalRegister(1, 'output-measure')
qc = QuantumCircuit(input,
output,
ancillas,
input_measure,
output_measure,
name="test-circuit")
# Mix states to get randomized test cases and record them
qc.h(input)
qc.measure(input, input_measure)
# Add circuit to test
add_and_4(qc, list(input), list(ancillas), output[0])
# Measure results
qc.measure(output, output_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Expected Results are strings 'output input'
expected_results: Dict[str, float] = {
'0 0000': 0.0625,
'0 0001': 0.0625,
'0 0010': 0.0625,
'0 0011': 0.0625,
'0 0100': 0.0625,
'0 0101': 0.0525,
'0 0110': 0.0625,
'0 0111': 0.0625,
'0 1000': 0.0625,
'0 1001': 0.0625,
'0 1010': 0.0625,
'0 1011': 0.0625,
'0 1100': 0.0625,
'0 1101': 0.0625,
'0 1110': 0.0625,
'1 1111': 0.0625
}
assert result == approx(expected_results, abs=config['absolute_error'])
assert calc_total_costs(qc) - 4 == 213
def test_cost_grover_without_ancilla(self):
#Given
qreg = QuantumRegister(2, "qreg")
creg = ClassicalRegister(2, "creg")
qc = QuantumCircuit(qreg, creg, name="grover-without-ancilla-circuit")
# Add one Grover step
add_grover_without_ancilla_1_0(qc, qreg)
# Measure
qc.measure(qreg[0], creg[0])
qc.measure(qreg[1], creg[1])
# When
result = calc_total_costs(qc)
# Then
assert result == 36
def test_cost_grover_with_ancilla(self):
#Given
qreg = QuantumRegister(2, "input")
ancilla = QuantumRegister(1, "ancilla")
measure = ClassicalRegister(2, "measure")
measure_ancilla = ClassicalRegister(1, "ancilla-measure")
qc = QuantumCircuit(qreg,
ancilla,
measure,
measure_ancilla,
name="grover-without-ancilla-circuit")
# Add one Grover step
add_grover_with_ancilla_1_0(qc, qreg, ancilla[0])
# Measure
qc.measure(qreg[0], measure[0])
qc.measure(qreg[1], measure[1])
# When
result = calc_total_costs(qc)
# Then
assert result == 95
def test_max_cut_on_default_example(self, simulator, config) -> None:
# Given
vertices = QuantumRegister(4, 'vertices')
edges = QuantumRegister(3, 'edges')
summation = QuantumRegister(2, 'summation')
ancilla = QuantumRegister(1, 'ancilla')
vertices_measure = ClassicalRegister(4, 'vertices-measure')
ancilla_measure = ClassicalRegister(1, 'ancilla-measure')
qc = QuantumCircuit(vertices,
edges,
summation,
ancilla,
vertices_measure,
ancilla_measure,
name="max-cut-circuit")
# Add MAX CUT circuit
add_max_cut_circuit(qc, vertices, edges, summation, ancilla[0])
# Measure results
qc.measure(ancilla, ancilla_measure)
qc.measure(vertices, vertices_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Then
# Expected Results are strings 'ancilla vertices'
# TODO How to deal with ancilla qubits in a systematic way?
expected_results: Dict[str, float] = {
'0 0000': 0,
'0 0001': 0.25,
'0 0010': 0,
'0 0011': 0,
'0 0100': 0,
'0 0101': 0,
'0 0110': 0,
'0 0111': 0,
'0 1000': 0,
'0 1001': 0,
'0 1010': 0,
'0 1011': 0,
'0 1100': 0,
'0 1101': 0,
'0 1110': 0.25,
'0 1111': 0,
'1 0000': 0,
'1 0001': 0.25,
'1 0010': 0,
'1 0011': 0,
'1 0100': 0,
'1 0101': 0,
'1 0110': 0,
'1 0111': 0,
'1 1000': 0,
'1 1010': 0,
'1 1001': 0,
'1 1011': 0,
'1 1100': 0,
'1 1101': 0,
'1 1110': 0.25,
'1 1111': 0
}
assert result == approx(expected_results, abs=config['absolute_error'])
assert calc_total_costs(qc) == 1538
def test_compare_2_external_edges(self, simulator, config) -> None:
# Given
edges: List[Tuple[QuantumRegister, VertexColor]] = [
(QuantumRegister(2, "v1"), VertexColor.YELLOW), # 10
(QuantumRegister(2, "v2"), VertexColor.GREEN) # 11
]
ancilla = QuantumRegister(2, 'ancilla')
target = QuantumRegister(1, 'target')
target_measure = ClassicalRegister(1, 'target-measure')
input_measure: List[ClassicalRegister] = [
ClassicalRegister(2, 'v1-measure'),
ClassicalRegister(2, 'v2-measure')
]
qc = QuantumCircuit(target,
ancilla,
target_measure,
name="test-circuit")
for v1, v2 in edges[0:2]:
qc.add_register(v1)
for c in input_measure:
qc.add_register(c)
# Mix the two states and measure to obtain random test cases
for (v1, v2), c in zip(edges[0:2], input_measure):
qc.h(v1)
qc.measure(v1, c)
# Compare edges
_compare_2_external_edges(qc, edges, list(ancilla), target[0])
# Measure result
qc.measure(target, target_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Then
# Expected Results are strings 'v2 v1 target'
# To interpret the expected results, notice that
# v2 is next to a 11 vertex
# v1 is next to a 10 vertex
expected_results: Dict[str, float] = {
'00 00 1': 0.0625,
'00 01 1': 0.0625,
'00 10 0': 0.0625,
'00 11 1': 0.0625,
'01 00 1': 0.0625,
'01 01 1': 0.0625,
'01 10 0': 0.0625,
'01 11 1': 0.0625,
'10 00 1': 0.0625,
'10 01 1': 0.0625,
'10 10 0': 0.0625,
'10 11 1': 0.0625,
'11 00 0': 0.0625,
'11 01 0': 0.0625,
'11 10 0': 0.0625,
'11 11 0': 0.0625
}
assert result == approx(expected_results, abs=config['absolute_error'])
assert calc_total_costs(qc) - 4 == 353
def test_compare_2_internal_edges(self, simulator, config) -> None:
# Given
edges = [(QuantumRegister(2,
f"v_{i}0"), (QuantumRegister(2, f"v_{i}1")))
for i in range(0, 2)]
ancilla = QuantumRegister(2, 'ancilla')
target = QuantumRegister(1, 'target')
edges_measure = [(ClassicalRegister(2, f"v_{i}0-measure"),
ClassicalRegister(2, f"v_{i}1-measure"))
for i in range(0, 2)]
target_measure = ClassicalRegister(1, 'target-measure')
qc = QuantumCircuit(target,
ancilla,
target_measure,
name="test-circuit")
for v1, v2 in edges:
qc.add_register(v1, v2)
for v1m, v2m in edges_measure:
qc.add_register(v1m, v2m)
# Mix states and measure to obtain random test cases
for v in list(sum(edges, ())):
qc.h(v)
for (v1, v2), (c1, c2) in zip(edges, edges_measure):
qc.measure(v1, c1)
qc.measure(v2, c2)
# Compare edges
_compare_2_internal_edges(qc, edges, list(ancilla), target[0])
# Measure result
qc.measure(target, target_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Then
# Expected Results are strings 'target second first'
expected_results: Dict[str, float] = {
'00 00 00 00 0': 0.0039,
'00 00 00 01 0': 0.0039,
'00 00 00 10 0': 0.0039,
'00 00 00 11 0': 0.0039,
'00 00 01 00 0': 0.0039,
'00 00 01 01 0': 0.0039,
'00 00 01 10 0': 0.0039,
'00 00 01 11 0': 0.0039,
'00 00 10 00 0': 0.0039,
'00 00 10 01 0': 0.0039,
'00 00 10 10 0': 0.0039,
'00 00 10 11 0': 0.0039,
'00 00 11 00 0': 0.0039,
'00 00 11 01 0': 0.0039,
'00 00 11 10 0': 0.0039,
'00 00 11 11 0': 0.0039,
'00 01 00 00 0': 0.0039,
'00 01 00 01 1': 0.0039,
'00 01 00 10 1': 0.0039,
'00 01 00 11 1': 0.0039,
'00 01 01 00 1': 0.0039,
'00 01 01 01 0': 0.0039,
'00 01 01 10 1': 0.0039,
'00 01 01 11 1': 0.0039,
'00 01 10 00 1': 0.0039,
'00 01 10 01 1': 0.0039,
'00 01 10 10 0': 0.0039,
'00 01 10 11 1': 0.0039,
'00 01 11 00 1': 0.0039,
'00 01 11 01 1': 0.0039,
'00 01 11 10 1': 0.0039,
'00 01 11 11 0': 0.0039,
'00 10 00 00 0': 0.0039,
'00 10 00 01 1': 0.0039,
'00 10 00 10 1': 0.0039,
'00 10 00 11 1': 0.0039,
'00 10 01 00 1': 0.0039,
'00 10 01 01 0': 0.0039,
'00 10 01 10 1': 0.0039,
'00 10 01 11 1': 0.0039,
'00 10 10 00 1': 0.0039,
'00 10 10 01 1': 0.0039,
'00 10 10 10 0': 0.0039,
'00 10 10 11 1': 0.0039,
'00 10 11 00 1': 0.0039,
'00 10 11 01 1': 0.0039,
'00 10 11 10 1': 0.0039,
'00 10 11 11 0': 0.0039,
'00 11 00 00 0': 0.0039,
'00 11 00 01 1': 0.0039,
'00 11 00 10 1': 0.0039,
'00 11 00 11 1': 0.0039,
'00 11 01 00 1': 0.0039,
'00 11 01 01 0': 0.0039,
'00 11 01 10 1': 0.0039,
'00 11 01 11 1': 0.0039,
'00 11 10 00 1': 0.0039,
'00 11 10 01 1': 0.0039,
'00 11 10 10 0': 0.0039,
'00 11 10 11 1': 0.0039,
'00 11 11 00 1': 0.0039,
'00 11 11 01 1': 0.0039,
'00 11 11 10 1': 0.0039,
'00 11 11 11 0': 0.0039,
'01 00 00 00 0': 0.0039,
'01 00 00 01 1': 0.0039,
'01 00 00 10 1': 0.0039,
'01 00 00 11 1': 0.0039,
'01 00 01 00 1': 0.0039,
'01 00 01 01 0': 0.0039,
'01 00 01 10 1': 0.0039,
'01 00 01 11 1': 0.0039,
'01 00 10 00 1': 0.0039,
'01 00 10 01 1': 0.0039,
'01 00 10 10 0': 0.0039,
'01 00 10 11 1': 0.0039,
'01 00 11 00 1': 0.0039,
'01 00 11 01 1': 0.0039,
'01 00 11 10 1': 0.0039,
'01 00 11 11 0': 0.0039,
'01 01 00 00 0': 0.0039,
'01 01 00 01 0': 0.0039,
'01 01 00 10 0': 0.0039,
'01 01 00 11 0': 0.0039,
'01 01 01 00 0': 0.0039,
'01 01 01 01 0': 0.0039,
'01 01 01 10 0': 0.0039,
'01 01 01 11 0': 0.0039,
'01 01 10 00 0': 0.0039,
'01 01 10 01 0': 0.0039,
'01 01 10 10 0': 0.0039,
'01 01 10 11 0': 0.0039,
'01 01 11 00 0': 0.0039,
'01 01 11 01 0': 0.0039,
'01 01 11 10 0': 0.0039,
'01 01 11 11 0': 0.0039,
'01 10 00 00 0': 0.0039,
'01 10 00 01 1': 0.0039,
'01 10 00 10 1': 0.0039,
'01 10 00 11 1': 0.0039,
'01 10 01 00 1': 0.0039,
'01 10 01 01 0': 0.0039,
'01 10 01 10 1': 0.0039,
'01 10 01 11 1': 0.0039,
'01 10 10 00 1': 0.0039,
'01 10 10 01 1': 0.0039,
'01 10 10 10 0': 0.0039,
'01 10 10 11 1': 0.0039,
'01 10 11 00 1': 0.0039,
'01 10 11 01 1': 0.0039,
'01 10 11 10 1': 0.0039,
'01 10 11 11 0': 0.0039,
'01 11 00 00 0': 0.0039,
'01 11 00 01 1': 0.0039,
'01 11 00 10 1': 0.0039,
'01 11 00 11 1': 0.0039,
'01 11 01 00 1': 0.0039,
'01 11 01 01 0': 0.0039,
'01 11 01 10 1': 0.0039,
'01 11 01 11 1': 0.0039,
'01 11 10 00 1': 0.0039,
'01 11 10 01 1': 0.0039,
'01 11 10 10 0': 0.0039,
'01 11 10 11 1': 0.0039,
'01 11 11 00 1': 0.0039,
'01 11 11 01 1': 0.0039,
'01 11 11 10 1': 0.0039,
'01 11 11 11 0': 0.0039,
'10 00 00 00 0': 0.0039,
'10 00 00 01 1': 0.0039,
'10 00 00 10 1': 0.0039,
'10 00 00 11 1': 0.0039,
'10 00 01 00 1': 0.0039,
'10 00 01 01 0': 0.0039,
'10 00 01 10 1': 0.0039,
'10 00 01 11 1': 0.0039,
'10 00 10 00 1': 0.0039,
'10 00 10 01 1': 0.0039,
'10 00 10 10 0': 0.0039,
'10 00 10 11 1': 0.0039,
'10 00 11 00 1': 0.0039,
'10 00 11 01 1': 0.0039,
'10 00 11 10 1': 0.0039,
'10 00 11 11 0': 0.0039,
'10 01 00 00 0': 0.0039,
'10 01 00 01 1': 0.0039,
'10 01 00 10 1': 0.0039,
'10 01 00 11 1': 0.0039,
'10 01 01 00 1': 0.0039,
'10 01 01 01 0': 0.0039,
'10 01 01 10 1': 0.0039,
'10 01 01 11 1': 0.0039,
'10 01 10 00 1': 0.0039,
'10 01 10 01 1': 0.0039,
'10 01 10 10 0': 0.0039,
'10 01 10 11 1': 0.0039,
'10 01 11 00 1': 0.0039,
'10 01 11 01 1': 0.0039,
'10 01 11 10 1': 0.0039,
'10 01 11 11 0': 0.0039,
'10 10 00 00 0': 0.0039,
'10 10 00 01 0': 0.0039,
'10 10 00 10 0': 0.0039,
'10 10 00 11 0': 0.0039,
'10 10 01 00 0': 0.0039,
'10 10 01 01 0': 0.0039,
'10 10 01 10 0': 0.0039,
'10 10 01 11 0': 0.0039,
'10 10 10 00 0': 0.0039,
'10 10 10 01 0': 0.0039,
'10 10 10 10 0': 0.0039,
'10 10 10 11 0': 0.0039,
'10 10 11 00 0': 0.0039,
'10 10 11 01 0': 0.0039,
'10 10 11 10 0': 0.0039,
'10 10 11 11 0': 0.0039,
'10 11 00 00 0': 0.0039,
'10 11 00 01 1': 0.0039,
'10 11 00 10 1': 0.0039,
'10 11 00 11 1': 0.0039,
'10 11 01 00 1': 0.0039,
'10 11 01 01 0': 0.0039,
'10 11 01 10 1': 0.0039,
'10 11 01 11 1': 0.0039,
'10 11 10 00 1': 0.0039,
'10 11 10 01 1': 0.0039,
'10 11 10 10 0': 0.0039,
'10 11 10 11 1': 0.0039,
'10 11 11 00 1': 0.0039,
'10 11 11 01 1': 0.0039,
'10 11 11 10 1': 0.0039,
'10 11 11 11 0': 0.0039,
'11 00 00 00 0': 0.0039,
'11 00 00 01 1': 0.0039,
'11 00 00 10 1': 0.0039,
'11 00 00 11 1': 0.0039,
'11 00 01 00 1': 0.0039,
'11 00 01 01 0': 0.0039,
'11 00 01 10 1': 0.0039,
'11 00 01 11 1': 0.0039,
'11 00 10 00 1': 0.0039,
'11 00 10 01 1': 0.0039,
'11 00 10 10 0': 0.0039,
'11 00 10 11 1': 0.0039,
'11 00 11 00 1': 0.0039,
'11 00 11 01 1': 0.0039,
'11 00 11 10 1': 0.0039,
'11 00 11 11 0': 0.0039,
'11 01 00 00 0': 0.0039,
'11 01 00 01 1': 0.0039,
'11 01 00 10 1': 0.0039,
'11 01 00 11 1': 0.0039,
'11 01 01 00 1': 0.0039,
'11 01 01 01 0': 0.0039,
'11 01 01 10 1': 0.0039,
'11 01 01 11 1': 0.0039,
'11 01 10 00 1': 0.0039,
'11 01 10 01 1': 0.0039,
'11 01 10 10 0': 0.0039,
'11 01 10 11 1': 0.0039,
'11 01 11 00 1': 0.0039,
'11 01 11 01 1': 0.0039,
'11 01 11 10 1': 0.0039,
'11 01 11 11 0': 0.0039,
'11 10 00 00 0': 0.0039,
'11 10 00 01 1': 0.0039,
'11 10 00 10 1': 0.0039,
'11 10 00 11 1': 0.0039,
'11 10 01 00 1': 0.0039,
'11 10 01 01 0': 0.0039,
'11 10 01 10 1': 0.0039,
'11 10 01 11 1': 0.0039,
'11 10 10 00 1': 0.0039,
'11 10 10 01 1': 0.0039,
'11 10 10 10 0': 0.0039,
'11 10 10 11 1': 0.0039,
'11 10 11 00 1': 0.0039,
'11 10 11 01 1': 0.0039,
'11 10 11 10 1': 0.0039,
'11 10 11 11 0': 0.0039,
'11 11 00 00 0': 0.0039,
'11 11 00 01 0': 0.0039,
'11 11 00 10 0': 0.0039,
'11 11 00 11 0': 0.0039,
'11 11 01 00 0': 0.0039,
'11 11 01 01 0': 0.0039,
'11 11 01 10 0': 0.0039,
'11 11 01 11 0': 0.0039,
'11 11 10 00 0': 0.0039,
'11 11 10 01 0': 0.0039,
'11 11 10 10 0': 0.0039,
'11 11 10 11 0': 0.0039,
'11 11 11 00 0': 0.0039,
'11 11 11 01 0': 0.0039,
'11 11 11 10 0': 0.0039,
'11 11 11 11 0': 0.0039
}
assert result == approx(expected_results, abs=config['absolute_error'])
assert calc_total_costs(qc) - 8 == 585
def compare_4_internal_edges(self, simulator, config_slow) -> None:
"""
ONLY RUN THIS TEST ON A LOCAL SIMULATOR IF YOU HAVE SOME TIME.
On SP's machine this takes about 2 minutes in total.
"""
# Given
edges = [(QuantumRegister(2,
f"v_{i}0"), (QuantumRegister(2, f"v_{i}1")))
for i in range(0, 4)]
ancilla = QuantumRegister(6, 'ancilla')
target = QuantumRegister(1, 'target')
first_vertex_measure = ClassicalRegister(2, 'first-vertex-measure')
second_vertex_measure = ClassicalRegister(2, 'second-vertex-measure')
target_measure = ClassicalRegister(1, 'target-measure')
qc = QuantumCircuit(target,
ancilla,
first_vertex_measure,
second_vertex_measure,
target_measure,
name="test-circuit")
for v1, v2 in edges:
qc.add_register(v1, v2)
# Prepare colors of three of four edges to keep the test size reasonable
for v1, v2 in edges[1:3]:
TestColoringCircuits.set_color(qc, v1, VertexColor.RED)
TestColoringCircuits.set_color(qc, v2, VertexColor.BLUE)
TestColoringCircuits.set_color(qc, edges[3][0], VertexColor.GREEN)
TestColoringCircuits.set_color(qc, edges[3][1], VertexColor.YELLOW)
# Mix the remaining states and measure to obtain random test cases
qc.h(edges[0][0])
qc.h(edges[0][1])
qc.measure(edges[0][0], first_vertex_measure)
qc.measure(edges[0][1], second_vertex_measure)
# Compare edges
_compare_4_internal_edges(qc, edges, list(ancilla), target[0])
# Measure result
qc.measure(target, target_measure)
# When
job: BaseJob = execute(qc, simulator, shots=config_slow['test_runs'])
# Calculate relative results
result: Dict[str, float] = {
key: value / config_slow['test_runs']
for key, value in job.result().get_counts(qc).items()
}
# Then
# Expected Results are strings 'target second first'
expected_results: Dict[str, float] = {
'0 00 00': 0.0625,
'0 01 01': 0.0625,
'0 10 10': 0.0625,
'0 11 11': 0.0625,
'1 00 01': 0.0625,
'1 00 10': 0.0625,
'1 00 11': 0.0625,
'1 01 00': 0.0625,
'1 01 10': 0.0625,
'1 01 11': 0.0625,
'1 10 00': 0.0625,
'1 10 01': 0.0625,
'1 10 11': 0.0625,
'1 11 00': 0.0625,
'1 11 01': 0.0625,
'1 11 10': 0.0625
}
assert result == approx(expected_results,
abs=config_slow['absolute_error'])
assert calc_total_costs(qc) - 7 == 1247
