Python | 個人用メモ帳

2022年2月13日

Python（Qiskit）について（２０）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, 学習サイト上で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

ベルンシュタイン・ヴァジラニアルゴリズムの演算方法で, 量子オラクルについて確認してみた.
5 ～ 6量子ビットで確認したが出力結果が改行されなかったので, wbrタグを手動埋め込みし改行させて確認している.
下記の (参考)シミュレーターでの実験の通り, ベルンシュタイン・ヴァジラニアルゴリズムのプログラム内に, 秘密の文字列を反転する操作が実装されており, 個人的には, 手計算前に, 秘密の文字列を反転させる操作と符合すると予想する.
演習問題では, 10量子ビット(“1110110101”)での記述もあったが, 実行後に, エラー(Too large to display)となったため, 詳細は確認できなかったが, 5 ～ 6量子ビットで確認出来たので, 十分だと思う.

ベルンシュタイン・ヴァジラニアルゴリズム(演習問題改題ほか)

量子オラクル(5量子ビット “10011”)

[手計算]

※ 秘密の文字列 "10011" を 反転し, "11001" と読み替えて, 計算する必要があるように見える.

1 / √32 * {
  (-1)(00000･11001)|00000> + 
  (-1)(00001･11001)|00001> + 
  (-1)(00010･11001)|00010> + 
  (-1)(00011･11001)|00011> + 
  (-1)(00100･11001)|00100> + 
  (-1)(00101･11001)|00101> + 
  (-1)(00110･11001)|00110> + 
  (-1)(00111･11001)|00111> + 
  (-1)(01000･11001)|01000> + 
  (-1)(01001･11001)|01001> + 
  (-1)(01010･11001)|01010> + 
  (-1)(01011･11001)|01011> + 
  (-1)(01100･11001)|01100> + 
  (-1)(01101･11001)|01101> + 
  (-1)(01110･11001)|01110> + 
  (-1)(01111･11001)|01111> + 
  (-1)(10000･11001)|10000> + 
  (-1)(10001･11001)|10001> + 
  (-1)(10010･11001)|10010> + 
  (-1)(10011･11001)|10011> + 
  (-1)(10100･11001)|10100> + 
  (-1)(10101･11001)|10101> + 
  (-1)(10110･11001)|10110> + 
  (-1)(10111･11001)|10111> + 
  (-1)(11000･11001)|11000> + 
  (-1)(11001･11001)|11001> + 
  (-1)(11010･11001)|11010> + 
  (-1)(11011･11001)|11011> + 
  (-1)(11100･11001)|11100> + 
  (-1)(11101･11001)|11101> + 
  (-1)(11110･11001)|11110> + 
  (-1)(11111･11001)|11111>
}

↓↓↓

1 / √32 * {
  (+ |00000>) + 
  (- |00001>) + 
  (+ |00010>) + 
  (- |00011>) + 
  (+ |00100>) + 
  (- |00101>) + 
  (+ |00110>) + 
  (- |00111>) + 
  (- |01000>) + 
  (+ |01001>) + 
  (- |01010>) + 
  (+ |01011>) + 
  (- |01100>) + 
  (+ |01101>) + 
  (- |01110>) + 
  (+ |01111>) + 
  (- |10000>) + 
  (+ |10001>) + 
  (- |10010>) + 
  (+ |10011>) + 
  (- |10100>) + 
  (+ |10101>) + 
  (- |10110>) + 
  (+ |10111>) + 
  (+ |11000>) + 
  (- |11001>) + 
  (+ |11010>) + 
  (- |11011>) + 
  (+ |11100>) + 
  (- |11101>) + 
  (+ |11110>) + 
  (- |11111>)
}

↓↓↓

1 / √32 * (+ |00000> - |00001> + |00010> - |00011> + |00100> - |00101> + |00110> - |00111> - |01000> + |01001> - |01010> + |01011> - |01100> + |01101> - |01110> + |01111> - |10000> + |10001> - |10010> + |10011> - |10100> + |10101> - |10110> + |10111> + |11000> - |11001> + |11010> - |11011> + |11100> - |11101> + |11110> - |11111>)

例)
11011･11001
= (左から, 1bit目どうしの積) + ... + (左から, 5bit目どうしの積) (modulo 2)
= 1 * 1 + 1 * 1 + 0 * 0 + 1 * 0 + 1 * 1 (modulo 2)
= 1 + 1 + 0 + 0 + 1 (modulo 2)
= 3 (modulo 2)
= 1 (modulo 2)
→ (-1) が 1個なので, -1 と 解釈.

01001･11001
= (左から, 1bit目どうしの積) + ... + (左から, 5bit目どうしの積) (modulo 2)
= 0 * 1 + 1 * 1 + 0 * 0 + 0 * 0 + 1 * 1 (modulo 2)
= 0 + 1 + 0 + 0 + 1 (modulo 2)
= 2 (modulo 2)
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

※ 秘密の文字列 "10011" を反転し, "11001" と読み替えて, 計算する必要があるように見える.

1 / √32 * {

(-1)(00000･11001)|00000> +

(-1)(00001･11001)|00001> +

(-1)(00010･11001)|00010> +

(-1)(00011･11001)|00011> +

(-1)(00100･11001)|00100> +

(-1)(00101･11001)|00101> +

(-1)(00110･11001)|00110> +

(-1)(00111･11001)|00111> +

(-1)(01000･11001)|01000> +

(-1)(01001･11001)|01001> +

(-1)(01010･11001)|01010> +

(-1)(01011･11001)|01011> +

(-1)(01100･11001)|01100> +

(-1)(01101･11001)|01101> +

(-1)(01110･11001)|01110> +

(-1)(01111･11001)|01111> +

(-1)(10000･11001)|10000> +

(-1)(10001･11001)|10001> +

(-1)(10010･11001)|10010> +

(-1)(10011･11001)|10011> +

(-1)(10100･11001)|10100> +

(-1)(10101･11001)|10101> +

(-1)(10110･11001)|10110> +

(-1)(10111･11001)|10111> +

(-1)(11000･11001)|11000> +

(-1)(11001･11001)|11001> +

(-1)(11010･11001)|11010> +

(-1)(11011･11001)|11011> +

(-1)(11100･11001)|11100> +

(-1)(11101･11001)|11101> +

(-1)(11110･11001)|11110> +

(-1)(11111･11001)|11111>

}

↓↓↓

1 / √32 * {

(+ |00000>) +

(- |00001>) +

(+ |00010>) +

(- |00011>) +

(+ |00100>) +

(- |00101>) +

(+ |00110>) +

(- |00111>) +

(- |01000>) +

(+ |01001>) +

(- |01010>) +

(+ |01011>) +

(- |01100>) +

(+ |01101>) +

(- |01110>) +

(+ |01111>) +

(- |10000>) +

(+ |10001>) +

(- |10010>) +

(+ |10011>) +

(- |10100>) +

(+ |10101>) +

(- |10110>) +

(+ |10111>) +

(+ |11000>) +

(- |11001>) +

(+ |11010>) +

(- |11011>) +

(+ |11100>) +

(- |11101>) +

(+ |11110>) +

(- |11111>)

}

↓↓↓

1 / √32 * (+ |00000> - |00001> + |00010> - |00011> + |00100> - |00101> + |00110> - |00111> - |01000> + |01001> - |01010> + |01011> - |01100> + |01101> - |01110> + |01111> - |10000> + |10001> - |10010> + |10011> - |10100> + |10101> - |10110> + |10111> + |11000> - |11001> + |11010> - |11011> + |11100> - |11101> + |11110> - |11111>)

例)

11011･11001

= (左から, 1bit目どうしの積) + ... + (左から, 5bit目どうしの積) (modulo 2)

= 1 * 1 + 1 * 1 + 0 * 0 + 1 * 0 + 1 * 1 (modulo 2)

= 1 + 1 + 0 + 0 + 1 (modulo 2)

= 3 (modulo 2)

= 1 (modulo 2)

→ (-1) が 1個なので, -1 と解釈.

01001･11001

= (左から, 1bit目どうしの積) + ... + (左から, 5bit目どうしの積) (modulo 2)

= 0 * 1 + 1 * 1 + 0 * 0 + 0 * 0 + 1 * 1 (modulo 2)

= 0 + 1 + 0 + 0 + 1 (modulo 2)

= 2 (modulo 2)

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

[結果]
手計算との一致を確認できた.

量子オラクル(6量子ビット “010110”)

[手計算]

※ 秘密の文字列 "010110" を 反転し, "011010" と読み替えて, 計算する必要があるように見える.

1 / √64 * {
  (-1)(000000･011010)|000000> + 
  (-1)(000001･011010)|000001> + 
  (-1)(000010･011010)|000010> + 
  (-1)(000011･011010)|000011> + 
  (-1)(000100･011010)|000100> + 
  (-1)(000101･011010)|000101> + 
  (-1)(000110･011010)|000110> + 
  (-1)(000111･011010)|000111> + 
  (-1)(001000･011010)|001000> + 
  (-1)(001001･011010)|001001> + 
  (-1)(001010･011010)|001010> + 
  (-1)(001011･011010)|001011> + 
  (-1)(001100･011010)|001100> + 
  (-1)(001101･011010)|001101> + 
  (-1)(001110･011010)|001110> + 
  (-1)(001111･011010)|001111> + 
  (-1)(010000･011010)|010000> + 
  (-1)(010001･011010)|010001> + 
  (-1)(010010･011010)|010010> + 
  (-1)(010011･011010)|010011> + 
  (-1)(010100･011010)|010100> + 
  (-1)(010101･011010)|010101> + 
  (-1)(010110･011010)|010110> + 
  (-1)(010111･011010)|010111> + 
  (-1)(011000･011010)|011000> + 
  (-1)(011001･011010)|011001> + 
  (-1)(011010･011010)|011010> + 
  (-1)(011011･011010)|011011> + 
  (-1)(011100･011010)|011100> + 
  (-1)(011101･011010)|011101> + 
  (-1)(011110･011010)|011110> + 
  (-1)(011111･011010)|011111> + 
  (-1)(100000･011010)|100000> + 
  (-1)(100001･011010)|100001> + 
  (-1)(100010･011010)|100010> + 
  (-1)(100011･011010)|100011> + 
  (-1)(100100･011010)|100100> + 
  (-1)(100101･011010)|100101> + 
  (-1)(100110･011010)|100110> + 
  (-1)(100111･011010)|100111> + 
  (-1)(101000･011010)|101000> + 
  (-1)(101001･011010)|101001> + 
  (-1)(101010･011010)|101010> + 
  (-1)(101011･011010)|101011> + 
  (-1)(101100･011010)|101100> + 
  (-1)(101101･011010)|101101> + 
  (-1)(101110･011010)|101110> + 
  (-1)(101111･011010)|101111> + 
  (-1)(110000･011010)|110000> + 
  (-1)(110001･011010)|110001> + 
  (-1)(110010･011010)|110010> + 
  (-1)(110011･011010)|110011> + 
  (-1)(110100･011010)|110100> + 
  (-1)(110101･011010)|110101> + 
  (-1)(110110･011010)|110110> + 
  (-1)(110111･011010)|110111> + 
  (-1)(111000･011010)|111000> + 
  (-1)(111001･011010)|111001> + 
  (-1)(111010･011010)|111010> + 
  (-1)(111011･011010)|111011> + 
  (-1)(111100･011010)|111100> + 
  (-1)(111101･011010)|111101> + 
  (-1)(111110･011010)|111110> + 
  (-1)(111111･011010)|111111>
}

