নোট

এই পৃষ্ঠাটি tutorials/operators/01_operator_flow.ipynb-থেকে বানানো হয়েছে।

কার্যকারক প্রবাহ (অপারেটর ফ্লো)

ভূমিকা

Qiskit গাণিতিক রাশিমালা (এলজেব্রিক এক্সপ্রেশন) প্রকাশের জন্য প্রয়োজনীয় দশা সম্বলিত ক্লাস (ক্লাসেস রিপ্রেজেন্টিং স্টেটস), কার্যকারক, গাণিতিক যোগ, টেন্সর গুণন এবং কম্পোজিশন সরবরাহ করে। Qiskit সরবারকৃত এইসব ক্লাস ব্যবহার করে আমরা গাণিতিক রাশিমালা তৈরি করতে পারি।

শুরুতে আমরা এইসব গাণিতিক রাশিমালা পাউলী কার্যকারক ব্যবহার করে প্রকাশ করব। পরবর্তী অধ্যায়গুলোতে, আমরা বিস্তারিতভাবে দেখাব কিভাবে এইসব কার্যকারক এবং দশা ব্যবহার করা যায়, তাদের প্রকাশ করা যায় এবং আরও কি কি রাশিমালা প্রকাশ করা যায়। সবশেষে দেখানো হবে কিভাবে এই দশা প্রস্তুত করা হয়, হ্যামিল্টনিয়ানের সাথে কিভাবে তা পরিবর্তিত হয় এবং সর্বোপরি একটি পর্যবেক্ষকের গড় মান নির্ণয় করা হবে।.

পাউলি কার্যকারক (অপারেটরস), গাণিতিক সংযোজন, কম্পোজিশন এবং টেন্সর গুণফল

সবচেয়ে গুরুত্ত্বপুর্ণ কার্যকারক হচ্ছে পাউলী কার্যকারক। এই পাউলী কার্যকারকের প্রকাশভঙ্গী নিম্নরূপ।

from qiskit.opflow import I, X, Y, Z
print(I, X, Y, Z)

I X Y Z

এইসব অপারেটর সহগ সম্বলিতও হতে পারে।

print(1.5 * I)
print(2.5 * X)

1.5 * I
2.5 * X

এই সহগগুলো গাণিতিক সংযোজনের সময় একটি পদ (টার্ম) হিসেবে ব্যবহার করা যায়।

print(X + 2.0 * Y)

1.0 * X
+ 2.0 * Y

টেনসর গুণনকে একটি ক্যারেট দিয়ে প্রকাশ করা যায়, যা দেখতে অনেকটা এইরকম।

print(X^Y^Z)

XYZ

কম্পোজিশন কে প্রকাশ করা হয় @ এই সংকেত দ্বারা।

print(X @ Y @ Z)

iI

উল্লেখিত উদাহরণ দুইটিতে, পাউলী কার্যকারকের টেনসর গুণন এবং কম্পোজিশন বহুকিউবিট সমতুল্য একটি পাউলী কার্যকারকে পরিণত হয়েছে। আরও টেনসর গুণন অথবা জটিল কম্পোশজিশন ফলাফলটিকে অসম্পূর্ণ কার্যকারকে পরিণত করে, যা বীজগাণিতিক রাশিমালা হিসেবে ব্যবহার করা যাবে।

উদাহরণস্বরূপ, দুইটি গাণিতিক সংযোজনের কম্পোজিশন

print((X + Y) @ (Y + Z))

1j * Z
+ -1j * Y
+ 1.0 * I
+ 1j * X

এবং দুইটি গাণিতিক সংযোজনের টেনসর হবে

print((X + Y) ^ (Y + Z))

1.0 * XY
+ 1.0 * XZ
+ 1.0 * YY
+ 1.0 * YZ

Let’s take a closer look at the types introduced above. First the Pauli operators.

(I, X)

(PauliOp(Pauli('I'), coeff=1.0), PauliOp(Pauli('X'), coeff=1.0))

প্রত্যেক পাউলী কার্যকারক PauliOp এর ইন্সটান্স, যা qiskit.quantum_info.Pauli এর একটি ইন্সটান্স এবং একটি সহগ coeff যুক্ত করে। সাধারণত একটি PauliOp পাউলী কার্যকারকের আবেশিত টেনসর গুণন প্রকাশ করে।

2.0 * X^Y^Z

PauliOp(Pauli('XYZ'), coeff=2.0)

পাউলী কার্যকারকসমূহকে একজোড়া বুলিয়ান মান হিসেবে এনকোড করতে চাইলে, qiskit.quantum_info.Pauli এই নির্দেশনা (ডকুমেন্টেশন) ব্যবহারের অনুরোধ রইল।

All of the objects representing operators, whether as "primitive"s such as PauliOp, or algebraic expressions carry a coefficient

print(1.1 * ((1.2 * X)^(Y + (1.3 * Z))))

1.2 * (
  1.1 * XY
  + 1.4300000000000002 * XZ
)

In the following we take a broader and deeper look at Qiskit’s operators, states, and the building blocks of quantum algorithms.

প্রথমতঃ দশার অন্বয় (ফাংশন) এবং পরিমাপ (মেজারমেন্টস)

