Note

இந்த பக்கம் tutorials/simulators/7_matrix_product_state_method.ipynb இலிருந்து உருவாக்கப்பட்டது.

மேட்ரிக்ஸ் ப்ராடக்ட் ஸ்டேட் சிமுலேஷன் முறை

சிமுலேஷன் முறைகள்

AerSimulator -ல் பல சிமுலேஷன் முறைகள் உள்ளன statevector, stabilizer, extended_stabilizer மற்றும் matrix_product_state உட்பட. இவை ஒவ்வொன்றும் குவாண்டம் சர்க்யூட்களின் உள் பிரதிநிதித்துவத்தையும், குவாண்டம் செயல்பாடுகளை செயலாக்கப் பயன்படுத்தப்படும் வழிமுறைகளையும் தீர்மானிக்கிறது. அவை ஒவ்வொன்றும் நன்மைகள் மற்றும் தீமைகள் உள்ளன, மேலும் சிறந்த முறையைத் தேர்ந்தெடுப்பது விசாரணைக்குரிய விஷயம். இந்த டுடோரியலில், matrix product state simulation method இல் கவனம் செலுத்துகிறோம்.

மேட்ரிக்ஸ் ப்ராடக்ட் ஸ்டேட் சிமுலேஷன் முறை

இந்த சிமுலேஷன் முறை matrix product states என்ற கருத்தை அடிப்படையாகக் கொண்டது. இந்த அமைப்பு ஆரம்பத்தில் இந்த ஆய்வில் முன்மொழியப்பட்டது Efficient classical simulation of slightly entangled quantum computations by Vidal in https://arxiv.org/abs/quant-ph/0301063. கட்டமைப்பை இன்னும் விரிவாக விவரிக்கும் கூடுதல் ஆவணங்கள் இங்கு உள்ளன, எடுத்துக்காட்டாக The density-matrix renormalization group in the age of matrix product states by Schollwoeck https://arxiv.org/abs/1008.3477.

ஒரு தூய்மையான குவாண்டம் நிலை பொதுவாக ஒரு ஸ்டேட் வெக்டர் ஆக விவரிக்கப்படுகிறது \(|\psi\rangle = \sum_{i_1=0}^1 {\ldots} \sum_{i_n=0}^1 c_{i_1 \ldots i_n} |i_i\rangle {\otimes} {\ldots} {\otimes} |i_n\rangle\).

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

மேட்ரிக்ஸ் ப்ராடக்ட் நிலை (MPS) பிரதிநிதித்துவம் ஒரு உள்ளூர் பிரதிநிதித்துவத்தை வழங்குகிறது, இந்த வடிவத்தில் \(\Gamma^{[1]} \lambda^{[1]} \Gamma^{[2]} \lambda^{[2]}\ldots \Gamma^{[1]} \lambda^{[n-1]} \Gamma^{[n]}\), அதுபோல் \(c_{i_1 \ldots i_n}\) இல் உள்ள அனைத்து தகவல்களும் MPS பிரதிநிதித்துவத்திலிருந்து உருவாக்கப்படலாம்.

ஒவ்வொரு \(\Gamma^{[i]}\) என்பது சிக்கலான எண்களின் டென்சார் ஆகும், இது \(i\) கியூபிட்டைக் குறிக்கும். ஒவ்வொரு \(\lambda^{[i]}\) என்பது உண்மையான எண்களின் மேட்ரிக்ஸ், இது \(i\) மற்றும் \(i+1\) கியூபிட்களின் வீச்சுகளை இயல்பாக்குவதற்குப் பயன்படுகிறது. ஒற்றை-கியூபிட் கேட்கள் தொடர்புடைய டென்சாரில் மட்டுமே இயங்குகின்றன.

இரண்டு-கியூபிட் கேட்கள் தொடர்ச்சியான கியூபிட்களில் இயங்குகின்றன \(i\) மற்றும் \(i+1\). இது ஒரு டென்சார்-ஒப்பந்த செயல்பாட்டை உள்ளடக்கியது \(\lambda^{[i-1]}\), \(\Gamma^{[i-1]}\), \(\lambda^{[i]}\), \(\Gamma^{[i+1]}\) மற்றும் \(\lambda^{[i+1]}\), இது ஒற்றை டென்சாரை உருவாக்குகிறது. இந்த டென்சாருக்கு நாங்கள் கேட்டைப் பயன்படுத்துகிறோம், பின்னர் அசல் கட்டமைப்பிற்கு சிதைக்கிறோம். இந்த செயல்பாடு அந்தந்த டென்சார்களின் அளவை அதிகரிக்கக்கூடும். தொடர்ச்சியாக இல்லாத இரண்டு கியூபிட்களை உள்ளடக்கிய கேட்கள், இரண்டு கியூபிட்களையும் ஒருவருக்கொருவர் கொண்டு வர தொடர்ச்சியான இடமாற்று கேட்கள் தேவை, பின்னர் தலைகீழ் இடமாற்றங்கள்.