↓↓↓

1 / √64 * {
  (+ |000000>) + 
  (+ |000001>) + 
  (- |000010>) + 
  (- |000011>) + 
  (+ |000100>) + 
  (+ |000101>) + 
  (- |000110>) + 
  (- |000111>) + 
  (- |001000>) + 
  (- |001001>) + 
  (+ |001010>) + 
  (+ |001011>) + 
  (- |001100>) + 
  (- |001101>) + 
  (+ |001110>) + 
  (+ |001111>) + 
  (- |010000>) + 
  (- |010001>) + 
  (+ |010010>) + 
  (+ |010011>) + 
  (- |010100>) + 
  (- |010101>) + 
  (+ |010110>) + 
  (+ |010111>) + 
  (+ |011000>) + 
  (+ |011001>) + 
  (- |011010>) + 
  (- |011011>) + 
  (+ |011100>) + 
  (+ |011101>) + 
  (- |011110>) + 
  (- |011111>) + 
  (+ |100000>) + 
  (+ |100001>) + 
  (- |100010>) + 
  (- |100011>) + 
  (+ |100100>) + 
  (+ |100101>) + 
  (- |100110>) + 
  (- |100111>) + 
  (- |101000>) + 
  (- |101001>) + 
  (+ |101010>) + 
  (+ |101011>) + 
  (- |101100>) + 
  (- |101101>) + 
  (+ |101110>) + 
  (+ |101111>) + 
  (- |110000>) + 
  (- |110001>) + 
  (+ |110010>) + 
  (+ |110011>) + 
  (- |110100>) + 
  (- |110101>) + 
  (+ |110110>) + 
  (+ |110111>) + 
  (+ |111000>) + 
  (+ |111001>) + 
  (- |111010>) + 
  (- |111011>) + 
  (+ |111100>) + 
  (+ |111101>) + 
  (- |111110>) + 
  (- |111111>)
}

↓↓↓

1 / √64 * (+ |000000> + |000001> - |000010> - |000011> + |000100> + |000101> - |000110> - |000111> - |001000> - |001001> + |001010> + |001011> - |001100> - |001101> + |001110> + |001111> - |010000> - |010001> + |010010> + |010011> - |010100> - |010101> + |010110> + |010111> + |011000> + |011001> - |011010> - |011011> + |011100> + |011101> - |011110> - |011111> + |100000> + |100001> - |100010> - |100011> + |100100> + |100101> - |100110> - |100111> - |101000> - |101001> + |101010> + |101011> - |101100> - |101101> + |101110> + |101111> - |110000> - |110001> + |110010> + |110011> - |110100> - |110101> + |110110> + |110111> + |111000> + |111001> - |111010> - |111011> + |111100> + |111101> - |111110> - |111111>)

例)
011011･011010
= (左から, 1bit目どうしの積) + ... + (左から, 6bit目どうしの積) (modulo 2)
= 0 * 0 + 1 * 1 + 1 * 1 + 0 * 0 + 1 * 1 + 1 * 0 (modulo 2)
= 0 + 1 + 1 + 0 + 1 + 0 (modulo 2)
= 3 (modulo 2)
= 1 (modulo 2)
→ (-1) が 1個なので, -1 と 解釈.

011100･011010
= (左から, 1bit目どうしの積) + ... + (左から, 6bit目どうしの積) (modulo 2)
= 0 * 0 + 1 * 1 + 1 * 1 + 1 * 0 + 0 * 1 + 0 * 0 (modulo 2)
= 0 + 1 + 1 + 0 + 0 + 0 (modulo 2)
= 2 (modulo 2)
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

※ 秘密の文字列 "010110" を反転し, "011010" と読み替えて, 計算する必要があるように見える.

1 / √64 * {

(-1)(000000･011010)|000000> +

(-1)(000001･011010)|000001> +

(-1)(000010･011010)|000010> +

(-1)(000011･011010)|000011> +

(-1)(000100･011010)|000100> +

(-1)(000101･011010)|000101> +

(-1)(000110･011010)|000110> +

(-1)(000111･011010)|000111> +

(-1)(001000･011010)|001000> +

(-1)(001001･011010)|001001> +

(-1)(001010･011010)|001010> +

(-1)(001011･011010)|001011> +

(-1)(001100･011010)|001100> +

(-1)(001101･011010)|001101> +

(-1)(001110･011010)|001110> +

(-1)(001111･011010)|001111> +

(-1)(010000･011010)|010000> +

(-1)(010001･011010)|010001> +

(-1)(010010･011010)|010010> +

(-1)(010011･011010)|010011> +

(-1)(010100･011010)|010100> +

(-1)(010101･011010)|010101> +

(-1)(010110･011010)|010110> +

(-1)(010111･011010)|010111> +

(-1)(011000･011010)|011000> +

(-1)(011001･011010)|011001> +

(-1)(011010･011010)|011010> +

(-1)(011011･011010)|011011> +

(-1)(011100･011010)|011100> +

(-1)(011101･011010)|011101> +

(-1)(011110･011010)|011110> +

(-1)(011111･011010)|011111> +

(-1)(100000･011010)|100000> +

(-1)(100001･011010)|100001> +

(-1)(100010･011010)|100010> +

(-1)(100011･011010)|100011> +

(-1)(100100･011010)|100100> +

(-1)(100101･011010)|100101> +

(-1)(100110･011010)|100110> +

(-1)(100111･011010)|100111> +

(-1)(101000･011010)|101000> +

(-1)(101001･011010)|101001> +

(-1)(101010･011010)|101010> +

(-1)(101011･011010)|101011> +

(-1)(101100･011010)|101100> +

(-1)(101101･011010)|101101> +

(-1)(101110･011010)|101110> +

(-1)(101111･011010)|101111> +

(-1)(110000･011010)|110000> +

(-1)(110001･011010)|110001> +

(-1)(110010･011010)|110010> +

(-1)(110011･011010)|110011> +

(-1)(110100･011010)|110100> +

(-1)(110101･011010)|110101> +

(-1)(110110･011010)|110110> +

(-1)(110111･011010)|110111> +

(-1)(111000･011010)|111000> +

(-1)(111001･011010)|111001> +

(-1)(111010･011010)|111010> +

(-1)(111011･011010)|111011> +

(-1)(111100･011010)|111100> +

(-1)(111101･011010)|111101> +

(-1)(111110･011010)|111110> +

(-1)(111111･011010)|111111>

}

↓↓↓

1 / √64 * {

(+ |000000>) +

(+ |000001>) +

(- |000010>) +

(- |000011>) +

(+ |000100>) +

(+ |000101>) +

(- |000110>) +

(- |000111>) +

(- |001000>) +

(- |001001>) +

(+ |001010>) +

(+ |001011>) +

(- |001100>) +

(- |001101>) +

(+ |001110>) +

(+ |001111>) +

(- |010000>) +

(- |010001>) +

(+ |010010>) +

(+ |010011>) +

(- |010100>) +

(- |010101>) +

(+ |010110>) +

(+ |010111>) +

(+ |011000>) +

(+ |011001>) +

(- |011010>) +

(- |011011>) +

(+ |011100>) +

(+ |011101>) +

(- |011110>) +

(- |011111>) +

(+ |100000>) +

(+ |100001>) +

(- |100010>) +

(- |100011>) +

(+ |100100>) +

(+ |100101>) +

(- |100110>) +

(- |100111>) +

(- |101000>) +

(- |101001>) +

(+ |101010>) +

(+ |101011>) +

(- |101100>) +

(- |101101>) +

(+ |101110>) +

(+ |101111>) +

(- |110000>) +

(- |110001>) +

(+ |110010>) +

(+ |110011>) +

(- |110100>) +

(- |110101>) +

(+ |110110>) +

(+ |110111>) +

(+ |111000>) +

(+ |111001>) +

(- |111010>) +

(- |111011>) +

(+ |111100>) +

(+ |111101>) +

(- |111110>) +

(- |111111>)

}

↓↓↓

1 / √64 * (+ |000000> + |000001> - |000010> - |000011> + |000100> + |000101> - |000110> - |000111> - |001000> - |001001> + |001010> + |001011> - |001100> - |001101> + |001110> + |001111> - |010000> - |010001> + |010010> + |010011> - |010100> - |010101> + |010110> + |010111> + |011000> + |011001> - |011010> - |011011> + |011100> + |011101> - |011110> - |011111> + |100000> + |100001> - |100010> - |100011> + |100100> + |100101> - |100110> - |100111> - |101000> - |101001> + |101010> + |101011> - |101100> - |101101> + |101110> + |101111> - |110000> - |110001> + |110010> + |110011> - |110100> - |110101> + |110110> + |110111> + |111000> + |111001> - |111010> - |111011> + |111100> + |111101> - |111110> - |111111>)

例)

011011･011010

= (左から, 1bit目どうしの積) + ... + (左から, 6bit目どうしの積) (modulo 2)

