Tamil
மொழிகள்
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Note

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

மேம்பட்ட சர்க்யூட்கள்

[1]:
import numpy as np
from qiskit import *

ஒளிபுகா கேட்டுகள்

[2]:
from qiskit.circuit import Gate

my_gate = Gate(name='my_gate', num_qubits=2, params=[])
[3]:
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])

circ.draw()
[3]:
     ┌──────────┐
q_0: ┤0         ├────────────
     │  my_gate │┌──────────┐
q_1: ┤1         ├┤0         ├
     └──────────┘│  my_gate │
q_2: ────────────┤1         ├
                 └──────────┘

கலப்பு கேட்டுகள்

[5]:
# Build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.id(sub_q[1])
sub_circ.u(1, 2, -2, sub_q[0])

# Convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()

qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])

circ.draw()
[5]:
     ┌───┐
q_0: ┤ H ├──■────────────────────
     └───┘┌─┴─┐     ┌───────────┐
q_1: ─────┤ X ├──■──┤0          ├
          └───┘┌─┴─┐│  sub_circ │
q_2: ──────────┤ X ├┤1          ├
               └───┘└───────────┘

அதிக அளவிலான சுருக்கத்தில் சர்க்யூட் வடிவமைப்பை அனுமதிக்க to_instruction ஐ மாற்றும்போது சர்க்யூட்கள் உடனடியாக சிதைக்கப்படுவதில்லை. விரும்பும் போது, ​​அல்லது தொகுக்கப்படுவதற்கு முன்பு, துணை சர்க்யூட்கள் decompose முறை வழியாக சிதைக்கப்படும்.

[6]:
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw()
[6]:
     ┌─────────┐
q_0: ┤ U2(0,π) ├──■─────────────────────────────────────
     └─────────┘┌─┴─┐     ┌───┐          ░ ┌───────────┐
q_1: ───────────┤ X ├──■──┤ H ├────■─────░─┤ U(1,2,-2) ├
                └───┘┌─┴─┐└───┘┌───┴───┐ ░ └───┬───┬───┘
q_2: ────────────────┤ X ├─────┤ Rz(1) ├─░─────┤ I ├────
                     └───┘     └───────┘ ░     └───┘    

அளவுரு சர்க்யூட்கள்

[7]:
from qiskit.circuit import Parameter

theta = Parameter('θ')

n = 5

qc = QuantumCircuit(5, 1)

qc.h(0)
for i in range(n-1):
    qc.cx(i, i+1)

qc.barrier()
qc.rz(theta, range(5))
qc.barrier()

for i in reversed(range(n-1)):
    qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)

qc.draw('mpl')
[7]:
../../_images/tutorials_circuits_advanced_01_advanced_circuits_10_0.png

We can inspect the circuit’s parameters

[8]:
print(qc.parameters)
ParameterView([Parameter(θ)])

அளவுருக்களை மதிப்புகளுடன் பிணைத்தல்

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

[9]:
import numpy as np

theta_range = np.linspace(0, 2 * np.pi, 128)

circuits = [qc.bind_parameters({theta: theta_val})
            for theta_val in theta_range]

circuits[-1].draw()
[9]:
     ┌───┐                     ░ ┌────────┐ ░                     ┌───┐┌─┐
q_0: ┤ H ├──■──────────────────░─┤ Rz(2π) ├─░──────────────────■──┤ H ├┤M├
     └───┘┌─┴─┐                ░ ├────────┤ ░                ┌─┴─┐└───┘└╥┘
q_1: ─────┤ X ├──■─────────────░─┤ Rz(2π) ├─░─────────────■──┤ X ├──────╫─
          └───┘┌─┴─┐           ░ ├────────┤ ░           ┌─┴─┐└───┘      ║
q_2: ──────────┤ X ├──■────────░─┤ Rz(2π) ├─░────────■──┤ X ├───────────╫─
               └───┘┌─┴─┐      ░ ├────────┤ ░      ┌─┴─┐└───┘           ║
q_3: ───────────────┤ X ├──■───░─┤ Rz(2π) ├─░───■──┤ X ├────────────────╫─
                    └───┘┌─┴─┐ ░ ├────────┤ ░ ┌─┴─┐└───┘                ║
q_4: ────────────────────┤ X ├─░─┤ Rz(2π) ├─░─┤ X ├─────────────────────╫─
                         └───┘ ░ └────────┘ ░ └───┘                     ║
c: 1/═══════════════════════════════════════════════════════════════════╩═
                                                                        0 
[12]:
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend))
counts = job.result().get_counts()

எடுத்துக்காட்டு சர்க்யூட்டில், நாங்கள் ஒரு உலகளாவிய \(R_z(\theta)\) ஐந்து-கியூபிட் சிக்கலான நிலையில் சுழற்சி செய்கிறோம், எனவே கியூபிட்-0 இல் \(5\theta\) ஊசலாட்டத்தைக் காணலாம்.