কোয়ান্টাম দশা StateFn উপশ্রেণী দ্বারা প্রকাশ করা যায়। চার ধরণের কোয়ান্টাম দশা প্রকাশভঙ্গী আছেঃ DictStateFn একটি গাণিতিক বেসিস দশা প্রকাশ করে, যা dict দ্বারা প্রকাশিত। VectorStateFn একটি নাম্পাই এরে দ্বারা প্রকাশিত একটি গাণিতিক দশা প্রকাশ ভঙ্গি। CircuitStateFn একটি যুক্তি বর্তনী ভিত্তিক প্রকাশভঙ্গী যা সকল-শুন্য ভিত্তি (বেসিস) দশাস্থিত যুক্তি বর্তনীর উপর মহড়া সম্পাদন করে। OperatorStateFn একটি ডেনসিটি ম্যাট্রিক্স দ্বারা প্রকাশিত মিশ্র দশা অবস্থা। (আমরা পরবর্ততীতে দেখব কিভাবে এই ``OperatorStateFn` একটি পর্যবেক্ষণ কার্যকারকের কাজে ব্যবহার করা যায়।)

পাঠক সুবিধার্থে কিছু StateFn উদাহরণ দেয়া হল। যেমন শুন্য, এক, যোগবোধক/ ধনাত্মক, বিপরীতবোধক/ ঋণাত্মক।.

from qiskit.opflow import (StateFn, Zero, One, Plus, Minus, H,
                           DictStateFn, VectorStateFn, CircuitStateFn, OperatorStateFn)

\(|0\rangle\) দ্বারা কোয়ান্টাম দশা শুন্য এবং \(|1\rangle\) দ্বারা কোয়ান্টাম দশা এক দ্বারা প্রকাশ করা হয়। এই প্রকাশভঙ্গী DictStateFn উপশ্রেণী অন্তর্ভুক্ত।

print(Zero, One)

DictStateFn({'0': 1}) DictStateFn({'1': 1})

\((|0\rangle + |1\rangle)/\sqrt{2}\) দ্বারা যোগবোধক/ ধনাত্মক দশা এবং \((|0\rangle - |1\rangle)/\sqrt{2}\) দ্বারা বিপরীতবোধক/ ঋণাত্মক দশা প্রকাশ করা হয়। এইক্ষেত্রে H যোগবোধক/ ধনাত্মক এর সমতুল্য।.

print(Plus, Minus)

CircuitStateFn(
   ┌───┐
q: ┤ H ├
   └───┘
) CircuitStateFn(
   ┌───┐┌───┐
q: ┤ X ├┤ H ├
   └───┘└───┘
)

কোয়ান্টাম দশার সংখ্যাক্রম (ইনডেক্সিং) eval পদ্ধতিতে নির্ণয় করা হয়। এই উদাহরণগুলো 0 এবং 1 বেসিস স্টেটের সহগ নির্ণয় পদ্ধতি বর্ণনা করে। (আমরা eval পদ্ধতিতে আরও গাণিতিক প্রক্রিয়া সম্পাদন পদ্ধতি বর্ণনা করব)।

print(Zero.eval('0'))
print(Zero.eval('1'))
print(One.eval('1'))
print(Plus.eval('0'))
print(Minus.eval('1'))

1.0
0.0
1.0
(0.7071067811865475+0j)
(-0.7071067811865475+8.7e-17j)

adjoint পদ্ধতি দ্বারা কোয়ান্টাম দশা দ্বৈত দিকরাশি ভিত্তিক ম্যাট্রিক্স যেমন bra কে ket ম্যাট্রিক্সে পরিণত করা যাবে। StateFn is_measurement নামে একটি সংকেত প্রদান করে, যা False হলে কেট ম্যাট্রিক্স নির্দেশ করে এবং True হলে ব্রা ম্যাট্রিক্স নির্দেশ করে।.

এখন আমরা \(\langle 1 |\) তৈরি করব।.

One.adjoint()

DictStateFn({'1': 1}, coeff=1.0, is_measurement=True)

প্রকাশ সুবিধার্থে, দ্বৈত দিকরাশি ম্যাট্রিক্স কে টিল্ড চিহ্ন দ্বারা সংকেতায়িত করা যাবে

~One

DictStateFn({'1': 1}, coeff=1.0, is_measurement=True)

বীজগাণিতিক কার্যকারক এবং প্রেডিকেটস

StateFnগুলির মধ্যে অনেক বীজগাণিতিক ক্রিয়াকলাপ (অপারেশন) এবং প্রেডিকেট সমর্থিত, সেই সঙ্গেঃ

• + - যোগ

• - - বিয়োজন, বিপরীতকরণ (-১ দ্বারা স্কেলার গুণন)

• * - স্কেলার গুণ

• / - স্কেলার বিভাজন

• @ - সমযোজন

• ^ - টেন্সর গুণন (প্রোডাক্ট) অথবা টেন্সর শক্তিমাত্রা (স্বয়ং n সংখ্যক বার টেন্সর)

• ** - সমযোজন শক্তিমাত্রা (স্বয়ং n সংখ্যক বার সমযোজন)

• == - সমতা

• ~ - সংলগ্ন, একটি অবস্থা (স্টেট) ফাংশন এবং পরিমাপের মধ্যে বিকল্প

খুব সচেতন থাকুন যে এই অপারেটরগুলি Python rules for operator precedence মেনে চলে, যা আপনি গাণিতিকভাবে যা প্রত্যাশিত করেন তা নাও হতে পারে। উদাহরণ স্বরূপ, I^X + X^I আসলে I ^ (X + X) ^ I == 2 * (I^X^I) হিসাবে বিশ্লেষিত হবে কারণ পাইথন ^ এর আগে + মূল্যায়ন করে। এই ক্ষেত্রে, আপনি পদ্ধতিগুলি (.tensor(), ইত্যাদি) অথবা বন্ধনীগুলি ব্যবহার করতে পারেন।

StateFns carry a coefficient. This allows us to multiply states by a scalar, and so to construct sums.

এইখানে আমরা \((2 + 3i)|0\rangle\) এই দশাটি প্রস্তুত করব।.

(2.0 + 3.0j) * Zero

DictStateFn({'0': 1}, coeff=(2+3j), is_measurement=False)

দুইটি DictStateFnএর যোগ একই রকমের একটি অবজেক্ট ফলাফল হিসেবে দেয়। ফলে আমরা \(|0\rangle + |1\rangle\) প্রস্তুত করতে পারি।

print(Zero + One)

DictStateFn({'0': 1.0, '1': 1.0})

দশার অভিলম্বীকরন (নরমালাইজ) হাতে কলমে করতে হবে। উদাহরণস্বরূপ কোন দশা \((|0\rangle + |1\rangle)/\sqrt{2}\) হলে আমরা লিখতে পারি

import math

v_zero_one = (Zero + One) / math.sqrt(2)
print(v_zero_one)

DictStateFn({'0': 1.0, '1': 1.0}) * 0.7071067811865475

অন্যান্য ক্ষেত্রে, দশাকে যোগ সম্বলিত চিহ্নসহ সংকেতায়িত করা হয়। উদাহরণস্বরূপ, একটি দশার সংকেত হচ্ছে \(|+\rangle + |-\rangle\)।

print(Plus + Minus)

SummedOp([
  CircuitStateFn(
     ┌───┐
  q: ┤ H ├
     └───┘
  ),
  CircuitStateFn(
     ┌───┐┌───┐
  q: ┤ X ├┤ H ├
     └───┘└───┘
  )
])

সমযোজন কার্যকারক (কম্পোজিশন অপারেটর) ইনার গুণন (ইনার প্রডাক্ট) এর কাজে ব্যবহৃত হয়, যা একটি অসম্পূর্ণ মূল্যায়িত অবস্থা। এইখানে ইনার গুণনের প্রকাশ দেখানো হল \(\langle 1 | 1 \rangle\)।

print(~One @ One)

ComposedOp([
  DictMeasurement({'1': 1}),
  DictStateFn({'1': 1})
])

লক্ষণীয় যে, is_measurement ব্রা দশাকে ~One হিসেবে সংকেতায়িত করে, যা DictMeasurement এ জমা থাকে।

সংকেত সম্বলিত রাশিমালাকে eval পদ্ধতি দ্বারা পরীক্ষণ করা যাবে।

(~One @ One).eval()

1.0

(~v_zero_one @ v_zero_one).eval()

0.9999999999999998

এইখানে \(\langle - | 1 \rangle = \langle (\langle 0| - \langle 1|)/\sqrt{2} | 1\rangle\)।

(~Minus @ One).eval()

(-0.7071067811865475-8.7e-17j)

সমযোজন কার্যকারক (কম্পোজিশন অপারেটর) @, compose পদ্ধতির সমতুল্য।

print((~One).compose(One))

ComposedOp([
  DictMeasurement({'1': 1}),
  DictStateFn({'1': 1})
])

ইনার গুণন সরাসরি eval পদ্ধতি দ্বারাও নির্ণয় করা যাবে, ComposedOp এর ব্যবহার ছাড়াই।

(~One).eval(One)

1.0

সংকেতায়িত টেনসর গুণন কে নিম্নরুপে প্রস্তুত করা যাবে \(|0\rangle \otimes |+\rangle\)।

print(Zero^Plus)

TensoredOp([
  DictStateFn({'0': 1}),
  CircuitStateFn(
     ┌───┐
  q: ┤ H ├
     └───┘
  )
])

যা সরল CircuitStateFn দ্বারা প্রকাশ করা যাবে।

print((Zero^Plus).to_circuit_op())

CircuitStateFn(
     ┌───┐
q_0: ┤ H ├
     └───┘
q_1: ─────

)

টেনসর শক্তিমাত্রা ^ এই ক্যারেট দ্বারা প্রকাশ করা হয়, যেমন \(600 (|11111\rangle + |00000\rangle)\) এবং \(|10\rangle^{\otimes 3}\)।

print(600 * ((One^5) + (Zero^5)))
print((One^Zero)^3)

DictStateFn({'11111': 1.0, '00000': 1.0}) * 600.0
DictStateFn({'101010': 1})

to_matrix_op থেকে VectorStateFn রূপান্তর প্রক্রিয়া।

print(((Plus^Minus)^2).to_matrix_op())
print(((Plus^One)^2).to_circuit_op())
print(((Plus^One)^2).to_matrix_op().sample())

VectorStateFn(Statevector([ 0.25-6.1e-17j, -0.25+6.1e-17j,  0.25-6.1e-17j,
             -0.25+6.1e-17j, -0.25+6.1e-17j,  0.25-6.1e-17j,
             -0.25+6.1e-17j,  0.25-6.1e-17j,  0.25-6.1e-17j,
             -0.25+6.1e-17j,  0.25-6.1e-17j, -0.25+6.1e-17j,
             -0.25+6.1e-17j,  0.25-6.1e-17j, -0.25+6.1e-17j,
              0.25-6.1e-17j],
            dims=(2, 2, 2, 2)))
CircuitStateFn(
     ┌───┐
q_0: ┤ X ├
     ├───┤
q_1: ┤ H ├
     ├───┤
q_2: ┤ X ├
     ├───┤
q_3: ┤ H ├
     └───┘
)
{'1101': 0.2734375, '0111': 0.2509765625, '1111': 0.24609375, '0101': 0.2294921875}

StateFn প্রস্তুত করা বেশ সহজ। StateFn ক্লাস একটি প্রস্তুতকারক (কন্সট্রাক্টর) হিসেবে কাজ করে যা যেকোনো ব্যবহারিক শ্রেণীকে ইনপুট হিসেবে নেয় আর সঠিক StateFn সাবক্লাস ফলাফল হিসেবে দেয়। এখন নিম্নোক্ত প্রাইমেটিভস কে কন্সট্রাকটর হিসেবে ব্যবহার করে এবং StateFn এর সাবক্লাস হিসেবে তালিকাভুক্ত করে।:

• str (ভিত্তি (বেসিস) বিটস্ট্রিং এর সমতুল্য) -> DictStateFn

• dict -> DictStateFn

• Qiskit ফলাফল অবজেক্ট -> DictStateFn

• তালিকা -> VectorStateFn

• np.ndarray -> VectorStateFn

• অবস্থা ভেক্টর বা দিকরাশি -> VectorStateFn

• কোয়ান্টাম যুক্তিবর্তনী -> CircuitStateFn

• নির্দেশমালা -> CircuitStateFn

• অপারেটরবেস -> OperatorStateFn

print(StateFn({'0':1}))
print(StateFn({'0':1}) == Zero)

print(StateFn([0,1,1,0]))

from qiskit.circuit.library import RealAmplitudes
print(StateFn(RealAmplitudes(2)))

DictStateFn({'0': 1})
True
VectorStateFn(Statevector([0.+0.j, 1.+0.j, 1.+0.j, 0.+0.j],
            dims=(2, 2)))
CircuitStateFn(
     ┌──────────────────────────────────────────────────────────┐
q_0: ┤0                                                         ├
     │  RealAmplitudes(θ[0],θ[1],θ[2],θ[3],θ[4],θ[5],θ[6],θ[7]) │
q_1: ┤1                                                         ├
     └──────────────────────────────────────────────────────────┘
)

দ্বিতীয়াংশঃ PrimitiveOps

মৌলিক কার্যকারকসমূহ হচ্ছে PrimitiveOp -এর উপশ্রেণি। StateFn এর অনুরূপ, PrimitiveOp হচ্ছে সঠিক PrimitiveOp ফলাফল প্রদানের মৌলিক শ্রেণি। এখন নিম্নোক্ত প্রাইমেটিভস কে কন্সট্রাকটরে পাঠানো যায় যেগুলো নিম্নলিখিত PrimitiveOp এর সাবক্লাস তৈরী করে:

• Terra’s Pauli -> PauliOp

• নির্দেশমালা -> CircuitOp

• কোয়ান্টাম যুক্তিবর্তনী -> CircuitOp

• দ্বিমাত্রিক তালিকা -> MatrixOp

• np.ndarray -> MatrixOp

• spmatrix -> MatrixOp

• Terra’s quantum_info.Operator -> MatrixOp

from qiskit.opflow import X, Y, Z, I, CX, T, H, S, PrimitiveOp

ম্যাট্রিক্স উপাদান বা ভুক্তি

eval একটি কার্যকারক থেকে একটি কলাম ম্যাট্রিক্স ফলাফল হিসেবে দেয়। যেমনঃ পাউলী \(X\) অপারেটরকে PauliOp দ্বারা চিহ্নিত করা হয়। এখন একটি কলাম ম্যাট্রিক্স ফলাফল হিসেবে পেতে হলে DictStateFn ব্যবহার করতে হবে।

X

PauliOp(Pauli('X'), coeff=1.0)

print(X.eval('0'))

DictStateFn({'1': (1+0j)})

একটি কার্যকারকের মহড়াক্রম ( সংখ্যাক্রম বা ইনডেক্সিং) একটি ম্যাট্রিক্স উপাদান বা ভুক্তি নির্ণয় করে, যা eval পদ্ধতিকে দুইবার নির্দেশের মাধ্যমে অর্জন করা যায়।

আমাদের ম্যাট্রিক্সটি হচ্ছে \(X = \left(\begin{matrix} 0 & 1 \\ 1 & 0 \end{matrix} \right)\) এবং ম্যাট্রিক্স উপাদান \(\left\{X \right\}_{0,1}\) হচ্ছে

X.eval('0').eval('1')

(1+0j)

এখানে একটি দুইকিউবিট কার্যকারক CX, নিয়ন্ত্রিত ``X` যা একটি যুক্তিবর্তনী দিয়ে দেখানো হচ্ছে, তার উদাহরণ দেয়া হল।

print(CX)
print(CX.to_matrix().real) # The imaginary part vanishes.

q_0: ──■──
     ┌─┴─┐
q_1: ┤ X ├
     └───┘
[[1. 0. 0. 0.]
 [0. 0. 0. 1.]
 [0. 0. 1. 0.]
 [0. 1. 0. 0.]]

CX.eval('01')  # 01 is the one in decimal. We get the first column.

VectorStateFn(Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
            dims=(2, 2)), coeff=1.0, is_measurement=False)