= 0 * 0 + 1 * 1 + 1 * 1 + 0 * 0 + 1 * 1 + 1 * 0 (modulo 2)

= 0 + 1 + 1 + 0 + 1 + 0 (modulo 2)

= 3 (modulo 2)

= 1 (modulo 2)

→ (-1) が 1個なので, -1 と解釈.

011100･011010

= (左から, 1bit目どうしの積) + ... + (左から, 6bit目どうしの積) (modulo 2)

= 0 * 0 + 1 * 1 + 1 * 1 + 1 * 0 + 0 * 1 + 0 * 0 (modulo 2)

= 0 + 1 + 1 + 0 + 0 + 0 (modulo 2)

= 2 (modulo 2)

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

[結果]
手計算との一致を確認できた.

(参考)量子オラクル(10量子ビット “1110110101”)

[結果]
エラー出力された.

(参考)シミュレーターでの実験

公式サイトでは, 秘密の文字列 “011” で, シミュレーターによる実験を見ることが出来る.
⇒ プログラム中に, 以下の実装箇所があるが, これをコメントアウト(秘密の文字列の反転を行わない)して, 結果を確認してみる.

～ (略) ～
s = s[::-1] # reverse s to fit qiskit's qubit ordering
～ (略) ～

～ (略) ～

s = s[::-1] # reverse s to fit qiskit's qubit ordering

～ (略) ～

[結果]
シミュレーターの結果が, 秘密の文字列 “110” で, 出力されることを確認できた.

参照サイト

ベルンシュタイン・ヴァジラニアルゴリズム

2022年2月12日2022年2月13日

Python（Qiskit）について（１９）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, 学習サイト上で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

ベルンシュタイン・ヴァジラニアルゴリズムの演算方法で, 量子オラクルについて確認してみた.
既に, 学習環境が用意されており, 数値を書き換えるなどして試行錯誤もできるので, 個人的には, 非常に面白く感じた.

ベルンシュタイン・ヴァジラニアルゴリズム

量子オラクル(1量子ビット “1”)

[手計算]

1 / √2 * {
  (-1)(0･1)|0> + 
  (-1)(1･1)|1> + 

↓↓↓

1 / √2 * {
  (+ |0>) + 
  (- |1>)
}

↓↓↓

1 / √2 * (+ |0> - |1>)

例)
0･1 
= (左から, 1bit目どうしの積)
= 0 * 1
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

1 / √2 * {

(-1)(0･1)|0> +

(-1)(1･1)|1> +

↓↓↓

1 / √2 * {

(+ |0>) +

(- |1>)

}

↓↓↓

1 / √2 * (+ |0> - |1>)

例)

0･1

= (左から, 1bit目どうしの積)

= 0 * 1

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

[結果]
手計算との一致を確認できた.

量子オラクル(2量子ビット “01”)

[手計算]

※ 秘密の文字列 "01" を 反転し, "10" と読み替えて, 計算する必要があるように見える.

1 / √4 * {
  (-1)(00･10)|00> + 
  (-1)(01･10)|01> + 
  (-1)(10･10)|10> + 
  (-1)(11･10)|11> + 
}

↓↓↓

1 / √4 * {
  (+ |00>) + 
  (+ |01>) + 
  (- |10>) + 
  (- |11>) + 
}

↓↓↓

1 / √4 * (+ |00> + |01> - |10> - |11>)

例)
01･10 
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) (modulo 2)
= 0 * 1 + 1 * 0 (modulo 2)
= 0 + 0 (modulo 2)
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

11･10
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) (modulo 2)
= 1 * 1 + 1 * 0 (modulo 2)
= 1 + 0 (modulo 2)
= 1 (modulo 2)
→ (-1) が 1個なので, -1 と 解釈.

※ 秘密の文字列 "01" を反転し, "10" と読み替えて, 計算する必要があるように見える.

1 / √4 * {

(-1)(00･10)|00> +

(-1)(01･10)|01> +

(-1)(10･10)|10> +

(-1)(11･10)|11> +

}

↓↓↓

1 / √4 * {

(+ |00>) +

(+ |01>) +

(- |10>) +

(- |11>) +

}

↓↓↓

1 / √4 * (+ |00> + |01> - |10> - |11>)

例)

01･10

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) (modulo 2)

= 0 * 1 + 1 * 0 (modulo 2)

= 0 + 0 (modulo 2)

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

11･10

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) (modulo 2)

= 1 * 1 + 1 * 0 (modulo 2)

= 1 + 0 (modulo 2)

= 1 (modulo 2)

→ (-1) が 1個なので, -1 と解釈.

[結果]
手計算との一致を確認できた.

量子オラクル(3量子ビット “110”)

[手計算]

※ 秘密の文字列 "110" を 反転し, "011" と読み替えて, 計算する必要があるように見える.

1 / √8 * {
  (-1)(000･011)|000> + 
  (-1)(001･011)|001> + 
  (-1)(010･011)|010> + 
  (-1)(011･011)|011> + 
  (-1)(100･011)|100> + 
  (-1)(101･011)|101> + 
  (-1)(110･011)|110> + 
  (-1)(111･011)|111>
}

↓↓↓

1 / √8 * {
  (+ |000>) + 
  (- |001>) + 
  (- |010>) + 
  (+ |011>) + 
  (+ |100>) + 
  (- |101>) + 
  (- |110>) + 
  (+ |111>)
}

↓↓↓

1 / √8 * (+ |000> - |001> - |010> + |011> + |100> - |101> - |110> + |111>)

例)
010･011 
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) (modulo 2)
= 0 * 0 + 1 * 1 + 0 * 1 (modulo 2)
= 0 + 1 + 0 (modulo 2)
= 1 (modulo 2)
→ (-1) が 1個なので, -1 と 解釈.

100･011
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) (modulo 2)
= 1 * 0 + 0 * 1 + 0 * 1 (modulo 2)
= 0 + 0 + 0 (modulo 2)
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

※ 秘密の文字列 "110" を反転し, "011" と読み替えて, 計算する必要があるように見える.

1 / √8 * {

(-1)(000･011)|000> +

(-1)(001･011)|001> +

(-1)(010･011)|010> +

(-1)(011･011)|011> +

(-1)(100･011)|100> +

(-1)(101･011)|101> +

(-1)(110･011)|110> +

(-1)(111･011)|111>

}

↓↓↓

1 / √8 * {

(+ |000>) +

(- |001>) +

(- |010>) +

(+ |011>) +

(+ |100>) +

(- |101>) +

(- |110>) +

(+ |111>)

}

↓↓↓

1 / √8 * (+ |000> - |001> - |010> + |011> + |100> - |101> - |110> + |111>)

例)

010･011

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) (modulo 2)

= 0 * 0 + 1 * 1 + 0 * 1 (modulo 2)

= 0 + 1 + 0 (modulo 2)

= 1 (modulo 2)

→ (-1) が 1個なので, -1 と解釈.

100･011

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) (modulo 2)

= 1 * 0 + 0 * 1 + 0 * 1 (modulo 2)

= 0 + 0 + 0 (modulo 2)

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

[結果]
手計算との一致を確認できた.

量子オラクル(4量子ビット “1011”)

[手計算]

※ 秘密の文字列 "1011" を 反転し, "1101" と読み替えて, 計算する必要があるように見える.

1 / √16 * {
  (-1)(0000･1101)|0000> + 
  (-1)(0001･1101)|0001> + 
  (-1)(0010･1101)|0010> + 
  (-1)(0011･1101)|0011> + 
  (-1)(0100･1101)|0100> + 
  (-1)(0101･1101)|0101> + 
  (-1)(0110･1101)|0110> + 
  (-1)(0111･1101)|0111> + 
  (-1)(1000･1101)|1000> + 
  (-1)(1001･1101)|1001> + 
  (-1)(1010･1101)|1010> + 
  (-1)(1011･1101)|1011> + 
  (-1)(1100･1101)|1100> + 
  (-1)(1101･1101)|1101> + 
  (-1)(1110･1101)|1110> + 
  (-1)(1111･1101)|1111>
}

↓↓↓

1 / √16 * {
  (+ |0000>) + 
  (- |0001>) + 
  (+ |0010>) + 
  (- |0011>) + 
  (- |0100>) + 
  (+ |0101>) + 
  (- |0110>) + 
  (+ |0111>) + 
  (- |1000>) + 
  (+ |1001>) + 
  (- |1010>) + 
  (+ |1011>) + 
  (+ |1100>) + 
  (- |1101>) + 
  (+ |1110>) + 
  (- |1111>)
}

↓↓↓

1 / √16 * (+ |0000> - |0001> + |0010> - |0011> - |0100> + |0101> - |0110> + |0111> - |1000> + |1001> - |1010> + |1011> + |1100> - |1101> + |1110> - |1111>)

例)
0111･1101 
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) + (左から, 4bit目どうしの積) (modulo 2)
= 0 * 1 + 1 * 1 + 1 * 0 + 1 * 1 (modulo 2)
= 0 + 1 + 0 + 1 (modulo 2)
= 2 (modulo 2)
= 0 (modulo 2)
→ (-1) が 0個なので, +1 と 解釈.

1101･1101
= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) + (左から, 4bit目どうしの積) (modulo 2)
= 1 * 1 + 1 * 1 + 0 * 0 + 1 * 1 (modulo 2)
= 1 + 1 + 0 + 1 (modulo 2)
= 3 (modulo 2)
= 1 (modulo 2)
→ (-1) が 1個なので, -1 と 解釈.

※ 秘密の文字列 "1011" を反転し, "1101" と読み替えて, 計算する必要があるように見える.

1 / √16 * {

(-1)(0000･1101)|0000> +

(-1)(0001･1101)|0001> +

(-1)(0010･1101)|0010> +

(-1)(0011･1101)|0011> +

(-1)(0100･1101)|0100> +

(-1)(0101･1101)|0101> +

(-1)(0110･1101)|0110> +

(-1)(0111･1101)|0111> +

(-1)(1000･1101)|1000> +

(-1)(1001･1101)|1001> +

(-1)(1010･1101)|1010> +

(-1)(1011･1101)|1011> +

(-1)(1100･1101)|1100> +

(-1)(1101･1101)|1101> +

(-1)(1110･1101)|1110> +

(-1)(1111･1101)|1111>

}