[13]:
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)

ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')

ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
[13]:
<matplotlib.legend.Legend at 0x7f8fcb307710>
../../_images/tutorials_circuits_advanced_01_advanced_circuits_18_1.png

தொகுப்பு செலவைக் குறைத்தல்

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

[14]:
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo

start = time.time()
qcs = []

theta_range = np.linspace(0, 2*np.pi, 32)

for n in theta_range:
    qc = QuantumCircuit(5)

    for k in range(8):
        for i,j in combinations(range(5), 2):
            qc.cx(i,j)
        qc.rz(n, range(5))
        for i,j in combinations(range(5), 2):
            qc.cx(i,j)

    qcs.append(qc)

compiled_circuits = transpile(qcs, backend=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())

end = time.time()
print('Time compiling over set of bound circuits: ', end-start)
Time compiling over set of bound circuits:  2.4267938137054443
[16]:
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')

for k in range(8):
    for i,j in combinations(range(5), 2):
        qc.cx(i,j)
    qc.rz(theta, range(5))
    for i,j in combinations(range(5), 2):
        qc.cx(i,j)

transpiled_qc = transpile(qc, backend=FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
                 for n in theta_range], backend=FakeVigo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start)
Time compiling over parameterized circuit, then binding:  1.4472951889038086

கலவை

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

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

[17]:
phi = Parameter('phi')

sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)

sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rx(phi, 0)
sub_circ2.rz(phi, 1)

qc = QuantumCircuit(4)
qr = qc.qregs[0]

qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])

qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])

print(qc.draw())

# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u3(0.1, phi2, 0.3, 0)
     ┌────────────┐┌────────────┐
q_0: ┤0           ├┤0           ├
     │  sc_1(phi) ││  sc_2(phi) │
q_1: ┤1           ├┤1           ├
     ├────────────┤└────────────┘
q_2: ┤0           ├──────────────
     │  sc_2(phi) │
q_3: ┤1           ├──────────────
     └────────────┘

வெவ்வேறு அளவுருக்களின் கீழ் ஒரு துணை சர்க்யூட்டை உள்ளிடுக, to_instruction முறையை ஒரு விருப்பமான வார்த்தையை ஏற்றுக்கொள்ளும் (parameter_map), அப்போது, தற்போதைய, மூல அளவுருக்கான ஆணைகள் புதிய அளவுருக்களால் மாற்றியமைக்கப்படும்.

[18]:
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)

theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')

qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())

print(larger_qc.decompose().draw())
       ┌────────────────┐
q24_0: ┤0               ├
       │                │
q24_1: ┤1 oracle(theta) ├
       │                │
q24_2: ┤2               ├
       └┬──────────────┬┘
q24_3: ─┤0             ├─
        │              │
q24_4: ─┤1 oracle(phi) ├─
        │              │
q24_5: ─┤2             ├─
       ┌┴──────────────┴┐
q24_6: ┤0               ├
       │                │
q24_7: ┤1 oracle(gamma) ├
       │                │
q24_8: ┤2               ├
       └────────────────┘
       ┌───────────┐
q24_0: ┤ Rz(theta) ├──■─────────────────────────────────
       └───────────┘┌─┴─┐┌───────────┐
q24_1: ─────────────┤ X ├┤ Rz(theta) ├──■───────────────
                    └───┘└───────────┘┌─┴─┐┌───────────┐
q24_2: ───────────────────────────────┤ X ├┤ Rz(theta) ├
        ┌─────────┐                   └───┘└───────────┘
q24_3: ─┤ Rz(phi) ├───■─────────────────────────────────
        └─────────┘ ┌─┴─┐ ┌─────────┐
q24_4: ─────────────┤ X ├─┤ Rz(phi) ├───■───────────────
                    └───┘ └─────────┘ ┌─┴─┐ ┌─────────┐
q24_5: ───────────────────────────────┤ X ├─┤ Rz(phi) ├─
       ┌───────────┐                  └───┘ └─────────┘
q24_6: ┤ Rz(gamma) ├──■─────────────────────────────────
       └───────────┘┌─┴─┐┌───────────┐
q24_7: ─────────────┤ X ├┤ Rz(gamma) ├──■───────────────
                    └───┘└───────────┘┌─┴─┐┌───────────┐
q24_8: ───────────────────────────────┤ X ├┤ Rz(gamma) ├
                                      └───┘└───────────┘
[19]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.19.0.dev0+be0ed5f
qiskit-aer0.8.2
qiskit-ignis0.6.0
qiskit-ibmq-provider0.16.0.dev0+4e20edc
System information
Python3.7.7 (default, May 6 2020, 04:59:01) [Clang 4.0.1 (tags/RELEASE_401/final)]
OSDarwin
CPUs6
Memory (Gb)32.0
Sat Jul 31 01:02:16 2021 EDT

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.

[ ]: