NoiseTransformer

NoiseTransformer.channel_matrix_representation(operators)

We convert the operators to a matrix by applying the channel to the four basis elements of the 2x2 matrix space representing density operators; this is standard linear algebra

Parameters

operators (list) – The list of operators to transform into a Matrix

Returns

The matrx representation of the operators

Return type

sympy.Matrix

NoiseTransformer.compute_P(As)

This method creates the matrix P in the f(x) = 1/2(x*P*x)+q*x representation of the objective function :param As: list of symbolic matrices repersenting the channel matrices :type As: list

Returns

The matrix P for the description of the quadaric program

Return type

matrix

static NoiseTransformer.compute_channel_operation(rho, operators)

Given a quantum state’s density function rho, the effect of the channel on this state is: rho -> sum_{i=1}^n E_i * rho * E_i^dagger

Parameters

• rho (number) – Density function
• operators (list) – List of operators

Returns

The result of applying the list of operators

Return type

number

NoiseTransformer.compute_q(As, C)

This method creates the vector q for the f(x) = 1/2(x*P*x)+q*x representation of the objective function :param As: list of symbolic matrices repersenting the quadratic program :type As: list :param C: matrix representing the the constant channel matrix :type C: matrix

Returns

The vector q for the description of the quadaric program

Return type

list

static NoiseTransformer.fidelity(channel)

Calculates channel fidelity

static NoiseTransformer.flatten_matrix(m)

Parameters

m (Matrix) – The matrix to flatten

Returns

A row vector repesenting the flattened matrix

Return type

list

NoiseTransformer.generate_channel_matrices(transform_channel_operators_list)

Generate symbolic channel matrices.

Generates a list of 4x4 symbolic matrices describing the channel defined from the given operators. The identity matrix is assumed to be the first element in the list:

[(I, ), (A1, B1, ...), (A2, B2, ...), ..., (An, Bn, ...)]

E.g. for a Pauli channel, the matrices are:

[(I,), (X,), (Y,), (Z,)]

For relaxation they are:

[(I, ), (|0><0|, |0><1|), |1><0|, |1><1|)]

We consider this input to symbolically represent a channel in the following manner: define indeterminates $x_0, x_1, ..., x_n$ which are meant to represent probabilities such that $x_i \ge 0$ and $x0 = 1-(x_1 + ... + x_n)$.

Now consider the quantum channel defined via the Kraus operators ${\sqrt(x_0)I, \sqrt(x_1) A_1, \sqrt(x1) B_1, ..., \sqrt(x_m)A_n, \sqrt(x_n) B_n, ...}$ This is the channel C symbolically represented by the operators.

Parameters

transform_channel_operators_list (list) – A list of tuples of matrices which represent Kraus operators.

Returns

A list of 4x4 complex matrices ([D1, D2, ..., Dn], E) such that the matrix $x_1 D_1 + ... + x_n D_n + E$ represents the operation of the channel C on the density operator. we find it easier to work with this representation of C when performing the combinatorial optimization.

Return type

list

NoiseTransformer.generate_channel_quadratic_programming_matrices(channel, symbols)

Generate matrices for quadratic program.

Parameters

• channel (Matrix) – a 4x4 symbolic matrix
• symbols (list) – the symbols x1, …, xn which may occur in the matrix

Returns

A list of 4x4 complex matrices ([D1, D2, …, Dn], E) such that: channel == x1*D1 + … + xn*Dn + E

Return type

list

static NoiseTransformer.get_const_matrix_from_channel(channel, symbols)

Extract the numeric constant matrix.

Parameters

• channel (matrix) – a 4x4 symbolic matrix.
• symbols (list) – The full list [x1, …, xn] of symbols used in the matrix.

Returns

a 4x4 numeric matrix.

Return type

matrix

Additional Information:

Each entry of the 4x4 symbolic input channel matrix is assumed to be a polynomial of the form a1x1 + … + anxn + c. The corresponding entry in the output numeric matrix is c.

static NoiseTransformer.get_matrix_from_channel(channel, symbol)

Extract the numeric parameter matrix.

Parameters

• channel (matrix) – a 4x4 symbolic matrix.
• symbol (list) – a symbol xi

Returns

a 4x4 numeric matrix.

Return type

matrix

Additional Information:

Each entry of the 4x4 symbolic input channel matrix is assumed to be a polynomial of the form a1x1 + … + anxn + c. The corresponding entry in the output numeric matrix is ai.

