Note

இந்த பக்கம் tutorials/circuits/1_getting_started_with_qiskit.ipynb இல் இருந்து உருவாக்கப்பட்டது.

மின்சுற்று அடிப்படை

இங்கு, நாங்கள் Qiskit யுடன் பணிபுரிந்த ஒரு மேலோட்டை வழங்குங்கள். Qiskit. Qiskit அடிப்படை தொகுப்பு டெர்ரா அதாவது நிரல் குண்டம் கணினிகளுக்கு தேவையான அடிப்படை கட்டிடக்கலை வழங்குகிறது. Qiskit இன் அடிப்படை அலகு ക്வாண்டம் சுழல். Qiskit பயன்படுத்தி ஒரு அடிப்படை பணிமேடை இரண்டு நிலைகளைக் கொண்டுள்ளது:Build and Execute. Build சிக்கலைக் குறிக்கும் வெவ்வேறு குவாண்டம் சுற்றுகளை நீங்கள் செய்ய வேண்டும், மற்றும் Execute இது வெவ்வேறு பின்தளத்தில் அவற்றை இயக்க உங்களை அனுமதிக்கிறது. வேலைகள் இயங்குவதற்கு பிறகு, தேவையான வெளியீட்டைப் பொறுத்து, தரவு தொகுக்கப்பட்டு பதவியேற்றுகிறது.

import numpy as np
from qiskit import QuantumCircuit

சுற்றுப்பாதை கட்டிடம்

உங்கள் முதல் திட்டத்திற்கு தேவையான அடிப்படை உறுப்பு குவாண்டம் சிர்குட் ஆகும். மூன்று க்யூபிட்களைக் கொண்ட QuantumCircuit ஐ உருவாக்குவதன் மூலம் தொடங்குவோம்.

# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)

After you create the circuit with its registers, you can add gates ("operations") to manipulate the registers. As you proceed through the tutorials you will find more gates and circuits; below is an example of a quantum circuit that makes a three-qubit GHZ state

\[|\psi\rகோணம் = (|000\rகோணம்+|111\rகோணம்)/\sqrt{2}.\]

அத்தகைய நிலையை உருவாக்க, நாம் மூன்று குவிட் குவாண்டம் பதிவேட்டில் தொடங்குகிறோம். இயல்பாக, பதிவேட்டில் உள்ள ஒவ்வொரு குவிட்டும் \(|0\rangle\) க்கு துவக்கப்படும். GHZ நிலையை உருவாக்க, பின்வரும் வாயில்களைப் பயன்படுத்துகிறோம்: - Qubit 0 இல் ஒரு Hadamard கேட் \(H\), இது சூப்பர்போசிஷன் நிலைக்கு \(\left(|0\rangle+|1\rangle\right )/\sqrt{2}\). - Qubit 0 மற்றும் qubit 1 க்கு இடையில் ஒரு கட்டுப்படுத்தப்பட்ட-NOT செயல்பாடு (\(C_{X}\)).

ஒரு சாதாரண வானிலை கணினியில், இந்த சுற்றுப்பாதை இயங்கும் மாநிலம் மேலே GHZ மாநிலமாக இருப்பது.

Qiskit இல், செயல்பாடுகள் ஒன்றை ஒன்று, கீழே காட்டப்பட்ட ஒன்று சேகரிக்கு சேர்க்கலாம்.

# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)

<qiskit.circuit.instructionset.InstructionSet at 0x7f7c92288310>

சுற்றுப்பாதை காட்சிப்படுத்தவும்

Qiskit QuantumCircuit.draw (), பல உரைநூல்களில் காணப்பட்ட மாதிரிகளில் சுற்றுப்பயணத்தை வரையறுக்கிறது.

circ.draw('mpl')

