CompMatr1

Functions for applying general one-qubit dense matrices, as CompMatr1. More...

Functions
void	applyCompMatr1 (Qureg qureg, int target, CompMatr1 matrix)
void	applyControlledCompMatr1 (Qureg qureg, int control, int target, CompMatr1 matrix)
void	applyMultiControlledCompMatr1 (Qureg qureg, int *controls, int numControls, int target, CompMatr1 matrix)
void	applyMultiStateControlledCompMatr1 (Qureg qureg, int *controls, int *states, int numControls, int target, CompMatr1 matrix)
void	multiplyCompMatr1 (Qureg qureg, int target, CompMatr1 matrix)

Detailed Description

Functions for applying general one-qubit dense matrices, as CompMatr1.

Function Documentation

applyCompMatr1()

void applyCompMatr1	(	Qureg	qureg,
		int	target,
		CompMatr1	matrix )

Applies a general one-qubit dense unitary matrix to the specified target qubit of qureg.

Diagram

Formulae

Let \( \hat{U} = \) matrix, \( t = \) target, and let \(\hat{U}_t\) notate operating \(\hat{U}\) upon the \( t \)-th qubit among \( N \), i.e.

\[ \hat{U}_t \equiv \id^{N-t} \otimes \hat{U} \otimes \id^{t-1}. \]

Then,

• When qureg is a statevector \( \svpsi \), this function effects

  \[ \svpsi \rightarrow \hat{U}_t \, \svpsi. \]

• When qureg is a density matrix \(\dmrho\), this function effects

  \[ \dmrho \rightarrow \hat{U}_t \, \dmrho \, {\hat{U}_t}^\dagger. \]

Constraints

• Unitarity of \( \hat{U} = \) matrix requires that \( \hat{U} \hat{U}^\dagger = \id \). Validation will check that matrix is approximately unitarity via

  \[ \max\limits_{ij} \Big|\left(\hat{U} \hat{U}^\dagger - \id\right)_{ij}\Big|^2 \le \valeps \]

  where the validation epsilon \( \valeps \) can be adjusted with setValidationEpsilon().

Example

Qureg qureg = createQureg(5);
 
CompMatr1 matrix = getInlineCompMatr1({
    {-1i/sqrt(2), 1i/sqrt(2)},
    {(1i-1)/2,    (1i-1)/2}
});
 
applyCompMatr1(qureg, 2, matrix); 

Parameters

[in,out]	qureg	the state to modify.
[in]	target	the index of the target qubit.
[in]	matrix	the Z-basis unitary matrix to effect.

Exceptions

error

if qureg or matrix are uninitialised. if matrix is not approximately unitary. if target is an invalid qubit index.

See also

• getCompMatr1()
• getInlineCompMatr1()
• multiplyCompMatr1()
• applyControlledCompMatr1()
• applyCompMatr2()
• applyCompMatr()

Author

Tyson Jones

Definition at line 81 of file operations.cpp.

                                                               {
 
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, nullptr, nullptr, 0, &target, 1, matrix, __func__);
}

Referenced by TEST_CASE().

applyControlledCompMatr1()

void applyControlledCompMatr1	(	Qureg	qureg,
		int	control,
		int	target,
		CompMatr1	matrix )

Note

Documentation for this function or struct is under construction!

Applies a singly-controlled one-qubit dense unitary matrix to the specified target qubit of qureg.

Diagram

See also

• applyCompMatr1()

Definition at line 86 of file operations.cpp.

                                                                                      {
 
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, &control, nullptr, 1, &target, 1, matrix, __func__);
}

applyMultiControlledCompMatr1()

void applyMultiControlledCompMatr1	(	Qureg	qureg,
		int *	controls,
		int	numControls,
		int	target,
		CompMatr1	matrix )

Note

Documentation for this function or struct is under construction!

Applies a multiply-controlled one-qubit dense unitary matrix to the specified target qubit of qureg.

Diagram

See also

• applyCompMatr1()

Definition at line 91 of file operations.cpp.

                                                                                                              {
 
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, controls, nullptr, numControls, &target, 1, matrix, __func__);
}

Referenced by applyMultiControlledCompMatr1().

applyMultiStateControlledCompMatr1()

void applyMultiStateControlledCompMatr1	(	Qureg	qureg,
		int *	controls,
		int *	states,
		int	numControls,
		int	target,
		CompMatr1	matrix )

Note

Documentation for this function or struct is under construction!

Applies an arbitrarily-controlled one-qubit dense unitary matrix to the specified target qubit of qureg, conditioned upon the controls being in the given states.

Diagram

See also

• applyCompMatr1()

Definition at line 96 of file operations.cpp.

                                                                                                                                {
 
    validateAndApplyAnyCtrlAnyTargUnitaryMatrix(qureg, controls, states, numControls, &target, 1, matrix, __func__);
}

Referenced by applyMultiStateControlledCompMatr1(), and applyMultiStateControlledRotateAroundAxis().

multiplyCompMatr1()

void multiplyCompMatr1	(	Qureg	qureg,
		int	target,
		CompMatr1	matrix )

Multiplies a general one-qubit dense matrix upon the specified target qubit of qureg.

Formulae

Let \( \hat{M} = \) matrix and \( t = \) target, and notate \(\hat{M}_t\) as per applyCompMatr1(). Unlike applyCompMatr1() however, this function only ever left-multiplies matrix upon qureg, regardless of whether it is a statevector or density matrix.

Explicitly,

• When qureg is a statevector \( \svpsi \), this function effects

  \[ \svpsi \rightarrow \hat{M}_t \, \svpsi. \]

• When qureg is a density matrix \(\dmrho\), this function effects

  \[ \dmrho \rightarrow \hat{M}_t \, \dmrho. \]

There are no additional constraints like unitarity.

Example

Qureg qureg = createDensityQureg(5);
 
CompMatr1 matrix = getInlineCompMatr1({
    {0.1, 0.2},
    {0.3i, 0.4i}
});
 
multiplyCompMatr1(qureg, 2, matrix); 

Parameters

[in,out]	qureg	the state to modify.
[in]	target	the index of the target qubit.
[in]	matrix	the Z-basis matrix to multiply.

Exceptions

error

if qureg or matrix are uninitialised. if target is an invalid qubit index.

See also

• getCompMatr1()
• getInlineCompMatr1()
• applyCompMatr1()
• applyQubitProjector()
• multiplyCompMatr()

Author

Tyson Jones

Definition at line 72 of file operations.cpp.

                                                                  {
    validate_quregFields(qureg, __func__);
    validate_target(qureg, target, __func__);
    validate_matrixFields(matrix, __func__); // matrix can be non-unitary
 
    bool conj = false;
    localiser_statevec_anyCtrlOneTargDenseMatr(qureg, {}, {}, target, matrix, conj);
}