CX.eval('01').eval('11')  # This returns element with (zero-based) index (1, 3)

(1+0j)

দশা দিকরাশির (স্টেট ভেক্টর) এর উপর কার্যকারক প্রয়োগ

দশা দিকরাশির (স্টেট ভেক্টর) উপর কার্যকারক প্রয়োগ compose দ্বারাও সম্পাদন করা সম্ভব (যা @ কার্যকারকের সমতুল্য)। একটি উদাহরণ হচ্ছে \(X | 1 \rangle = |0\rangle\)।

print(X @ One)

ComposedOp([
  X,
  DictStateFn({'1': 1})
])

DictStateFn দ্বারা একই দশা দিকরাশি প্রকাশ করা যাবে \(|0\rangle\) এইভাবে, যা বেশ সহজতর এবং এটি অর্জিত হয়েছে eval দ্বারা।

(X @ One).eval()

DictStateFn({'0': (1+0j)}, coeff=(1+0j), is_measurement=False)

মধ্যবর্তী ComposedOp ধাপ পরিহার করা যাবে সরাসরি eval ব্যবহারে মাধ্যমে।

X.eval(One)

DictStateFn({'0': (1+0j)}, coeff=(1+0j), is_measurement=False)

সমযোজন এবং টেনসর গুণন @ এবং ^ দ্বারা প্রভাবিত। কিছু উদাহরণের মাধ্যমে তা বুঝানো হল।