NoiseTransformer.operator_circuit(operator)

Converts an operator representation to noise circuit.

Parameters

operator (operator) – operator representation. Can be a noise circuit or a matrix or a list of matrices.

Returns

The operator, converted to noise circuit representation.

Return type

List

NoiseTransformer.operator_matrix(operator)

Converts an operator representation to Kraus matrix representation

Parameters

operator (operator) – operator representation. Can be a noise circuit or a matrix or a list of matrices.

Returns

the operator, converted to Kraus representation.

Return type

Kraus

static NoiseTransformer.prepare_channel_operator_list(ops_list)

Prepares a list of channel operators.

Parameters

ops_list (List) – The list of operators to prepare

Returns

The channel operator list

Return type

List

NoiseTransformer.prepare_honesty_constraint(transform_channel_operators_list)

Prepares the honesty constraint.

Parameters

• transform_channel_operators_list (list) – A list of tuples of matrices which represent
• operators. (Kraus) –

NoiseTransformer.solve_quadratic_program(P, q)

Solve the quadratic program optimization problem.

This function solved the quadratic program to minimize the objective function f(x) = 1/2(x*P*x)+q*x subject to the additional constraints Gx <= h

Where P, q are given and G,h are computed to ensure that x represents a probability vector and subject to honesty constraints if required :param P: A matrix representing the P component of the objective function :type P: matrix :param q: A vector representing the q component of the objective function :type q: list

Returns

The solution of the quadratic program (represents probabilities)

Return type

list

Additional information:

This method is the only place in the code where we rely on the cvxpy library should we consider another library, only this method needs to change.

NoiseTransformer.transform_by_given_channel(channel_matrices, const_channel_matrix)

Transform by by quantum channels.

This method creates objective function representing the Hilbert-Schmidt norm of the matrix (A-B) obtained as the difference of the input noise channel and the output channel we wish to determine.

This function is represented by a matrix P and a vector q, such that f(x) = 1/2(x*P*x)+q*x where x is the vector we wish to minimize, where x represents probabilities for the noise operators that construct the output channel

Parameters

• channel_matrices (list) – A list of 4x4 symbolic matrices
• const_channel_matrix (matrix) – a 4x4 constant matrix

Returns

a list of the optimal probabilities for the channel matrices, determined by the quadratic program solver

Return type

list

NoiseTransformer.transform_by_operator_list(transform_channel_operators, noise_kraus_operators)

Transform input Kraus operators.

Allows approximating a set of input Kraus operators as in terms of a different set of Kraus matrices.

For example, setting $[X, Y, Z]$ allows approximating by a Pauli channel, and $[(|0 \langle\rangle 0|, |0\langle\rangle 1|), |1\langle\rangle 0|, |1 \langle\rangle 1|)]$ represents the relaxation channel

In the case the input is a list $[A_1, A_2, ..., A_n]$ of transform matrices and $[E_0, E_1, ..., E_m]$ of noise Kraus operators, the output is a list $[p_1, p_2, ..., p_n]$ of probabilities such that:

1. $p_i \ge 0$
2. $p_1 + ... + p_n \le 1$
3. $[\sqrt(p_1) A_1, \sqrt(p_2) A_2, ..., \sqrt(p_n) A_n, \sqrt(1-(p_1 + ... + p_n))I]$ is a list of Kraus operators that define the output channel (which is “close” to the input channel given by $[E_0, ..., E_m]$.)

This channel can be thought of as choosing the operator $A_i$ in probability $p_i$ and applying this operator to the quantum state.

More generally, if the input is a list of tuples (not necessarily of the same size): $[(A_1, B_1, ...), (A_2, B_2, ...), ..., (A_n, B_n, ...)]$ then the output is still a list $[p_1, p_2, ..., p_n]$ and now the output channel is defined by the operators: $[\sqrt(p_1)A1, \sqrt(p_1)B_1, ..., \sqrt(p_n)A_n, \sqrt(p_n)B_n, ..., \sqrt(1-(p_1 + ... + p_n))I]$

Parameters

• noise_kraus_operators (List) – a list of matrices (Kraus operators) for the input channel.
• transform_channel_operators (List) – a list of matrices or tuples of matrices representing Kraus operators that can construct the output channel.

Returns

A list of amplitudes that define the output channel.

Return type

List