From 55ead254ae11203a924c3df3a37e016134902e56 Mon Sep 17 00:00:00 2001 From: minatoyuichiro Date: Mon, 18 Apr 2022 01:41:49 +0000 Subject: [PATCH 1/2] add photonqat --- blueqat/_version.py | 3 +- blueqat/photonqat/Fock.py | 133 +++++++++++++ blueqat/photonqat/Fockbase/WignerFunc.py | 130 +++++++++++++ blueqat/photonqat/Fockbase/__init__.py | 4 + blueqat/photonqat/Fockbase/bosonicLadder.py | 165 ++++++++++++++++ blueqat/photonqat/Fockbase/gateOps.py | 155 +++++++++++++++ blueqat/photonqat/Fockbase/gates.py | 178 +++++++++++++++++ blueqat/photonqat/Fockbase/stateOps.py | 33 ++++ blueqat/photonqat/Fockbase/states.py | 67 +++++++ blueqat/photonqat/Gaussian.py | 182 ++++++++++++++++++ blueqat/photonqat/Gaussianformula/__init__.py | 2 + blueqat/photonqat/Gaussianformula/baseFunc.py | 73 +++++++ blueqat/photonqat/Gaussianformula/gateOps.py | 91 +++++++++ blueqat/photonqat/Gaussianformula/gates.py | 176 +++++++++++++++++ blueqat/photonqat/Gaussianformula/ordering.py | 72 +++++++ blueqat/photonqat/__init__.py | 3 + blueqat/photonqat/opt.py | 9 + setup.py | 2 +- 18 files changed, 1476 insertions(+), 2 deletions(-) create mode 100644 blueqat/photonqat/Fock.py create mode 100644 blueqat/photonqat/Fockbase/WignerFunc.py create mode 100644 blueqat/photonqat/Fockbase/__init__.py create mode 100644 blueqat/photonqat/Fockbase/bosonicLadder.py create mode 100644 blueqat/photonqat/Fockbase/gateOps.py create mode 100644 blueqat/photonqat/Fockbase/gates.py create mode 100644 blueqat/photonqat/Fockbase/stateOps.py create mode 100644 blueqat/photonqat/Fockbase/states.py create mode 100644 blueqat/photonqat/Gaussian.py create mode 100644 blueqat/photonqat/Gaussianformula/__init__.py create mode 100644 blueqat/photonqat/Gaussianformula/baseFunc.py create mode 100644 blueqat/photonqat/Gaussianformula/gateOps.py create mode 100644 blueqat/photonqat/Gaussianformula/gates.py create mode 100644 blueqat/photonqat/Gaussianformula/ordering.py create mode 100644 blueqat/photonqat/__init__.py create mode 100644 blueqat/photonqat/opt.py diff --git a/blueqat/_version.py b/blueqat/_version.py index 56d0b90..06a6ce4 100644 --- a/blueqat/_version.py +++ b/blueqat/_version.py @@ -14,4 +14,5 @@ """The version of blueqat.""" -__version__ = "0.5.0-dev" +__version__ = "0.6.0" +#__version__ = "0.5.0-dev" diff --git a/blueqat/photonqat/Fock.py b/blueqat/photonqat/Fock.py new file mode 100644 index 0000000..9f3178f --- /dev/null +++ b/blueqat/photonqat/Fock.py @@ -0,0 +1,133 @@ +import numpy as np +import matplotlib.pyplot as plt +from .Fockbase.gates import * +from .Fockbase.gateOps import homodyneFock +from .Fockbase.states import * +from .Fockbase.WignerFunc import * + +STATE_SET = { + "vacuum": vacuumState, + "coherent": coherentState, + "cat": catState, + "n_photon": photonNumberState +} + +GATE_SET = { + "D": Dgate, + "BS": BSgate, + "S": Sgate, + "Kerr": Kgate, + "MeasF": MeasF, + "MeasX": MeasX, + "MeasP": MeasP, + "polyH": polyH, +} + +class Fock(): + """ + Class for continuous variable quantum compting in Fock basis. + """ + def __init__(self, N, cutoff = 10): + self.N = N + self.cutoff = cutoff + self.initState = np.zeros([N, self.cutoff + 1]) + 0j + self.initState[:, 0] = 1 + self.state = None + self.initStateFlag = False + self.ops = [] + self.creg = [[None, None, None] for i in range(self.N)] # [x, p, n] + + def __getattr__(self, name): + if name in STATE_SET: + if self.initStateFlag: + raise ValueError("State must be set before gate operation.") + self.ops.append(STATE_SET[name]) + return self._setGateParam + + elif name in GATE_SET: + self.ops.append(GATE_SET[name]) + self.initStateFlag = True + return self._setGateParam + + else: + raise AttributeError('The method does not exist') + + def _setGateParam(self, *args, **kwargs): + self.ops[-1] = self.ops[-1](self, *args, **kwargs) + return self + + def Creg(self, idx, var, scale = 1): + """ + Access to classical register. + """ + return CregReader(self.creg, idx, var, scale) + + def run(self): + """ + Run the circuit. + """ + for op in self.ops: + if isinstance(op, STATE): + self.initState = op.run(self.initState) + elif isinstance(op, GATE): + if self.state is None: + self.state = self._multiTensordot() + self.state = op.run(self.state) + sum_of_prob = np.sum(np.abs(self.state)**2) + if np.abs(1 - sum_of_prob) < 0.3: + self.state /= np.sqrt(sum_of_prob) + # print(op, np.sum(np.abs(self.state)**2)) + return self + + def _multiTensordot(self): + self.state = self.initState[0, :] + for i in range(self.N - 1): + self.state = np.tensordot(self.state, self.initState[i+1, :], axes = 0) + return self.state + + def Wigner(self, mode, method = 'clenshaw', plot = 'y', xrange = 5.0, prange = 5.0): + """ + Calculate the Wigner function of a selected mode. + + Args: + mode (int): Selecting a optical mode. + method: "clenshaw" (default) or "moyal". + plot: If 'y', the plot of wigner function is output using matplotlib.\ + If 'n', only the meshed values are returned. + x(p)range: The range in phase space for calculateing Wigner function. + """ + if self.state is None: + self.state = self._multiTensordot() + self.initState == None + x = np.arange(-xrange, xrange, xrange / 50) + p = np.arange(-prange, prange, prange / 50) + m = len(x) + xx, pp = np.meshgrid(x, -p) + W = FockWigner(xx, pp, self.state, mode, method) + if plot == 'y': + h = plt.contourf(x, p, W) + plt.show() + return (x, p, W) + + def photonSampling(self, mode, ite = 1): + """ + Simulate the result of photon number resolving measurement for a selected mode. + + Args: + mode (int): Selecting a optical mode. + ite: The number of sampling. + """ + if self.state is None: + self.state = self._multiTensordot() + self.initState == None + reducedDensity = reduceState(self.state, mode) + probs = np.real(np.diag(reducedDensity)) + probs = probs / np.sum(probs) + return np.random.choice(probs.shape[0], ite, p = probs) + + def homodyneSampling(self, mode, theta, ite = 1): + if self.state is None: + self.state = self._multiTensordot() + self.initState == None + res, psi = homodyneFock(self.state, mode, theta, ite = ite) + return res diff --git a/blueqat/photonqat/Fockbase/WignerFunc.py b/blueqat/photonqat/Fockbase/WignerFunc.py new file mode 100644 index 0000000..e823503 --- /dev/null +++ b/blueqat/photonqat/Fockbase/WignerFunc.py @@ -0,0 +1,130 @@ + + +""" +`WignerFunc` module implements calculation of Wigner function. +This module is internally used. +""" + +import numpy as np +from scipy.special import factorial as fact + +def FockWigner(xmat, pmat, fockState, mode, method = 'clenshaw', tol=1e-10): + if fockState.ndim < mode + 1: + raise ValueError("The mode is not exist.") + if fockState.ndim > 1: + rho = reduceState(fockState, mode) + else: + rho = np.outer(np.conj(fockState), fockState) + if method == 'moyal': + W = _Wigner_Moyal(rho, xmat, pmat, tol) + elif method == 'clenshaw': + W = _Wigner_clenshaw(rho, xmat, pmat, tol) + else: + raise ValueError("method is invalid.") + return W + +def reduceState(fockState, mode): + modeNum = fockState.ndim + cutoff = fockState.shape[-1] - 1 + fockState = np.swapaxes(fockState, mode, -1) + fockState = fockState.flatten() + rho = np.outer(np.conj(fockState), fockState) + for i in range(modeNum - 1): + rho = partialTrace(rho, cutoff) + return rho + +def partialTrace(rho, cutoff): + dim1 = np.int(cutoff + 1) + dim2 = np.int(rho.shape[0] / dim1) + rho_ = np.zeros([dim2, dim2]) + 0j + for j in range(dim1): + rho_ += rho[(j * dim2):(j * dim2 + dim2), (j * dim2):(j * dim2 + dim2)] + return rho_ + +def _Wigner_Moyal(rho, xmat, pmat, tol): + dim = rho.shape[0] + [l, m] = np.indices([dim, dim]) + A = np.max(np.dstack([l, m]), axis=2) + B = np.abs(l - m) + C = np.min(np.dstack([l, m]), axis=2) + R0 = xmat**2 + pmat**2 + xmat = xmat[:, :, np.newaxis, np.newaxis] + pmat = pmat[:, :, np.newaxis, np.newaxis] + R = xmat**2 + pmat**2 + X = xmat - np.sign(l-m) * 1j * pmat + W = 2 * (-1)**C * np.sqrt(2**(B) * fact(C) / fact(A)) + W = W * np.exp(-R) * X**(B) + S = _Sonin(C, B, 2 * R0) + W = W * S + W = rho * W + W = np.sum(np.sum(W, axis = -1), axis = -1) + if np.max(np.imag(W)) < tol: + W = np.real(W) + else: + raise ValueError("Wigner plot has imaginary value.") + return W + +# Based on QuTiP +def _Wigner_clenshaw(rho, xmat, pmat, tol, hbar = 1): + g = np.sqrt(2 / hbar) + M = rho.shape[0] + A2 = g * (xmat + 1.0j * pmat) + B = np.abs(A2) + B *= B + w0 = (2*rho[0, -1])*np.ones_like(A2) + L = M-1 + rho = rho * (2*np.ones((M,M)) - np.diag(np.ones(M))) + while L > 0: + L -= 1 + w0 = _Wigner_laguerre(L, B, np.diag(rho, L)) + w0 * A2 * (L+1)**-0.5 + W = w0 * np.exp(-B * 0.5) * (g ** 2 * 0.5 / np.pi) + # if np.max(np.imag(W)) < tol: + # W = np.real(W) + # else: + # raise ValueError("Wigner plot has imaginary value.") + W = np.real(W) + return W + +def _Wigner_laguerre(L, x, c): + + if len(c) == 1: + y0 = c[0] + y1 = 0 + elif len(c) == 2: + y0 = c[0] + y1 = c[1] + else: + k = len(c) + y0 = c[-2] + y1 = c[-1] + for i in range(3, len(c) + 1): + k -= 1 + y0, y1 = c[-i] - y1 * (float((k - 1)*(L + k - 1))/((L+k)*k))**0.5, \ + y0 - y1 * ((L + 2*k -1) - x) * ((L+k)*k)**-0.5 + + return y0 - y1 * ((L + 1) - x) * (L + 1)**-0.5 + +def _to_2d_ndarray(a): + if isinstance(a,(np.ndarray)): + return a + else: + return np.array([[a]]) + +# slow! +def _Sonin(n, alpha, x): + n = _to_2d_ndarray(n) + alpha = _to_2d_ndarray(alpha) + x = _to_2d_ndarray(x) + a = fact(n + alpha) + k0 = np.arange(np.max(n) + 1) + k0 = k0[:, np.newaxis, np.newaxis] + k = k0 * np.ones([np.max(n) + 1, n.shape[0], n.shape[0]], dtype = np.int) + mask = np.ones(k.shape, dtype = np.int) + for i in range(k.shape[0]): + ind = (np.ones(n.shape) * i) > n + mask[i, ind] = 0 + k *= mask + S = mask * (-1)**k * a / fact(n - k) / fact(k + alpha) / fact(k) + X = x ** k0 + S = S[:, np.newaxis, np.newaxis, :, :] * X[:, :, :, np.newaxis, np.newaxis] + return np.sum(S, axis = 0) \ No newline at end of file diff --git a/blueqat/photonqat/Fockbase/__init__.py b/blueqat/photonqat/Fockbase/__init__.py new file mode 100644 index 0000000..7c33f04 --- /dev/null +++ b/blueqat/photonqat/Fockbase/__init__.py @@ -0,0 +1,4 @@ +from .bosonicLadder import * +from .gates import * +from .states import * +from .WignerFunc import * \ No newline at end of file diff --git a/blueqat/photonqat/Fockbase/bosonicLadder.py b/blueqat/photonqat/Fockbase/bosonicLadder.py new file mode 100644 index 0000000..70d8168 --- /dev/null +++ b/blueqat/photonqat/Fockbase/bosonicLadder.py @@ -0,0 +1,165 @@ + +import numpy as np +from scipy.special import factorial as fact +from scipy.linalg import expm +from sympy.physics.quantum import Operator +from sympy.parsing.sympy_parser import parse_expr +from sympy import Matrix, matrix2numpy, MatrixSymbol +from sympy import I as symI + +def _downMat(dim, order): + if order == 0: + A = np.eye(dim) + return A + else: + A = np.zeros([dim, dim]) + for i in np.arange(order, dim): + A[i, i - order] = np.prod(np.sqrt(np.arange(i, i - order, -1))) + return A + +def _upMat(dim, order): + if order == 0: + A = np.eye(dim) + return A + else: + A = np.zeros([dim, dim]) + for i in np.arange(0, dim - order): + A[i, i + order] = np.prod(np.sqrt(np.arange(i + 1, i + 1 + order))) + return A + +def _downMatLeft(dim, order): + if order == 0: + A = np.eye(dim) + return A + else: + A = np.zeros([dim, dim]) + for i in np.arange(order, dim): + A[i - order, i] = np.prod(np.sqrt(np.arange(i, i - order, -1))) + return A + +def _upMatLeft(dim, order): + if order == 0: + A = np.eye(dim) + return A + else: + A = np.zeros([dim, dim]) + for i in np.arange(0, dim - order): + A[i - order, i] = np.prod(np.sqrt(np.arange(i + 1, i + 1 + order))) + return A + +def _nMat(dim, order): + if order == 0: + A = np.eye(dim) + return A + else: + A = np.diag(np.arange(dim) ** order) + return A + +def exp_annihiration(fockState, alpha, order = 1, cutoff = 10): + row = fockState.shape[0] + mat = _downMat(fockState.shape[-1], order) + mat_ = np.empty(mat.shape, dtype=np.complex) + mat_ = expm(alpha * mat) + res = np.dot(fockState, mat_) + return res + +def exp_creation(fockState, alpha, order = 1, cutoff = 10): + row = fockState.shape[0] + mat = _upMat(fockState.shape[-1], order) + mat_ = np.empty(mat.shape, dtype=np.complex) + mat_ = expm(alpha * mat) + res = np.dot(fockState, mat_) + return res + +def exp_photonNum(fockState, alpha, order = 1, cutoff = 10): + row = fockState.shape[0] + mat = _nMat(fockState.shape[-1], order) + mat_ = np.empty(mat.shape, dtype=np.complex) + mat_ = expm(alpha * mat) + res = np.dot(fockState, mat_) + return res + +def _mat_for_mode2(mat): + l = mat.shape[0] + mat_ = np.zeros(np.array(mat.shape)**2) + for i in range(mat.shape[0]): + mat_[i*l:i*l+l, i*l:i*l+l] = mat + return mat_ + +def _mat_for_mode1(mat): + l = mat.shape[0] + mat_ = np.zeros(np.array(mat.shape)**2) + for i in range(mat.shape[0]): + for j in range(mat.shape[0]): + mat_[i*l:i*l+l, j*l:j*l+l] = np.eye(l) * mat[i, j] + return mat_ + +def exp_BS(fockState, alpha, cutoff): + state = np.zeros(fockState.shape) + 0j + down = _downMat(cutoff + 1, 1) + up = _upMat(cutoff + 1, 1) + mat1_ = np.dot(_mat_for_mode1(up), _mat_for_mode2(down)) + mat2_ = np.dot(_mat_for_mode1(down), _mat_for_mode2(up)) + mat_ = mat1_ - mat2_ + emat_ = expm(alpha * mat_) + res = np.dot(fockState, emat_) + return res + +def exp_AAaa(fockState, alpha, cutoff): + mat = _downMat(fockState.shape[-1], 2) + #mat = np.dot(_upMat(fockState.shape[-1], 2), mat) + mat = np.dot(mat, _upMat(fockState.shape[-1], 2)) + mat_ = np.empty(mat.shape, dtype=np.complex) + mat_ = expm(alpha * mat) + res = np.dot(fockState, mat_) + return res + +def exp_aa_minus_AA(fockState, alpha, cutoff): + mat_a = _downMat(fockState.shape[-1], 2) # aa + mat_A = _upMat(fockState.shape[-1], 2) # AA + mat_ = np.empty(mat_a.shape, dtype=np.complex) + mat_ = expm(np.conj(alpha) * mat_a - alpha * mat_A) + res = np.dot(fockState, mat_) + return res + +def expand_xp_to_aA(expr_string, dim, evaluate = True, hbar = 1): + x = Operator('x') + p = Operator('p') + expr = parse_expr(expr_string, local_dict = {'x':x, 'p':p}) + a_ = Operator('a') + A_ = Operator('A') + expr_ = expr.subs([(x, (a_ + A_) * sym.sqrt(hbar / 2)), (p, (a_ - A_) * sym.sqrt(hbar / 2) / 1j)]) + expr_ = expr_.expand() + aA = str(expr_) + if evaluate == False: + return aA + + a = sym.MatrixSymbol('a', dim, dim) + A = sym.MatrixSymbol('A', dim, dim) + down = Matrix(downMatLeft(dim, 1)) + up = Matrix(upMatLeft(dim, 1)) + expr__ = parse_expr(aA, local_dict = {'a':a, 'A':A, 'I':sym.I}) + expr__ = expr__.subs([(a, down), (A, up)]) + res = matrix2numpy(expr__, dtype = np.complex) + return res + +def exp_str_aA(expr_string, alpha, N = 5): + a = sym.Symbol('a', commutative = False) + A = sym.Symbol('A', commutative = False) + E = sym.Symbol('E', commutative = False) + expr = parse_expr(expr_string, local_dict = {'a':a, 'A':A}) + exp_expr = E + for i in range(1, N + 1): + exp_expr += alpha**i * (expr)**i / np.math.factorial(i) + exp_aA = exp_expr.expand() + return str(exp_aA) + +def str_to_aA_mat(expr_string, dim, hbar = 1): + a = sym.MatrixSymbol('a', dim, dim) + A = sym.MatrixSymbol('A', dim, dim) + down = Matrix(_downMatLeft(dim, 1)) + up = Matrix(_upMatLeft(dim, 1)) + expr_ = parse_expr(expr_string, local_dict = {'a':a, 'A':A, 'I':sym.I, 'E':sym.eye(dim)}) + expr_ = expr_.subs([(a, down), (A, up)]) + res = matrix2numpy(expr_, dtype = np.complex) + return res \ No newline at end of file diff --git a/blueqat/photonqat/Fockbase/gateOps.py b/blueqat/photonqat/Fockbase/gateOps.py new file mode 100644 index 0000000..ec5a56e --- /dev/null +++ b/blueqat/photonqat/Fockbase/gateOps.py @@ -0,0 +1,155 @@ + +""" +`gateOps` module implements calculation for quantum gate operations. +This module may be redefined as a backend option in later versions. +""" + + +import numpy as np +from .bosonicLadder import * +from .WignerFunc import reduceState, partialTrace +from scipy.special import eval_hermite as hermite +from scipy.linalg import expm + +def Displacement(state, mode, alpha, modeNum, cutoff): + state = _singleGate_preProcess(state, mode) + state = exp_annihiration(state, -np.conj(alpha), cutoff = cutoff) + state = exp_creation(state, alpha, cutoff = cutoff) + state = _singleGate_postProcess(state, mode, modeNum) + state = state * np.exp(-np.abs(alpha)**2 / 2) + return state + +def Beamsplitter(state, mode1, mode2, theta, modeNum, cutoff): + if modeNum < 2: + raise ValueError("The gate requires more than one mode.") + state = _twoModeGate_preProcess(state, mode1, mode2) + state = exp_BS(state, -theta, cutoff = cutoff) + state = _twoModeGate_postProcess(state, mode1, mode2, modeNum) + return state + +def Squeeze(state, mode, r, phi, modeNum, cutoff): + G = np.exp(2 * 1j * phi) * np.tanh(r) + state = _singleGate_preProcess(state, mode) + state = exp_annihiration(state, np.conj(G) / 2, order = 2, cutoff = cutoff) + state = exp_photonNum(state, -np.log(np.cosh(r)), cutoff = cutoff) + state = exp_creation(state, -G / 2, order = 2, cutoff = cutoff) + state = _singleGate_postProcess(state, mode, modeNum) + state = state / np.sqrt(np.cosh(r)) + return state + +# def Squeeze(state, mode, r, phi, modeNum, cutoff): +# state = _singleGate_preProcess(state, mode) +# state = exp_aa_minus_AA(state, r * np.exp(2j * phi) / 2, cutoff = cutoff) +# state = _singleGate_postProcess(state, mode, modeNum) +# return state + +def KerrEffect(state, mode, chi, modeNum, cutoff): + state = _singleGate_preProcess(state, mode) + state = exp_AAaa(state, 1j * chi / 2, cutoff = cutoff) + state = _singleGate_postProcess(state, mode, modeNum) + return state + +def HamiltonianEvo(state, mode, expr, gamma, modeNum, cutoff): + dim = state.shape[0] + str_aA = expand_xp_to_aA(expr, dim, evaluate = False, hbar = 1) + str_exp_aA = exp_str_aA(str_aA, -1j * gamma, N = 5) + mat = str_to_aA_mat(str_exp_aA, dim, hbar = 1) + state = _singleGate_preProcess(state, mode) + mat_ = expm(-1j * gamma * mat) + state = np.dot(mat_, state.T) + state = _singleGate_postProcess(state.T, mode, modeNum) + return state + +def photonMeasurement(state, mode, post_select): + reducedDensity = reduceState(state, mode) + probs = np.real(np.diag(reducedDensity)) + probs = probs / np.sum(probs) + if post_select is None: + res = np.random.choice(probs.shape[0], 1, p = probs) + else: + res = post_select + prob = probs[res] + + state_ = np.swapaxes(state, mode, 0) + ind = np.ones((state.shape[-1]), bool) + ind[res] = False + state_[ind] = 0 + state_ = np.swapaxes(state_, mode, 0) + state_ = state_ / np.sqrt(prob) + return res, state_ + +def homodyneMeasurement(state, mode, theta, post_select): + if post_select is None: + res, psi = homodyneFock(state, mode, theta, ite = 1, hbar = 1) + else: + res = post_select + state_ = _afterHomodyne(state, mode, res, psi, theta) + return res, state_ + +def homodyneFock(state, mode, theta, ite = 1, hbar = 1): + dim = state.shape[0] + rho = reduceState(state, mode) + lim = np.sqrt(dim * 2) + 3 # heuristic + q = np.arange(-lim, lim, lim / 500) + q_ = q / np.sqrt(hbar) + psi = _positionWaveFunc(dim, q_, theta) # psi_{n}(q, theta) + probs = np.zeros(q.shape) + 0j + for i in range(dim): + for j in range(dim): + tmp = rho[i, j] * psi[i, :] * np.conj(psi[j, :])# * np.exp(1j * theta * (j - i)) + probs += tmp + probs = np.abs(np.real(probs)) + probs_sum = np.abs(np.sum(probs)) + if 1 - probs_sum < 0.01: + probs = probs / probs_sum + else: + print("sum of probability", probs_sum) + raise ValueError('probabilities do not sum to 1') + res = np.random.choice(probs.shape[0], ite, p = probs) + return q[res], psi[:, res] + +def _afterHomodyne(state, mode, q, psi, theta): + dim = state.shape[-1] + modeNum = state.ndim + #psi = _positionWaveFunc(dim, q, theta) + state = _singleGate_preProcess(state, mode) + state = state * psi.T + state[:, 0] = np.sum(state, axis = -1) + state[:, 1:] = 0 + state = _singleGate_postProcess(state, mode, modeNum) + state = state / np.sqrt(np.sum(np.abs(state) ** 2)) + return state + +def _positionWaveFunc(n, q, theta, hbar = 1): + #lim = np.sqrt(n * 2) + 3 # heuristic + n_ = np.arange(n)[:, np.newaxis] + H = hermite(n_, q) + A = (np.pi * hbar) ** 0.25 / np.sqrt(2 ** n_ * fact(n)) + psi = A * H * np.exp(-q ** 2 / 2 / hbar) * np.exp(-1j * n_ * theta) + C = np.sum(np.abs(psi) ** 2, axis=1) + 0j # sum of squeres + psi = psi / np.sqrt(C)[:, np.newaxis] # normalized wave functions + return psi + +def _singleGate_preProcess(fockState, mode): + cutoff = fockState.shape[-1] - 1 + fockState = np.swapaxes(fockState, mode, fockState.ndim - 1) + return fockState.reshape(-1, cutoff + 1) + +def _singleGate_postProcess(fockState, mode, modeNum): + cutoff = fockState.shape[-1] - 1 + fockState = fockState.reshape([cutoff + 1] * modeNum) + return np.swapaxes(fockState, mode, modeNum - 1) + +def _twoModeGate_preProcess(fockState, mode1, mode2): + cutoff = fockState.shape[-1] - 1 + modeNum = fockState.ndim + fockState = np.swapaxes(fockState, mode2, modeNum - 1) + fockState = np.swapaxes(fockState, mode1, modeNum - 2) + return fockState.reshape(-1, (cutoff + 1) ** 2) + +def _twoModeGate_postProcess(fockState, mode1, mode2, modeNum): + dim = np.int(np.sqrt(fockState.shape[-1])) + fockState = fockState.reshape([dim] * modeNum) + fockState = np.swapaxes(fockState, mode1, modeNum - 2) + fockState = np.swapaxes(fockState, mode2, modeNum - 1) + return fockState diff --git a/blueqat/photonqat/Fockbase/gates.py b/blueqat/photonqat/Fockbase/gates.py new file mode 100644 index 0000000..b7b41d6 --- /dev/null +++ b/blueqat/photonqat/Fockbase/gates.py @@ -0,0 +1,178 @@ + +""" +`gate` module implements quantum gate operations. +This module is internally used. +""" + +import numpy as np +from .bosonicLadder import * +from .gateOps import * + +class GATE(): + """Quantum gate class.""" + def __init__(self, obj): + self.obj = obj + +class Dgate(GATE): + """ + Displacement gate. + """ + def __init__(self, obj, mode, alpha): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.alpha = alpha + super().__init__(obj) + + def run(self, state): + self.alpha = _paramCheck(self.alpha) + return Displacement(state, self.mode, self.alpha, self.N, self.cutoff) + +class BSgate(GATE): + """ + Beamsplitter gate. + """ + def __init__(self, obj, mode1, mode2, theta = np.pi / 4): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode1 = mode1 + self.mode2 = mode2 + self.theta = theta + super().__init__(obj) + + def run(self, state): + self.theta = _paramCheck(self.theta) + return Beamsplitter(state, self.mode1, self.mode2, self.theta, self.N, self.cutoff) + +class Sgate(GATE): + """ + Squeezing gate. + """ + def __init__(self, obj, mode, r, phi = 0): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.r = r + self.phi = phi + super().__init__(obj) + + def run(self, state): + self.r = _paramCheck(self.r) + self.phi = _paramCheck(self.phi) + return Squeeze(state, self.mode, self.r, self.phi, self.N, self.cutoff) + +class Kgate(GATE): + """ + Kerr gate. + """ + def __init__(self, obj, mode, chi): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.chi = chi + super().__init__(obj) + + def run(self, state): + self.chi = _paramCheck(self.chi) + return KerrEffect(state, self.mode, self.chi, self.N, self.cutoff) + +class polyH(GATE): + """ + Time evolution for one qumode Hamiltonian. + """ + def __init__(self, obj, mode, gamma, expr): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.gamma = gamma + self.expr = expr + if not isinstance(expr, str): + raise ValueError("Polynomial expression must be string.") + super().__init__(obj) + + def run(self, state): + self.gamma = _paramCheck(self.gamma) + return HamiltonianEvo(state, self.mode, self.expr, self.gamma, self.N, self.cutoff) + +class MeasF(GATE): + """ + Photon number measurement gate. + """ + def __init__(self, obj, mode, post_select = None): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.post_select = post_select + super().__init__(obj) + + def run(self, state): + res, state = photonMeasurement(state, self.mode, self.post_select) + self.obj.creg[self.mode][2] = res + return state + +class MeasX(GATE): + """ + Homodyne measurement gate. + """ + def __init__(self, obj, mode, post_select = None): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.post_select = post_select + super().__init__(obj) + + def run(self, state): + res, state = homodyneMeasurement(state, self.mode, 0, self.post_select) + self.obj.creg[self.mode][0] = res + return state + +class MeasP(GATE): + """ + Homodyne measurement gate. + """ + def __init__(self, obj, mode, post_select = None): + self.obj = obj + self.cutoff = self.obj.cutoff + self.N = self.obj.N + self.mode = mode + self.post_select = post_select + super().__init__(obj) + + def run(self, state): + res, state = homodyneMeasurement(state, self.mode, np.pi / 2, self.post_select) + self.obj.creg[self.mode][1] = res + return state + +def _paramCheck(param): + if isinstance(param, CregReader): + return param.read() + else: + return param + +class CregReader(): + """ + Class for reading classical register. + """ + def __init__(self, reg, idx, var, scale = 1): + self.reg = reg + self.idx = idx + self.var = var + self.scale = scale + + def read(self): + if self.var == "x": + v = 0 + elif self.var == "p": + v = 1 + elif self.var == "n": + v = 2 + else: + raise ValueError('Creg keeps measurement results of "x" or "p" or "n".') + return self.reg[self.idx][v] * self.scale \ No newline at end of file diff --git a/blueqat/photonqat/Fockbase/stateOps.py b/blueqat/photonqat/Fockbase/stateOps.py new file mode 100644 index 0000000..545fd2c --- /dev/null +++ b/blueqat/photonqat/Fockbase/stateOps.py @@ -0,0 +1,33 @@ + +import numpy as np +from scipy.special import factorial as fact + +def coherent(initState, mode, alpha, cutoff): + n = np.arange(cutoff + 1) + state = np.exp(- 0.5 * np.abs(alpha) ** 2) / np.sqrt(fact([n])) * alpha ** n + initState[mode, :] = state + return initState + +def vacuum(initState, mode): + initState[mode, :] = 0 + initState[mode, 0] = 1 + return initState + +# arXiv:quant-ph/0509137 +def cat(initState, mode, alpha, parity, cutoff): + n = np.arange(cutoff + 1) + if parity == 'e': + N = 1 / np.sqrt(2 * (1 + np.exp(-2 * np.abs(alpha) ** 2))) + coeff = 2 * N * np.exp(-(np.abs(alpha) ** 2) / 2) + initState[mode, :] = coeff * alpha ** (n) / np.sqrt(fact(n)) * np.mod(n + 1, 2) + elif parity == 'o': + N = 1 / np.sqrt(2 * (1 - np.exp(-2 * np.abs(alpha)**2))) + coeff = 2 * N * np.exp(-(np.abs(alpha) ** 2) / 2) + initState[mode, :] = coeff * alpha ** (n) / np.sqrt(fact(n)) * np.mod(n, 2) + return initState + +def photonNumState(initState, mode, n, cutoff): + photonNumState = np.zeros(cutoff + 1) + photonNumState[n] = 1 + initState[mode, :] = photonNumState + return initState \ No newline at end of file diff --git a/blueqat/photonqat/Fockbase/states.py b/blueqat/photonqat/Fockbase/states.py new file mode 100644 index 0000000..8399236 --- /dev/null +++ b/blueqat/photonqat/Fockbase/states.py @@ -0,0 +1,67 @@ + +""" +`state` module implements quantum state preparation. +This module is internally used. +""" + +import numpy as np +from .stateOps import * + +class STATE(): + """Quantum state preparating class.""" + def __init__(self, obj): + self.obj = obj + +class coherentState(STATE): + """ + Coherent state. + """ + def __init__(self, obj, mode, alpha): + self.obj = obj + self.cutoff = self.obj.cutoff + self.mode = mode + self.alpha = alpha + super().__init__(obj) + + def run(self, initState): + return coherent(initState, self.mode, self.alpha, self.cutoff) + +class vacuumState(STATE): + """ + Vacuum state. + """ + def __init__(self, obj, mode): + self.obj = obj + self.mode = mode + super().__init__(obj) + + def run(self, initState): + return vacuum(initState, self.mode) + +class catState(STATE): + """ + Cat state. + """ + def __init__(self, obj, mode, alpha, parity): + self.obj = obj + self.cutoff = self.obj.cutoff + self.mode = mode + self.alpha = alpha + self.parity = parity + if (parity != "e") and (parity != "o"): + raise ValueError("parity must be 'e'(even) or 'o'(odd).") + + def run(self, initState): + return cat(initState, self.mode, self.alpha, self.parity, self.cutoff) + +class photonNumberState(STATE): + """ + Photon number state. + """ + def __init__(self, obj, mode, n): + self.obj = obj + self.cutoff = self.obj.cutoff + self.mode = mode + self.n = n + def run(self, initState): + return photonNumState(initState, self.mode, self.n, self.cutoff) diff --git a/blueqat/photonqat/Gaussian.py b/blueqat/photonqat/Gaussian.py new file mode 100644 index 0000000..b245545 --- /dev/null +++ b/blueqat/photonqat/Gaussian.py @@ -0,0 +1,182 @@ +import numpy as np +from .Gaussianformula.baseFunc import * +from .Gaussianformula.ordering import * +from .Gaussianformula.gates import * +import matplotlib.pyplot as plt + +GATE_SET = { + "D": Dgate, + "BS": BSgate, + "S": Sgate, + "R": Rgate, + "XS": Sgate, + "PS": PSgate, + "X": Xgate, + "Z": Zgate, + "TMS": TMSgate, + "MeasX": MeasX, + "MeasP": MeasP +} + +class Gaussian(): + """ + Class for continuous variable quantum compting in Gaussian formula. + This class can only deal with gaussian states and gaussian gate. + """ + def __init__(self, N): + self.N = N + self.V = (np.eye(2 * N)) * 0.5 + self.mu = np.zeros(2 * N) + self.ops = [] + self.creg = [[None, None] for i in range(self.N)] # [x, p] + + def __getattr__(self, name): + if name in GATE_SET: + self.ops.append(GATE_SET[name]) + return self._setGateParam + else: + raise AttributeError('The state method does not exist') + + def _setGateParam(self, *args, **kwargs): + self.ops[-1] = self.ops[-1](self, *args, **kwargs) + return self + + def Creg(self, idx, var, scale = 1): + return CregReader(self.creg, idx, var, scale) + + def run(self): + """ + Run the circuit. + """ + for gate in self.ops: + [self.mu, self.V] = gate.run(state = [self.mu, self.V]) + return self + + def mean(self, idx): + res = np.copy(self.mu[2 * idx:2 * idx + 2]) + return res + + def cov(self, idx): + res = np.copy(self.V[(2 * idx):(2 * idx + 2), (2 * idx):(2 * idx + 2)]) + return res + + def Wigner(self, idx, plot = 'y', xrange = 5.0, prange = 5.0): + """ + Calculate the Wigner function of a selected mode. + + Args: + mode (int): Selecting a optical mode + plot: If 'y', the plot of wigner function is output using matplotlib. If 'n', only the meshed values are returned + x(p)range: The range in phase space for calculateing Wigner function + + """ + idx = idx * 2 + x = np.arange(-xrange, xrange, 0.1) + p = np.arange(-prange, prange, 0.1) + m = len(x) + xx, pp = np.meshgrid(x, p) + xi_array = np.dstack((pp, xx)) + W = np.zeros((m, m)) + for i in range(m): + for j in range(m): + W[i][j] = GaussianWigner(xi_array[j][i], self.V[idx:idx+2, idx:idx+2], self.mu[idx:idx+2]) + if plot == 'y': + h = plt.contourf(x, p, W) + plt.show() + return (x, p, W) + + def PhotonDetectionProb(self, m, n): + """ + Calculate Fock density matrix element rho_{mn}. + m and n should be numpy array which length is same as mode number. + When m = n, the returned value is probability for photon number m is measured. + For example, if m = n = np.array([0, 0]), returned value is probability \ + for detecting 0 photon for both two modes. + """ + if len(m) != self.N or len(n) != self.N: + raise ValueError("Input array dimension must be same as mode Number.") + return np.real(FockDensityMatrix(self.V, self.mu, m, n)) + + def GaussianToFock(self, cutoffDim = 10): + photonNumList = [] + cutoffDim += 1 + rho = np.empty([cutoffDim ** self.N, cutoffDim ** self.N]) + for i in range(cutoffDim ** self.N): + photonNum = [] + for j in range(self.N): + photonNum.insert(0, np.int(np.floor(i / (cutoffDim ** j))) % cutoffDim) + photonNumList.append(photonNum) + + for i in range(cutoffDim ** self.N): + for j in range(cutoffDim ** self.N): + m = np.array(photonNumList[i]) + n = np.array(photonNumList[j]) + row = [m[i] ** (self.N - i - 1) for i in range(self.N)] + col = [n[i] ** (self.N - i - 1) for i in range(self.N)] + rho[row, col] = FockDensityMatrix(self.V, self.mu, m, n) + + return rho + + def Interferometer(self, U): + num = self.N + n = U.shape[0] + BSang = [0]*(int(n*(n-1)/2)) + rot = [0]*(int(n*(n-1)/2)) + for i in range (1, n): + if ((i+2)%2==1): + for j in range (i): + T = np.identity(n, dtype = complex) + if U[n-j-1][i-j-1]==0: + theta = 0 + alpha = 0 + elif U[n-j-1][i-j]==0: + theta = 0 + alpha = np.pi/2 + else: + theta = np.angle(U[n-j-1][i-1-j])-np.angle(U[n-j-1][i-j]) + alpha = np.arctan(np.absolute(U[n-j-1][i-1-j])/np.absolute(U[n-j-1][i-j])) + BSang[int(i/2)+j] = alpha + rot[int(i/2)+j] = theta + e = np.cos(-theta) + np.sin(-theta)*1j + T[i-1-j][i-1-j] = e*(np.cos(alpha)+0*1j) + T[i-1-j][i-j] = -np.sin(alpha)+0*1j + T[i-j][i-1-j] = e*(np.sin(alpha)+0*1j) + T[i-j][i-j] = np.cos(alpha)+0*1j + U = U @ np.transpose(T) + else: + for j in range (i): + T = np.identity(n, dtype = complex) + if U[n-i+j][j]==0: + theta = 0 + alpha = 0 + elif U[n-i+j-1][j]==0: + theta = 0 + alpha = np.pi/2 + else: + theta = -np.angle(U[n-i+j-1][j])+np.angle(U[n-i+j][j]) + alpha = np.arctan(-(np.absolute(U[n-i+j][j])/np.absolute(U[n-i+j-1][j]))) + BSang[-(i-1+j)] = alpha + rot[-(i-1+j)] = theta + e = np.cos(theta) + np.sin(theta)*1j + T[n-i+j-1][n-i+j-1] = e*(np.cos(alpha)+0*1j) + T[n-i+j-1][n-i+j] = -np.sin(alpha)+0*1j + T[n-i+j][n-i+j-1] = e*(np.sin(alpha)+0*1j) + T[n-i+j][n-i+j] = np.cos(alpha)+0*1j + U = T @ U + + counter = 0 + for i in range(1, n, 2): + for k in range(i): + self.ops.append(GATE_SET['R']) + self.ops[-1] = self.ops[-1](self, i-1-k, rot[counter]) + self.ops.append(GATE_SET['BS']) + self.ops[-1] = self.ops[-1](self, i-1-k, i-1-k+1, BSang[counter]) + counter += 1 + for i in reversed(range(2, n-2 if (n-1)%2==0 else n-1, 2)): + for k in range(i): + self.ops.append(GATE_SET['R']) + self.ops[-1] = self.ops[-1](self, n-2-k, rot[counter]) + self.ops.append(GATE_SET['BS']) + self.ops[-1] = self.ops[-1](self, n-2-k, n-1-k, BSang[counter]) + counter += 1 + diff --git a/blueqat/photonqat/Gaussianformula/__init__.py b/blueqat/photonqat/Gaussianformula/__init__.py new file mode 100644 index 0000000..896e6c0 --- /dev/null +++ b/blueqat/photonqat/Gaussianformula/__init__.py @@ -0,0 +1,2 @@ +from .baseFunc import * +from .ordering import * \ No newline at end of file diff --git a/blueqat/photonqat/Gaussianformula/baseFunc.py b/blueqat/photonqat/Gaussianformula/baseFunc.py new file mode 100644 index 0000000..da11760 --- /dev/null +++ b/blueqat/photonqat/Gaussianformula/baseFunc.py @@ -0,0 +1,73 @@ +import numpy as np +from .ordering import * +from scipy import special +from thewalrus import hafnian + +def GaussianWigner(xi, V, mu): + xi = xi - mu + xi_tmp = np.ravel(xi) + N = np.int(len(xi_tmp) / 2) + det_V = np.linalg.det(V) + V_inv = np.linalg.inv(V) + W = (2 * np.pi)**(-N) / np.sqrt(det_V) * np.exp(-1/2 * np.dot(xi_tmp, np.dot(V_inv, xi_tmp.T))) + return W + +def StateAfterMeasurement(mu, V, idx, res, Pi): + N = np.int(V.shape[0] / 2) + subSysA = np.delete(np.delete(V, [2 * idx, 2 * idx + 1], 0), [2 * idx, 2 * idx + 1], 1) + subSysB = V[(2 * idx):(2 * idx + 2), (2 * idx):(2 * idx + 2)] + arrayList = [] + for j in range(N): + if j != idx: + arrayList.append(V[(2 * j):(2 * j + 2), (2 * idx):(2 * idx + 2)]) + C = np.concatenate(arrayList) + post_V = subSysA - np.dot(C, np.dot(1 / np.sum(subSysB * Pi) * Pi, C.T)) + post_V = np.insert(post_V, 2 * idx, [[0], [0]], axis = 0) + post_V = np.insert(post_V, 2 * idx, [[0], [0]], axis = 1) + post_V[2 * idx, 2 * idx] = 1 + post_V[2 * idx + 1, 2 * idx + 1] = 1 + + post_mu = np.delete(mu, [2 * idx, 2 * idx + 1]) + \ + np.dot(np.dot(C, 1 / np.sum(subSysB * Pi) * Pi), res * np.diag(Pi) - mu[(2 * idx):(2 * idx + 2)]) + post_mu = np.insert(post_mu, 2 * idx, [0, 0]) + + return post_mu, post_V + +def GaussianQfunc(alpha, V, mu): + mu_Q = RtoTvec(mu) + V_Q = RtoTmat(V) + alpha_Q = RtoTvec(alpha) + alpha_Q = alpha_Q - mu_Q + V_Q = V_Q + (np.eye(V_Q.shape[0]) * 0.5) + + det_V_Q = np.linalg.det(V_Q) + V_Qinv = np.linalg.inv(V_Q) + + Q = 1 / np.sqrt(det_V_Q * np.pi) * np.exp(-1/2 * np.dot(np.conj(alpha_Q), np.dot(V_Qinv, alpha_Q))) + +def FockDensityMatrix(cov, mu, m, n, tol = 1e-10): + if np.max(cov - cov.T) > tol: + raise ValueError("Covariance matrix must be symmetric.") + else: + cov = (cov + cov.T) / 2 + + N = np.int(cov.shape[0] / 2) + cov_Q = RtoQmat(cov) + cov_Q_inv = np.linalg.inv(cov_Q) + cov_Q_det = np.linalg.det(cov_Q) + mu_Q = RtoTvec(mu) + + T1 = np.exp(-0.5 * np.dot(np.dot(np.conj(mu_Q), cov_Q_inv), mu_Q)) + T2 = np.sqrt(cov_Q_det * np.prod(special.factorial(m)) * np.prod(special.factorial(n))) + T = T1 / T2 + + X = np.block([[np.zeros([N, N]), np.eye(N)], [np.eye(N), np.zeros([N, N])]]) + A = np.dot(X, (np.eye(2 * N) - cov_Q_inv)) + A = (A + A.T) / 2 # cancel the numeric error of symmetray + A_rp = np.repeat(A, np.hstack([n, m]), axis = 0) + A_rp = np.repeat(A_rp, np.hstack([n, m]), axis = 1) + gamma = np.dot(np.conj(mu_Q), cov_Q_inv) + gamma_rp = np.repeat(gamma, np.hstack([n, m])) + np.fill_diagonal(A_rp, gamma_rp) + prob = T * hafnian(A_rp, loop = True) + return prob diff --git a/blueqat/photonqat/Gaussianformula/gateOps.py b/blueqat/photonqat/Gaussianformula/gateOps.py new file mode 100644 index 0000000..645f0b9 --- /dev/null +++ b/blueqat/photonqat/Gaussianformula/gateOps.py @@ -0,0 +1,91 @@ + +import numpy as np +from .baseFunc import StateAfterMeasurement + +def Xsqueeze(state, N, idx, r): + mu = state[0] + V = state[1] + idx = 2 * idx + S = np.eye(2 * N) + S[idx:idx+2, idx:idx+2] = np.array([[np.exp(-r), 0], [0, np.exp(r)]]) + V_ = np.dot(S, np.dot(V, S.T)) + mu_ = np.dot(S, mu) + return [mu_, V_] + +def Rotation(state, N, idx, theta): + mu = state[0] + V = state[1] + idx = 2 * idx + S = np.eye(2 * N) + S[idx:idx+2, idx:idx+2] = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) + V_ = np.dot(S, np.dot(V, S.T)) + mu_ = np.dot(S, mu) + return [mu_, V_] + +# 10.1103/RevModPhys.77.513 +def Beamsplitter(state, N, idx1, idx2, theta): + mu = state[0] + V = state[1] + idx1 = 2 * idx1 + idx2 = 2 * idx2 + S = np.eye(2 * N) + S[idx1:idx1+2, idx1:idx1+2] = np.array([[np.cos(theta), 0], [0, np.cos(theta)]]) + S[idx1:idx1+2, idx2:idx2+2] = np.array([[np.sin(theta), 0], [0, np.sin(theta)]]) + S[idx2:idx2+2, idx1:idx1+2] = np.array([[-np.sin(theta), 0], [0, -np.sin(theta)]]) + S[idx2:idx2+2, idx2:idx2+2] = np.array([[np.cos(theta), 0], [0, np.cos(theta)]]) + V_ = np.dot(S, np.dot(V, S.T)) + mu_ = np.dot(S, mu) + return [mu_, V_] + +def Displace(state, idx, alpha): + mu = state[0] + V = state[1] + dx = np.real(alpha) * np.sqrt(2) # np.sqrt(2 * hbar) + dp = np.imag(alpha) * np.sqrt(2) # np.sqrt(2 * hbar) + mu[2 * idx:2 * idx + 2] = mu[2 * idx:2 * idx + 2] + np.array([dx, dp]) + mu_ = mu + return [mu_, V] + +def Xtrans(state, idx, dx): + mu = state[0] + V = state[1] + mu[2 * idx] += dx + mu_ = mu + return [mu_, V] + +def Ztrans(state, idx, dp): + mu = state[0] + V = state[1] + mu[2 * idx + 1] += dp + mu_ = mu + return [mu_, V] + +def twoModeSqueezing(state, N, idx1, idx2, r): + mu = state[0] + V = state[1] + idx1 = 2 * idx1 + idx2 = 2 * idx2 + S = np.eye(2 * N) + S[idx1:idx1+2, idx1:idx1+2] = np.array([[np.cosh(r), 0], [0, np.cosh(r)]]) + S[idx1:idx1+2, idx2:idx2+2] = np.array([[np.sinh(r), 0], [0, -np.sinh(r)]]) + S[idx2:idx2+2, idx1:idx1+2] = np.array([[np.sinh(r), 0], [0, -np.sinh(r)]]) + S[idx2:idx2+2, idx2:idx2+2] = np.array([[np.cosh(r), 0], [0, np.cosh(r)]]) + V_ = np.dot(S, np.dot(V, S.T)) + mu_ = np.dot(S, mu) + return [mu_, V_] + +def HomodyneX(state, idx): + mu = state[0] + V = state[1] + res = np.random.normal(mu[2 * idx], np.sqrt(V[2 * idx, 2 * idx])) + mu_, V_ = StateAfterMeasurement(mu, V, idx, res, np.diag([1, 0])) + return res, [mu_, V_] + +def HomodyneP(state, idx): + mu = state[0] + V = state[1] + res = np.random.normal(mu[2 * idx + 1], np.sqrt(V[2 * idx + 1, 2 * idx + 1])) + mu_, V_ = StateAfterMeasurement(mu, V, idx, res, np.diag([0, -1])) + return res, [mu_, V_] + + diff --git a/blueqat/photonqat/Gaussianformula/gates.py b/blueqat/photonqat/Gaussianformula/gates.py new file mode 100644 index 0000000..f64151b --- /dev/null +++ b/blueqat/photonqat/Gaussianformula/gates.py @@ -0,0 +1,176 @@ + +""" +`gate` module implements quantum gate operations. +This module is internally used. +""" + +import numpy as np +from .baseFunc import * +from .gateOps import * + +class Sgate(): + """ + Squeezing gate. + """ + def __init__(self, obj, idx, r): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.r = r + + def run(self, state): + self.r = _paramCheck(self.r) + return Xsqueeze(state, self.N, self.idx, self.r) + +class PSgate(): + """ + Squeezing gate for p direction. + """ + def __init__(self, obj, idx, r): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.r = r + + def run(self, state): + self.r = _paramCheck(self.r) + return Xsqueeze(state, self.N, self.idx, -self.r) + +class Rgate(): + """ + Rotation gate. + """ + def __init__(self, obj, idx, theta): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.theta = theta + + def run(self, state): + self.theta = _paramCheck(self.theta) + return Rotation(state, self.N, self.idx, self.theta) + +class BSgate(): + """ + Beamsplitter gate. + """ + def __init__(self, obj, idx1, idx2, theta): + self.obj = obj + self.N = self.obj.N + self.idx1 = idx1 + self.idx2 = idx2 + self.theta = theta + + def run(self, state): + self.theta = _paramCheck(self.theta) + return Beamsplitter(state, self.N, self.idx1, self.idx2, self.theta) + +class Dgate(): + """ + Displacement gate. + """ + def __init__(self, obj, idx, alpha): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.alpha = alpha + + def run(self, state): + self.alpha = _paramCheck(self.alpha) + return Displace(state, self.idx, self.alpha) + +class Xgate(): + """ + x axis shift in phase space. + """ + def __init__(self, obj, idx, dx): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.dx = dx + + def run(self, state): + self.dx = _paramCheck(self.dx) + return Xtrans(state, self.idx, self.dx) + +class Zgate(): + """ + p axis shift in phase space. + """ + def __init__(self, obj, idx, dp): + self.obj = obj + self.N = self.obj.N + self.idx = idx + self.dp = dp + + def run(self, state): + self.dp = _paramCheck(self.dp) + return Ztrans(state, self.idx, self.dp) + +class TMSgate(): + """ + Two mode squeezing gate. + """ + def __init__(self, obj, idx1, idx2, r): + self.obj = obj + self.N = self.obj.N + self.idx1 = idx1 + self.idx2 = idx2 + self.r = r + + def run(self, state): + self.r = _paramCheck(self.r) + return twoModeSqueezing(state, self.N, self.idx1, self.idx2, self.r) + +class MeasX(): + """ + Homodyne measurement for x quadrature. + """ + def __init__(self, obj, idx): + self.obj = obj + self.N = self.obj.N + self.idx = idx + + def run(self, state): + res, state_ = HomodyneX(state, self.idx) + self.obj.creg[self.idx][0] = res + return state_ + +class MeasP(): + """ + Homodyne measurement for p quadrature. + """ + def __init__(self, obj, idx): + self.obj = obj + self.N = self.obj.N + self.idx = idx + + def run(self, state): + res, state_ = HomodyneP(state, self.idx) + self.obj.creg[self.idx][1] = res + return state_ + +def _paramCheck(param): + if isinstance(param, CregReader): + return param.read() + else: + return param + +class CregReader(): + """ + Class for reading classical register. + """ + def __init__(self, reg, idx, var, scale = 1): + self.reg = reg + self.idx = idx + self.var = var + self.scale = scale + + def read(self): + if self.var == "x": + v = 0 + elif self.var == "p": + v = 1 + else: + raise ValueError('Creg keeps measurement results of "x" or "p".') + return self.reg[self.idx][v] * self.scale \ No newline at end of file diff --git a/blueqat/photonqat/Gaussianformula/ordering.py b/blueqat/photonqat/Gaussianformula/ordering.py new file mode 100644 index 0000000..91da3b1 --- /dev/null +++ b/blueqat/photonqat/Gaussianformula/ordering.py @@ -0,0 +1,72 @@ +''' +References +arxiv: quant-ph/0503237 +Physical Review A 49, 1567 (1994) + +Conversion between vectors of deffrent ordered operators +R = (q_1, p_1, ..., q_n, p_n) +S = (q_1, ..., q_n, p_1, ..., p_n) +T = (a_1, ..., a^*_1, ..., a^*n) +''' + +import numpy as np + +def StoTmat(cov): + N2 = cov.shape[0] + N = np.int(N2/2) + Omega = np.zeros([N2, N2]) + 0j + for i in range(N): + Omega[i, i] = 1 / np.sqrt(2) + Omega[i, i + N] = 1j / np.sqrt(2) + Omega[i + N, i] = 1 / np.sqrt(2) + Omega[i + N, i + N] = -1j / np.sqrt(2) + + cov_T = np.dot(Omega, np.dot(cov, np.transpose(np.conj(Omega)))) + return cov_T + +def RtoSmat(cov): + N2 = cov.shape[0] + N = np.int64(N2/2) + P = np.zeros([N2, N2]) + 0j + for i in range(N): + P[i, i * 2] = 1 + for i in range(N, N2): + P[i, (i-N) * 2 + 1] = 1 + cov_T = np.dot(P, np.dot(cov, np.transpose(P))) + return cov_T + +def RtoTmat(cov): + cov_T = RtoSmat(cov) + return StoTmat(cov_T) + +def StoTvec(vec): + N2 = len(vec) + N = np.int(N2/2) + T = np.zeros(N2) + 0j + T[:N] = (vec[:N] + 1j * vec[N:N2]) / np.sqrt(2) + T[N:N2] = (vec[:N] - 1j * vec[N:N2]) / np.sqrt(2) + return T + +def RtoSvec(vec): + N2 = len(vec) + N = np.int(N2/2) + S = np.zeros(N2) + 0j + S[:N] = vec[0:N2:2] + S[N:N2] = vec[1:N2:2] + return S + +def RtoTvec(vec): + S = RtoSvec(vec) + return StoTvec(S) + +def RtoQmat(cov): + N = np.int(cov.shape[0] / 2) + V = RtoSmat(cov) + Vxx = V[:N, :N] + Vxp = V[:N, N:] + Vpp = V[N:, N:] + A = Vxx - 1j * (Vxp - Vxp.T) + Vpp + B = Vxx + 1j * (Vxp - Vxp.T) + Vpp + C = Vxx - 1j * (Vxp + Vxp.T) - Vpp + sigma_Q = np.block([[A, C], [np.conj(C), B]]) * 0.5 + np.eye(2 * N) * 0.5 + return sigma_Q \ No newline at end of file diff --git a/blueqat/photonqat/__init__.py b/blueqat/photonqat/__init__.py new file mode 100644 index 0000000..54c22a4 --- /dev/null +++ b/blueqat/photonqat/__init__.py @@ -0,0 +1,3 @@ +from photonqat.Gaussian import * +from photonqat.Fock import * +from photonqat.opt import * \ No newline at end of file diff --git a/blueqat/photonqat/opt.py b/blueqat/photonqat/opt.py new file mode 100644 index 0000000..88b7a66 --- /dev/null +++ b/blueqat/photonqat/opt.py @@ -0,0 +1,9 @@ + +import numpy as np +from scipy.special import factorial as fact +from scipy.linalg import expm +from .Fockbase.bosonicLadder import * +from .Fock import * + +#class GD(): + diff --git a/setup.py b/setup.py index 790cbc9..8213ae4 100644 --- a/setup.py +++ b/setup.py @@ -14,7 +14,7 @@ version=__version__, author="The Blueqat Developers", author_email="info@blueqat.com", - description="Quantum gate simulator", + description="Quantum Computer Library for Everyone", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/Blueqat/Blueqat", From 1be0150ca48bf40527936561d1bf4687dbf435b4 Mon Sep 17 00:00:00 2001 From: minatoyuichiro Date: Mon, 18 Apr 2022 01:49:33 +0000 Subject: [PATCH 2/2] example and readme --- README.md | 53 +++ examples_photonqat/Basic Operations.ipynb | 327 ++++++++++++++++++ examples_photonqat/GaussianGates.ipynb | 267 ++++++++++++++ examples_photonqat/KerrGate.ipynb | 95 +++++ .../PhotonCountingForGaussian.ipynb | 134 +++++++ examples_photonqat/StateTeleportation.ipynb | 106 ++++++ examples_photonqat/catState.ipynb | 114 ++++++ examples_photonqat/photonqat_Fock.ipynb | 123 +++++++ 8 files changed, 1219 insertions(+) create mode 100644 examples_photonqat/Basic Operations.ipynb create mode 100644 examples_photonqat/GaussianGates.ipynb create mode 100644 examples_photonqat/KerrGate.ipynb create mode 100644 examples_photonqat/PhotonCountingForGaussian.ipynb create mode 100644 examples_photonqat/StateTeleportation.ipynb create mode 100644 examples_photonqat/catState.ipynb create mode 100644 examples_photonqat/photonqat_Fock.ipynb diff --git a/README.md b/README.md index e73a746..fd5a947 100644 --- a/README.md +++ b/README.md @@ -242,6 +242,59 @@ else: print("timeout") ``` +# Photonic Continuous Variable Circuit + +## Fock basis + +### Circuit +```python +import photonqat as pq +import numpy as np +import matplotlib.pyplot as plt + +# mode number = 2, cutoff dimension = 15 +F = pq.Fock(2, cutoff = 15) +``` + +### Applying gate +```python +alpha = (1 + 1j) +r = -0.5 + +F.D(0, alpha) # Displacement to mode 0 +F.S(1, r) # Squeezeng to mode 1 +``` + +method chain is also available +```python +F.D(0, alpha).S(1, r) +``` + +### run +```python +F.run() +``` + +### Plot Wigner function +```python +# Plot Wigner fucntion for mode 0 using matplotlib +(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) +``` + +## Gaussian formula + +### Circuit +```python +import photonqat as pq +import numpy as np +import matplotlib.pyplot as plt + +# mode number = 2 +G = pq.Gaussian(2) +``` +Applying gate, run the circuit, and plotting Wigner function are also available in same fasion as Fock basis. +But there are differences in availavle getes and measurement methods. + ### Example1: GHZ ```python from blueqat import Circuit diff --git a/examples_photonqat/Basic Operations.ipynb b/examples_photonqat/Basic Operations.ipynb new file mode 100644 index 0000000..57d029d --- /dev/null +++ b/examples_photonqat/Basic Operations.ipynb @@ -0,0 +1,327 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic Operations\n", + "\n", + "photonqatのFockbaseについて、基本的な状態やゲートを学びます。\n", + "\n", + "GaussianbaseはFockbaseの機能が一部使用不可な点を除き同じ処理ができます。 \n", + "backendでの処理が異なるためで、代わりにFockbaseより高速で精度が良いです。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$\\def\\bra#1{\\mathinner{\\left\\langle{#1}\\right|}} \\def\\ket#1{\\mathinner{\\left|{#1}\\right\\rangle}}\\def\\braket#1#2{\\mathinner{\\left\\langle{#1}\\middle|#2\\right\\rangle}}$$\n", + "### Photon number state (Fock state)\n", + "\n", + "$\\ket{\\psi} = \\alpha_0 \\ket{0} + \\alpha_1 \\ket{1} + \\alpha_2 \\ket{2} + ...$\n", + "\n", + "$\\braket{n}{m} = \\delta_{nm}$ \n", + "$\\sum_{k}|\\alpha_{k}|^2 = 1$\n", + "\n", + "```n_photon(mode, photonNum)``` メソッドで任意の$\\ket{n}$状態を用意することができます。\n", + "初期状態は$\\ket{0}$です。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Photon number state:\n", + " [0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j\n", + " 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]\n" + ] + } + ], + "source": [ + "F = pq.Fock(1, cutoff = 15) # (qumode数, cutoff 数)\n", + "F.n_photon(0, 4) # (qumode, photon number state)\n", + "\n", + "F.run()\n", + "\n", + "(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) # plot Wigner function\n", + "\n", + "print(\"Photon number state:\\n\", F.state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Wigner function\n", + "\n", + "光の量子状態は光子数状態で表す他に、Wigner関数を用いて$(q, p)$位相平面上の関数としてプロットすることができます。\n", + "\n", + "```F.Wigner(mode, plot = 'y' or 'n', xrange = 5.0, prange = 5.0)```\n", + "\n", + "光子数状態は密度演算子表記$\\rho = \\sum_{n, n'}C_{n n'}\\ket{n}\\bra{n'}$で書けて、\n", + "\n", + "$\\rho = \\ket{n'}\\bra{n}$に対して\n", + "- $n \\leq n'$の場合\n", + "$W_{nn'}(q, p) = \\frac{2(-1)^n}{\\pi} \\sqrt{\\frac{2^{n'} n!}{2^{n} n'!}} (q-ip)^{n'-n}e^{-(q^2+p^2)}L_{n}^{n'-n}(2(q^2+p^2))$ \n", + "- $n' \\leq n$の場合\n", + "$W_{nn'}(q, p) = \\frac{2(-1)^{n'}}{\\pi} \\sqrt{\\frac{2^{n} n'!}{2^{n'} n!}} (q+ip)^{n-n'}e^{-(q^2+p^2)}L_{n'}^{n-n'}(2(q^2+p^2))$ \n", + "\n", + "を各$(q, p)$について計算し、プロットします。 \n", + "ここでプロットされた関数は、量子状態を位置$q$, または運動量$p$で測定する確率を表します。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Desplacement gate\n", + "\n", + "$D(\\alpha) = \\exp(\\alpha \\hat{a}^{\\dagger} - \\alpha^{*}a^{\\dagger})$\n", + "\n", + "$(q, p)$位相平面上で状態を$(Re(\\alpha), Im(\\alpha))$だけ平行移動させます。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAATlUlEQVR4nO3dXahdZ53H8d+/Sdoak9qLqMGTMAmZARu04FDqQC8c0o50arC3zqAgXgSGEVroUKxh7gcEdUBBQmdgwEIZUFGkoinVi4FRmtbWoU2U1tecvlm8MG2K5pD/XJyzm52Tvfd6e9Z63r4fKDTnZe1nrb32dz9n7bXXNncXACBf18UeAABgGEIOAJkj5ACQOUIOAJkj5ACQuZ0xbvT6Xe/0G2+4OcZNA0C2Lrz50uvu/u7tX48S8htvuFkfvvWfYtw0AGTr8f/9198s+jqHVgAgc4QcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc8FCbmY7zOynZvbdUMsEADQLOSO/T9LZgMsDALQQJORmdkDSxyQ9HGJ5AID2Qs3IvyzpQUmXl/2AmZ0wszNmdubSpTcD3SwAYHDIzey4pNfc/alVP+fup9z9Nne/bdeudw69WQDAlhAz8jskfdzMfi3pUUnHzOzrAZYLAGhhcMjd/SF3P+DuhyR9QtIT7v7JwSMDALTCeeQAkLmdIRfm7j+S9KOQywQArMaMHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyR8gBIHOEHAAyF/QzO4GUXTj8jlGWu/dXb42yXKAtQo4ijRXttrdF3DElQo4iTBnuNraPh7BjTIQc2Uot3qvMj5WoIzRCjqzkFO9liDpCI+TIQgkBX2S2XgQdQxByJC1kwN9YG+ds2z3rlwcvg6BjCEKOJIUI+FjhbrqdIWEn6OiDkCMpQwI+VbibhAg7QUcXhBxJKCHgy8zGR9AxFkKO6PpEfEi8Lx4Yfkxbknaf7zaG+TF3jfqFw+8g5liKkCOqrhHvGvBQ0W677LZx7zNLJ+ZYhpAjmrEiPma8u9x2m6i/sXYdMcdghBxRdIn42AHf+b6LrX5u46XdnZY7G09T0LvOzjluju0IOSY1xiy8bcDbBrvr7zcFvkvQmZ2jD0KOJIUK+NB4tzF/G6ui3ibofWbnxByDz9sys4Nm9kMze97MnjOz+0IMDOVpOxtvivjFA5cbI77zfRd7R/yW/a/qlv2v9vrdNrfbZvypn1KJtISYkW9IesDdnzazvZKeMrPT7v58gGWjECEjvkqbeLeNdNPPnX3lvY3jaJqhN83O28zMmZVjcMjd/WVJL2/9/wUzOytpTRIhh6RpIt4U8L4z7LbLXBb1pqATc4QQ9O83Mzsk6UOSfrLgeyfM7IyZnbl06c2QN4uExY74kMMkXTTdzqpDLqEOs5R6hUg0C/Zip5ntkfQNSfe7+x+3f9/dT0k6JUk37VnzULeL8i0LXVPA2zi271ynsTzx+vtXfn92u6tm6Itm500zc2CVICE3s13ajPgj7v7NEMtE/kLMxrtGvCngXcPd9PvLwr4q6H1iziEWrBLirBWT9B+Szrr7F4cPCTWZKuLH9p0bHPE+y102pj6HWTiTBcuE2DPukPQpScfM7Jmt/+4JsFxkbKzjtX0jPrZVQQ8Z8zY4Vl6fEGet/I8kCzAWVKbPbHyRZaFsE/B79nQ7ueqxN46u/P6xfecWHm65Zf+rK09XbKvruz9RB/5WQ3K6HFLpG/F79jzfOeJtf6/LzHysWTnqQsgRXOw/7VdFvG/Auy5nzMM5bY6Vx74PMC1Cjii6vnDXZTa+TIiAD11ml1k50BYhR1GmeGFzu2UxHzoWDq+gLUKOpIwVrzFm40AqCDkAZI6QAxPjODlCI+RIXg6R49ANYiLkSF7Xz8qMoemNQvMWvTEoh3VEugg5AGSOkCMpY13KtcuMOaVlA20QchSl6XrhUxo6Fq5PjrbYUxBF1ws/LTqGvOwiVMsC+tgbR4POnvssL8TxcS6ahe0IOYIb+sEGXWaifa4oGCLmTctY9GQS4uqHbfHhEnUJ9lFvwNg2Xtrd+lTEJ15//8q3yM+HuO2pg22fALocUlk2G+ewCrog5BjF3l+91XgFvj3rl5dePGv3+esWvl1/UczPvvLehW+ymQW16ZonoQ63rAp4l9n4qohzWAWL8LSPIqwK5RQvgPaJ+FjnjnNYpT7MyBFVqFm5dCWYq2bnUrgrJDY9Qax6culzSIXZOJaJEnL70yXtfHH9mq9vHFmLMBqMpc3hFSlszKXlh1pmhkS97ew+VsSZjZdnUSuv+ZkJxtHabMAEvRxjx1xafC2WVbPzeaEPu/QJuMSLm7hWm4C//bMjjqM3go7tlsVcap6dz3T9RKG22ryQOSTizMbr0iXgb//OCOMIZueL68S8ACFm5VJzzKXVV0oMGfW2Z6E0vaBJxDGvT8SlxEOOcoSMubT8k4TaBF0a/805QwMuEXG0l/yBub7PUEhP2+DsWb/cGLGmEG68tPvt/6bU5jaJOBYZ0jpm5JhU25m5NHx2PjMf1tAfUtHliSJkwCUijiuSDznHyMsTMuZS+6BLy8PbFPghM/u2Z6QQ8bptHFnjGDny0jXmkloHXWoX9XmhD8F0OZ2w6xt9iDi2SzrkzMbL1iXmUvugS8Oi3lfXc8H7vFOTiJet76w86ZCjfF1jLnULurQ4sEPjPuQNPH3fak/EsUyyIWc2Xo9ZoMYO+rwY76Qk4Gijz6w8uZAT8Hr1mZ1LVweyT9THNPRCV0S8TrMOtg16UiEn4ug7O59JIeohrlJIwCG1n50nEXICju2GBl1aHNTQcQ99aVkCju3azM6jhpyAo0mIoM9L9ZreBBxNNo6sSa8t/l6UkPsNu4g4Ogkd9FQQcIQQJORmdrekf5e0Q9LD7v5vIZYLbDcfvlyjTrwR2uCQm9kOSV+V9HeSzkt60sy+4+7tPpoc6Gl7EFMOO/HGmELMyG+X9IK7/1KSzOxRSfdKIuSYVEphJ9yYUoiQr0n63dy/z0v68PYfMrMTkk5I0o3XvyvAzQKrLYtpqMATa6Rishc73f2UpFOSdNOeNZ/qdoHtCDBKE+Kk2nVJB+f+fWDrawCACYQI+ZOS/srMDpvZ9ZI+Iek7AZYLAGhh8KEVd98ws89K+r42Tz/8T3d/bvDIAACtBDlG7u6PSXosxLIAAN2kdak4AEBnhBwAMkfIASBzhBwAMkfIASBzhBwAMpfEJwSF1uajkbgeOoC+2n6W5lSdyT7kXT9tevvvEXQAbXX+dPttPz9Wb7IMed94L1sWMQfQJER35pcRsjtZHSPf+eJ60IjPLxcAlhmrO6GWm/yMnMgCKFmIWXqyISfgAGrT97W75EJOwAHUrmvQkwk5AQeAq7UNetSQpxJvzloBsMrGkbWovWq67WhnrRBxADlJuRVRQm5/uhTjZq+R8h0DID2pNiOr88hDSvUOAZC2FNtRZchTvCMA5CO1hiRz1soUUtv4API160kKr/dVMyMn4gDGkEJbqgh5ChsaQLk2jqxF7UzRIY+9cQHUJVZvig05AQcQQ4z2FPdiJwEHENvUL4QWNSMn4gBSwke9dUDAAaRqitl59jNyIg4gB2OefJFtyDkjBUCOxuhWlodWUg54lz+fUl4PIFUlPMZCXxY3q5CneqdI/Y5/7XxxPel1AlLT9XHW96PTphDy2Hk2h1ZSvCOk4Z+EncJ1GoAcDH2cpfpYC9G25GfkKQccQF5SnaEPnZ0nPSNPbWPPEHEgb6k+hvs2L8kZOQEHMLaSZueDZuRm9gUzO2dmPzOzb5nZzUOWJ6W3UWeIOBDXWG1I9fh5l/UdemjltKQPuPutkn4h6aG+C0r1vPCx7+QU1xmoUaoxb9OIQSF39x+4+8bWP38s6UDXZaQacGn8OzbV9QZSNfZjJsWYS82dDPli52ckfW/ZN83shJmdMbMzf778VsCbDS/VP7UATBPz3B7/jS92mtnjkvYv+NZJd//21s+clLQh6ZFly3H3U5JOSdK7dr3HU52NTnUHprr+ADbl9Ia9xpC7+12rvm9mn5Z0XNKd7u5tbtRv2NVqcFMj4kAeQr/FfZlcYj7o9EMzu1vSg5I+4u4XwwxpelP+GZXDTgHkYMqYz24vVUOPkX9F0l5Jp83sGTP7WoAxTYqIA/ma8jGV8nHzQTNyd//LUAOJgYgD+ZtqZi6le6glyXd2jm3qZ9aYd3ybdU1xx0R6Ut6Xpo757DZTkfS1VsZQS8S7nEKV8p+MSEOXfSnW/jT1Yy2lx01VIa8p4lP8DuqQ0/5Ua8yrCXkNEc/xjQwoV6z9scaYVxHyWiIOpIiYj6/okMeYERBx4Fq1xDzWY7HYkNew40hEHPngMTmeIkNeS9xqWU+Uo5Z9dur1LO48cp71+0lhHVI6LzclsbdT6HO0p35TTchPq+9iyvUsKuREPH2rxp7iGy1iWrat5r+e67aK8Q7JKd80NDPVehZzaCXnuHWR83ryBqX2athWTLzCKSLktbz5YCxTrEfX+yjGfTo762D7fzHGMebP91HKvi6VGfPsQx7rWb2UnSHFiA/9vT6303TIZ+rreEz1e12Msa/UNAkbc12zDnnOf1Z2leu6pj7uLuMraV1SQsyHyzbk3PnDlfTnch85XUOkrVw/MDz17RrSGOuaZciJeB5yHjumx2HS/rILeU0RH9MUn0SesiHjK3nd2ijtsRBLyPspu5DHkNPlaIGcMVHrJ6uQ13LeqTTuutY+G69BzrPymmIeal2zCvnUiHiZQmxfnqyIeUoI+RK53qGxhXwA1ngfhFzn3J9siHl7hHyB1D8sua8cd1CkrdR9Krf1yirkuW3crphBIbTc75OY45+iN6FuI6uQjy3WOaVS3i9OoW4lv3iey+Mmu5CPtWFLPZwylRLWoVS5XodlXokxD7nc7EIu5fMsmYoct1cObwXn0gnoK/R9nGXIpXAbIubhFIlDKpgGs/JhQnZijO2Ubcil4RskduRKORxRynogfbH3tVSbk3XIpf7PlDVEPPY6oj4pX98+lL69GXPbZB/ymS4bisCFk+uHXaSupA9xKFGX1kzy5Db6LUwshwgwG0fJpviQ4xgf3rxd7NufV8yMPBclzYpKWpdalHSflbQuQxHyAqU0U0CdptoHifkmQj4hdjp0wRMy2iLkhcl9JkS8xjfVhCL3fTEnQUJuZg+YmZvZvhDLKxE7W5m4X1fjiXkag0NuZgclfVTSb4cPp0ylzYByRXSvKG1blLY+XYWYkX9J0oOSPMCyilNixGt/0KAbDrGMb1DIzexeSevu/myLnz1hZmfM7MylS28OuVkUir8orsU2QRuNbwgys8cl7V/wrZOSPq/NwyqN3P2UpFOSdNOetSpm78zGkbIp31QzxZuEpDTeKBRDY8jd/a5FXzezD0o6LOlZM5OkA5KeNrPb3f2VoKMEACzV+9CKu/+fu7/H3Q+5+yFJ5yX9NREH8jHlX1g1zpSnwnnkI+GwSjc8yJdj23RT4+G/YCHfmpm/Hmp5ucvpg1uBqbDPjoMZOVqpcZZTi9Lu2xqfLAh5pmrcWVEG9t3wCPmI2GERCvtSO7VuJ0I+sjF2rNJ21tLWJ0dTH17hcREWIZ9A6p/A3aS0Y6ihsX36CfmYqDniEiGfVKqfwF0DYpsmHhNhFPeZnamb3/G6xCXWDksA6xHr7e1d375PvK9FyCOa7ZCrdmJ2WsxMdb2SGHgsDEPIE1DzDlrzuqco9kWn2B/64Rg5lip19geUhpADQOYIOQBkjpAjGo6Hdsc2wyKEHAAyR8gBIHOEHEvxZzyQB3Of/nOQzez3kn4z+Q1fa58kPgxjE9viamyPq7E9roi5Lf7C3d+9/YtRQp4KMzvj7rfFHkcK2BZXY3tcje1xRYrbgkMrAJA5Qg4Amas95KdiDyAhbIursT2uxva4IrltUfUxcgAoQe0zcgDIHiEHgMwR8i1m9oCZuZntiz2WWMzsC2Z2zsx+ZmbfMrObY48pBjO728x+bmYvmNnnYo8nFjM7aGY/NLPnzew5M7sv9phSYGY7zOynZvbd2GOZIeTa3GElfVTSb2OPJbLTkj7g7rdK+oWkhyKPZ3JmtkPSVyX9vaSjkv7BzI7GHVU0G5IecPejkv5G0j9XvC3m3SfpbOxBzCPkm74k6UFJVb/y6+4/cPeNrX/+WNKBmOOJ5HZJL7j7L939z5IelXRv5DFF4e4vu/vTW/9/QZvxqvq6DWZ2QNLHJD0ceyzzqg+5md0rad3dn409lsR8RtL3Yg8igjVJv5v793lVHi9JMrNDkj4k6SdxRxLdl7U56bsceyDzqvjMTjN7XNL+Bd86Kenz2jysUoVV28Ldv731Mye1+Wf1I1OODWkysz2SviHpfnf/Y+zxxGJmxyW95u5Pmdnfxh7PvCpC7u53Lfq6mX1Q0mFJz5qZtHko4Wkzu93dX5lwiJNZti1mzOzTko5LutPrfJPBuqSDc/8+sPW1KpnZLm1G/BF3/2bs8UR2h6SPm9k9km6UdJOZfd3dPxl5XLwhaJ6Z/VrSbe5e5VXezOxuSV+U9BF3/33s8cRgZju1+ULvndoM+JOS/tHdn4s6sAhsc3bzX5L+4O73xx5PSrZm5P/i7sdjj0XiGDmu9hVJeyWdNrNnzOxrsQc0ta0Xez8r6fvafHHvv2uM+JY7JH1K0rGt/eGZrdkoEsOMHAAyx4wcADJHyAEgc4QcADJHyAEgc4QcADJHyAEgc4QcADL3/7rgYc54JINwAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "alpha = (0 + 1j) # parameter\n", + "\n", + "F = pq.Fock(1, cutoff = 15)\n", + "F.D(0, alpha) # Dgate\n", + "\n", + "F.run()\n", + "\n", + "(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) # plot Wigner function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Squeezing gate \n", + "\n", + "$S(\\epsilon) = \\exp{(\\frac{1}{2}\\epsilon^{*}\\hat{a}^{2}} - \\frac{1}{2}\\epsilon\\hat{a}^{\\dagger 2})$ \n", + "$\\epsilon = re^{2i\\phi}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Normal ordered form \n", + "\n", + "$S(r, \\phi) = (\\cosh{r})^{-1/2} \\exp(-\\frac{\\Gamma}{2}\\hat{a}^{\\dagger 2}) \\exp(-\\ln(\\cosh{r})\\hat{a}^{\\dagger}\\hat{a}) \\exp(\\frac{\\Gamma^{*}}{2}\\hat{a}^{2})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$(q, p)$位相平面上で状態を狭窄化(squeeze)します。 \n", + "パラメータ$\\phi$はsqueezeの向きを示し、パラメータ$r$が大きいとより強くsqueezeされます。 \n", + "ある方向にsqueezeされ分布が狭くなると、それと直交する方向は逆に分布が広がります。" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "r = .5\n", + "phi = np.pi/2\n", + "eps = r * np.exp(2j * phi)\n", + "\n", + "F = pq.Fock(1, cutoff = 15)\n", + "F.S(0, eps) # Sgate\n", + "\n", + "F.run()\n", + "\n", + "(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) # plot Wigner function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Beam splitter\n", + "\n", + "Beam splitter hamiltonian: $\\hat{H} = i\\hbar \\theta (\\hat{a}_{1}^{\\dagger}\\hat{a}_{2} -\\hat{a}_{1} \\hat{a}_{2}^{\\dagger})$\n", + "\n", + "$BSgate = \\exp(\\frac{i}{\\hbar}\\hat{H})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ビームスプリッタという素子で2つのモードにある光を混ぜ合わせます。 \n", + "ビームスプリッタとは入ってきた光の$R$%を反射し、$T$%を透過する($R + T=100$)素子で、一定量の光を透過する鏡のようなものです。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2 2 0 2 2 2 2 0 0 2 0 0 2 2 2 0 2 2 2 0 0 0 0 2 0 0 2 2 0 2 2 2 0 0 0 0 2\n", + " 2 0 0 2 0 2 2 0 0 0 2 2 0]\n", + "HOM干渉計：2つのSingle photon Modeをビームスプリッタに入力すると出力モードの光子数は必ず1方のモードが2, もう1方が0になる\n" + ] + } + ], + "source": [ + "mode = 0\n", + "F = pq.Fock(2, cutoff = 20)\n", + "F.n_photon(0, 1)\n", + "F.n_photon(1, 1)\n", + "F.BS(0, 1, -np.pi/4) # 50:50 ビームスプリッタ\n", + "F.run()\n", + "res = F.photonSampling(0, ite = 50) # mode 0 のphoton数を50回サンプリング\n", + "print(res)\n", + "print(\"HOM干渉計：2つのSingle photon Modeをビームスプリッタに入力すると出力モードの光子数は必ず1方のモードが2, もう1方が0になる\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Kerr gate \n", + "\n", + "Kerr hamiltoninan: $H = \\hbar \\frac{\\chi}{2} (\\hat{a}^{\\dagger})^2 \\hat{a}^2$\n", + "\n", + "$K = \\exp{(\\frac{i}{\\hbar}H)} = \\exp{(i\\frac{\\chi}{2} (\\hat{a}^{\\dagger})^2 \\hat{a}^2)} = \\exp{(i\\frac{\\chi}{2} \\hat{a}^{\\dagger} \\hat{n} \\hat{a})}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "光の媒質の中には屈折率が光の強度に依存するものが存在し、その現象はKerr効果と呼ばれます。 \n", + "位相平面上では中心からの距離(=強度)によって異なる角度で位相が回転します。\n", + "\n", + "Kerr gateは非線形ゲートと呼ばれるものの1種です。 \n", + "連続量光量子計算においてユニバーサルな計算を行うには少なくとも1種の非線形ゲートが必要と言われています。" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "alpha = 2\n", + "chi = .2\n", + "\n", + "F = pq.Fock(1, cutoff = 20)\n", + "F.D(0, alpha)\n", + "F.Kerr(0, chi)\n", + "F.run()\n", + "\n", + "x, p, W = F.Wigner(0, method = 'clenshaw') # plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples_photonqat/GaussianGates.ipynb b/examples_photonqat/GaussianGates.ipynb new file mode 100644 index 0000000..2fed4cd --- /dev/null +++ b/examples_photonqat/GaussianGates.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Photonqat\n", + "\n", + "基本的なゲート動作と測定を一通り行っています。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured x = -1.5222550182126553\n", + "mu0 = [ 1.10144286 -0.24285338]\n", + "cov0 = [[ 0.79001283 -0.38079708]\n", + " [-0.38079708 0.5 ]]\n" + ] + } + ], + "source": [ + "G = pq.Gaussian(2) # two qumode [0, 1]\n", + "G.D(0, 2) # Displacement gate, x to x+2\n", + "G.S(0, 1) # X squeeIng gate, r=1\n", + "G.R(0, np.pi/4) # pi/4 rotation gate\n", + "G.BS(0, 1, np.pi/4) # 50:50 beam splitter\n", + "G.MeasX(1) # Measure mode 1\n", + "G.run()\n", + "G.Wigner(0) # plot\n", + "print('measured x =', G.Creg(1, \"x\").read())\n", + "print('mu0 =', G.mean(0)) # mu of qumode 0\n", + "print('cov0 =', G.cov(0)) # covarince of qumode 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Method chain is available" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured x = -0.42699214217093645\n", + "mu0 = [0.46616229 0.59129242]\n", + "cov0 = [[ 0.79001283 -0.38079708]\n", + " [-0.38079708 0.5 ]]\n" + ] + } + ], + "source": [ + "G = pq.Gaussian(2).D(0, 2).S(0, 1).R(0, np.pi/4).BS(0, 1, np.pi/4)\n", + "G.MeasX(1).run()\n", + "G.Wigner(0) # plot\n", + "print('measured x =', G.Creg(1, \"x\").read())\n", + "print('mu0 =', G.mean(0)) # mu of qumode 0\n", + "print('cov0 =', G.cov(0)) # covarince of qumode 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 以下、メモ" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phase space について\n", + "\n", + "N bosonic mode Hilbert space \n", + "$\\otimes^{N}_{k=1} \\mathcal{H}_k$\n", + "\n", + "vectorial operator \n", + "$\\hat{\\mathbf{b}} = (\\hat{a}_1, \\hat{a}_1^{\\dagger}, \\dots, \\hat{a}_N, \\hat{a}_N^{\\dagger})$ : 2N elements\n", + "\n", + "bosonic commutation relations \n", + "$[\\hat{b}_i, \\hat{b}_j] = \\Omega_{ij}\\ \\ (i, j = 1, \\dots, 2N)$ \n", + "\n", + "$\\mathbf{\\Omega} = \\oplus_{k=1}^{N}\\omega\\ \\ \\ \n", + "\\omega = \n", + "\\begin{pmatrix}\n", + "0 & 1 \\\\\n", + "-1 & 0 \\\\\n", + "\\end{pmatrix}\n", + "$\n", + "\n", + "Quadrature field \n", + "$\\hat{\\mathbf{x}} = (\\hat{q}_1, \\hat{p}_1, \\dots, \\hat{q}_N, \\hat{p}_N)$ : 2N elements\n", + "\n", + "canonical commutation relation \n", + "$[\\hat{x}_i, \\hat{x}_j] = 2i\\Omega_{ij}\\ \\ (i, j = 1, \\dots, 2N)$ " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 密度演算子とWigner関数\n", + "\n", + "任意の密度演算子$\\hat{\\rho}$を考える \n", + "\n", + "任意の密度演算子は等価なWigner関数が存在する\n", + "\n", + "Weyl operator \n", + "$D(\\xi) = \\exp(i \\hat{x}^T \\Omega \\hat{\\xi})$ \n", + "\n", + "これを用いて、Wigner characteristic functionを定義できる \n", + "$\\chi (\\xi) = \\mathrm{Tr}[\\hat{\\rho}D(\\xi)]$\n", + "\n", + "Wigner characteristic functionのフーリエ変換がWigner function \n", + "$W(\\mathbf{x}) = \\int_{R^{2N}} \\frac{d^{2N}}{(2\\pi)^{2N}} \\exp{(-i \\hat{x}^T \\Omega \\hat{\\xi})} \\chi (\\xi)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 統計量とWigner関数\n", + "\n", + "Wigner functionは統計量でも定義できる \n", + "\n", + "- first moment \n", + "$\\bar{\\mathbf{x}} = \\langle \\hat{\\mathbf{x}} \\rangle= \\mathrm{Tr}[\\hat{\\mathbf{x}} \\hat{\\rho}]$\n", + "\n", + "- second moment \n", + "$V_{ij} = \\frac{1}{2}\\langle \\{\\Delta\\hat{x}_i, \\Delta\\hat{x}_j \\}\\rangle$ \n", + "$\\{ A, B \\} = AB+BA$\n", + "\n", + "$V_{ii}$は$\\hat{x}_i$の分散をあらわす\n", + "\n", + "Gaussian stateは最初の2モーメントだけで完全に記述可能" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gaussian Unitaryについて\n", + "\n", + "Quadrature operatorにおいては、Gaussian UnitaryはAffien写像で書ける！ \n", + "$(\\mathbf{S}, \\mathbf{d}) : \\hat{\\mathrm{x}}\\to \\mathbf{S}\\mathrm{x} + \\mathbf{d}$\n", + "\n", + "Williamson's Theorem \n", + "任意の偶数次元の正定値実行列はsimplectic transformで対角化できる \n", + "$\\mathbf{V} = \\mathbf{SV}^{\\oplus}\\mathbf{S}^{T}$ \n", + "$\\mathbf{V}^{\\oplus} = \\oplus^{N}_{k=1} \\nu_k \\mathbf{I}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gaussian Measurement \n", + "\n", + "POVM: $\\Pi_i = E_{i}^{\\dagger}E_i\\ \\ \\ (\\sum_i E_{i}^{\\dagger}E_i = I)$ \n", + "これを連続量に置き換える \n", + "\n", + "Gaussian Measurementとは、Gaussian stateに対して行い、出力結果がGaussian Distributionで、測定しなかったモードはGaussian stateのままである\n", + "\n", + "測定するsubsystemを$\\mathbf{B}$として、それ以外のsubsystemを$\\mathbf{A}$とする。\n", + "\n", + "測定結果の確率分布：測定モード以外の直交位相を周辺化したGaussian Wigner分布 \n", + "測定後の状態：以下のようになる.\n", + "\n", + "\n", + "$\\mathbf{V} = \\mathbf{A} - \\mathbf{C}(\\mathbf{\\Pi B \\Pi})^{-1}\\mathbf{C}^T$ \n", + "$\\mathbf{\\Pi} = \\rm{diag}(1, 0)$ ($\\hat{x}$測定の場合)\n", + "\n", + "$\\mathbf{\\Pi B \\Pi}$は非正則。pseudo-inverseを用いる。 \n", + "$(\\mathbf{\\Pi B \\Pi})^{-1} = B_{11}^{-1}\\Pi$\n", + "\n", + "これは多変量ガウス分布の条件付き分布をとるのと基本的に同じ \n", + "なので同様に測定後の状態の平均もとれる\n", + "\n", + "$\\mathbf{\\mu} = \\mathbf{\\mu_A} - \\mathbf{C}(\\mathbf{\\Pi B \\Pi})^{-1}(\\mathbf{\\mu_B} - x_B\\mathbf{\\Pi})$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples_photonqat/KerrGate.ipynb b/examples_photonqat/KerrGate.ipynb new file mode 100644 index 0000000..2e9d095 --- /dev/null +++ b/examples_photonqat/KerrGate.ipynb @@ -0,0 +1,95 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Photonqat\n", + "\n", + "Kerr Gate" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "chi = .2\n", + "alpha = 2\n", + "mode = 0\n", + "F = pq.Fock(1, cutoff = 20).D(0, alpha).Kerr(0, chi)\n", + "F.run()\n", + "\n", + "(x, p, W) = F.Wigner(mode, plot = 'y', xrange = 5.0, prange = 5.0) # plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples_photonqat/PhotonCountingForGaussian.ipynb b/examples_photonqat/PhotonCountingForGaussian.ipynb new file mode 100644 index 0000000..86469d0 --- /dev/null +++ b/examples_photonqat/PhotonCountingForGaussian.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gaussian stateの光子数測定" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gaussian stateは通常、直交位相成分$\\hat{x}, \\hat{p}$を変数にもつ多変数ガウス分布で記述されるため、状態を知るにはホモダイン測定を行う方が自然に思えます。 \n", + "photonqatにもMeasureX, MeasurePとして実装しています。\n", + "\n", + "Gaussian stateに対して光子数測定を行いたくなる理由は以下の通りです。\n", + "\n", + "1つはGaussian Boson Samplingというスキームです。 \n", + "Gaussian stateに対し光子数測定を行った場合に、ある光子数が測定結果として得られる確率はHafnianという関数で計算されます。 \n", + "Hafnianは既存のアルゴリズムでは計算量が指数関数的増加するため、Gaussian Boson Samplingによって計算の加速が期待されています。 \n", + "Hafnianはグラフ理論におけるPerfect Matchingの計算などと深い関係があるようです。\n", + "\n", + "もう1つは、ユニバーサルな光量子計算を行うために提案されているスキームの1つとしてのガウス操作と光子数測定の組み合わせです。 \n", + "こちらは最近ニュースになった古澤研の量子もつれ状態を用いたユニバーサル量子コンピューティングと関係しています。\n", + "\n", + "Gaussian Boson SamplingはカナダのXanadu社が近年研究を推し進めており、複数の関連論文とthe Walrus(https://the-walrus.readthedocs.io/en/latest/index.html) というライブラリを公開しています。 \n", + "\n", + "photonqatへのGaussian stateに対する光子数測定の実装も、彼らが論文(arXiv:1905.07011 [quant-ph] )として公開しているアイデア、定式に則っています。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy import special" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Photonqat\n", + "\n", + "基本的なゲート操作と光子数測定を行った後、2モードの光子数が(0, 0)である確率を計算しています。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mu0 = [0.5202601 0.5202601]\n", + "cov = [[ 1.19054892 -0.9067151 ]\n", + " [-0.9067151 1.19054892]]\n", + "Probability of photon number [0 0] : 0.5695892908718674\n" + ] + } + ], + "source": [ + "G = pq.Gaussian(2) # two qumode [0, 1]\n", + "G.D(0, 2) # Displacement gate\n", + "G.S(0, 1) # X squeeIng gate, r=1\n", + "G.R(0, np.pi/4) # pi/4 rotation gate\n", + "G.BS(0, 1, np.pi/4) # 50:50 beam splitter\n", + "G.run()\n", + "G.Wigner(0) # plot\n", + "print('mu0 =', G.mean(0)) # mu of qumode 0\n", + "print('cov =', G.cov(0)) # covarince of qumode 1\n", + "\n", + "m = np.array([0, 0]) # measured output of photon number for each mode\n", + "prob = G.PhotonDetectionProb(m, m) # probability\n", + "print(\"Probability of photon number\", m, \": \", prob)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples_photonqat/StateTeleportation.ipynb b/examples_photonqat/StateTeleportation.ipynb new file mode 100644 index 0000000..11d7e6e --- /dev/null +++ b/examples_photonqat/StateTeleportation.ipynb @@ -0,0 +1,106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State teleportation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Photonqat" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measured x = 0.14816259391076148\n", + "measured p = -1.9605587218781348\n", + "teleported mu = [1.37087831 0.58193155]\n" + ] + } + ], + "source": [ + "r = 2\n", + "\n", + "G = pq.Gaussian(3)\n", + "\n", + "G.D(0, 1 + 0.5j) # state to teleport\n", + "G.S(1, -r)\n", + "G.S(2, r)\n", + "G.BS(1, 2, np.pi/4) # 50:50 beam splitter\n", + "G.BS(0, 1, np.pi/4) # 50:50 beam splitter\n", + "G.MeasX(0)\n", + "G.MeasP(1)\n", + "G.X(2, G.Creg(0, \"x\", scale = np.sqrt(2)))\n", + "G.Z(2, G.Creg(1, \"p\", scale = np.sqrt(2)))\n", + "G.run()\n", + "\n", + "G.Wigner(2) # plot\n", + "print('measured x =', G.Creg(0, \"x\").read())\n", + "print('measured p =', G.Creg(1, \"p\").read())\n", + "print('teleported mu =', G.mean(2)) # mu of qumode 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples_photonqat/catState.ipynb b/examples_photonqat/catState.ipynb new file mode 100644 index 0000000..2f1b083 --- /dev/null +++ b/examples_photonqat/catState.ipynb @@ -0,0 +1,114 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Photonqat\n", + "\n", + "シュレーディンガーの猫状態" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "alpha = 1\n", + "mode = 0\n", + "F = pq.Fock(1, cutoff = 10)\n", + "F.cat(0, alpha, 'e').run()\n", + "\n", + "(x, p, W) = F.Wigner(mode, plot = 'y', xrange = 5.0, prange = 5.0) # plot" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "alpha = 1\n", + "mode = 0\n", + "F = pq.Fock(1, cutoff = 15)\n", + "F.cat(0, alpha, 'o').run()\n", + "\n", + "(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) # plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples_photonqat/photonqat_Fock.ipynb b/examples_photonqat/photonqat_Fock.ipynb new file mode 100644 index 0000000..aca7f04 --- /dev/null +++ b/examples_photonqat/photonqat_Fock.ipynb @@ -0,0 +1,123 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import photonqat as pq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Photonqat\n", + "\n", + "真空場状態とコヒーレント状態を準備し、スクイージング、ビームスプリッタ操作を行う。 \n", + "出力状態をWigner関数を用いて可視化する。 \n", + "cutoffの値を大きくすると計算時間がかかるが、計算結果の精度が上がる。 \n", + "要求される精度(=cutoff値)はゲートの種類やパラメータによって決まる。\n", + "cutoff値が小さすぎるとWigner関数が歪む。 \n", + "簡潔に言うと、Wigner関数の分布が中心$(x, p)=(0, 0)$から離れるほどcutoff値を大きくする必要がある。 \n", + "位相平面上で中心からの距離は光子数に対応するから。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "alpha = (1 + 1j)\n", + "mode = 0\n", + "r = -0.5\n", + "F = pq.Fock(2, cutoff = 15)\n", + "F.D(0, alpha)\n", + "F.S(0, r)\n", + "F.BS(0, 1, -np.pi/4)\n", + "F.run()\n", + "(x, p, W) = F.Wigner(0, plot = 'y', xrange = 5.0, prange = 5.0) # plot" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2 2 0 2 2 0 2 0 0 2 2 2 2 0 2 2 2 0 2 2 2 0 0 0 0 2 0 0 2 2 0 2 2 2 2 2 0\n", + " 0 2 2 2 2 2 2 0 2 2 0 0 0]\n", + "2つのSingle photon Modeをビームスプリッタに入力すると出力モードの光子数は必ず1方のモードが2, もう1方が0になる\n" + ] + } + ], + "source": [ + "mode = 0\n", + "F = pq.Fock(2, cutoff = 20)\n", + "F.n_photon(0, 1)\n", + "F.n_photon(1, 1)\n", + "F.BS(0, 1, -np.pi/4)\n", + "F.run()\n", + "res = F.photonSampling(0, ite = 50)\n", + "print(res)\n", + "print(\"2つのSingle photon Modeをビームスプリッタに入力すると出力モードの光子数は必ず1方のモードが2, もう1方が0になる\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}