மோசமான நிலையில், டென்சார்கள் அதிவேகமாக வளரக்கூடும். இருப்பினும், ஒட்டுமொத்த கட்டமைப்பின் அளவு ‘பல’ இரண்டு-கியூபிட் கேட்கள் இல்லாத சர்க்யூட்களுக்கு ‘சிறியதாக’ உள்ளது. இது ஒப்பீட்டளவில் ‘குறைந்த’ என்டாங்கில்மென்ட்டுடன் சர்க்யூட்களில் மிகவும் திறமையான செயல்பாடுகளை அனுமதிக்கிறது. மற்ற முறைகளில் இந்த முறையை எப்போது பயன்படுத்த வேண்டும் என்பதைக் குறிப்பிடுவது தற்போதைய ஆராய்ச்சியின் ஒரு விடயமாகும்.

மேட்ரிக்ஸ் ப்ரோடக்ட் நிலை சிமுலஷன் முறையைப் பயன்படுத்துதல்

சிமுலேஷன் முறையை அமைப்பதன் மூலம் மேட்ரிக்ஸ் ப்ரோடக்ட் நிலை சிமுலேஷன் முறை AerSimulator பயன்படுத்தப்படுகிறது. இது தவிர, அனைத்து செயல்பாடுகளும் பின்வரும் எடுத்துக்காட்டில் உள்ளதைப் போலவே AerSimulator கட்டுப்படுத்தப்படுகின்றன:

import numpy as np

# Import Qiskit
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import AerSimulator

# Construct quantum circuit
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0, 1)
circ.measure([0,1], [0,1])

# Select the AerSimulator from the Aer provider
simulator = AerSimulator(method='matrix_product_state')

# Run and get counts, using the matrix_product_state method
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
counts = result.get_counts(0)
counts

{'11': 515, '00': 509}

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

circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0, 1)

# Define a snapshot that shows the current state vector
circ.save_statevector(label='my_sv')
circ.save_matrix_product_state(label='my_mps')
circ.measure([0,1], [0,1])

# Execute and get saved data
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
data = result.data(0)

#print the result data
data

{'counts': {'0x0': 494, '0x3': 530},
 'my_sv': array([0.70710678+0.j, 0.        +0.j, 0.        +0.j, 0.70710678+0.j]),
 'my_mps': ([(array([[1.-0.j, 0.-0.j]]), array([[0.-0.j, 1.-0.j]])),
   (array([[1.-0.j],
           [0.-0.j]]),
    array([[0.-0.j],
           [1.-0.j]]))],
  [array([0.70710678, 0.70710678])])}

மேட்ரிக்ஸ் ப்ரோடக்ட் நிலை சிமுலேஷன் முறையைப் பயன்படுத்தி சர்க்யூட்களை இயக்குவது மற்ற முறைகளுடன் ஒப்பிடும்போது வேகமாக இருக்கும். எவ்வாறாயினும், செயல்படுத்தும் போது நாம் ஸ்டேட் வெக்டரை உருவாக்கினால், ஸ்டேட் வெக்டருக்கான மாற்றம் நிச்சயமாக நினைவகத்திலும் நேரத்திலும் அதிவேகமானது, எனவே இந்த முறையைப் பயன்படுத்துவதால் நாம் பயனடைய மாட்டோம். முழு ஸ்டேட் வெக்டரை அச்சிடத் தேவையில்லாத செயல்பாடுகளை மட்டுமே செய்தால் நாம் பயனடையலாம். உதாரணமாக, நாம் ஒரு சர்க்யூட் இயக்கி பின்னர் அளவீடு எடுத்தால். கீழே உள்ள சர்க்யூட் 200 கியூபிட்களைக் கொண்டுள்ளது. இந்த வினாக்கள் அனைத்தையும் உள்ளடக்கிய ஒரு EPR state ஐ உருவாக்குகிறோம். இந்த நிலை மிகவும் என்டாங்கில்டாக இருந்தாலும், மேட்ரிக்ஸ் ப்ரோடக்ட் நிலை முறையால் இது நன்கு கையாளப்படுகிறது, ஏனெனில் திறம்பட இரண்டு நிலைகள் மட்டுமே உள்ளன.

இதை விட அதிகமான வினாடிகளை நாம் கையாள முடியும், ஆனால் செயல்படுத்த சில நிமிடங்கள் ஆகலாம். இதேபோன்ற 500 கியூபிட்களுடன் உள்ள சர்க்யூட்டை இயக்க முயற்சிக்கவும்! அல்லது 1000 கூட இருக்கலாம் (காத்திருக்கும்போது ஒரு கப் காபி பெறலாம்).

num_qubits = 50
circ = QuantumCircuit(num_qubits, num_qubits)

# Create EPR state
circ.h(0)
for i in range (0, num_qubits-1):
    circ.cx(i, i+1)

# Measure
circ.measure(range(num_qubits), range(num_qubits))

tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
print("Time taken: {} sec".format(result.time_taken))
result.get_counts()

Time taken: 0.31022214889526367 sec

{'11111111111111111111111111111111111111111111111111': 548,
 '00000000000000000000000000000000000000000000000000': 476}

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.25.0
Terra	0.17.0
Aer	0.8.0
Ignis	0.6.0
Aqua	0.9.0
IBM Q Provider	0.12.2
System information
Python	3.8.8 | packaged by conda-forge | (default, Feb 20 2021, 16:22:27) [GCC 9.3.0]
OS	Linux
CPUs	8
Memory (Gb)	31.38858413696289
Tue Apr 20 15:22:58 2021 UTC

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.