Note

இந்த பக்கம் tutorials/circuits_advanced/02_operators_overview.ipynb இருந்து உருவாக்கப்பட்டது.

ஆபரேட்டர்கள்

import numpy as np

from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity

from qiskit.extensions import RXGate, XGate, CXGate

ஆபரேட்டர் வகுப்பு

குவாண்டம் அமைப்பில் செயல்படும் மேட்ரிக்ஸ் ஆபரேட்டர்களைக் குறிக்க Qiskit-ல் Operator வகுப்பு பயன்படுத்தப்படுகிறது. சிறிய ஆபரேட்டர்களின் tensor product-கள் பயன்படுத்தி கலப்பு ஆபரேட்டர்களை உருவாக்குவதற்கும், ஆபரேட்டர்களை உருவாக்குவதற்கும் இது பல முறைகளைக் கொண்டுள்ளது.

ஆபரேட்டர்களை உருவாக்குதல்

ஒரு ஆபரேட்டர் ஆப்ஜெக்ட்டை உருவாக்குவதற்கான எளிதான வழி, ஒரு பட்டியல் அல்லது ஒரு வரிசை வரிசையாக கொடுக்கப்பட்ட மேட்ரிக்ஸுடன் அதை துவக்குவது. எடுத்துக்காட்டாக, இரண்டு-கியூபிட் பவுலி-XX ஆபரேட்டரை உருவாக்க:

XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
XX

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
          [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

ஆபரேட்டர் பண்புகள்

ஆபரேட்டர் ஆப்ஜெக்ட் அடிப்படை மேட்ரிக்ஸ், மற்றும் துணை அமைப்புகளின் உள்ளீட்டு மற்றும் வெளியீடு பரிமாணங்களை சேமிக்கிறது.

• data: அடிப்படை Numpy வரிசையை அணுக, நாங்கள் Operator.data பண்பைப் பயன்படுத்தலாம்.

• dims: ஆபரேட்டரின் மொத்த உள்ளீடு மற்றும் வெளியீட்டு பரிமாணத்தை வழங்க, நாம் Operator.dim பண்பைப் பயன்படுத்தலாம். குறிப்பு: வெளியீடு ஒரு டூப்பிள் (input_dim, output_dim), இது அடிப்படை அணிகளின் வடிவத்தின் தலைகீழ் ஆகும்.

XX.data

array([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
       [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])

input_dim, output_dim = XX.dim
input_dim, output_dim

(4, 4)

உள்ளீடு மற்றும் வெளியீட்டு பரிமாணங்கள்

ஆபரேட்டர் வகுப்பு துணை அமைப்பு பரிமாணங்களையும் தடை செய்கிறது, இது ஒன்றாக சேர்ந்த ஆபரேட்டர்களுக்காக பயன்படுகிறது. இவை input_dims மற்றும் output_dims செயல்பாடுகளைப் பயன்படுத்தலாம்.

\(2^N\) by \(2^M\) ஆபரேட்டர்களுக்கு, உள்ளீடு மற்றும் வெளியீட்டு பரிமாணம் தானாகவே M-கியூபிட் மற்றும் N-கியூபிட் என கருதப்படும்:

op = Operator(np.random.rand(2 ** 1, 2 ** 2))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())

Input dimensions: (2, 2)
Output dimensions: (2,)

உள்ளீட்டு மேட்ரிக்ஸ், கியூபிட் துணை அமைப்புகளாகத் தெரியவில்லை என்றால், அது ஒற்றை கியூபிட் ஆபரேட்டராக சேமிக்கப்படும். எடுத்துக்காட்டாக, நாம்மிடம் ஒரு \(6\times6\) மேட்ரிக்ஸ்:

op = Operator(np.random.rand(6, 6))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())

Input dimensions: (6,)
Output dimensions: (6,)

புதிய ஆபரேட்டரை துவக்கும்போது உள்ளீடு மற்றும் வெளியீட்டுக் குணங்கள் நாமாகவே குறிப்பிடலாம்:

