The qINTERCONNECT solver is a Python module that can be called from within the INTERCONNECT scripting environment or from an external Python environment (e.g. a Jupyter notebook). Since qINTERCONNECT requires a GUI license to run, two licenses are required to run qINTERCONNECT directly within the INTERCONNECT scripting environment. Users with only one available license must run qINTERCONNECT from an external Python environment. First, verify that the version of Python being used is the packaged version. Next, add the necessary directories to path and import the qINTERCONNECT solver as shown below.

import sys
from qinterconnect.solver import QSolver

Additionally, Matplotlib and NumPy Python modules must be loaded

from matplotlib import pyplot as plt
import numpy as np

QSolver

A qINTERCONNECT simulation is configured by creating a QSolver object with a set of parameters. For more information on the qINTERCONNECT solver physics, see qINTERCONNECT Solver Introduction.

The QSolver object contains several methods to further configure and run a simulation. These methods are described in the following table.

Required Parameters

The properties of each simulation are set within the params argument of the QSolver object. The params argument is a dictionary defining the simulation parameters with the following fields:

{ (0,1) : [0.5,0], 
(1,0) : [0.866,0] }

Other options of the params dictionary

The fidelity of a quantum circuit can be calculated if the expected output state is specified.

If manually including loss channels (not with the .add_loss_ports() method), information about the loss channels must also be specified:

Sweeps over parameter values can be performed with the “parameters” argument of params:

Optionally, a custom S-matrix can be used to run a simulation in place of using an S-matrix generated from INTERCONNECT.

The following parameters are used for multi-frequency simulations.

Results

After the simulation has run, we can use the following commands to access various useful properties of the QSolver object.

simulation = QSolver(**params)
simulation.run()

# simulation has the following results:

We can also access any input parameter to our simulation by calling, for example, simulation.ket_in
After a sweep is performed, we can access the fidelity and probability of success over the range of the sweep through the following commands

simulation = QSolver(**params)
Results = simulation.run_sweep()

# Results has the following results:

Example_1

The following script shows the syntax for configuring the params argument and running a sweep over a circuit parameter “theta_1” in an INTERCONNECT project file named ‘NLS_ideal.icp’. The fidelity is plotted as a function of the swept parameter and the final density matrix for the last simulation in the sweep is shown.

nlsparams_sweep = {
    "mode_per_channel": 1,
    "nchannel": 3,
    "interconnect_file": "NLS_ideal.icp",
    "circuit": "NLS",
    "input_ports": ["signal_in", "ancilla1_in", "ancilla0_in"],
    "output_ports": ["signal_out", "ancilla1_out", "ancilla0_out"],
    "parameters":{
        "theta_1":[1.00,1.3,0.025]
        },
    "nmax":3,
    "input_dims": [3,3,3],
    "ket_in":{
        (0, 1, 0): [0.4,0],
        (1, 1, 0): [0.1,0],
        (2, 1, 0): [0.91104,0]
        },
    "ket_out":{
        (0,): [0.4,0],
        (1,): [0.1,0],
        (2,): [-0.91104,0]
        },
    "measurement_mask":[100,1,0]
    }
nls_sweep = QSolver(**nlsparams_sweep)
results = nls_sweep.run_sweep()

data = np.array(results["Fidelity"])
theta_1 = np.array(results["paramVals"])
plt.plot(theta_1[0], data)
plt.xlabel(r"$\theta$$_{1}$",size=20)
plt.ylabel("Fidelity",size=15)

print('Final density matrix for the last simulation in the sweep is: \n',nls_sweep.rho_final[:])

UnitaryCircuit

The UnitaryCircuit method can be used to automatically generate a circuit in INTERCONNECT with an S-matrix corresponding to a user-defined unitary matrix. The circuit is constructed using Clements decomposition, resulting in a mesh of a beamsplitter elements which consist of 50:50 directional couplers and phase shifters [1]. The method must first be imported from the qINTERCONNECT solver as shown below.

from qinterconnect.solver import UnitaryCircuit

The syntax for calling the UnitaryCircuit method is given in the following table:

Example_2

For example, the circuit for a randomly generated 6x6 unitary matrix can be created as follows:

from qinterconnect.solver import UnitaryCircuit
from scipy.stats import unitary_group

unitary_matrix=unitary_group.rvs(6)
myU=UnitaryCircuit(unitary_matrix)
myU.construct_circuit("Clements","unitary_6x6.icp")

For a more detailed example see Unitary Circuit Generation and Simulation – Ansys Optics.

Related Publications 

1. W. R. Clements, P. C. Humphreys, B. J. Metcalf, W. S. Kolthammer and I. A. Walmsley, "Optimal design for universal multiport interferometers", Optica Vol. 3, No. 12, p. 1460-1465, 2016.