为更快的帮您定位问题，推荐您用以下模板反馈：

1、出现问题时，您做了哪些操作？

答复：在 mindspore 使用 get_expect_with_grad 计算量子电路在可观测量下的期望的时候, 如果量子模拟器选择 mqmatrix, 结果似乎有误，在下面我提供了完整的代码, 这个bug似乎是可复现的

2、在哪个步骤出现了问题？

答复：在运行下面 py 程序的时候, 我利用 mqvector 计算结果是 f2, mqmatrix 模拟器计算结果是 f2。 我使用的电路中是不包含噪声的. 因此都是pure state. 在电路中只有 pure state 的时候, 原则上 mqvector 和 mqmatrix计算的结果应该是一样的(至少物理定律上这俩结果应该一样). 但是实际计算的 f 和 f2 是不一样的. 您可以直接运行我在下面提供的python 代码

#!/usr/bin/env python

coding: utf-8

In[1]:

mqmatrix 和 get_expect_with_grad 结合之后出现的bug.

from mindquantum.core.circuit import Circuit, UN
from mindquantum.core.gates import H, Rzz, RX
from mindquantum.core.operators import Hamiltonian, QubitOperator
from mindquantum.framework import MQAnsatzOnlyLayer
from mindquantum.simulator import Simulator
import networkx as nx
import mindspore.nn as nn

graph = nx.Graph()
nx.add_path(graph, [0, 1])
nx.add_path(graph, [1, 2])
nx.add_path(graph, [2, 3])
nx.add_path(graph, [3, 4])
nx.add_path(graph, [0, 4])
nx.add_path(graph, [0, 2])
nx.draw(graph, with_labels=True, font_weight='bold')

def build_hc(g, para):
hc = Circuit() # 创建量子线路
for i in g.edges:
hc += Rzz(para).on(i) # 对图中的每条边作用Rzz门
hc.barrier() # 添加Barrier以方便展示线路
return hc

def build_hb(g, para):
hb = Circuit() # 创建量子线路
for i in g.nodes:
hb += RX(para).on(i) # 对每个节点作用RX门
hb.barrier() # 添加Barrier以方便展示线路
return hb

def build_ansatz(g, p): # g是max-cut问题的图，p是ansatz线路的层数
circ = Circuit() # 创建量子线路
for i in range(p):
circ += build_hc(g, f'g{i}') # 添加Uc对应的线路，参数记为g0、g1、g2...
circ += build_hb(g, f'b{i}') # 添加Ub对应的线路，参数记为b0、b1、b2...
return circ

def build_ham(g):
ham = QubitOperator()
for i in g.edges:
ham += QubitOperator(f'Z{i[0]} Z{i[1]}') # 生成HC哈密顿量
return ham

pylint: disable=W0104

p = 4
ham = Hamiltonian(build_ham(graph)) # 生成哈密顿量
init_state_circ = UN(H, graph.nodes) # 生成均匀叠加态，即对所有量子比特作用H门
ansatz = build_ansatz(graph, p) # 生成ansatz线路
circ = init_state_circ + ansatz # 将初始化线路与ansatz线路组合成一个线路
circ.svg(width=1200)

In[2]:

import numpy as np

In[3]:

def numbers_to_binary_matrix(n):
# 确定每个数二进制表示需要的最大位数
max_bits = int(np.ceil(np.log2(n)))
# 创建一个全为 0 的矩阵，矩阵的行数为 n+1，列数为 max_bits
binary_matrix = np.zeros((n, max_bits), dtype=int)

# 填充矩阵
for i in range(n):
    # 将数 i 转换为二进制表示，并将结果填充到矩阵的第 i 行
    binary_representation = list(bin(i)[2:])  # 将数字转换为二进制字符串，去掉前缀 '0b'，然后转换为列表
    binary_matrix[i, -len(binary_representation):] = list(map(int, binary_representation))  # 右对齐填充二进制数

return binary_matrix

qubit_num = circ.n_qubits
output_dim = 2**qubit_num
max_bits = int(np.ceil(np.log2(output_dim)))
hams2 = [None] * output_dim
hams_sign = numbers_to_binary_matrix(output_dim)
for index in range(output_dim):
ham2 = QubitOperator('I0',1)
# ham2 = QubitOperator()
for jndex in range(0,max_bits):
ham2 = ham2 * (QubitOperator(f'I{jndex}',0.5) + (-1)**hams_sign[index,jndex]*QubitOperator(f'Z{jndex}',0.5))
hams2[index] = Hamiltonian(ham2)

In[4]:

hams2

In[5]:

sim = Simulator('mqmatrix', circ.n_qubits)
grad_ops = sim.get_expectation_with_grad(hams2, circ)

sim_mat = Simulator('mqvector', circ.n_qubits)

grad_ops_mat = sim_mat.get_expectation_with_grad(hams2, circ)
import numpy as np

rng = np.random.default_rng(10)
p0 = rng.random(size=len(circ.params_name)) * np.pi * 2 - np.pi
f, g = grad_ops(p0)
f2, g2 = grad_ops_mat(p0)

In[6]:

print(f)
print(f2)

In[7]:

np.sum(np.abs(np.real(f.reshape(-1)) - np.real(f2.reshape(-1))))

In[8]:

np.sum(f)

In[9]:

np.sum(f2)

In[ ]:

3、您希望得到什么结果？

答复：按照量子力学的物理定律, f 和 f2 的结果应该一样