# Force input dimension to be (4,) rather than (2, 2)
op = Operator(np.random.rand(2 ** 1, 2 ** 2), input_dims=[4])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())

Input dimensions: (4,)
Output dimensions: (2,)

# Specify system is a qubit and qutrit
op = Operator(np.random.rand(6, 6),
              input_dims=[2, 3], output_dims=[2, 3])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())

Input dimensions: (2, 3)
Output dimensions: (2, 3)

input_dims மற்றும் output_dims செயல்பாடுகளைப் பயன்படுத்தி துணை அமைப்புகளின் துணைக்குழுவின் உள்ளீடு அல்லது வெளியீட்டு பரிமாணங்களையும் நாம் பிரித்தெடுக்க முடியும்:

print('Dimension of input system 0:', op.input_dims([0]))
print('Dimension of input system 1:', op.input_dims([1]))

Dimension of input system 0: (2,)
Dimension of input system 1: (3,)

வகுப்புகளை ஆபரேட்டர்களாக மாற்றுவது

Qiskit-ல் உள்ள பல வகுப்புகளை ஆபரேட்டர் துவக்க முறையைப் பயன்படுத்தி நேரடியாக Operator ஆப்ஜெக்டாக மாற்றலாம். உதாரணத்திற்கு:

• Pauli ஆப்ஜெக்ட்கள்

• Gate மற்றும் Instruction ஆப்ஜெக்ட்கள்

