Skip to main contentIBM Quantum Documentation
You are viewing the API reference for an old version of Qiskit SDK. Switch to latest version

NoiseTransformer

NoiseTransformer

GitHub(opens in a new tab)

Transforms one quantum channel to another based on a specified criteria.


Methods

channel_matrix_representation

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

compute_P

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

compute_channel_operation

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

compute_q

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

fidelity

static NoiseTransformer.fidelity(channel)

Calculates channel fidelity

flatten_matrix

static NoiseTransformer.flatten_matrix(m)

Parameters

m (Matrix) – The matrix to flatten

Returns

A row vector repesenting the flattened matrix

Return type

list

generate_channel_matrices

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 x0,x1,...,xnx_0, x_1, ..., x_n which are meant to represent probabilities such that xi0x_i \ge 0 and x0=1(x1+...+xn)x0 = 1-(x_1 + ... + x_n).

Now consider the quantum channel defined via the Kraus operators (x0)I,(x1)A1,(x1)B1,...,(xm)An,(xn)Bn,...{\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 x1D1+...+xnDn+Ex_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

generate_channel_quadratic_programming_matrices

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

get_const_matrix_from_channel

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.

get_matrix_from_channel

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.

operator_circuit

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

operator_matrix

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

prepare_channel_operator_list

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

prepare_honesty_constraint

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) –

solve_quadratic_program

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.

transform_by_given_channel

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

transform_by_operator_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][X, Y, Z] allows approximating by a Pauli channel, and [(00,01),10,11)][(|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 [A1,A2,...,An][A_1, A_2, ..., A_n] of transform matrices and [E0,E1,...,Em][E_0, E_1, ..., E_m] of noise Kraus operators, the output is a list [p1,p2,...,pn][p_1, p_2, ..., p_n] of probabilities such that:

  1. pi0p_i \ge 0
  2. p1+...+pn1p_1 + ... + p_n \le 1
  3. [(p1)A1,(p2)A2,...,(pn)An,(1(p1+...+pn))I][\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 [E0,...,Em][E_0, ..., E_m].)

This channel can be thought of as choosing the operator AiA_i in probability pip_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): [(A1,B1,...),(A2,B2,...),...,(An,Bn,...)][(A_1, B_1, ...), (A_2, B_2, ...), ..., (A_n, B_n, ...)] then the output is still a list [p1,p2,...,pn][p_1, p_2, ..., p_n] and now the output channel is defined by the operators: [(p1)A1,(p1)B1,...,(pn)An,(pn)Bn,...,(1(p1+...+pn))I][\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

Was this page helpful?
Report a bug or request content on GitHub.