↓↓↓

1 / √16 * {

(+ |0000>) +

(- |0001>) +

(+ |0010>) +

(- |0011>) +

(- |0100>) +

(+ |0101>) +

(- |0110>) +

(+ |0111>) +

(- |1000>) +

(+ |1001>) +

(- |1010>) +

(+ |1011>) +

(+ |1100>) +

(- |1101>) +

(+ |1110>) +

(- |1111>)

}

↓↓↓

1 / √16 * (+ |0000> - |0001> + |0010> - |0011> - |0100> + |0101> - |0110> + |0111> - |1000> + |1001> - |1010> + |1011> + |1100> - |1101> + |1110> - |1111>)

例)

0111･1101

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) + (左から, 4bit目どうしの積) (modulo 2)

= 0 * 1 + 1 * 1 + 1 * 0 + 1 * 1 (modulo 2)

= 0 + 1 + 0 + 1 (modulo 2)

= 2 (modulo 2)

= 0 (modulo 2)

→ (-1) が 0個なので, +1 と解釈.

1101･1101

= (左から, 1bit目どうしの積) + (左から, 2bit目どうしの積) + (左から, 3bit目どうしの積) + (左から, 4bit目どうしの積) (modulo 2)

= 1 * 1 + 1 * 1 + 0 * 0 + 1 * 1 (modulo 2)

= 1 + 1 + 0 + 1 (modulo 2)

= 3 (modulo 2)

= 1 (modulo 2)

→ (-1) が 1個なので, -1 と解釈.

[結果]
手計算との一致を確認できた.

参照サイト

ベルンシュタイン・ヴァジラニアルゴリズム

2022年1月30日

Python（Qiskit）について（１８）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, 学習サイト上で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

前回の続きを確認してみた, より複雑なパターンになるが, 非常に面白く感じた.

Hello Qiskitゲーム

パズル６

[Choose gate] で, [NOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果]
真ん中の円が, 白になった.
[Success!] が表示されるので, 操作手順が正しかったことを確認できる.

[参考（初期状態を, Zゲートに変更した場合）]

～（略）～
initialize = [['z', '0']]
～（略）～

～（略）～

initialize = [['z', '0']]

～（略）～

[Choose gate] で, [NOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果]
真ん中の円が, 白になった.
[Success!] が表示されるので, 操作手順が正しかったことを確認できる.

パズル７

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[Choose gate] で, [NOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果]
真ん中の円が, 白になった.
[Success!] が表示されるので, 操作手順が正しかったことを確認できる.

参照サイト

Hello Qiskitゲーム

2022年1月29日2022年1月30日

Python（Qiskit）について（１７）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, 学習サイト上で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

個人的には, 視覚的に, 量子ビット, 量子ゲートを確認出来るため, 非常に面白く感じた.
さらに, 学習サイト上で, プログラムを編集して, 実行できるので, 非常に便利に感じた.

Hello Qiskitゲーム

パズル１

[Choose gate] で, [NOT]クリック.

[Choose bit] で, [the only bit]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[一回目結果（NOTゲート）]

手順を略して,
[二回目結果（NOTゲート）]

[三回目結果（NOTゲート）]
[Success!] が表示されるので, 操作手順が正しかったか確認できる.

パズル２

[Choose gate] で, [NOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（NOTゲート）]

[参考（ANDゲート）]
ちなみに, AND を指定すると, もう一方のビットは, オン（黒 ⇒ 白）にならないことも確認できる.

～（略）～
allowed_gates = {'0': {}, '1': {'AND': 0}, 'both': {}}
～（略）～

～（略）～

allowed_gates = {'0': {}, '1': {'AND': 0}, 'both': {}}

～（略）～

とプログラムを修正している

パズル３

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
右側のビットがオンになったことを確認出来る

[参考（左側のビットをオンにするには？）]

～（略）～
initialize = [['x', '1']]
～（略）～

～（略）～

initialize = [['x', '1']]

～（略）～

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
左側のビットがオンになったことを確認出来る

パズル４

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
左側のビットがオフ, 右側のビットがオンになったことを確認出来る

[参考（左側のビットをオン, 右側のビットをオフにするには？）]

～（略）～
initialize = [['x', '1']]
success_condition = {'ZI': -1.0, 'IZ': 1.0}
～（略）～

～（略）～

initialize = [['x', '1']]

success_condition = {'ZI': -1.0, 'IZ': 1.0}

～（略）～

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
左側のビットがオン, 右側のビットがオフになったことを確認出来る

パズル５

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the right]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
右側のビットがランダムになることを確認出来る

[参考（左側のビットをランダムにするには？）]

～（略）～
initialize = [['h', '1']]
～（略）～

～（略）～

initialize = [['h', '1']]

～（略）～

[Choose gate] で, [CNOT]クリック.

[Choose bit] で, [the bit on the left]クリック.

[Make it happen!] で, [Apply Operation]クリック.

[結果（CNOTゲート）]
左側のビットがランダムになることを確認出来る

参照サイト

Hello Qiskitゲーム

2021年8月16日2021年8月16日

Python（Qiskit）について（１６）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

ドイチ-ジョサ(Deutsch-Jozsa)のアルゴリズム(演習問題)

本家のサイトにある, dj_oracle関数をベースに, 演習問題用のオラクルを実装してみた.
具体的には, n が, 1 ～ 4 で分布型, 5 で定値型となるようにしている.
出力結果(量子回路)については, n = 1 ～ 5 で同じ内容が出力されたと理解する.
グラフ(添付画像)については, n = 1 ～ 4 で ‘1111’ が, 100%, n = 5 で ‘0000’ が 100% だった.

# initialization
import numpy as np

# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile

# import basic plot tools
from qiskit.visualization import plot_histogram

# n is between 1 and 5.
def dj_problem_oracle(n):
    # We need to make a QuantumCircuit object to return
    # This circuit has 5 qubits: the input size is 5, plus one output qubit.
    oracle_qc = QuantumCircuit(5)
    
    # Try changing the location of the X gate depending on the value of n.
    # If n is 4 or less, make the X gate act on the bit at the corresponding location.
    if n in [(i + 1) for i in range(4)]:
        oracle_qc.x(n - 1)
        
        # Controlled-NOT gates
        for qubit in range(4):
            oracle_qc.cx(qubit, 4)
    
    # If n is 5, do nothing
    if n == 5:
        pass
    
    # Convert to quantum gate.
    oracle_gate = oracle_qc.to_gate()
    
    # To show when we display the circuit.
    oracle_gate.name = "Deutsch-Jozsa Problem Oracle"
    
    # Return a quantum gate.
    return oracle_gate

# This function (dj_algorithm) quotes the contents of the following site.
# https://qiskit.org/textbook/ja/ch-algorithms/deutsch-jozsa.html
def dj_algorithm(oracle):
    dj_circuit = QuantumCircuit(5, 4)
    
    # Set up the output qubit:
    dj_circuit.x(4)
    dj_circuit.h(4)
    
    # And set up the input register:
    for qubit in range(4):
        dj_circuit.h(qubit)
    
    # Let's append the oracle gate to our circuit:
    dj_circuit.append(oracle, range(5))
    
    # Finally, perform the H-gates again and measure:
    for qubit in range(4):
        dj_circuit.h(qubit)
    
    for i in range(4):
        dj_circuit.measure(i, i)
    
    return dj_circuit

# oracle_gate = dj_problem_oracle(1)
# oracle_gate = dj_problem_oracle(2)
# oracle_gate = dj_problem_oracle(3)
# oracle_gate = dj_problem_oracle(4)
oracle_gate = dj_problem_oracle(5)
dj_circuit = dj_algorithm(oracle_gate)
dj_circuit.draw()

# initialization

import numpy as np

# importing Qiskit

from qiskit import IBMQ, Aer

from qiskit.providers.ibmq import least_busy

from qiskit import QuantumCircuit, assemble, transpile

# import basic plot tools

from qiskit.visualization import plot_histogram

# n is between 1 and 5.

def dj_problem_oracle(n):

# We need to make a QuantumCircuit object to return

# This circuit has 5 qubits: the input size is 5, plus one output qubit.

oracle_qc = QuantumCircuit(5)

# Try changing the location of the X gate depending on the value of n.

# If n is 4 or less, make the X gate act on the bit at the corresponding location.

if n in [(i + 1) for i in range(4)]:

oracle_qc.x(n - 1)

# Controlled-NOT gates

for qubit in range(4):

oracle_qc.cx(qubit, 4)

# If n is 5, do nothing

if n == 5:

pass

# Convert to quantum gate.

oracle_gate = oracle_qc.to_gate()

# To show when we display the circuit.

oracle_gate.name = "Deutsch-Jozsa Problem Oracle"

# Return a quantum gate.

return oracle_gate

# This function (dj_algorithm) quotes the contents of the following site.

# https://qiskit.org/textbook/ja/ch-algorithms/deutsch-jozsa.html

def dj_algorithm(oracle):

dj_circuit = QuantumCircuit(5, 4)

# Set up the output qubit:

dj_circuit.x(4)

dj_circuit.h(4)

# And set up the input register:

for qubit in range(4):

dj_circuit.h(qubit)

# Let's append the oracle gate to our circuit:

dj_circuit.append(oracle, range(5))

# Finally, perform the H-gates again and measure:

for qubit in range(4):

dj_circuit.h(qubit)

for i in range(4):

dj_circuit.measure(i, i)

return dj_circuit

# oracle_gate = dj_problem_oracle(1)

# oracle_gate = dj_problem_oracle(2)

# oracle_gate = dj_problem_oracle(3)

# oracle_gate = dj_problem_oracle(4)

oracle_gate = dj_problem_oracle(5)

dj_circuit = dj_algorithm(oracle_gate)

dj_circuit.draw()

出力結果(量子回路, n = 1)

     ┌───┐     ┌───────────────────────────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0                              ├┤ H ├┤M├─────────
     ├───┤     │                               │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1                              ├┤ H ├─╫─┤M├──────
     ├───┤     │                               │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │                               │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3                              ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│                               │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4                              ├──────╫──╫──╫──╫─
     └───┘└───┘└───────────────────────────────┘      ║  ║  ║  ║ 
c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
                                                      0  1  2  3