இந்த சுற்றுப்பாதையில், க்யூபிட்கள் வரிசையில் வைக்கப்பட்டு, மேலே குறும்படத்துடன், கீழே இரண்டு மேல் விட்டு. சுற்றுச்சூழல் வலது இடமாக வாசிக்கப்பட்டுள்ளது (அதாவது முந்தைய சுற்றுப்பாதையில் பயன்படுத்தப்பட்டிருக்கும் கோடுகள் மேலும் இடது வரை காட்டுகின்றன).

பல-க்யூபிட் அமைப்பின் நிலையைக் குறிக்கும் போது, ​​Qiskit டில் பயன்படுத்தப்படும் டென்சர் வரிசை பெரும்பாலான இயற்பியல் பாடப்புத்தகங்களில் பயன்படுத்தப்படுவதை விட வித்தியாசமானது. \(n\) க்யூபிட், மற்றும் க்யூபிட் \(j\) என பெயரிடப்பட்டுள்ளது \(Q_{j}\). Qiskit ஒரு வரிசையைப் பயன்படுத்துகிறது: இதில் \(n^{\mathrm{th}}\) க்யூபிட் டென்சர் தயாரிப்பின் இடது பக்கத்தில் உள்ளது, இதனால் அடிப்படை திசையன்கள் பின்வருமாறு பெயரிடப்பட்டுள்ளன \(Q_{n-1}\otimes \cdots \otimes Q_1\otimes Q_0\).

எடுத்துக்காட்டாக, க்யூபிட் பூஜ்ஜியம் 0 நிலையிலும், குவிட் 1 நிலை 0 ஆகவும், க்யூபிட் 2 நிலை 1 ஆகவும் இருந்தால், Qiskit இந்த நிலையை பின்வருமாறு குறிக்கும் \(|100\rangle\), அதே நேரத்தில் பல இயற்பியல் பாடப்புத்தகங்கள் இதைக் குறிக்கும் \(|001\rangle\).

இந்த வேறுபாட்டில் வேறுபாடு பாதிக்கப்படாமல் பல விரிவான செயல்பாடுகள் மடங்குகளாக பிரதிபலிக்கும். எடுத்துக்காட்டாக, Qiskit ஒரு கட்டுப்பாட்டை-X (\(C_{X}\)) செயல்பாடு 0 ஆக இருப்பது கட்டுப்பாட்டை மற்றும் க்யூபிட் 1 என்று இலக்கு என்று

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ \end{pmatrix}.\end{split}\]

சிம்லேட்டிங் குறும்படங்கள்

ஒரு சர்க்யூட்டை உருவகப்படுத்த நாம் Qiskit இல் குவாண்ட்_இன்ஃபோ தொகுதியைப் பயன்படுத்துகிறோம். இந்த சிமுலேட்டர் குவாண்டம் நிலையை அளிக்கிறது, இது பரிமாணங்களின் சிக்கலான திசையன் \(2^n\), எங்கே \(n\) என்பது க்யூபிட்களின் எண்ணிக்கை (எனவே இதைப் பயன்படுத்துவதில் கவனமாக இருங்கள், ஏனெனில் அது விரைவாக இயங்க பெரிதாகிவிடும் உங்கள் கணினியில்).

சிமுலேட்டருக்கு இரண்டு நிலைகள் உள்ளன. முதலாவது உள்ளீட்டு நிலையை அமைப்பது மற்றும் இரண்டாவது குவாண்டம் சுற்று மூலம் நிலையை உருவாக்குவது.

from qiskit.quantum_info import Statevector

# Set the intial state of the simulator to the ground state using from_int
state = Statevector.from_int(0, 2**3)

# Evolve the state by the quantum circuit
state = state.evolve(circ)

#draw using latex
state.draw('latex')

$$ \begin{bmatrix} \tfrac{1}{\sqrt{2}} & 0 & 0 & 0 & 0 & 0 & 0 & \tfrac{1}{\sqrt{2}} \\ \end{bmatrix} $$

from qiskit.visualization import array_to_latex

#Alternative way of representing in latex
array_to_latex(state)

