def bitstring(bits):
return ''.join(str(int(b)) for b in bits)
if __name__ == '__main__':
qubit_count = 4
input_qubits = [cirq.GridQubit(i, 0) for i in range(qubit_count)]
circuit = make_circuit(qubit_count, input_qubits)
circuit = cg.optimized_for_sycamore(circuit, optimizer_type='sqrt_iswap')
circuit_sample_count = 2000
info = cirq.final_state_vector(circuit)
qubits = round(log2(len(info)))
frequencies = {
np.binary_repr(i, qubits): round(
(info[i] * (info[i].conjugate())).real, 3)
for i in range(2**qubits)
}
writefile = open("../data/startCirq_Class2.csv", "w+")
print(format(frequencies), file=writefile)
print("results end", file=writefile)
print(circuit.__len__(), file=writefile)
print(circuit, file=writefile)
def test_run_zeta_chi_gamma_calibration_for_moments() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(zeta=0.5,
chi=0.4,
gamma=0.3)
parameters_bc = cirq_google.PhasedFSimCharacterization(zeta=-0.5,
chi=-0.4,
gamma=-0.3)
parameters_cd = cirq_google.PhasedFSimCharacterization(zeta=0.2,
chi=0.3,
gamma=0.4)
a, b, c, d = cirq.LineQubit.range(4)
engine_simulator = cirq_google.PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab.merge_with(SQRT_ISWAP_PARAMETERS),
(b, c): parameters_bc.merge_with(SQRT_ISWAP_PARAMETERS),
(c, d): parameters_cd.merge_with(SQRT_ISWAP_PARAMETERS),
})
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
])
options = cirq_google.FloquetPhasedFSimCalibrationOptions(
characterize_theta=False,
characterize_zeta=True,
characterize_chi=True,
characterize_gamma=True,
characterize_phi=False,
)
calibrated_circuit, calibrations = workflow.run_zeta_chi_gamma_compensation_for_moments(
circuit,
engine_simulator,
processor_id=None,
gate_set=cirq_google.SQRT_ISWAP_GATESET,
options=options,
)
assert cirq.allclose_up_to_global_phase(
engine_simulator.final_state_vector(calibrated_circuit.circuit),
cirq.final_state_vector(circuit),
)
assert calibrations == [
cirq_google.PhasedFSimCalibrationResult(
gate=SQRT_ISWAP_GATE,
parameters={
(a, b): parameters_ab,
(c, d): parameters_cd
},
options=options,
),
cirq_google.PhasedFSimCalibrationResult(gate=SQRT_ISWAP_GATE,
parameters={
(b, c): parameters_bc
},
options=options),
]
assert calibrated_circuit.moment_to_calibration == [
None, None, 0, None, None, 1, None
]
def test_create_from_dictionary_simulates_correctly():
parameters_ab_1 = {
'theta': 0.6,
'zeta': 0.5,
'chi': 0.4,
'gamma': 0.3,
'phi': 0.2
}
parameters_ab_2 = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
parameters_bc = {
'theta': 0.8,
'zeta': -0.5,
'chi': -0.4,
'gamma': -0.3,
'phi': -0.2
}
parameters_cd = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(b), cirq.Z(c),
cirq.H(d)],
[SQRT_ISWAP_INV_GATE.on(a, b),
SQRT_ISWAP_INV_GATE.on(d, c)],
[SQRT_ISWAP_INV_GATE.on(b, c)],
[cirq_google.SYC.on(a, b),
SQRT_ISWAP_INV_GATE.on(c, d)],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(b), cirq.Z(c),
cirq.H(d)],
[
cirq.PhasedFSimGate(**parameters_ab_1).on(a, b),
cirq.PhasedFSimGate(**parameters_cd).on(c, d),
],
[cirq.PhasedFSimGate(**parameters_bc).on(b, c)],
[
cirq.PhasedFSimGate(**parameters_ab_2).on(a, b),
cirq.PhasedFSimGate(**parameters_cd).on(c, d),
],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary(
parameters={
(a, b): {
SQRT_ISWAP_INV_GATE: parameters_ab_1,
cirq_google.SYC: parameters_ab_2
},
(b, c): {
SQRT_ISWAP_INV_GATE: parameters_bc
},
(c, d): {
SQRT_ISWAP_INV_GATE: parameters_cd
},
})
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_tensor_state_vector_4():
qubits = cirq.LineQubit.range(4)
circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=100, op_density=0.8)
psi1 = cirq.final_state_vector(circuit, dtype=np.complex128)
psi2 = ccq.tensor_state_vector(circuit, qubits)
np.testing.assert_allclose(psi1, psi2, atol=1e-8)
def assert_url_to_circuit_returns(
json_text: str,
circuit: 'cirq.Circuit' = None,
*,
unitary: Optional[np.ndarray] = None,
diagram: Optional[str] = None,
output_amplitudes_from_quirk: Optional[List[Dict[str, float]]] = None,
maps: Optional[Dict[int, int]] = None,
):
"""Assert that `quirk_url_to_circuit` functions correctly.
Args:
json_text: The part of the quirk URL after "#circuit=".
circuit: The optional expected circuit. If specified and not
equal to the parsed circuit, an assertion fails.
unitary: The optional expected unitary of the circuit. If specified
and the parsed circuit has a different unitary, an assertion fails.
diagram: The optional expected circuit diagram. If specified and the
parsed circuit has a different diagram, an assertion fails.
output_amplitudes_from_quirk: Optional data copied from Quirk's "export
simulation data" function, for comparison to Cirq's simulator
results. If specified and the output from the simulation differs
from this data (after accounting for differences in endian-ness),
an assertion fails.
maps: Optional dictionary of test computational basis input states and
the output computational basis state that they should be mapped to.
If any state is mapped to the wrong thing, an assertion fails. Note
that the states are specified using Quirk's little endian
convention, meaning that the last bit of a binary literal will refer
to the last qubit's value instead of vice versa.
"""
parsed = quirk_url_to_circuit(
f'https://algassert.com/quirk#circuit={json_text}')
if diagram is not None:
cirq.testing.assert_has_diagram(parsed, diagram)
if circuit is not None:
cirq.testing.assert_same_circuits(parsed, circuit)
if unitary is not None:
np.testing.assert_allclose(cirq.unitary(parsed), unitary, atol=1e-8)
if output_amplitudes_from_quirk is not None:
expected = np.array([
float(e['r']) + 1j * float(e['i'])
for e in output_amplitudes_from_quirk
])
np.testing.assert_allclose(
cirq.final_state_vector(
parsed,
# Match Quirk's endian-ness for comparison purposes.
qubit_order=sorted(parsed.all_qubits(), reverse=True),
),
expected,
atol=1e-8,
)
if maps:
cirq.testing.assert_equivalent_computational_basis_map(maps, parsed)