print(((~One^2) @ (CX.eval('01'))).eval())

print(((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2)
print((((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2) @ (Minus^5))
print(((H^I^I)@(X^I^I)@Zero))

(1+0j)
          ┌───┐          ┌───┐
q_0: ──■──┤ H ├───────■──┤ H ├─────
     ┌─┴─┐└───┘┌───┐┌─┴─┐└───┘┌───┐
q_1: ┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├
     └───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤
q_2: ──■──┤ X ├┤ H ├──■──┤ X ├┤ H ├
     ┌─┴─┐└───┘├───┤┌─┴─┐└───┘├───┤
q_3: ┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├
     └───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤
q_4: ─────┤ X ├┤ H ├─────┤ X ├┤ H ├
          └───┘└───┘     └───┘└───┘
CircuitStateFn(
     ┌───┐┌───┐     ┌───┐          ┌───┐
q_0: ┤ X ├┤ H ├──■──┤ H ├───────■──┤ H ├─────
     ├───┤├───┤┌─┴─┐└───┘┌───┐┌─┴─┐└───┘┌───┐
q_1: ┤ X ├┤ H ├┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├
     ├───┤├───┤└───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤
q_2: ┤ X ├┤ H ├──■──┤ X ├┤ H ├──■──┤ X ├┤ H ├
     ├───┤├───┤┌─┴─┐└───┘├───┤┌─┴─┐└───┘├───┤
q_3: ┤ X ├┤ H ├┤ X ├──■──┤ H ├┤ X ├──■──┤ H ├
     ├───┤├───┤└───┘┌─┴─┐├───┤└───┘┌─┴─┐├───┤
q_4: ┤ X ├┤ H ├─────┤ X ├┤ H ├─────┤ X ├┤ H ├
     └───┘└───┘     └───┘└───┘     └───┘└───┘
)
CircuitStateFn(
     ┌─────────────┐
q_0: ┤0            ├─────
     │             │
q_1: ┤1 Pauli(XII) ├─────
     │             │┌───┐
q_2: ┤2            ├┤ H ├
     └─────────────┘└───┘
)

print(~One @ Minus)

ComposedOp([
  DictMeasurement({'1': 1}),
  CircuitStateFn(
     ┌───┐┌───┐
  q: ┤ X ├┤ H ├
     └───┘└───┘
  )
])

Part III: ListOp and subclasses

ListOp

কার্যকারক এবং দশাসমূহের তালিকার উপর কার্যকারকসমূহকে দিকরাশিতে রূপান্তরিত করার জন্য ListOp একটি যথার্থ কন্টেইনার।

from qiskit.opflow import ListOp

print((~ListOp([One, Zero]) @ ListOp([One, Zero])))

ComposedOp([
  ListOp([
    DictMeasurement({'1': 1}),
    DictMeasurement({'0': 1})
  ]),
  ListOp([
    DictStateFn({'1': 1}),
    DictStateFn({'0': 1})
  ])
])

উদাহরণস্বরূপ, উপরে বর্ণিত সমযোজনকে একটি সহজ reduce নির্দেশমালা দ্বারা একটি তালিকাভুক্ত করা হল (ListOp এর মাধ্যমে)।

print((~ListOp([One, Zero]) @ ListOp([One, Zero])).reduce())

ListOp([
  ListOp([
    ComposedOp([
      DictMeasurement({'1': 1}),
      DictStateFn({'1': 1})
    ]),
    ComposedOp([
      DictMeasurement({'1': 1}),
      DictStateFn({'0': 1})
    ])
  ]),
  ListOp([
    ComposedOp([
      DictMeasurement({'0': 1}),
      DictStateFn({'1': 1})
    ]),
    ComposedOp([
      DictMeasurement({'0': 1}),
      DictStateFn({'0': 1})
    ])
  ])
])

ListOp: SummedOp, ComposedOp, TensoredOp

ListOp, introduced above, is useful for vectorizing operations. But, it also serves as the superclass for list-like composite classes. If you’ve already played around with the above, you’ll notice that you can easily perform operations between OperatorBases which we may not know how to perform efficiently in general (or simply haven’t implemented an efficient procedure for yet), such as addition between CircuitOps. In those cases, you may receive a ListOp result (or subclass thereof) from your operation representing the lazy execution of the operation. For example, if you attempt to add together a DictStateFn and a CircuitStateFn, you’ll receive a SummedOp representing the sum of the two. This composite State function still has a working eval (but may need to perform a non-scalable computation under the hood, such as converting both to vectors).

এই সমযোজন OperatorBaseজটিল এবং বহুল গাণিতিক ব্যবহার (রিচ কম্পিউটেশন) সম্বলিত PrimitiveOp এবং StateFn এর মৌলিক ভিত্তি।

Every ListOp has four properties:

• oplist - The list of OperatorBases which may represent terms, factors, etc.

• combo_fn - The function taking a list of complex numbers to an output value which defines how to combine the outputs of the oplist items. For broadcasting simplicity, this function is defined over NumPy arrays.

• coeff - A coefficient multiplying the primitive. Note that coeff can be int, float, complex or a free Parameter object (from qiskit.circuit in Terra) to be bound later using my_op.bind_parameters.

• abelian - Indicates whether the Operators in oplist are known to mutually commute (usually set after being converted by the AbelianGrouper converter).

Note that ListOp supports typical sequence overloads, so you can use indexing like my_op[4] to access the OperatorBases in oplist.

OperatorStateFn

পুর্বে বর্ণিত হয়েছে OperatorStateFn একটি ডেনসিটি কার্যকারক নির্দেশ করে। কিন্তু যদি is_measurement নির্দেশনা True হয় সেইক্ষেত্রে OperatorStateFn একটি কার্যকারক হিসেবে কাজ করে। এই কার্যকারকের গড় মান ComposedOp দ্বারা তৈরি করা যায়। অথবা সরাসরি eval পদ্ধতি দ্বারা একই গড় মান নির্ণয় করা যাবে। বিশেষভাবে লক্ষণীয় যে, is_measurement নির্দেশনা একটি adjoint পদ্ধতি দ্বারা নির্ণয় করা যায়।

এইখানে পাউলী \(Z\) কার্যকারক দ্বারা সংশ্লিষ্ট পর্যবেক্ষনসমূহ তৈরি প্রক্রিয়া দেখানো হবে। বিশেষ লক্ষণীয় যে, যখন কার্যকারকটি সম্পাদিত হবে তখন তাকে বলা হবে OperatorMeasurement।

print(StateFn(Z).adjoint())
StateFn(Z).adjoint()

OperatorMeasurement(Z)

OperatorStateFn(PauliOp(Pauli('Z'), coeff=1.0), coeff=1.0, is_measurement=True)

এখন আমরা \(\langle 0 | Z | 0 \rangle\), \(\langle 1 | Z | 1 \rangle\) এবং \(\langle + | Z | + \rangle\) গণনা করব, যেখানে \(|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}\)।

print(StateFn(Z).adjoint().eval(Zero))
print(StateFn(Z).adjoint().eval(One))
print(StateFn(Z).adjoint().eval(Plus))

(1+0j)
(-1+0j)
0j

চতুর্থাংশঃ রূপান্তরক

Converters are classes that manipulate operators and states and perform building blocks of algorithms. Examples include changing the basis of operators and Trotterization. Converters traverse an expression and perform a particular manipulation or replacement, defined by the converter’s convert() method, of the Operators within. Typically, if a converter encounters an OperatorBase in the recursion which is irrelevant to its conversion purpose, that OperatorBase is left unchanged.

import numpy as np
from qiskit.opflow import I, X, Y, Z, H, CX, Zero, ListOp, PauliExpectation, PauliTrotterEvolution, CircuitSampler, MatrixEvolution, Suzuki
from qiskit.circuit import Parameter
from qiskit import Aer

পরিবর্তন, exp_i(), এবং EvolvedOp

Every PrimitiveOp and ListOp has an .exp_i() function such that H.exp_i() corresponds to \(e^{-iH}\). In practice, only a few of these Operators have an efficiently computable exponentiation (such as MatrixOp and the PauliOps with only one non-identity single-qubit Pauli), so we need to return a placeholder, or symbolic representation, (similar to how SummedOp is a placeholder when we can’t perform addition). This placeholder is called EvolvedOp, and it holds the OperatorBase to be exponentiated in its .primitive property.

Qiskit operators fully support parameterization, so we can use a Parameter for our evolution time here. Notice that there’s no "evolution time" argument in any function. The Operator flow exponentiates whatever operator we tell it to, and if we choose to multiply the operator by an evolution time, \(e^{-iHt}\), that will be reflected in our exponentiation parameters.

পাউলী কার্যকারকের আবেশিত যোগফল

একটি হ্যামিল্টনিয়ান কে বহুকিউবিট পাউলী অপারেটর ভিত্তিক যোগাশ্রয়ী সমযোজন দ্বারা প্রকাশ করা যায়।

two_qubit_H2 =  (-1.0523732 * I^I) + \
                (0.39793742 * I^Z) + \
                (-0.3979374 * Z^I) + \
                (-0.0112801 * Z^Z) + \
                (0.18093119 * X^X)

লক্ষণীয় যে, two_qubit_H2 কে একটি SummedOp দ্বারা প্রকাশ করা যায়, যার পদগুলো PauliOp।

print(two_qubit_H2)

-1.0523732 * II
+ 0.39793742 * IZ
- 0.3979374 * ZI
- 0.0112801 * ZZ
+ 0.18093119 * XX

এরপর, আমরা হ্যামিল্টোনিয়ানটিকে Parameter দিয়ে গুণ করি, Parameter টিকে SummedOp``এর বৈশিষ্ট্য``coeff``এতে সংগ্রহ করে রাখা হয়। ফলাফলেতে ``exp_i()``কে ডাকা মানে এটিকে ``EvolvedOp এতে আবৃত করা, যা এক্সপোনেন্সিয়েশন সজ্জাকে প্রদর্শিত করে।

evo_time = Parameter('θ')
evolution_op = (evo_time*two_qubit_H2).exp_i()
print(evolution_op) # Note, EvolvedOps print as exponentiations
print(repr(evolution_op))

e^(-i*1.0*θ * (
  -1.0523732 * II
  + 0.39793742 * IZ
  - 0.3979374 * ZI
  - 0.0112801 * ZZ
  + 0.18093119 * XX
))
EvolvedOp(PauliSumOp(SparsePauliOp(['II', 'IZ', 'ZI', 'ZZ', 'XX'],
              coeffs=[-1.0523732 +0.j,  0.39793742+0.j, -0.3979374 +0.j, -0.0112801 +0.j,
  0.18093119+0.j]), coeff=1.0*θ), coeff=1.0)

আমরা h2_measurement নির্মাণ করি, যা একটি পর্যবেক্ষণযোগ্য হিসাবে two_qubit_H2 প্রতিনিধিত্ব করে।

h2_measurement = StateFn(two_qubit_H2).adjoint()
print(h2_measurement)

OperatorMeasurement(-1.0523732 * II
+ 0.39793742 * IZ
- 0.3979374 * ZI
- 0.0112801 * ZZ
+ 0.18093119 * XX)

আমরা \(|\Phi_+\rangle\) এবং \(\text{CX} (H\otimes I) |00\rangle\) দ্বারা একটি বেল স্টেট বানাব।

bell = CX @ (I ^ H) @ Zero
print(bell)

CircuitStateFn(
     ┌───┐
q_0: ┤ H ├──■──
     └───┘┌─┴─┐
q_1: ─────┤ X ├
          └───┘
)

যার গাণিতিক প্রকাশভঙ্গী \(H e^{-iHt} |\Phi_+\rangle\)।

evo_and_meas = h2_measurement @ evolution_op @ bell
print(evo_and_meas)

ComposedOp([
  OperatorMeasurement(-1.0523732 * II
  + 0.39793742 * IZ
  - 0.3979374 * ZI
  - 0.0112801 * ZZ
  + 0.18093119 * XX),
  e^(-i*1.0*θ * (
    -1.0523732 * II
    + 0.39793742 * IZ
    - 0.3979374 * ZI
    - 0.0112801 * ZZ
    + 0.18093119 * XX
  )),
  CircuitStateFn(
       ┌───┐
  q_0: ┤ H ├──■──
       └───┘┌─┴─┐
  q_1: ─────┤ X ├
            └───┘
  )
])

সাধারণত, আমরা \(e^{-iHt}\) কে অনুমান করতে চাই দুই-কিউবিট (two-qubit) বর্তনী দিয়ে। আমরা এটা convert পদ্ধতির PauliTrotterEvolution দিয়ে করি, যেটা রাশিমালার উপর যেতে যেতে সব EvolvedOp এর উপর ট্রটারাইজেশন প্র​য়োগ​ করে।যদিও আমরা এখানে PauliTrotterEvolution` ব্যবহার করেছি, অন্য পদ্ধতি যেমন ``MatrixEvolution ও এই এক্সপোনেন্সিয়েশন করতে পারে।

trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=1)).convert(evo_and_meas)
# We can also set trotter_mode='suzuki' or leave it empty to default to first order Trotterization.
print(trotterized_op)

ComposedOp([
  OperatorMeasurement(-1.0523732 * II
  + 0.39793742 * IZ
  - 0.3979374 * ZI
  - 0.0112801 * ZZ
  + 0.18093119 * XX),
  CircuitStateFn(
  global phase: 1.0523732*θ
       ┌───┐     ┌───┐┌───┐┌──────────────────┐┌───┐┌───┐┌───┐»
  q_0: ┤ H ├──■──┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├┤ X ├»
       └───┘┌─┴─┐├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤└─┬─┘»
  q_1: ─────┤ X ├┤ H ├──■────────────────────────■──┤ H ├──■──»
            └───┘└───┘                              └───┘     »
  «     ┌──────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»
  «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ Rz(0.39793742*θ) ├┤ Rz(0.39793742*θ) ├┤ X ├»
  «     └──────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»
  «q_1: ──────────────────────■──┤ Rz(-0.3979374*θ) ├┤ Rz(-0.3979374*θ) ├──■──»
  «                              └──────────────────┘└──────────────────┘     »
  «     ┌──────────────────┐┌───┐┌───┐┌───┐┌──────────────────┐┌───┐┌───┐
  «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├
  «     └──────────────────┘└─┬─┘├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤
  «q_1: ──────────────────────■──┤ H ├──■────────────────────────■──┤ H ├
  «                              └───┘                              └───┘
  )
])

trotterized_op``এতে থাকে একটি ``Parameter, bind_parameters``পদ্ধতিটি বন্ধিতমানকে নির্দিষ্ট পরামিতির নামেতে প্রকাশন করতে ``dict হয়ে ঘোরে।এইক্ষেত্রে, একটি মাত্রই পরামিতি রয়েছে।

bound = trotterized_op.bind_parameters({evo_time: .5})

bound is a ComposedOp. The second factor is the circuit. Let’s draw it to verify that the binding has taken place.

bound[1].to_circuit().draw()

global phase: 0.52619
     ┌───┐     ┌───┐┌───┐┌─────────────────┐┌───┐┌───┐┌───┐┌─────────────────┐»
q_0: ┤ H ├──■──┤ H ├┤ X ├┤ Rz(0.090465595) ├┤ X ├┤ H ├┤ X ├┤ Rz(-0.00564005) ├»
     └───┘┌─┴─┐├───┤└─┬─┘└─────────────────┘└─┬─┘├───┤└─┬─┘└─────────────────┘»
q_1: ─────┤ X ├┤ H ├──■───────────────────────■──┤ H ├──■─────────────────────»
          └───┘└───┘                             └───┘                        »
«     ┌───┐┌────────────────┐┌────────────────┐┌───┐┌─────────────────┐┌───┐»
«q_0: ┤ X ├┤ Rz(0.19896871) ├┤ Rz(0.19896871) ├┤ X ├┤ Rz(-0.00564005) ├┤ X ├»
«     └─┬─┘├────────────────┤├────────────────┤└─┬─┘└─────────────────┘└─┬─┘»
«q_1: ──■──┤ Rz(-0.1989687) ├┤ Rz(-0.1989687) ├──■───────────────────────■──»
«          └────────────────┘└────────────────┘                             »
«     ┌───┐┌───┐┌─────────────────┐┌───┐┌───┐
«q_0: ┤ H ├┤ X ├┤ Rz(0.090465595) ├┤ X ├┤ H ├
«     ├───┤└─┬─┘└─────────────────┘└─┬─┘├───┤
«q_1: ┤ H ├──■───────────────────────■──┤ H ├
«     └───┘                             └───┘

অনুমান

Expectationগুলি হল পরিবর্তক (কনভার্টার) যেটা পর্যবেক্ষণযোগ্য বা দৃষ্টিগ্রাহ্য (অবজারভেবল) -এর আনুমানিক মান গণনা চালু করে। তারা একটি অপারেটর ট্রি ভ্রমণ করে, OperatorStateFn (অবজারভেবল) গুলিকে সমতূল্য নির্দেশনা দিয়ে বদলে দেয় যা কোয়ান্টাম বা ধ্রুপদী (ক্লাসিক্যাল) হার্ডওয়্যারের উপর গণনা আরো সুবিধাজনক।উদাহরণ স্বরূপ, যদি আমরা একটি অপারেটর o``এর আনুমানিক মান এমনভাবে পরিমাপ করতে চাই যাতে কোনো অবস্থা (স্টেট) ফাংশন সাপেক্ষে তা একটি পাওলির সমষ্টি বোঝায়, কিন্তু একমাত্র কোয়ান্টাম হার্ডওয়্যারের কর্ণ বরাবর পরিমাপ করার অধিকার রয়েছে, আমরা একটি পর্যবেক্ষণযোগ্য ``~StateFn(o) তৈরী করতে পারি এবং একটি PauliExpectation কে ব্যবহার করে কর্ণ বরাবর পরিমাপেতে এবংবর্তনী (সার্কিট) কে প্রাক-ঘূর্ণন মান বা অবস্থাতে নিয়ে আসতে পারি, যাতে তা অবস্থা (স্টেট) -এ যোগ করা যায়।

অন্য আরেকটি কৌতূহলোদ্দীপক Expectation হল AerPauliExpectation, যা পর্যবেক্ষণযোগ্যকে একটি``CircuitStateFn``এতে রূপান্তরিত করে যার মধ্যে একটি বিশেষ অনুমান স্ন্যাপশট নির্দেশনা থাকে যা Aer উচ্চ কর্মদক্ষতাসহ সপাদন করতে পারে।

# Note that XX was the only non-diagonal measurement in our H2 Observable
print(PauliExpectation(group_paulis=False).convert(h2_measurement))

SummedOp([
  ComposedOp([
    OperatorMeasurement(-1.0523732 * II),
    II
  ]),
  ComposedOp([
    OperatorMeasurement(0.39793742 * IZ),
    II
  ]),
  ComposedOp([
    OperatorMeasurement(-0.3979374 * ZI),
    II
  ]),
  ComposedOp([
    OperatorMeasurement(-0.0112801 * ZZ),
    II
  ]),
  ComposedOp([
    OperatorMeasurement(0.18093119 * ZZ),
         ┌───┐
    q_0: ┤ H ├
         ├───┤
    q_1: ┤ H ├
         └───┘
  ])
])

স্বতঃসিদ্ধ নিয়মানুসারে group_paulis=True, যেটা AbelianGrouper কে ব্যবহার করে ``SummedOp``কে সমসংখক কিউবিট অনুযায়ী সমসংখক পাউলিদের দলে পরিবর্তিত করে। এটা বর্তনী (সার্কিট) এর চালনার ঊর্ধ্বস্থিতকে কমায়ে, যেমন প্রতিটি দল সমান বর্তনী (সার্কিট) কে ভাগ করে চালনা করতে পারে।

print(PauliExpectation().convert(h2_measurement))

SummedOp([
  ComposedOp([
    OperatorMeasurement(0.18093119 * ZZ
    - 1.0523732 * II),
         ┌───┐
    q_0: ┤ H ├
         ├───┤
    q_1: ┤ H ├
         └───┘
  ]),
  ComposedOp([
    OperatorMeasurement(0.39793742 * IZ
    - 0.3979374 * ZI
    - 0.0112801 * ZZ),
    II
  ])
])

মনে রেখো যে রূপান্তরকারীরা পুনরাবৃতভাবে কাজ করে, অর্থাৎ, তারা শুধুমাত্র সম্ভব যেখানে সেইখানেই তাদের কর্ম প্রয়োগ করে একটি রাশিমালা ভ্রমণ করে। তাই আমরা শুধু আমাদের সম্পূর্ণ বিবর্তনকে এবং পরিমাপ অভিব্যক্তিকে রূপান্তর করতে পারি। আমরা সমানভাবে রূপান্তরিত 'h2_measurement " কে আমাদের বিবর্তনের CircuitStateFn সাথে সুবিন্যস্ত করতে পারতাম। আমরা সমগ্র অভিব্যক্তিটির উপর রূপান্তর প্রয়োগ করে এগিয়ে যেতে পারি।

diagonalized_meas_op = PauliExpectation().convert(trotterized_op)
print(diagonalized_meas_op)

SummedOp([
  ComposedOp([
    OperatorMeasurement(0.18093119 * ZZ
    - 1.0523732 * II),
    CircuitStateFn(
    global phase: 1.0523732*θ
         ┌───┐     ┌───┐┌───┐┌──────────────────┐┌───┐┌───┐┌───┐»
    q_0: ┤ H ├──■──┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├┤ X ├»
         └───┘┌─┴─┐├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤└─┬─┘»
    q_1: ─────┤ X ├┤ H ├──■────────────────────────■──┤ H ├──■──»
              └───┘└───┘                              └───┘     »
    «     ┌──────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»
    «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ Rz(0.39793742*θ) ├┤ Rz(0.39793742*θ) ├┤ X ├»
    «     └──────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»
    «q_1: ──────────────────────■──┤ Rz(-0.3979374*θ) ├┤ Rz(-0.3979374*θ) ├──■──»
    «                              └──────────────────┘└──────────────────┘     »
    «     ┌──────────────────┐┌───┐┌───┐┌───┐┌──────────────────┐┌───┐┌───┐┌───┐
    «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├┤ H ├
    «     └──────────────────┘└─┬─┘├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤├───┤
    «q_1: ──────────────────────■──┤ H ├──■────────────────────────■──┤ H ├┤ H ├
    «                              └───┘                              └───┘└───┘
    )
  ]),
  ComposedOp([
    OperatorMeasurement(0.39793742 * IZ
    - 0.3979374 * ZI
    - 0.0112801 * ZZ),
    CircuitStateFn(
    global phase: 1.0523732*θ
         ┌───┐     ┌───┐┌───┐┌──────────────────┐┌───┐┌───┐┌───┐»
    q_0: ┤ H ├──■──┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├┤ X ├»
         └───┘┌─┴─┐├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤└─┬─┘»
    q_1: ─────┤ X ├┤ H ├──■────────────────────────■──┤ H ├──■──»
              └───┘└───┘                              └───┘     »
    «     ┌──────────────────┐┌───┐┌──────────────────┐┌──────────────────┐┌───┐»
    «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ Rz(0.39793742*θ) ├┤ Rz(0.39793742*θ) ├┤ X ├»
    «     └──────────────────┘└─┬─┘├──────────────────┤├──────────────────┤└─┬─┘»
    «q_1: ──────────────────────■──┤ Rz(-0.3979374*θ) ├┤ Rz(-0.3979374*θ) ├──■──»
    «                              └──────────────────┘└──────────────────┘     »
    «     ┌──────────────────┐┌───┐┌───┐┌───┐┌──────────────────┐┌───┐┌───┐
    «q_0: ┤ Rz(-0.0112801*θ) ├┤ X ├┤ H ├┤ X ├┤ Rz(0.18093119*θ) ├┤ X ├┤ H ├
    «     └──────────────────┘└─┬─┘├───┤└─┬─┘└──────────────────┘└─┬─┘├───┤
    «q_1: ──────────────────────■──┤ H ├──■────────────────────────■──┤ H ├
    «                              └───┘                              └───┘
    )
  ])
])

এখন আমরা একাধিক পরামিতি মানকে একটি ListOp``তে আবদ্ধ করি, এর পর ``eval``যোগ করবো যাতে অভিব্যাক্তিটি মূল্যায়ন করা যায়। যদি আমরা আগে আবদ্ধ করতাম তাহলে ``eval কে আগে ব্যবহার পারতাম, কিন্তু তা সাশ্রয়ী হতো না।এখানে, eval আমাদের CircuitStateFn গুলিকে আভ্যন্তরীণভাবে সিমুলেশনের মাধ্যমে VectorStateFn গুলিতে পরিবর্তিত করে ।

evo_time_points = list(range(8))
h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time: evo_time_points})

এখানে আনুমানিক মানগুলি হল \(\langle \Phi_+| e^{iHt} H e^{-iHt} |\Phi_+\rangle\) , পরামিতির বিভিন্ন সংশ্লিষ্ট মানগুলির সঙ্গে বজায়ে রেখে।

h2_trotter_expectations.eval()

array([-0.88272211+0.0e+00j, -0.88272211+0.0e+00j, -0.88272211+0.0e+00j,
       -0.88272211+0.0e+00j, -0.88272211+0.0e+00j, -0.88272211+0.0e+00j,
       -0.88272211+5.6e-17j, -0.88272211+0.0e+00j])

CircuitSampler দ্বারা CircuitStateFn সম্পাদন

The CircuitSampler traverses an Operator and converts any CircuitStateFns into approximations of the resulting state function by a DictStateFn or VectorStateFn using a quantum backend. Note that in order to approximate the value of the CircuitStateFn, it must 1) send the state function through a depolarizing channel, which will destroy all phase information and 2) replace the sampled frequencies with square roots of the frequency, rather than the raw probability of sampling (which would be the equivalent of sampling the square of the state function, per the Born rule).

sampler = CircuitSampler(backend=Aer.get_backend('aer_simulator'))
# sampler.quantum_instance.run_config.shots = 1000
sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)
sampled_trotter_energies = sampled_trotter_exp_op.eval()
print('Sampled Trotterized energies:\n {}'.format(np.real(sampled_trotter_energies)))

Sampled Trotterized energies:
 [-0.88272211 -0.88272211 -0.88272211 -0.88272211 -0.88272211 -0.88272211
 -0.88272211 -0.88272211]

টীকা আবার যে বর্তনী (সার্কিট) এর নমুনা সম্ভাবনার ** বর্গমূল **এর ডিক্স দ্বারা বর্তনী (সার্কিট) গুলির সাথে প্রতিস্থাপিত হয়। রূপান্তরের আগে এবং পরে একটি উপ-অভিব্যক্তি চেহারার দিকে নজর দিনঃ

print('Before:\n')
print(h2_trotter_expectations.reduce()[0][0])
print('\nAfter:\n')
print(sampled_trotter_exp_op[0][0])

Before:

ComposedOp([
  OperatorMeasurement(0.18093119 * ZZ
  - 1.0523732 * II),
  CircuitStateFn(
       ┌───┐     ┌───┐┌───┐┌───────┐┌───┐┌───┐┌───┐┌───────┐┌───┐┌───────┐»
  q_0: ┤ H ├──■──┤ H ├┤ X ├┤ Rz(0) ├┤ X ├┤ H ├┤ X ├┤ Rz(0) ├┤ X ├┤ Rz(0) ├»
       └───┘┌─┴─┐├───┤└─┬─┘└───────┘└─┬─┘├───┤└─┬─┘└───────┘└─┬─┘├───────┤»
  q_1: ─────┤ X ├┤ H ├──■─────────────■──┤ H ├──■─────────────■──┤ Rz(0) ├»
            └───┘└───┘                   └───┘                   └───────┘»
  «     ┌───────┐┌───┐┌───────┐┌───┐┌───┐┌───┐┌───────┐┌───┐┌───┐┌───┐
  «q_0: ┤ Rz(0) ├┤ X ├┤ Rz(0) ├┤ X ├┤ H ├┤ X ├┤ Rz(0) ├┤ X ├┤ H ├┤ H ├
  «     ├───────┤└─┬─┘└───────┘└─┬─┘├───┤└─┬─┘└───────┘└─┬─┘├───┤├───┤
  «q_1: ┤ Rz(0) ├──■─────────────■──┤ H ├──■─────────────■──┤ H ├┤ H ├
  «     └───────┘                   └───┘                   └───┘└───┘
  )
])

After:

ComposedOp([
  OperatorMeasurement(0.18093119 * ZZ
  - 1.0523732 * II),
  DictStateFn({'00': 0.7167090588237321, '11': 0.6973723001381686})
])

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.19.0.dev0+fe3eb3f
qiskit-aer	0.10.0.dev0+b78f265
qiskit-ignis	0.7.0.dev0+0eb9dcc
qiskit-ibmq-provider	0.17.0.dev0+15d2dfe
System information
Python version	3.9.5
Python compiler	Clang 10.0.0
Python build	default, May 18 2021 12:31:01
OS	Darwin
CPUs	4
Memory (Gb)	32.0
Fri Oct 29 16:10:45 2021 BST

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.