$$ \begin{bmatrix} \tfrac{1}{\sqrt{2}} & 0 & 0 & 0 & 0 & 0 & 0 & \tfrac{1}{\sqrt{2}} \\ \end{bmatrix} $$

இந்த முடிவுகளைக் காண உங்களை அனுமதிக்க கிஸ்கிட் ஒரு காட்சிப்படுத்தல் கருவிப்பெட்டியையும் வழங்குகிறது.

கீழே, நாம் விசைவு செயல்கூறு பயன்படுத்த qsphere மற்றும் ஒரு ஹிங்கன், மாநில அடர்த்தி மாட்ரிக்ஸ் \(\rho\).

state.draw('qsphere')

state.draw('hinton')

ஒரு சுற்றுச்சூழல் ஒழுங்குபடுத்தல்

Qiskit’s quant_info module also has an operator method which can be used to make a unitary operator for the circuit. This calculates the \(2^n \times 2^n\) matrix representing the quantum circuit.

from qiskit.quantum_info import Operator

U = Operator(circ)

# Show the results
U.data

array([[ 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.        +0.j,  0.        +0.j,  0.        +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.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.        +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,  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,  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.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.70710678+0.j,  0.70710678+0.j],
       [ 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]])

OpenQASM பின்னணி

மேலேயுள்ள சிமுலேட்டர்கள் பயனுள்ளதாக இருக்கும், ஏனெனில் அவை நிலை சுற்று பற்றிய தகவல்களை இலட்சிய சுற்று மற்றும் சுற்றுகளின் மேட்ரிக்ஸ் பிரதிநிதித்துவத்தால் வழங்குகின்றன. இருப்பினும், ஒரு உண்மையான சோதனை ஒவ்வொரு க்யூபிட்டையும் measuring மூலம் முடிவடைகிறது (வழக்கமாக கணக்கீட்டில் \(|0\rangle, |1 \rangle\) அடிப்படையில்).அளவீடு இல்லாமல், நாங்கள் நிலையைப் பற்றிய தகவல்களைப் பெற முடியாது. அளவீடுகள் குவாண்டம் அமைப்பு கிளாசிக்கல் பிட்களில் சரிவதற்கு காரணமாகின்றன.

எடுத்துக்காட்டாக, நாம் மூன்று-கிட் GHZ மாநிலத்தின் ஒவ்வொரு விகிதத்தில் சுதந்திரமான அளவீடுகள் செய்யும்

\[| \psi\rகோணம் = (| 000\rகோணம் + | 111\rகோணம்)/\sqrt{2},\]

மற்றும் விடுங்கள் \(xyz\) விளைவிக்கும் பிட்ஸ்ட்ரிங்கைக் குறிக்கிறது. Qiskit பயன்படுத்திய க்யூபிட் லேபிளிங்கின் கீழ் , \(x\) என்பது க்யூபிட் 2 இன் முடிவுக்கு ஒத்திருக்கும், \(y\) க்யூபிட் 1 இன் முடிவுக்கு, மற்றும் \(z\) க்யூபிட் 0.

குறிப்பு: பிட்ரசின் இந்த பிரதிநிதிப்பு இடது மிகவும் குறிப்பிடத்தக்க பிட் (MSB), மற்றும் குறைந்தது குறிப்பிடத்தக்க பிட் (LSB) வலது. இது இரும bitstrings-யின் நிலையான ஒழுங்குபடுத்தும். நாம் ஒரே வழியில் க்யூபிட் வரிசையில் வரிசைப்படுத்துகிறது (MSB குறித்த குறும்படம் சுட்டி 0), அதனால் Qiskit ஒரு நிலையான டென்ஸர் தயாரிப்பு வரிசை பயன்படுத்துகிறது.

முடிவைப் பெறுவதற்கான நிகழ்தகவை நினைவுகூருங்கள் \(xyz\) வழங்கியது

\[\mathrm{Pr}(xyz) = |\langle xyz |\psi \rangle|^{2}\]

