def prog():
"""Program used for testing"""
program = sf.Program(2)
with program.context as q:
Sgate(0.54, 0) | q[0]
Sgate(0.54, 0) | q[1]
BSgate(6.283, 0.6283) | (q[0], q[1])
MeasureFock() | q
return program
def test_pre_measure_state_and_samples_non_analytic(self, tol):
"""Test that the pre_measure method operates as expected in non-analytic mode by
generating the correct output state and samples of the right shape"""
dev = qml.device("strawberryfields.gbs", wires=4, cutoff_dim=3, shots=2)
prog = Program(4)
op1 = GraphEmbed(0.1767767 * np.ones((4, 4)), mean_photon_per_mode=0.25)
op2 = MeasureFock()
prog.append(op1, prog.register)
prog.append(op2, prog.register)
dev.prog = prog
dev.pre_measure()
assert np.allclose(dev.state.displacement(), np.zeros(4))
assert np.allclose(dev.state.cov(), target_cov, atol=tol)
assert dev.samples.shape == (2, 4)
def test_pre_measure_non_analytic_cache(self, mocker):
"""Test that the pre_measure method does not overwrite existing samples if present in
non-analytic mode when use_cache is ``True``"""
samples = -1 * np.ones((10, 4))
dev = qml.device(
"strawberryfields.gbs",
wires=4,
cutoff_dim=3,
shots=10,
samples=samples,
use_cache=True,
)
prog = Program(4)
op1 = GraphEmbed(0.1767767 * np.ones((4, 4)), mean_photon_per_mode=0.25)
op2 = MeasureFock()
prog.append(op1, prog.register)
prog.append(op2, prog.register)
dev.prog = prog
dev.pre_measure()
spy = mocker.spy(sf.Engine, "run")
assert np.allclose(dev.samples, samples)
spy.assert_not_called()
def apply(self, operation, wires, par):
self._params, A, n_mean = par
A *= rescale(A, n_mean)
self.Z_inv = self._calculate_z_inv(A)
if len(self._params) != self.num_wires:
raise ValueError(
"The number of variable parameters must be equal to the total number of wires."
)
self._WAW = self.calculate_WAW(self._params, A)
if self.shots is not None and self._use_cache:
op = GraphEmbed(A, mean_photon_per_mode=n_mean / len(A))
else:
n_mean_WAW = self.calculate_n_mean(self._WAW)
op = GraphEmbed(self._WAW, mean_photon_per_mode=n_mean_WAW / len(A))
op | [self.q[wires.index(i)] for i in wires]
if self.shots is not None:
MeasureFock() | [self.q[wires.index(i)] for i in wires]
device = eng.device
# create a list of list of gate arguments for a GBS instance
gate_args_list = borealis_gbs(device, modes=288, squeezing="high")
# create a Strawberry Fields program
delays = [1, 6, 36]
vac_modes = sum(delays)
n, N = get_mode_indices(delays)
prog = sf.TDMProgram(N)
with prog.context(*gate_args_list) as (p, q):
Sgate(p[0]) | q[n[0]]
for i in range(len(delays)):
Rgate(p[2 * i + 1]) | q[n[i]]
BSgate(p[2 * i + 2], np.pi / 2) | (q[n[i + 1]], q[n[i]])
MeasureFock() | q[0]
# define number of shots and submit job to hardware
shots = 250_000
results = eng.run(prog, shots=shots, crop=True)
# the GBS samples
samples = results.samples
# plot the estimated simulation times of the experimental samples
plot_simulation_time(samples)
# obtain first and second moment of the photon-number distribution: mean photon
# number and photon-number covariance
mean_n = np.mean(samples, axis=(0, 1))
cov_n = np.cov(samples[:, 0, :].T)