┌───┐ ┌───────────────────────────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└───────────────────────────────┘ ║ ║ ║ ║

c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═

0 1 2 3

出力結果(量子回路, n = 2)

     ┌───┐     ┌───────────────────────────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0                              ├┤ H ├┤M├─────────
     ├───┤     │                               │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1                              ├┤ H ├─╫─┤M├──────
     ├───┤     │                               │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │                               │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3                              ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│                               │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4                              ├──────╫──╫──╫──╫─
     └───┘└───┘└───────────────────────────────┘      ║  ║  ║  ║ 
c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
                                                      0  1  2  3

┌───┐ ┌───────────────────────────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└───────────────────────────────┘ ║ ║ ║ ║

c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═

0 1 2 3

出力結果(量子回路, n = 3)

     ┌───┐     ┌───────────────────────────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0                              ├┤ H ├┤M├─────────
     ├───┤     │                               │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1                              ├┤ H ├─╫─┤M├──────
     ├───┤     │                               │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │                               │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3                              ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│                               │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4                              ├──────╫──╫──╫──╫─
     └───┘└───┘└───────────────────────────────┘      ║  ║  ║  ║ 
c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
                                                      0  1  2  3

┌───┐ ┌───────────────────────────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└───────────────────────────────┘ ║ ║ ║ ║

c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═

0 1 2 3

出力結果(量子回路, n = 4)

     ┌───┐     ┌───────────────────────────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0                              ├┤ H ├┤M├─────────
     ├───┤     │                               │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1                              ├┤ H ├─╫─┤M├──────
     ├───┤     │                               │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │                               │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3                              ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│                               │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4                              ├──────╫──╫──╫──╫─
     └───┘└───┘└───────────────────────────────┘      ║  ║  ║  ║ 
c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
                                                      0  1  2  3

┌───┐ ┌───────────────────────────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└───────────────────────────────┘ ║ ║ ║ ║

c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═

0 1 2 3

出力結果(量子回路, n = 5)

     ┌───┐     ┌───────────────────────────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0                              ├┤ H ├┤M├─────────
     ├───┤     │                               │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1                              ├┤ H ├─╫─┤M├──────
     ├───┤     │                               │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │                               │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3                              ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│                               │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4                              ├──────╫──╫──╫──╫─
     └───┘└───┘└───────────────────────────────┘      ║  ║  ║  ║ 
c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
                                                      0  1  2  3

┌───┐ ┌───────────────────────────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Deutsch-Jozsa Problem Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└───────────────────────────────┘ ║ ║ ║ ║

c: 4/═════════════════════════════════════════════════╩══╩══╩══╩═

0 1 2 3

補足

上記だけだと分かりづらい印象があったため, dj_problem_oracle関数内の量子回路(オラクル)も確認した.

# initialization
import numpy as np

# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile

# import basic plot tools
from qiskit.visualization import plot_histogram

# n is between 1 and 5.
def dj_problem_oracle(n):
    # We need to make a QuantumCircuit object to return
    # This circuit has 5 qubits: the input size is 5, plus one output qubit.
    oracle_qc = QuantumCircuit(5)
    
    # Try changing the location of the X gate depending on the value of n.
    # If n is 4 or less, make the X gate act on the bit at the corresponding location.
    if n in [(i + 1) for i in range(4)]:
        oracle_qc.x(n - 1)
        
        # Controlled-NOT gates
        for qubit in range(4):
            oracle_qc.cx(qubit, 4)
    
    # If n is 5, do nothing
    if n == 5:
        pass
    
    # Return a QuantumCircuit.
    return oracle_qc

# oracle_qc = dj_problem_oracle(1)
# oracle_qc = dj_problem_oracle(2)
# oracle_qc = dj_problem_oracle(3)
# oracle_qc = dj_problem_oracle(4)
oracle_qc = dj_problem_oracle(5)
oracle_qc.draw()

# initialization

import numpy as np

# importing Qiskit

from qiskit import IBMQ, Aer

from qiskit.providers.ibmq import least_busy

from qiskit import QuantumCircuit, assemble, transpile

# import basic plot tools

from qiskit.visualization import plot_histogram

# n is between 1 and 5.

def dj_problem_oracle(n):

# We need to make a QuantumCircuit object to return

# This circuit has 5 qubits: the input size is 5, plus one output qubit.

oracle_qc = QuantumCircuit(5)

# Try changing the location of the X gate depending on the value of n.

# If n is 4 or less, make the X gate act on the bit at the corresponding location.

if n in [(i + 1) for i in range(4)]:

oracle_qc.x(n - 1)

# Controlled-NOT gates

for qubit in range(4):

oracle_qc.cx(qubit, 4)

# If n is 5, do nothing

if n == 5:

pass

# Return a QuantumCircuit.

return oracle_qc

# oracle_qc = dj_problem_oracle(1)

# oracle_qc = dj_problem_oracle(2)

# oracle_qc = dj_problem_oracle(3)

# oracle_qc = dj_problem_oracle(4)

oracle_qc = dj_problem_oracle(5)

oracle_qc.draw()

出力結果(オラクル／量子回路, n = 1)

     ┌───┐                    
q_0: ┤ X ├──■─────────────────
     └───┘  │                 
q_1: ───────┼────■────────────
            │    │            
q_2: ───────┼────┼────■───────
            │    │    │       
q_3: ───────┼────┼────┼────■──
          ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├
          └───┘└───┘└───┘└───┘

┌───┐

q_0: ┤ X ├──■─────────────────

└───┘ │

q_1: ───────┼────■────────────

│ │

q_2: ───────┼────┼────■───────

│ │ │

q_3: ───────┼────┼────┼────■──

┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐

q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├

└───┘└───┘└───┘└───┘

出力結果(オラクル／量子回路, n = 2)

q_0: ───────■─────────────────
     ┌───┐  │                 
q_1: ┤ X ├──┼────■────────────
     └───┘  │    │            
q_2: ───────┼────┼────■───────
            │    │    │       
q_3: ───────┼────┼────┼────■──
          ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├
          └───┘└───┘└───┘└───┘

q_0: ───────■─────────────────

┌───┐ │

q_1: ┤ X ├──┼────■────────────

└───┘ │ │

q_2: ───────┼────┼────■───────

│ │ │

q_3: ───────┼────┼────┼────■──

┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐

q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├

└───┘└───┘└───┘└───┘

出力結果(オラクル／量子回路, n = 3)

q_0: ───────■─────────────────
            │                 
q_1: ───────┼────■────────────
     ┌───┐  │    │            
q_2: ┤ X ├──┼────┼────■───────
     └───┘  │    │    │       
q_3: ───────┼────┼────┼────■──
          ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├
          └───┘└───┘└───┘└───┘

q_0: ───────■─────────────────

│

q_1: ───────┼────■────────────

┌───┐ │ │

q_2: ┤ X ├──┼────┼────■───────

└───┘ │ │ │

q_3: ───────┼────┼────┼────■──

┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐

q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├

└───┘└───┘└───┘└───┘

出力結果(オラクル／量子回路, n = 4)

q_0: ───────■─────────────────
            │                 
q_1: ───────┼────■────────────
            │    │            
q_2: ───────┼────┼────■───────
     ┌───┐  │    │    │       
q_3: ┤ X ├──┼────┼────┼────■──
     └───┘┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├
          └───┘└───┘└───┘└───┘

q_0: ───────■─────────────────

│

q_1: ───────┼────■────────────

│ │

q_2: ───────┼────┼────■───────

┌───┐ │ │ │

q_3: ┤ X ├──┼────┼────┼────■──

└───┘┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐

q_4: ─────┤ X ├┤ X ├┤ X ├┤ X ├

└───┘└───┘└───┘└───┘

出力結果(オラクル／量子回路, n = 5)

q_0: 
     
q_1: 
     
q_2: 
     
q_3: 
     
q_4:

q_0:

q_1:

q_2:

q_3:

q_4:

参照サイト

ドイチ-ジョサのアルゴリズム

2021年8月15日

Python（Qiskit）について（１５）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

ドイチ-ジョサ(Deutsch-Jozsa)のアルゴリズム

