strawberryfields

#!/usr/bin/env python3
import strawberryfields as sf
from strawberryfields.ops import *
# initialize engine and program objects
eng = sf.Engine(backend="fock", backend_options={"cutoff_dim": 7})
boson_sampling = sf.Program(4)
with boson_sampling.context as q:
    # prepare the input fock states
    Fock(1) | q[0]
    Fock(1) | q[1]
    Vac     | q[2]
    Fock(1) | q[3]
    # rotation gates
    Rgate(0.5719) | q[0]
    Rgate(-1.9782) | q[1]
    Rgate(2.0603) | q[2]
    Rgate(0.0644) | q[3]
    # beamsplitter array
    BSgate(0.7804, 0.8578)  | (q[0], q[1])
    BSgate(0.06406, 0.5165) | (q[2], q[3])
    BSgate(0.473, 0.1176)   | (q[1], q[2])
    BSgate(0.563, 0.1517)   | (q[0], q[1])
    BSgate(0.1323, 0.9946)  | (q[2], q[3])
    BSgate(0.311, 0.3231)   | (q[1], q[2])
    BSgate(0.4348, 0.0798)  | (q[0], q[1])
    BSgate(0.4368, 0.6157)  | (q[2], q[3])
    # end circuit
# run the engine
results = eng.run(boson_sampling)
# extract the joint Fock probabilities
probs = results.state.all_fock_probs()
# print the joint Fock state probabilities
print(probs[1, 1, 0, 1])
print(probs[2, 0, 0, 1])

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#     http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A comparison of the asymptotic homodyne distributions and sampled values,
for GKP and cat states."""
import strawberryfields as sf
import numpy as np
import matplotlib.pyplot as plt
# Create cat state
prog_cat = sf.Program(1)
with prog_cat.context as q:
    sf.ops.Catstate(alpha=2) | q
eng = sf.Engine("bosonic")
cat = eng.run(prog_cat).state
# Calculate the asymptotic quadrature distributions
scale = np.sqrt(sf.hbar)
quad = np.linspace(-6, 6, 1000) * scale
cat_prob_x = cat.marginal(0, quad)
cat_prob_p = cat.marginal(0, quad, phi=np.pi / 2)
# Run the program again, collecting x samples this time
prog_cat_x = sf.Program(1)
with prog_cat_x.context as q:
    sf.ops.Catstate(alpha=2) | q
    sf.ops.MeasureX | q
eng = sf.Engine("bosonic")
cat_samples_x = eng.run(prog_cat_x, shots=2000).samples[:, 0]
# Run the program again, collecting p samples this time
prog_cat_p = sf.Program(1)
with prog_cat_p.context as q:
    sf.ops.Catstate(alpha=2) | q
    sf.ops.MeasureP | q
eng = sf.Engine("bosonic")
cat_samples_p = eng.run(prog_cat_p, shots=2000).samples[:, 0]
# Plot the results

#!/usr/bin/env python3
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#     http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import strawberryfields as sf
from strawberryfields.ops import *
from strawberryfields.utils import operation
@operation(4)
def prepare_squeezing(q):
    """This operation prepares modes 0 and 1
    as squeezed states with r = -1.
    Args:
        q (register): the qumode register.
    """
    S = Sgate(-1)
    S | q[0]
    S | q[1]
@operation(3)
def circuit_op(v1, v2, q):
    """Some gates that are groups into a custom operation.
    Args:
        v1 (float): parameter for CZgate
        v2 (float): parameter for the cubic phase gate
        q (register): the qumode register
    """
    CZgate(v1) | (q[0], q[1])
    Vgate(v2) | q[1]
# initialize engine and program objects
eng = sf.Engine(backend="fock", backend_options={"cutoff_dim": 5})
circuit = sf.Program(4)
with circuit.context as q:
    # The following operation takes no arguments
    prepare_squeezing() | q
    # another operation with 2 parameters that operates on three registers: 0, 1