• குவாண்டம் சர்க்யூட்` பொருள்கள்

கடைசி புள்ளி என்பது ஒரு சிமுலேட்டர் பின்தளத்தில் அழைக்காமல், ஒரு குவாண்டம் சர்க்யூட்டிற்கான இறுதி யூனிடரி மேட்ரிக்ஸைக் கணக்கிட Operator வகுப்பை ஒரு யூனிடரி சிமுலேட்டராகப் பயன்படுத்தலாம் என்பதை நினைவில் கொள்க. சர்க்யூட்டுக்கு ஆதரிக்கப்படாத செயல்பாடுகள் ஏதேனும் இருந்தால், விதிவிலக்கு எழுப்பப்படும். ஆதரிக்கப்படாத செயல்பாடுகள்: அளவீட்டு, மீட்டமைத்தல், நிபந்தனை செயல்பாடுகள் அல்லது மேட்ரிக்ஸ் வரையறைகளுடன் கூடிய கேட்டின் அடிப்படையில் மேட்ரிக்ஸ் வரையறை அல்லது சிதைவு இல்லாத ஒரு கேட்.

# Create an Operator from a Pauli object

pauliXX = Pauli('XX')
Operator(pauliXX)

Operator([[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
          [1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an Operator for a Gate object
Operator(CXGate())

Operator([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
          [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
          [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
          [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

# Create an operator from a parameterized Gate object
Operator(RXGate(np.pi / 2))

Operator([[0.70710678+0.j        , 0.        -0.70710678j],
          [0.        -0.70710678j, 0.70710678+0.j        ]],
         input_dims=(2,), output_dims=(2,))

# Create an operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1, 10):
    circ.cx(j-1, j)

# Convert circuit to an operator by implicit unitary simulation
Operator(circ)

Operator([[ 0.70710678+0.j,  0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          ...,
          [ 0.        +0.j,  0.        +0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j],
          [ 0.70710678+0.j, -0.70710678+0.j,  0.        +0.j, ...,
            0.        +0.j,  0.        +0.j,  0.        +0.j]],
         input_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2), output_dims=(2, 2, 2, 2, 2, 2, 2, 2, 2, 2))

சர்க்யூட்களில் ஆபரேட்டர்களைப் பயன்படுத்துதல்

யூனிடரி Operators நேரடியாக QuantumCircuit இல் QuantumCircuit.append முறையைப் பயன்படுத்தி சேர்க்கலாம். இது Operator ஐ UnitaryGate பொருளாக மாற்றுகிறது, இது சர்க்யூட்டுக்கு சேர்க்கப்படுகிறது.

ஆபரேட்டர் யூனிடரியாக இல்லாவிட்டால், ஒரு விதிவிலக்கு எழுப்பப்படும். Operator.is_unitary() செயல்பாட்டைப் பயன்படுத்தி இதைச் சரிபார்க்கலாம், இது ஆபரேட்டர் யூனிடரியாக இருந்தால் True மற்றும் இல்லையெனில் False.

# Create an operator
XX = Operator(Pauli('XX'))

# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0,1], [0,1])
circ.draw('mpl')

மேலே உள்ள எடுத்துக்காட்டில் ஆபரேட்டரை Pauli ஆப்ஜெக்டிலிருந்து துவக்குகிறோம் என்பதை நினைவில் கொள்க. இருப்பினும், Pauli ஆப்ஜெக்ட் நேரடியாக சர்க்யூட்டுக்குள் சேர்க்கப்படலாம், மேலும் இது ஒற்றை கியூபிட் Pauli கேட்கள் வரிசையாக மாற்றப்படும்:

backend = BasicAer.get_backend('qasm_simulator')
circ = transpile(circ, backend, basis_gates=['u1','u2','u3','cx'])
job = backend.run(circ)
job.result().get_counts(0)

{'11': 1024}

# Add to a circuit
circ2 = QuantumCircuit(2, 2)
circ2.append(Pauli('XX'), [0, 1])
circ2.measure([0,1], [0,1])
circ2.draw()

     ┌────────────┐┌─┐
q_0: ┤0           ├┤M├───
     │  Pauli(XX) │└╥┘┌─┐
q_1: ┤1           ├─╫─┤M├
     └────────────┘ ║ └╥┘
c: 2/═══════════════╩══╩═
                    0  1 

ஆபரேட்டர்களை இணைத்தல்

ஆபரேட்டர்கள் பல முறைகளைப் பயன்படுத்தி இணைக்கப்படலாம்.

டென்சர் ப்ராடக்ட்

இரண்டு ஆபரேட்டர்கள் \(A\) மற்றும் \(B\) ஆகியவை Operator.tensor செயல்பாட்டைப் பயன்படுத்தி ஒரு டென்சர் தயாரிப்பு இயக்கி \(A\otimes B\) ஆக இணைக்கப்படலாம். \(A\) மற்றும் \(B\) இரண்டும் ஒற்றை-க்யூபிட் ஆபரேட்டர்கள் என்றால், A.tensor(B) = \(A\otimes B\) துணை அமைப்புகளை இவ்வாறு அட்டவணைப்படுத்தியிருக்கும். துணை அமைப்பு 0 இல் அணி \(B\) மற்றும் துணை அமைப்பு 1 இல் அணி \(A\).

A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.tensor(B)

Operator([[ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
          [ 0.+0.j, -0.+0.j,  0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],
          [ 0.+0.j, -1.+0.j,  0.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

டென்சர் விரிவாக்கம்

ஒரு நெருங்கிய தொடர்புடைய செயல்பாடு Operator.expand ஆகும், இது ஒரு டென்சர் தயாரிப்பாக செயல்படுகிறது ஆனால் தலைகீழ் வரிசையில் செயல்படுகிறது. எனவே, இரண்டு ஆபரேட்டர்களுக்கு \(A\) மற்றும் \(B\) எங்களிடம் A.expand(B) = \(B\otimes A\), அங்கு துணை அமைப்புகள் அணி :math:` எனக் குறியிடப்படும். துணை அமைப்பு 0 இல் A` மற்றும் துணை அமைப்பு 1 இல் அணி \(B\).

A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.expand(B)

Operator([[ 0.+0.j,  1.+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, -0.+0.j, -1.+0.j],
          [ 0.+0.j,  0.+0.j, -1.+0.j, -0.+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

கலவை

Operator.compose முறையைப் பயன்படுத்தி மேட்ரிக்ஸ் பெருக்கலை செயல்படுத்த \(A\) மற்றும் \(B\) ஆகிய இரண்டு ஆபரேட்டர்களையும் நாங்கள் உருவாக்கலாம். A.compose(B) ஆபரேட்டரை மேட்ரிக்ஸ் \(B.A\) துடன் திருப்பித் தருகிறோம்:

A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B)

Operator([[ 0.+0.j,  1.+0.j],
          [-1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

compose -ன் front kwarg -ஐப் பயன்படுத்தி \(B\) -க்கு முன்னால் \(A\) -ஐப் பயன்படுத்துவதன் மூலம் நாம் தலைகீழ் வரிசையில் எழுத முடியும்: A.compose(B, front=True) = \(A.B\):

A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B, front=True)

Operator([[ 0.+0.j, -1.+0.j],
          [ 1.+0.j,  0.+0.j]],
         input_dims=(2,), output_dims=(2,))

துணை அமைப்பு கலவை

முந்தைய தொகுப்பிற்கு முதல் ஆபரேட்டரின் மொத்த வெளியீட்டு பரிமாணம் தேவைப்படுகிறது என்பதை நினைவில் கொள்க \(A\) என்பது இயற்றப்பட்ட ஆபரேட்டரின் மொத்த உள்ளீட்டு பரிமாணத்திற்கு சமம் \(B\) (அதேபோல், கணிதத்தின் வெளியீட்டு பரிமாணம் \(B\) இன் உள்ளீட்டு பரிமாணத்திற்கு சமமாக இருக்க வேண்டும் \(A\) உடன் எழுதும்போது front=True).

முன்=உண்மை உடன் அல்லது இல்லாமலேயே கோர்க்ஸ் க்வார்க் கம்பஸ் ஐப் பயன்படுத்தி பெரிய ஆபரேட்டரில் துணை அமைப்புகளின் தேர்வுடன் சிறிய ஆபரேட்டரை உருவாக்கலாம். இந்த வழக்கில், உருவாக்கப்படும் துணை அமைப்புகளின் தொடர்புடைய உள்ளீடு மற்றும் வெளியீட்டு பரிமாணங்கள் பொருந்த வேண்டும். சிறிய ஆபரேட்டர் எப்போதும் இயற்றுதல் முறையின் வாதமாக இருக்க வேண்டும் என்பதை நினைவில் கொள்ளவும்.

எடுத்துக்காட்டாக, மூன்று-கியூபிட் ஆபரேட்டருடன் இரண்டு-கியூபிட் கேட் உருவாக்க:

# Compose XZ with an 3-qubit identity operator
op = Operator(np.eye(2 ** 3))
XZ = Operator(Pauli('XZ'))
op.compose(XZ, qargs=[0, 2])

Operator([[ 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,  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,  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,  0.+0.j,  0.+0.j,  0.+0.j,
           -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  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,
            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],
          [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

# Compose YX in front of the previous operator
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(XZ, qargs=[0, 2], front=True)

Operator([[ 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,  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,  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,  0.+0.j,  0.+0.j,  0.+0.j,
           -1.+0.j],
          [ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  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,
            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],
          [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,
            0.+0.j]],
         input_dims=(2, 2, 2), output_dims=(2, 2, 2))

நேர் இணைப்புகள்

சிக்கலான எண்களால் கூட்டல், கழித்தல் மற்றும் அளவிடுதல் பெருக்கத்திற்கான நிலையான நேரியல் ஆபரேட்டர்களைப் பயன்படுத்தி ஆபரேட்டர்கள் இணைக்கப்படலாம்.

XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))

op = 0.5 * (XX + YY - 3 * ZZ)
op

Operator([[-1.5+0.j,  0. +0.j,  0. +0.j,  0. +0.j],
          [ 0. +0.j,  1.5+0.j,  1. +0.j,  0. +0.j],
          [ 0. +0.j,  1. +0.j,  1.5+0.j,  0. +0.j],
          [ 0. +0.j,  0. +0.j,  0. +0.j, -1.5+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

ஒரு முக்கியமான விஷயம் என்னவென்றால், tensor, expand மற்றும் compose ஆகியவை யூனிடரி ஆபரேட்டர்களின் ஒற்றுமையைப் பாதுகாக்கும், நேரியல் சேர்க்கைகள் இருக்காது; எனவே, இரண்டு யூனிடரி ஆபரேட்டர்களைச் சேர்ப்பது, பொதுவாக, யூனிடரி அல்லாத ஆபரேட்டருக்கு வழிவகுக்கும்:

op.is_unitary()

False

ஆபரேட்டர்களுக்கான மறைமுக மாற்றம்

பின்வரும் அனைத்து முறைகளுக்கும், இரண்டாவது ஆப்ஜெக்ட் ஏற்கனவே Operator ஆப்ஜெக்ட்டாக இல்லாவிட்டால், அது முறையால் ஒன்றாக மறைமுகமாக மாற்றப்படும் என்பதை நினைவில் கொள்க. முதலில் Operator என வெளிப்படையாக மாற்றப்படாமல் மேட்ரிக்ஸ்களை நேரடியாக அனுப்ப முடியும் என்பதே இதன் பொருள். மாற்றம் சாத்தியமில்லை என்றால், ஒரு விதிவிலக்கு எழுப்பப்படும்.

# Compose with a matrix passed as a list
Operator(np.eye(2)).compose([[0, 1], [1, 0]])

Operator([[0.+0.j, 1.+0.j],
          [1.+0.j, 0.+0.j]],
         input_dims=(2,), output_dims=(2,))

ஆபரேட்டர்களின் ஒப்பீடு

ஆபரேட்டர்கள் ஒரு சமத்துவ முறையை செயல்படுத்துகின்றன, இது இரண்டு ஆபரேட்டர்கள் தோராயமாக சமமாக இருக்கிறதா என்று சோதிக்க பயன்படுகிறது.

Operator(Pauli('X')) == Operator(XGate())

True

ஆபரேட்டர்களின் ஒவ்வொரு மேட்ரிக்ஸ் உறுப்பு தோராயமாக சமமாக இருப்பதை இது சரிபார்க்கிறது என்பதை நினைவில் கொள்க; உலகளாவிய கட்டத்தால் வேறுபடும் இரண்டு அலகுகள் சமமாக கருதப்படாது:

Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())

False

செயல்முறை நம்பகத்தன்மை

Quantum Information தொகுதியிலிருந்து process_fidelity செயல்பாட்டைப் பயன்படுத்தி ஆபரேட்டர்களையும் ஒப்பிடலாம். இரண்டு குவாண்டம் channels ஒருவருக்கொருவர் எவ்வளவு நெருக்கமாக உள்ளன என்பதற்கான தகவல் கோட்பாட்டு அளவு இது, மற்றும் யூனிடரி ஆபரேட்டர்களைப் பொறுத்தவரை இது உலகளாவிய கட்டத்தை சார்ந்தது அல்ல.

# Two operators which differ only by phase
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())

# Compute process fidelity
F = process_fidelity(op_a, op_b)
print('Process fidelity =', F)

Process fidelity = 1.0

உள்ளீட்டு ஆபரேட்டர்கள் யூனிடரியாக இருந்தால் (அல்லது குவாண்டம் சேனல்களின் விஷயத்தில் CP) செயல்முறை நம்பகத்தன்மை பொதுவாக நெருக்கமான ஒரு சரியான நடவடிக்கை மட்டுமே என்பதை நினைவில் கொள்க, மேலும் உள்ளீடுகள் CP இல்லையென்றால் விதிவிலக்கு எழுப்பப்படும்.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.20.2
qiskit-aer	0.10.4
qiskit-ignis	0.7.1
qiskit-ibmq-provider	0.19.1
qiskit	0.36.2
System information
Python version	3.9.9
Python compiler	GCC 11.1.0
Python build	main, Dec 29 2021 22:19:36
OS	Linux
CPUs	32
Memory (Gb)	125.64821243286133
Wed Jun 22 15:52:11 2022 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.