ஆயிரக்கணக்கான GHZ மாநில உற்பத்தி மாநில அளவிலான ஆயிரம் அல்லது 111 இரண்டும்.

அளவீடுகளைக் கொண்டிருக்கும் ஒரு சுற்றுச்சூழல், நாம் மேலே மூல சுற்றுப்பாதைக்கு அளவுகோல்களை சேர்க்க வேண்டும், மற்றும் வேறுபடும் ஆர் பின்னணியை பயன்படுத்தவும்.

# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))

# The Qiskit circuit object supports composition.
# Here the meas has to be first and front=True (putting it before)
# as compose must put a smaller circuit into a larger one.
qc = meas.compose(circ, range(3), front=True)

#drawing the circuit
qc.draw('mpl')

இந்த சுற்றுப்பாதை ஒரு கிளாசிரியர் பதிப்பு சேர்க்கிறது, மற்றும் மூன்று அளவுகள் that are used to map to map to map to the classical bits.

இந்த சுற்றுப்பாதை பாதிப்பதற்கு, நாங்கள் Qiskit Aer qasm_simulator பயன்படுத்தும்.இந்த சுற்றுச்சூழல் ஒவ்வொரு ஓட்டும் பிட்ரேட் 000 அல்லது 111. Bitstrings (to, எ. கா, கணக்கெடுப்பு \(\mathrm{Pr}(000)\)) பற்றிய புள்ளிவிவரங்கள் பற்றிய புள்ளிவிவரங்கள் உருவாக்க வேண்டும். இந்த சாதனத்தின் எண்ணிக்கை மறுபடியும், shots என்ற சொல் வழியாக, execute செயல்பாட்டில் குறிப்பிடலாம்.

# Adding the transpiler to reduce the circuit to QASM instructions
# supported by the backend
from qiskit import transpile

# Use AerSimulator
from qiskit_aer import AerSimulator

backend = AerSimulator()

# First we have to transpile the quantum circuit
# to the low-level QASM instructions used by the
# backend
qc_compiled = transpile(qc, backend)

# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = backend.run(qc_compiled, shots=1024)

# Grab the results from the job.
result_sim = job_sim.result()

உங்களிடம் ஒரு முடிவு பொருள் கிடைத்ததும், get_counts (circuit) முறை மூலம் எண்ணிக்கையை அணுகலாம். இது நீங்கள் ஓடிய சோதனையின் மொத்த விளைவுகளை வழங்குகிறது.

counts = result_sim.get_counts(qc_compiled)
print(counts)

{'111': 522, '000': 502}

ஏறத்தாழ 50 சதவீதம் நேரம், வெளியீடு பிட்ரம் 000. Qiskit also provides a function plot_histogram, which allows you to view the outcomes.

from qiskit.visualization import plot_histogram
plot_histogram(counts)

மதிப்பிடப்பட்ட விளைவு நிகழ்தகவுகள் \(\mathrm{Pr}(000)\) மற்றும் \(\mathrm{Pr}(111)\) மொத்த எண்ணிக்கையை எடுத்து காட்சிகளின் எண்ணிக்கையால் வகுப்பதன் மூலம் கணக்கிடப்படுகிறது (சுற்று இருந்த நேரங்கள் மீண்டும் மீண்டும்). execute செயல்பாட்டில் shots முக்கிய சொல்லை மாற்ற முயற்சிக்கவும், மதிப்பிடப்பட்ட நிகழ்தகவுகள் எவ்வாறு மாறுகின்றன என்பதைப் பார்க்கவும்.

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.26.2
Terra	0.17.4
Aer	0.8.2
Ignis	0.6.0
Aqua	0.9.1
IBM Q Provider	0.13.1
System information
Python	3.8.5 (default, Sep 4 2020, 07:30:14) [GCC 7.3.0]
OS	Linux
CPUs	2
Memory (Gb)	7.523967742919922
Fri Jun 04 17:48:05 2021 IST

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

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.