ドイチ-ジョサ(1-bit／定値型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├
     ├───┤┌───┐│  Oracle │└───┘└╥┘
q_1: ┤ X ├┤ H ├┤1        ├──────╫─
     └───┘└───┘└─────────┘      ║ 
c: 1/═══════════════════════════╩═
                                0

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├

├───┤┌───┐│ Oracle │└───┘└╥┘

q_1: ┤ X ├┤ H ├┤1 ├──────╫─

└───┘└───┘└─────────┘ ║

c: 1/═══════════════════════════╩═

ドイチ-ジョサ(1-bit／分布型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├
     ├───┤┌───┐│  Oracle │└───┘└╥┘
q_1: ┤ X ├┤ H ├┤1        ├──────╫─
     └───┘└───┘└─────────┘      ║ 
c: 1/═══════════════════════════╩═
                                0

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├

├───┤┌───┐│ Oracle │└───┘└╥┘

q_1: ┤ X ├┤ H ├┤1 ├──────╫─

└───┘└───┘└─────────┘ ║

c: 1/═══════════════════════════╩═

ドイチ-ジョサ(2-bit／定値型関数)

[出力結果(量子回路)]
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├───
     ├───┤     │         │├───┤└╥┘┌─┐
q_1: ┤ H ├─────┤1 Oracle ├┤ H ├─╫─┤M├
     ├───┤┌───┐│         │└───┘ ║ └╥┘
q_2: ┤ X ├┤ H ├┤2        ├──────╫──╫─
     └───┘└───┘└─────────┘      ║  ║ 
c: 2/═══════════════════════════╩══╩═
                                0  1

[出力結果(量子回路)]

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├───

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 Oracle ├┤ H ├─╫─┤M├

├───┤┌───┐│ │└───┘ ║ └╥┘

q_2: ┤ X ├┤ H ├┤2 ├──────╫──╫─

└───┘└───┘└─────────┘ ║ ║

c: 2/═══════════════════════════╩══╩═

0 1

ドイチ-ジョサ(2-bit／分布型関数)

[出力結果(量子回路)]
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├───
     ├───┤     │         │├───┤└╥┘┌─┐
q_1: ┤ H ├─────┤1 Oracle ├┤ H ├─╫─┤M├
     ├───┤┌───┐│         │└───┘ ║ └╥┘
q_2: ┤ X ├┤ H ├┤2        ├──────╫──╫─
     └───┘└───┘└─────────┘      ║  ║ 
c: 2/═══════════════════════════╩══╩═
                                0  1

[出力結果(量子回路)]

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├───

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 Oracle ├┤ H ├─╫─┤M├

├───┤┌───┐│ │└───┘ ║ └╥┘

q_2: ┤ X ├┤ H ├┤2 ├──────╫──╫─

└───┘└───┘└─────────┘ ║ ║

c: 2/═══════════════════════════╩══╩═

0 1

ドイチ-ジョサ(3-bit／定値型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐      
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├──────
     ├───┤     │         │├───┤└╥┘┌─┐   
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├───
     ├───┤     │  Oracle │├───┤ ║ └╥┘┌─┐
q_2: ┤ H ├─────┤2        ├┤ H ├─╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║ └╥┘
q_3: ┤ X ├┤ H ├┤3        ├──────╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║ 
c: 3/═══════════════════════════╩══╩══╩═
                                0  1  2

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├──────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├───

├───┤ │ Oracle │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 ├┤ H ├─╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ └╥┘

q_3: ┤ X ├┤ H ├┤3 ├──────╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║

c: 3/═══════════════════════════╩══╩══╩═

0 1 2

ドイチ-ジョサ(3-bit／分布型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐      
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├──────
     ├───┤     │         │├───┤└╥┘┌─┐   
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├───
     ├───┤     │  Oracle │├───┤ ║ └╥┘┌─┐
q_2: ┤ H ├─────┤2        ├┤ H ├─╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║ └╥┘
q_3: ┤ X ├┤ H ├┤3        ├──────╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║ 
c: 3/═══════════════════════════╩══╩══╩═
                                0  1  2

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├──────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├───

├───┤ │ Oracle │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 ├┤ H ├─╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ └╥┘

q_3: ┤ X ├┤ H ├┤3 ├──────╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║

c: 3/═══════════════════════════╩══╩══╩═

0 1 2

ドイチ-ジョサ(4-bit／定値型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├─────────
     ├───┤     │         │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├──────
     ├───┤     │         │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │         │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3        ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4        ├──────╫──╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║  ║ 
c: 4/═══════════════════════════╩══╩══╩══╩═
                                0  1  2  3

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║ ║

c: 4/═══════════════════════════╩══╩══╩══╩═

0 1 2 3

ドイチ-ジョサ(4-bit／分布型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐         
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├─────────
     ├───┤     │         │├───┤└╥┘┌─┐      
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├──────
     ├───┤     │         │├───┤ ║ └╥┘┌─┐   
q_2: ┤ H ├─────┤2 Oracle ├┤ H ├─╫──╫─┤M├───
     ├───┤     │         │├───┤ ║  ║ └╥┘┌─┐
q_3: ┤ H ├─────┤3        ├┤ H ├─╫──╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║  ║ └╥┘
q_4: ┤ X ├┤ H ├┤4        ├──────╫──╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║  ║ 
c: 4/═══════════════════════════╩══╩══╩══╩═
                                0  1  2  3

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├─────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├──────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 Oracle ├┤ H ├─╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ └╥┘

q_4: ┤ X ├┤ H ├┤4 ├──────╫──╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║ ║

c: 4/═══════════════════════════╩══╩══╩══╩═

0 1 2 3

ドイチ-ジョサ(5-bit／定値型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐            
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├────────────
     ├───┤     │         │├───┤└╥┘┌─┐         
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├─────────
     ├───┤     │         │├───┤ ║ └╥┘┌─┐      
q_2: ┤ H ├─────┤2        ├┤ H ├─╫──╫─┤M├──────
     ├───┤     │  Oracle │├───┤ ║  ║ └╥┘┌─┐   
q_3: ┤ H ├─────┤3        ├┤ H ├─╫──╫──╫─┤M├───
     ├───┤     │         │├───┤ ║  ║  ║ └╥┘┌─┐
q_4: ┤ H ├─────┤4        ├┤ H ├─╫──╫──╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║  ║  ║ └╥┘
q_5: ┤ X ├┤ H ├┤5        ├──────╫──╫──╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║  ║  ║ 
c: 5/═══════════════════════════╩══╩══╩══╩══╩═
                                0  1  2  3  4

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├────────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├─────────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 ├┤ H ├─╫──╫─┤M├──────

├───┤ │ Oracle │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ ║ └╥┘┌─┐

q_4: ┤ H ├─────┤4 ├┤ H ├─╫──╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ ║ └╥┘

q_5: ┤ X ├┤ H ├┤5 ├──────╫──╫──╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║ ║ ║

c: 5/═══════════════════════════╩══╩══╩══╩══╩═

0 1 2 3 4

ドイチ-ジョサ(5-bit／分布型関数)

[出力結果(量子回路)]
     ┌───┐     ┌─────────┐┌───┐┌─┐            
q_0: ┤ H ├─────┤0        ├┤ H ├┤M├────────────
     ├───┤     │         │├───┤└╥┘┌─┐         
q_1: ┤ H ├─────┤1        ├┤ H ├─╫─┤M├─────────
     ├───┤     │         │├───┤ ║ └╥┘┌─┐      
q_2: ┤ H ├─────┤2        ├┤ H ├─╫──╫─┤M├──────
     ├───┤     │  Oracle │├───┤ ║  ║ └╥┘┌─┐   
q_3: ┤ H ├─────┤3        ├┤ H ├─╫──╫──╫─┤M├───
     ├───┤     │         │├───┤ ║  ║  ║ └╥┘┌─┐
q_4: ┤ H ├─────┤4        ├┤ H ├─╫──╫──╫──╫─┤M├
     ├───┤┌───┐│         │└───┘ ║  ║  ║  ║ └╥┘
q_5: ┤ X ├┤ H ├┤5        ├──────╫──╫──╫──╫──╫─
     └───┘└───┘└─────────┘      ║  ║  ║  ║  ║ 
c: 5/═══════════════════════════╩══╩══╩══╩══╩═
                                0  1  2  3  4

[出力結果(量子回路)]

┌───┐ ┌─────────┐┌───┐┌─┐

q_0: ┤ H ├─────┤0 ├┤ H ├┤M├────────────

├───┤ │ │├───┤└╥┘┌─┐

q_1: ┤ H ├─────┤1 ├┤ H ├─╫─┤M├─────────

├───┤ │ │├───┤ ║ └╥┘┌─┐

q_2: ┤ H ├─────┤2 ├┤ H ├─╫──╫─┤M├──────

├───┤ │ Oracle │├───┤ ║ ║ └╥┘┌─┐

q_3: ┤ H ├─────┤3 ├┤ H ├─╫──╫──╫─┤M├───

├───┤ │ │├───┤ ║ ║ ║ └╥┘┌─┐

q_4: ┤ H ├─────┤4 ├┤ H ├─╫──╫──╫──╫─┤M├

├───┤┌───┐│ │└───┘ ║ ║ ║ ║ └╥┘

q_5: ┤ X ├┤ H ├┤5 ├──────╫──╫──╫──╫──╫─

└───┘└───┘└─────────┘ ║ ║ ║ ║ ║

c: 5/═══════════════════════════╩══╩══╩══╩══╩═

0 1 2 3 4

参照サイト

ドイチ-ジョサのアルゴリズム

2021年6月6日

Python（Qiskit）について（１４）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

位相キックバック(練習問題含む)

練習問題 1(Controlled-U)

[編集内容]
from qiskit import QuantumCircuit, Aer, execute
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector, plot_histogram
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the 
# array_to_latex function and use print() instead.
from qiskit_textbook.tools import array_to_latex

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)
qc.h(0)
qc.cu1(pi/4, 0, 1)

# 量子回路を表示.
display(qc.draw('mpl'))

# 状態ベクトルを表示.
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)
plot_bloch_multivector(final_state)

[編集内容]

from qiskit import QuantumCircuit, Aer, execute

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector, plot_histogram

# In Jupyter Notebooks we can display this nicely using Latex.

# If not using Jupyter Notebooks you may need to remove the

# array_to_latex function and use print() instead.

from qiskit_textbook.tools import array_to_latex

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

qc.h(0)

qc.cu1(pi/4, 0, 1)

# 量子回路を表示.

display(qc.draw('mpl'))

# 状態ベクトルを表示.

statevector_backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, statevector_backend).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)

練習問題 1(T)

[編集内容]
# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)
qc.h(0)
qc.t(1)

# 量子回路を表示.
display(qc.draw('mpl'))

# 状態ベクトルを表示.
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)
plot_bloch_multivector(final_state)

[編集内容]

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

qc.h(0)

qc.t(1)

# 量子回路を表示.

display(qc.draw('mpl'))

# 状態ベクトルを表示.

statevector_backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, statevector_backend).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)

練習問題 2(Controlled-U)

[編集内容]
# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.cu1(-pi/2, 0, 1)

# 量子回路を表示.
display(qc.draw('mpl'))

# 状態ベクトルを表示.
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)
plot_bloch_multivector(final_state)

[編集内容]

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)

qc.cu1(-pi/2, 0, 1)

# 量子回路を表示.

display(qc.draw('mpl'))

# 状態ベクトルを表示.

statevector_backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, statevector_backend).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)

練習問題 2(Controlled-Dagger)

[編集内容]
# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.sdg(0)

# 量子回路を表示.
display(qc.draw('mpl'))

# 状態ベクトルを表示.
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)
plot_bloch_multivector(final_state)

[編集内容]

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)

qc.sdg(0)

# 量子回路を表示.

display(qc.draw('mpl'))

# 状態ベクトルを表示.

statevector_backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, statevector_backend).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)

練習問題 3

[編集内容]
# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)
qc.x(0)
qc.x(1)
qc.cu1(pi/4, 0, 1)

# 量子回路を表示.
display(qc.draw('mpl'))

# 状態ベクトルを表示.
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)
plot_bloch_multivector(final_state)

[編集内容]

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

qc.x(0)

qc.x(1)

qc.cu1(pi/4, 0, 1)

# 量子回路を表示.

display(qc.draw('mpl'))

# 状態ベクトルを表示.

statevector_backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, statevector_backend).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)

参照サイト

位相キックバック

2021年5月24日

Python（Qiskit）について（１３）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

単一量子ビットゲート(練習問題含む)

演算(X, H, Z)

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# X, H, Zゲート作用.
qc.x(0)
qc.h(0)
qc.z(0)

# ユニタリ行列に変換.
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.
print(unitary)

# 行列計算チェック.
c = 1 / np.sqrt(2)
z = np.array([[1, 0],[0, -1]])
h = np.array([[c, c],[c, -c]])
x = np.array([[0, 1],[1, 0]])
zhx = z @ h @ x
print(zhx)

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# X, H, Zゲート作用.

qc.x(0)

qc.h(0)

qc.z(0)

# ユニタリ行列に変換.

backend = Aer.get_backend('unitary_simulator')

unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.

print(unitary)

# 行列計算チェック.

c = 1 / np.sqrt(2)

z = np.array([[1, 0],[0, -1]])

h = np.array([[c, c],[c, -c]])

x = np.array([[0, 1],[1, 0]])

zhx = z @ h @ x

print(zhx)

[出力結果]
[[ 0.70710678+0.00000000e+00j  0.70710678-8.65956056e-17j]
 [ 0.70710678+1.57009246e-16j -0.70710678+8.65956056e-17j]]
[[ 0.70710678  0.70710678]
 [ 0.70710678 -0.70710678]]
※ 計算結果が一致していると理解できる.

[出力結果]

[[ 0.70710678+0.00000000e+00j 0.70710678-8.65956056e-17j]

[ 0.70710678+1.57009246e-16j -0.70710678+8.65956056e-17j]]

[[ 0.70710678 0.70710678]

[ 0.70710678 -0.70710678]]

※ 計算結果が一致していると理解できる.

演算(X, Y, Z)

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# X, Y, Zゲート作用.
qc.x(0)
qc.y(0)
qc.z(0)

# ユニタリ行列に変換.
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.
print(unitary)

# 行列計算チェック.
z = np.array([[1, 0],[0, -1]])
y = np.array([[0, -1j],[1j, 0]])
x = np.array([[0, 1],[1, 0]])
zyx = z @ y @ x
print(zyx)

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# X, Y, Zゲート作用.

qc.x(0)

qc.y(0)

qc.z(0)

# ユニタリ行列に変換.

backend = Aer.get_backend('unitary_simulator')

unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.

print(unitary)

# 行列計算チェック.

z = np.array([[1, 0],[0, -1]])

y = np.array([[0, -1j],[1j, 0]])

x = np.array([[0, 1],[1, 0]])

zyx = z @ y @ x

print(zyx)

[出力結果]
[[6.123234e-17-1.j 0.000000e+00+0.j]
 [0.000000e+00+0.j 6.123234e-17-1.j]]
[[0.-1.j 0.+0.j]
 [0.+0.j 0.-1.j]]
※ 計算結果が一致していると理解できる.

[出力結果]

[[6.123234e-17-1.j 0.000000e+00+0.j]

[0.000000e+00+0.j 6.123234e-17-1.j]]

[[0.-1.j 0.+0.j]

[0.+0.j 0.-1.j]]

※ 計算結果が一致していると理解できる.

演算(T, X, S, H, Y)

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# T, X, S, H, Yゲート作用.
qc.t(0)
qc.x(0)
qc.s(0)
qc.h(0)
qc.y(0)

# ユニタリ行列に変換.
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.
print(unitary)

# 行列計算チェック.
c = 1 / np.sqrt(2)
y = np.array([[0, -1j],[1j, 0]])
h = np.array([[c, c],[c, -c]])
s = np.array([[1, 0],[0, 1j]])
x = np.array([[0, 1],[1, 0]])
t = np.array([[1, 0],[0, c + c * 1j]])
yhsxt = y @ h @ s @ x @ t
print(yhsxt)

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# T, X, S, H, Yゲート作用.

qc.t(0)

qc.x(0)

qc.s(0)

qc.h(0)

qc.y(0)

# ユニタリ行列に変換.

backend = Aer.get_backend('unitary_simulator')

unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.

print(unitary)

# 行列計算チェック.

c = 1 / np.sqrt(2)

y = np.array([[0, -1j],[1j, 0]])

h = np.array([[c, c],[c, -c]])

s = np.array([[1, 0],[0, 1j]])

x = np.array([[0, 1],[1, 0]])

t = np.array([[1, 0],[0, c + c * 1j]])

yhsxt = y @ h @ s @ x @ t

print(yhsxt)

[出力結果]
[[-0.70710678-8.65956056e-17j  0.5       -5.00000000e-01j]
 [-0.70710678-8.65956056e-17j -0.5       +5.00000000e-01j]]
[[-0.70710678+0.j   0.5       -0.5j]
 [-0.70710678+0.j  -0.5       +0.5j]]
※ 計算結果が一致していると理解できる.

[出力結果]

[[-0.70710678-8.65956056e-17j 0.5 -5.00000000e-01j]

[-0.70710678-8.65956056e-17j -0.5 +5.00000000e-01j]]

[[-0.70710678+0.j 0.5 -0.5j]

[-0.70710678+0.j -0.5 +0.5j]]

※ 計算結果が一致していると理解できる.

複数量子ビットゲート(練習問題含む)

演算(CNOT)

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# CNOTゲート作用.
qc.cx(0, 1)

# ユニタリ行列に変換.
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.
print(unitary)

# 行列計算チェック.
cx = np.array([[1, 0, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0],[0, 1, 0, 0]])
print(cx)

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# CNOTゲート作用.

qc.cx(0, 1)

# ユニタリ行列に変換.

backend = Aer.get_backend('unitary_simulator')

unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.

print(unitary)

# 行列計算チェック.

cx = np.array([[1, 0, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0],[0, 1, 0, 0]])

print(cx)

[出力結果]
[[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]]
[[1 0 0 0]
 [0 0 0 1]
 [0 0 1 0]
 [0 1 0 0]]
※ 計算結果が一致していると理解できる.

[出力結果]

[[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]]

[[1 0 0 0]

[0 0 0 1]

[0 0 1 0]

[0 1 0 0]]

※ 計算結果が一致していると理解できる.

演算(H, CNOT)

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# H, CNOTゲート作用.
qc.h(0)
qc.cx(0, 1)

# ユニタリ行列に変換.
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.
print(unitary)

# 行列計算チェック.
c = 1 / np.sqrt(2)
h = np.array([[c, c, 0, 0],[c, -c, 0, 0],[0, 0, c, c],[0, 0, c, -c]])
cx = np.array([[1, 0, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0],[0, 1, 0, 0]])
cxh = cx @ h
print(cxh)

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# H, CNOTゲート作用.

qc.h(0)

qc.cx(0, 1)

# ユニタリ行列に変換.

backend = Aer.get_backend('unitary_simulator')

unitary = execute(qc,backend).result().get_unitary()

# ユニタリ行列表示.

print(unitary)

# 行列計算チェック.

c = 1 / np.sqrt(2)

h = np.array([[c, c, 0, 0],[c, -c, 0, 0],[0, 0, c, c],[0, 0, c, -c]])

cx = np.array([[1, 0, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0],[0, 1, 0, 0]])

cxh = cx @ h

print(cxh)

[出力結果]
[[ 0.70710678+0.00000000e+00j  0.70710678-8.65956056e-17j
   0.        +0.00000000e+00j  0.        +0.00000000e+00j]
 [ 0.        +0.00000000e+00j  0.        +0.00000000e+00j
   0.70710678+0.00000000e+00j -0.70710678+8.65956056e-17j]
 [ 0.        +0.00000000e+00j  0.        +0.00000000e+00j
   0.70710678+0.00000000e+00j  0.70710678-8.65956056e-17j]
 [ 0.70710678+0.00000000e+00j -0.70710678+8.65956056e-17j
   0.        +0.00000000e+00j  0.        +0.00000000e+00j]]
[[ 0.70710678  0.70710678  0.          0.        ]
 [ 0.          0.          0.70710678 -0.70710678]
 [ 0.          0.          0.70710678  0.70710678]
 [ 0.70710678 -0.70710678  0.          0.        ]]
※ 計算結果が一致していると理解できる.

[出力結果]

[[ 0.70710678+0.00000000e+00j 0.70710678-8.65956056e-17j

0. +0.00000000e+00j 0. +0.00000000e+00j]

[ 0. +0.00000000e+00j 0. +0.00000000e+00j

0.70710678+0.00000000e+00j -0.70710678+8.65956056e-17j]

[ 0. +0.00000000e+00j 0. +0.00000000e+00j

0.70710678+0.00000000e+00j 0.70710678-8.65956056e-17j]

[ 0.70710678+0.00000000e+00j -0.70710678+8.65956056e-17j

0. +0.00000000e+00j 0. +0.00000000e+00j]]

[[ 0.70710678 0.70710678 0. 0. ]

[ 0. 0. 0.70710678 -0.70710678]

[ 0. 0. 0.70710678 0.70710678]

[ 0.70710678 -0.70710678 0. 0. ]]

※ 計算結果が一致していると理解できる.

ベル状態

[編集内容]
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit_textbook.tools import array_to_latex

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# X, H, CNOTゲート作用.
qc.x(1)
qc.h(0)
qc.cx(0, 1)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector, plot_histogram

from qiskit_textbook.tools import array_to_latex

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# X, H, CNOTゲート作用.

qc.x(1)

qc.h(0)

qc.cx(0, 1)

# 量子回路を表示.

qc.draw('mpl')

ベル状態(続き)

[編集内容]
# Statevector.
backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc, backend).result().get_statevector()

# Statevector表示.
array_to_latex(final_state, pretext="\\text{Statevector = }")

[編集内容]

# Statevector.

backend = Aer.get_backend('statevector_simulator')

final_state = execute(qc, backend).result().get_statevector()

# Statevector表示.

array_to_latex(final_state, pretext="\\text{Statevector = }")

ベル状態(続き)

[編集内容]
results = execute(qc, backend).result().get_counts()
plot_histogram(results)

[編集内容]

results = execute(qc, backend).result().get_counts()

plot_histogram(results)

参照サイト

複数量子ビットともつれ状態

2021年5月16日2021年5月16日

Python（Qiskit）について（１２）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

単一量子ビットゲート

単一量子ビットゲート

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(5)
qc.x(0)
qc.y(1)
qc.z(2)
qc.i(3)
qc.h(4)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(5)

qc.x(0)

qc.y(1)

qc.z(2)

qc.i(3)

qc.h(4)

# 量子回路を表示.

qc.draw('mpl')

ブロッホ球

[編集内容(ブロッホ球)]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# ブロッホ球で表示.
backend = Aer.get_backend('statevector_simulator')
out = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out)

[編集内容(ブロッホ球)]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# ブロッホ球で表示.

backend = Aer.get_backend('statevector_simulator')

out = execute(qc, backend).result().get_statevector()

plot_bloch_multivector(out)

単一量子ビットゲート

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(5)
qc.rz(pi/4, 0)
qc.s(1)
qc.sdg(2)
qc.t(3)
qc.tdg(4)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(5)

qc.rz(pi/4, 0)

qc.s(1)

qc.sdg(2)

qc.t(3)

qc.tdg(4)

# 量子回路を表示.

qc.draw('mpl')

ブロッホ球

[編集内容(ブロッホ球)]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# ブロッホ球で表示.
backend = Aer.get_backend('statevector_simulator')
out = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out)

[編集内容(ブロッホ球)]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# ブロッホ球で表示.

backend = Aer.get_backend('statevector_simulator')

out = execute(qc, backend).result().get_statevector()

plot_bloch_multivector(out)

複数量子ビットともつれ状態(練習問題含む)

Statevector(|1>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# Xゲート作用.
qc.x(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# Xゲート作用.

qc.x(0)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|+>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# Hゲート作用.
qc.h(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# Hゲート作用.

qc.h(0)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|->)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# X, Hゲート作用.
qc.x(0)
qc.h(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# X, Hゲート作用.

qc.x(0)

qc.h(0)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|0>|1>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# Xゲート作用.
# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲート で 解説されている通り, 
# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.
# -> |0>|1> = I|q1> tensor X|q0> = I|0> tensor X|0> = (I tensor X)|00> のような計算するように記述している.
# なお, |00> は, I tensor X の 1列目 を取得すると理解する.
qc.x(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# Xゲート作用.

# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲートで解説されている通り,

# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.

# -> |0>|1> = I|q1> tensor X|q0> = I|0> tensor X|0> = (I tensor X)|00> のような計算するように記述している.

# なお, |00> は, I tensor X の 1列目を取得すると理解する.

qc.x(0)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|0>|+>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# Hゲート作用.
# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲート で 解説されている通り, 
# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.
# -> |0>|+> = I|q1> tensor H|q0> = I|0> tensor H|0> = (I tensor H)|00> のような計算するように記述している.
# なお, |00> は, I tensor H の 1列目 を取得すると理解する.
qc.h(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# Hゲート作用.

# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲートで解説されている通り,

# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.

# -> |0>|+> = I|q1> tensor H|q0> = I|0> tensor H|0> = (I tensor H)|00> のような計算するように記述している.

# なお, |00> は, I tensor H の 1列目を取得すると理解する.

qc.h(0)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|+>|1>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# H, Xゲート作用.
# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲート で 解説されている通り, 
# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.
# -> |+>|1> = H|q1> tensor X|q0> = H|0> tensor X|0> = (H tensor X)|00> のような計算するように記述している.
# なお, |00> は, H tensor X の 1列目 を取得すると理解する.
qc.h(0)
qc.x(1)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# H, Xゲート作用.

# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲートで解説されている通り,

# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.

# -> |+>|1> = H|q1> tensor X|q0> = H|0> tensor X|0> = (H tensor X)|00> のような計算するように記述している.

# なお, |00> は, H tensor X の 1列目を取得すると理解する.

qc.h(0)

qc.x(1)

# 量子回路を表示.

qc.draw('mpl')

Statevector(|->|+>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# H, Xゲート作用.
# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲート で 解説されている通り, 
# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.
# -> |->|+> = XH|q1> tensor H|q0> = XH|0> tensor H|0> = (XH tensor H)|00> のような計算するように記述している.
# なお, |00> は, XH tensor H の 1列目 を取得すると理解する.
qc.h(0)
qc.x(1)
qc.h(1)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# H, Xゲート作用.

# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲートで解説されている通り,

# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.

# -> |->|+> = XH|q1> tensor H|q0> = XH|0> tensor H|0> = (XH tensor H)|00> のような計算するように記述している.

# なお, |00> は, XH tensor H の 1列目を取得すると理解する.

qc.h(0)

qc.x(1)

qc.h(1)

# 量子回路を表示.

qc.draw('mpl')

Statevector

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(1)

# H, Sゲート作用.
qc.h(0)
qc.s(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(1)

# H, Sゲート作用.

qc.h(0)

qc.s(0)

# 量子回路を表示.

qc.draw('mpl')

量子ビット(1/√2|00> + i/√2|01>)

[編集内容]
from qiskit import *
from math import pi
from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.
qc = QuantumCircuit(2)

# H, Sゲート作用.
# |+> に S を 作用 = [1/√2, i/√2] は, 前問で確認した.
# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲート で 解説されている通り, 
# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.
# -> |0>(|+> に S を 作用) = I|q1> tensor (|+> に S を 作用)|q0> = I|0> tensor (|+> に S を 作用)|0>
# = (I tensor (|+> に S を 作用))|00> のような計算するように記述している.
# なお, |00> は, I tensor (|+> に S を 作用) の 1列目 を取得すると理解する.
qc.h(0)
qc.s(0)

# 量子回路を表示.
qc.draw('mpl')

[編集内容]

from qiskit import *

from math import pi

from qiskit.visualization import plot_bloch_multivector

# 量子ビットに対してゲート作用させてみる.

qc = QuantumCircuit(2)

# H, Sゲート作用.

# |+> に S を作用 = [1/√2, i/√2] は, 前問で確認した.

# ※ 複数量子ビット状態ベクトル上の単一量子ビットゲートで解説されている通り,

# X|q1> tensor H|q0>= (X tensor H)|q1q0> のように計算されるとのことなので, 演算順序に注意する.

# -> |0>(|+> に S を作用) = I|q1> tensor (|+> に S を作用)|q0> = I|0> tensor (|+> に S を作用)|0>

# = (I tensor (|+> に S を作用))|00> のような計算するように記述している.

# なお, |00> は, I tensor (|+> に S を作用) の 1列目を取得すると理解する.

qc.h(0)

qc.s(0)

# 量子回路を表示.

qc.draw('mpl')

参照サイト

2021年5月10日

Python（Qiskit）について（１１）

概要

Qiskit について, 学習サイトのサンプルプログラムを動かしてみた.
動作環境は, Google Colaboratory で行った
実行プログラム, 解説は, 下記の参照サイトをご覧ください

感想

本家のサイトの学習教材が非常に詳しいので, 今後も, 時間を見つけて, 確認していこうと思う.

ブロッホ球(練習問題含む)

状態|+>

[編集内容(|+>)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
coords = [pi / 2, 0, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容(|+>)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

coords = [pi / 2, 0, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

状態|0>

[編集内容(|0>)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
coords = [0, 0, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容(|0>)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

coords = [0, 0, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

状態|1>

[編集内容(|1>)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
coords = [pi, 0, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容(|1>)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

coords = [pi, 0, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

状態(|0> + |1>) / √2

[編集内容((|0> + |1>) / √2)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
coords = [pi / 2, 0, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容((|0> + |1>) / √2)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

coords = [pi / 2, 0, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

状態(|0> – i * |1>) / √2

[編集内容((|0> - i * |1>) / √2)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
coords = [pi / 2, 3 * pi / 2, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容((|0> - i * |1>) / √2)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

coords = [pi / 2, 3 * pi / 2, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

状態 [i, 1] / √2

[編集内容([i, 1] / √2)]
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]
# i * (|0> - i * |1>) / √2 と見ると, 前項の結果を, i倍すれば良さそうに見える.
# -> 従って, 前項の結果と同じものを表示すれば良いと考える(i倍の差分は, とりあえず, グローバル位相と理解).
coords = [pi / 2, 3 * pi / 2, 1]

# 球面座標を持つブロッホベクトル
plot_bloch_vector_spherical(coords)

[編集内容([i, 1] / √2)]

from qiskit import QuantumCircuit, execute, Aer

from qiskit.visualization import plot_histogram, plot_bloch_vector

from math import sqrt, pi

from qiskit_textbook.widgets import plot_bloch_vector_spherical

# [Theta, Phi, Radius]

# i * (|0> - i * |1>) / √2 と見ると, 前項の結果を, i倍すれば良さそうに見える.

# -> 従って, 前項の結果と同じものを表示すれば良いと考える(i倍の差分は, とりあえず, グローバル位相と理解).

coords = [pi / 2, 3 * pi / 2, 1]

# 球面座標を持つブロッホベクトル

plot_bloch_vector_spherical(coords)

[出力結果]
※ブロッホ球が表示された.

1 2	[出力結果] ※ブロッホ球が表示された.

参照サイト

量子ビット状態を表現する

概要

感想

ベルンシュタイン・ヴァジラニ アルゴリズム(演習問題改題ほか)

参照サイト

概要

感想

ベルンシュタイン・ヴァジラニ アルゴリズム

参照サイト

概要

感想

Hello Qiskitゲーム

参照サイト

概要

感想

Hello Qiskitゲーム

参照サイト

概要

感想

ドイチ-ジョサ(Deutsch-Jozsa)のアルゴリズム(演習問題)

補足

参照サイト

概要

感想

ドイチ-ジョサ(Deutsch-Jozsa)のアルゴリズム

参照サイト

概要

感想

位相キックバック(練習問題含む)

参照サイト

概要

感想

単一量子ビットゲート(練習問題含む)

複数量子ビットゲート(練習問題含む)

参照サイト

概要

感想

単一量子ビットゲート

複数量子ビットともつれ状態(練習問題含む)

参照サイト

概要

感想

ブロッホ球(練習問題含む)

参照サイト

ベルンシュタイン・ヴァジラニアルゴリズム(演習問題改題ほか)

ベルンシュタイン・ヴァジラニアルゴリズム