def test_basis_change(simulator): for angle in list(uniform(0, 2 * pi, 5)): EX = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle), H=PX(0)), backend=simulator) EY = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle), H=PY(0)), backend=simulator) EZ = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle), H=PZ(0)), backend=simulator) EXX = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle) + change_basis(target=0, axis=0), H=PZ(0)), backend=simulator) EYY = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle) + change_basis(target=0, axis=1), H=PZ(0)), backend=simulator) EZZ = simulate(ExpectationValue(U=gates.Rx(target=0, angle=angle) + change_basis(target=0, axis=2), H=PZ(0)), backend=simulator) assert (isclose(EX, EXX, atol=1.e-4)) assert (isclose(EY, EYY, atol=1.e-4)) assert (isclose(EZ, EZZ, atol=1.e-4)) for i, gate in enumerate([gates.Rx, gates.Ry, gates.Rz]): angle = uniform(0, 2 * pi) U1 = gate(target=0, angle=angle) U2 = change_basis(target=0, axis=i) + gates.Rz(target=0, angle=angle) + change_basis(target=0, axis=i, daggered=True) wfn1 = simulate(U1, backend=simulator) wfn2 = simulate(U2, backend=simulator) assert (isclose(numpy.abs(wfn1.inner(wfn2)) ** 2, 1.0, atol=1.e-4)) if simulator == "qiskit": return # initial state not yet supported wfn1 = simulate(U1, initial_state=1, backend=simulator) wfn2 = simulate(U2, initial_state=1, backend=simulator) assert (isclose(numpy.abs(wfn1.inner(wfn2)) ** 2, 1.0, atol=1.e-4))
def test_convert_to_from_pyzx_optimizing_circuit(tequila_circuit, t_reduce): pyzx_circuit = convert_to_pyzx(tequila_circuit) pyzx_graph = pyzx_circuit.to_graph() if t_reduce: pyzx.teleport_reduce(pyzx_graph) pyzx_circuit_opt = pyzx.Circuit.from_graph(pyzx_graph) else: pyzx.full_reduce(pyzx_graph) pyzx_graph.normalize() pyzx_circuit_opt = pyzx.extract_circuit(pyzx_graph.copy()) # compare_tensors returns True if pyzx_circuit and pyzx_circuit_opt # implement the same circuit (up to global phase) assert (pyzx.compare_tensors(pyzx_circuit, pyzx_circuit_opt)) # verify_equality return True if full_reduce() is able to reduce the # composition of the circuits to the identity assert (pyzx_circuit.verify_equality(pyzx_circuit_opt)) converted_circuit = convert_from_pyzx(pyzx_circuit_opt) wfn1 = simulate(tequila_circuit, backend="symbolic") wfn2 = simulate(converted_circuit, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_mixed_power( simulator, value1=(numpy.random.randint(0, 1000) / 1000.0 * (numpy.pi / 2.0)), value2=(numpy.random.randint(0, 1000) / 1000.0 * (numpy.pi / 2.0))): angle1 = Variable(name="angle1") angle2 = Variable(name="angle2") variables = {angle1: value1, angle2: value2} qubit = 0 control = 1 H1 = paulis.X(qubit=qubit) U1 = gates.X(target=control) + gates.Ry( target=qubit, control=control, angle=angle1) e1 = ExpectationValue(U=U1, H=H1) H2 = paulis.Y(qubit=qubit) U2 = gates.X(target=control) + gates.Rx( target=qubit, control=control, angle=angle2) e2 = ExpectationValue(U=U2, H=H2) added = e1**e2 val = simulate(added, variables=variables, backend=simulator) en1 = simulate(e1, variables=variables, backend=simulator) en2 = simulate(e2, variables=variables, backend=simulator) an1 = np.sin(angle1(variables=variables)) an2 = -np.sin(angle2(variables=variables)) assert np.isclose(val, en1**en2, atol=1.e-4) assert np.isclose(val, an1**an2, atol=1.e-4)
def test_gradient_UX_HY_wfnsim(simulator, angle, controlled, silent=True): # same as before just with wavefunction simulation # case YX # U = cos(angle/2) + sin(-angle/2)*i*X # O = cos*sin*i*<0|YX|0> + sin*cos*(-i)<0|XY|0> # = 0.5*sin(-angle)*i <0|[YX,XY]|0> # = -sin(angle) angle_value = angle angle = Variable(name="angle") variables = {angle: angle_value} qubit = 0 H = paulis.Y(qubit=qubit) if controlled: control = 1 U = gates.X(target=control) + gates.Rx( target=qubit, control=control, angle=angle) else: U = gates.Rx(target=qubit, angle=angle) O = ExpectationValue(U=U, H=H) E = simulate(O, variables=variables, backend=simulator) dO = grad(objective=O, variable=angle) dE = simulate(dO, variables=variables) assert (numpy.isclose(E, -numpy.sin(angle(variables)), atol=0.0001)) assert (numpy.isclose(dE, -numpy.cos(angle(variables)), atol=0.0001)) if not silent: print("E =", E) print("-sin(angle)=", -numpy.sin(angle(variables))) print("dE =", dE) print("-cos(angle)=", -numpy.cos(angle(variables)))
def test_endianness_simulators(): tests = ["000111", "111000", "101010", "010101", "10010010001", "111100101000010"] for string in tests: binary = BitString.from_binary(binary=string) c = QCircuit() for i, v in enumerate(binary): if v == 1: c += gates.X(target=i) if v == 0: c += gates.Z(target=i) wfn_cirq = simulate(c, initial_state=0, backend="cirq") counts_cirq = simulate(c, samples=1, backend="cirq") counts_qiskit = simulate(c, samples=1, backend="qiskit") print("counts_cirq =", type(counts_cirq)) print("counts_qiskit=", type(counts_qiskit)) print("counts_cirq =", counts_cirq) print("counts_qiskit=", counts_qiskit) assert (counts_cirq.isclose(counts_qiskit)) assert (wfn_cirq.state == counts_cirq.state)
def test_akward_expression( simulator, value1=(numpy.random.randint(0, 1000) / 1000.0 * (numpy.pi / 2.0)), value2=(numpy.random.randint(0, 1000) / 1000.0 * (numpy.pi / 2.0))): angle1 = Variable(name="angle1") angle2 = Variable(name="angle2") variables = {angle1: value1, angle2: value2} prod = angle1 * angle2 qubit = 0 control = None H = paulis.Y(qubit=qubit) U = gates.Rx(target=qubit, control=control, angle=prod) Up = gates.Rx(target=qubit, control=control, angle=prod + np.pi / 2) Down = gates.Rx(target=qubit, control=control, angle=prod - np.pi / 2) e1 = ExpectationValue(U=U, H=H) en1 = simulate(e1, variables=variables, backend=simulator) uen = simulate(0.5 * ExpectationValue(Up, H), variables=variables, backend=simulator) den = simulate(-0.5 * ExpectationValue(Down, H), variables=variables, backend=simulator) an1 = -np.sin(prod(variables=variables)) anval = prod(variables=variables) an2 = angle2(variables=variables) added = angle1 * e1 dO = grad(added, 'angle1') dE = grad(e1, 'angle1') deval = simulate(dE, variables=variables, backend=simulator) doval = simulate(dO, variables=variables, backend=simulator) dtrue = angle1(variables=variables) * deval + en1 assert np.isclose(en1, an1) assert np.isclose(deval, an2 * (uen + den), atol=1.e-4) assert np.isclose(doval, dtrue, atol=1.e-4)
def test_import_qasm_with_custom_gates(): openqasmcode = "OPENQASM 2.0;\n" \ "include \"qelib1.inc\";\n" \ "gate mycustom a,b,c\n" \ "{\n" \ "cx c,b;\n" \ "cx c,a;\n" \ "}\n" \ "qreg q1[3];\n" \ "qreg q2[4];\n" \ "creg c[3];\n" \ "y q1[1];\n" \ "z q2[2];\n" \ "mycustom q1[0],q2[0],q1[2];\n" \ "h q2[1];\n" \ "mycustom q2[3],q1[1],q2[2];\n" \ "y q2[1];\n" imported_circuit = import_open_qasm(qasm_code=openqasmcode) # openqasm -> tequila qbits # qreg q1[3] -> 0, 1, 2 # qreg q2[4] -> 3, 4, 5, 6 tequila_circuit = Y(target=1) + Z(target=5) + \ CX(target=3, control=2) + CX(target=3, control=0) + \ H(target=4) + \ CX(target=1, control=5) + CX(target=6, control=5) + \ Y(target=4) wfn1 = simulate(tequila_circuit, backend="symbolic") wfn2 = simulate(imported_circuit, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_gradient_deep_H(simulator, power, controls): if controls > 2 and simulator == "qiskit": # does not work yet return qubit = 0 angle = Variable(name="angle") variables = {angle: power} control = [i for i in range(1, controls + 1)] H = paulis.X(qubit=qubit) U = gates.X(target=control) + gates.H( target=qubit, control=control, power=angle) O = ExpectationValue(U=U, H=H) E = simulate(O, variables=variables, backend=simulator) assert (numpy.isclose(E, -numpy.cos(angle(variables) * (numpy.pi)) / 2 + 0.5, atol=1.e-4)) dO = grad(objective=O, variable=angle) dE = simulate(dO, variables=variables, backend=simulator) assert (numpy.isclose(dE, numpy.pi * numpy.sin(angle(variables) * (numpy.pi)) / 2, atol=1.e-4))
def test_export_import_qasm_trotterized_gate(zx_calculus, string1, string2, angles, steps): variables = { "ang1": angles[0] } if string2 is None else { "ang1": angles[0], "ang2": angles[1] } g1 = QubitHamiltonian.from_string(string1) g2 = None if string2 is None else QubitHamiltonian.from_string(string2) tequila_circuit = Trotterized( generators=[g1] if string2 is None else [g1, g2], angles=["ang1"] if string2 is None else ["ang1", "ang2"], steps=steps) qasm_code = export_open_qasm(tequila_circuit, variables=variables, zx_calculus=zx_calculus) imported_circuit = import_open_qasm(qasm_code=qasm_code) wfn1 = simulate(tequila_circuit, backend="symbolic", variables=variables) wfn2 = simulate(imported_circuit, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_endianness_simulators(): tests = [ "000111", "111000", "101010", "010101", "10010010001", "111100101000010" ] for string in tests: number = int(string, 2) binary = BitString.from_binary(binary=string) c = QCircuit() for i, v in enumerate(binary): if v == 1: c += gates.X(target=i) c += gates.Measurement(target=[x for x in range(len(string))]) wfn_cirq = simulate(c, initial_state=0, backend="cirq") counts_cirq = simulate(c, samples=1, backend="cirq") counts_qiskit = simulate(c, samples=1, backend="qiskit") print("counts_cirq =", type(counts_cirq)) print("counts_qiskit=", type(counts_qiskit)) print("counts_cirq =", counts_cirq) print("counts_qiskit=", counts_qiskit) assert (counts_cirq == counts_qiskit) assert (wfn_cirq.state == counts_cirq.state)
def test_gradient_H(simulator, power, controlled): qubit = 0 control = 1 angle = Variable(name="angle") variables = {angle: power} H = paulis.X(qubit=qubit) if not controlled: U = gates.H(target=qubit, power=angle) else: U = gates.X(target=control) + gates.H( target=qubit, control=control, power=angle) O = ExpectationValue(U=U, H=H) E = simulate(O, variables=variables, backend=simulator) assert (numpy.isclose(E, -numpy.cos(angle(variables) * (numpy.pi)) / 2 + 0.5, atol=1.e-4)) dO = grad(objective=O, variable=angle) dE = simulate(dO, variables=variables, backend=simulator) assert (numpy.isclose(dE, numpy.pi * numpy.sin(angle(variables) * (numpy.pi)) / 2, atol=1.e-4))
def test_gradient_UY_HX(simulator, angle_value, controlled, silent=True): # case X Y # U = cos(angle/2) + sin(-angle/2)*i*Y # <0|Ud H U |0> = cos^2(angle/2)*<0|X|0> # + sin^2(-angle/2) <0|YXY|0> # + cos(angle/2)*sin(angle/2)*i<0|XY|0> # + sin(-angle/2)*cos(angle/2)*(-i) <0|YX|0> # = cos^2*0 + sin^2*0 + cos*sin*i(<0|[XY,YX]|0>) # = 0.5*sin(-angle)*i <0|[XY,YX]|0> = -0.5*sin(angle)*i * 2 i <0|Z|0> # = sin(angle) angle = Variable(name="angle") variables = {angle: angle_value} qubit = 0 H = paulis.X(qubit=qubit) if controlled: control = 1 U = gates.X(target=control) + gates.Ry( target=qubit, control=control, angle=angle) else: U = gates.X(target=qubit) + gates.X(target=qubit) + gates.Ry( target=qubit, angle=angle) O = ExpectationValue(U=U, H=H) E = simulate(O, variables=variables, backend=simulator) print("O={type}".format(type=type(O))) dO = grad(objective=O, variable=angle) dE = simulate(dO, variables=variables, backend=simulator) assert (numpy.isclose(E, numpy.sin(angle(variables)), atol=1.e-4)) assert (numpy.isclose(dE, numpy.cos(angle(variables)), atol=1.e-4)) if not silent: print("E =", E) print("sin(angle)=", numpy.sin(angle())) print("dE =", dE) print("cos(angle)=", numpy.cos(angle()))
def test_gradient_PHASE_HY(simulator, angle_value, controlled, silent=False): angle = Variable(name="angle") variables = {angle: angle_value} qubit = 0 H = paulis.Y(qubit=qubit) if controlled: control = 1 U = gates.X(target=control) + gates.H(target=qubit) + gates.Phase( target=qubit, control=control, phi=angle) + gates.H(target=qubit) else: U = gates.H(target=qubit) + gates.Phase( target=qubit, phi=angle) + gates.H(target=qubit) O = ExpectationValue(U=U, H=H) E = simulate(O, variables=variables, backend=simulator) dO = grad(objective=O, variable='angle') dE = simulate(dO, variables=variables) assert (numpy.isclose(E, -numpy.sin(angle(variables)), atol=1.e-4)) assert (numpy.isclose(dE, -numpy.cos(angle(variables)), atol=1.e-4)) if not silent: print("E =", E) print("-sin(angle)=", -numpy.sin(angle(variables))) print("dE =", dE) print("-cos(angle)=", -numpy.cos(angle(variables)))
def test_convert_to_from_pyzx_simple(tequila_circuit): pyzx_circuit = convert_to_pyzx(tequila_circuit) converted_circuit = convert_from_pyzx(pyzx_circuit) wfn1 = simulate(tequila_circuit, backend="symbolic") wfn2 = simulate(converted_circuit, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_exponential_pauli_wfn(simulator, angle, axis, control): U1 = gates.RotationGate(axis=axis, angle=angle, target=0, control=control) U2 = gates.ExpPauli(paulistring=axis + "(0)", angle=angle, control=control) wfn1 = simulate(U1, backend=simulator) wfn2 = simulate(U2, backend=simulator) wfn3 = simulate(U2, backend=None) assert (isclose(numpy.abs(wfn1.inner(wfn2))**2, 1.0, atol=1.e-4)) assert (isclose(numpy.abs(wfn2.inner(wfn3))**2, 1.0, atol=1.e-4))
def test_controls(target, control, gate): c0 = gates.X(target=control) + gate(target=target, control=None) c1 = gates.X(target=control) + gate(target=target, control=control) wfn0 = simulate(c0, initial_state=0, backend="symbolic") wfn1 = simulate(c1, initial_state=0, backend="symbolic") assert (wfn0.isclose(wfn1)) c0 = gates.QCircuit() c1 = gate(target=target, control=control) wfn0 = simulate(c0, initial_state=0) wfn1 = simulate(c1, initial_state=0) assert (wfn0.isclose(wfn1))
def test_controlled_rotations(simulator): angles = uniform(0, 2 * pi, 5) gs = [gates.Rx, gates.Ry, gates.Rz] for angle in angles: for gate in gs: qubit = randint(0, 1) control = randint(2, 3) U = gates.X(target=control) + gate(target=qubit, control=control, angle=angle) RCU = compile_controlled_rotation(gate=U) wfn1 = simulate(U, initial_state=0, backend=simulator) wfn2 = simulate(RCU, initial_state=0, backend=simulator) assert (isclose(numpy.abs(wfn1.inner(wfn2)) ** 2, 1.0, atol=1.e-4))
def test_export_import_qasm_h_ch_gate(zx_calculus, target1, control1, target2, control2): tequila_circuit = H(target=target1, control=control1) + H(target=target2, control=control2) qasm_code = export_open_qasm(tequila_circuit, zx_calculus=zx_calculus) imported_circuit = import_open_qasm(qasm_code=qasm_code) wfn1 = simulate(tequila_circuit, backend="symbolic") wfn2 = simulate(imported_circuit, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_l_addition(simulator, value=(numpy.random.randint(0, 1000) / 1000.0 * (numpy.pi / 2.0))): angle1 = Variable(name="angle1") variables = {angle1: value} qubit = 0 control = 1 H1 = paulis.X(qubit=qubit) U1 = gates.X(target=control) + gates.Ry(target=qubit, control=control, angle=angle1) e1 = ExpectationValue(U=U1, H=H1) added = e1 + 1 val = simulate(added, variables=variables, backend=simulator) en1 = simulate(e1, variables=variables, backend=simulator) + 1. an1 = np.sin(angle1(variables=variables)) + 1. assert np.isclose(val, en1, atol=1.e-4) assert np.isclose(val, an1, atol=1.e-4)
def test_r_power(simulator, value=numpy.random.uniform(0.1, 1.9*numpy.pi, 1)[0]): angle1 = Variable(name="angle1") variables = {angle1: value} qubit = 0 control = 1 H1 = paulis.X(qubit=qubit) U1 = gates.X(target=control) + gates.Ry(target=qubit, control=control, angle=angle1) e1 = ExpectationValue(U=U1, H=H1) added = 2 ** e1 val = simulate(added, variables=variables, backend=simulator) en1 = 2 ** simulate(e1, variables=variables, backend=simulator) an1 = 2. ** np.sin(angle1(variables=variables)) assert np.isclose(val, en1, atol=1.e-4) assert np.isclose(val, an1, atol=1.e-4)
def test_l_division(simulator, value=numpy.random.uniform(0.0, 2.0*numpy.pi, 1)[0]): angle1 = Variable(name="angle1") variables = {angle1: value} qubit = 0 control = 1 H1 = paulis.X(qubit=qubit) U1 = gates.X(target=control) + gates.Ry(target=qubit, control=control, angle=angle1) e1 = ExpectationValue(U=U1, H=H1) added = e1 / 2 val = simulate(added, variables=variables, backend=simulator) en1 = simulate(e1, variables=variables, backend=simulator) / 2 an1 = np.sin(value) / 2. assert np.isclose(val, en1, atol=1.e-4) assert np.isclose(val, an1, atol=1.e-4)
def fill_grads_values(self, grads_values, var, variables, objectives_grad): """ Inserts into "grads_values" the gradient values per objective in objectives_grad[var], where var is the name of the variable. Parameters ---------- grads_values List in which we insert the gradient values (No returns) var Variable over which we are calculating the gradient values variables Dict mapping all variables to their current values objectives_grad List of ExpectationValueImpls that will be simulated to calculate the gradient value of a given variable """ var_results = [] grads_wrt_var = objectives_grad[var] if not isinstance(grads_wrt_var, List): grads_wrt_var = [grads_wrt_var] for obj in grads_wrt_var: var_results.append( simulate(objective=obj, variables=variables, backend=self.compile_args["backend"], samples=self.samples)) grads_values.append(var_results)
def test_total_type_jumble(simulator,value1=(numpy.random.randint(10, 1000) / 1000.0 * (numpy.pi / 2.0)), value2=(numpy.random.randint(10, 1000) / 1000.0 * (numpy.pi / 2.0))): a = Variable('a') b = Variable('b') values = {a: value1, b: value2} H1 = tq.paulis.X(0) H2 = tq.paulis.Y(0) U1= tq.gates.Ry(angle=a,target=0) U2= tq.gates.Rx(angle=b,target=0) e1=ExpectationValue(U1,H1) e2=ExpectationValue(U2,H2) stacked= tq.objective.vectorize([e1, e2]) stacked = stacked*a*e2 out=simulate(stacked,variables=values,backend=simulator) v1=out[0] v2=out[1] appendage = a(values) * -np.sin(b(values)) an1= np.sin(a(values)) * appendage an2= -np.sin(b(values)) * appendage assert np.isclose(v1+v2,an1+an2) # not gonna contract, lets make gradient do some real work ga=grad(stacked,a) gb=grad(stacked,b) la=[tq.simulate(x,variables=values) for x in ga] print(la) lb=[tq.simulate(x,variables=values) for x in gb] print(lb) tota=np.sum(np.array(la)) totb=np.sum(np.array(lb)) gan1= np.cos(a(values)) * appendage + (np.sin(a(values)) * -np.sin(b(values))) - (np.sin(b(values)) * -np.sin(b(values))) gan2= np.sin(a(values)) * a(values) * -np.cos(b(values)) + 2 * (-np.cos(b(values)) * appendage) assert np.isclose(tota+totb,gan1+gan2)
def test_paulistring_sampling(backend, case): print(case) H = QubitHamiltonian.from_paulistrings(PauliString.from_string(case[0])) U = gates.X(target=1) + gates.X(target=3) + gates.X(target=5) E = ExpectationValue(H=H, U=U) result = simulate(E,backend=backend, samples=1) assert isclose(result, case[1], 1.e-4)
def test_hadamard(qubit, init): gate = gates.H(target=qubit) iwfn = QubitWaveFunction.from_int(i=init, n_qubits=qubit + 1) wfn = simulate(gate, initial_state=init) test = 1.0 / numpy.sqrt(2) * (iwfn.apply_qubitoperator(paulis.Z(qubit)) + iwfn.apply_qubitoperator(paulis.X(qubit))) assert (wfn.isclose(test))
def test_compilation(backend): U = gates.X(target=[0, 1, 2, 3, 4, 5]) for i in range(10): U += gates.Ry(angle=(i, ), target=numpy.random.randint(0, 5, 1)[0]) U += gates.CZ(0, 1) + gates.CNOT(1, 2) + gates.CZ(2, 3) + gates.CNOT( 3, 4) + gates.CZ(5, 6) H = paulis.X(0) + paulis.X(1) + paulis.X(2) + paulis.X(3) + paulis.X( 4) + paulis.X(5) H += paulis.Z(0) + paulis.Z(1) + paulis.Z(2) + paulis.Z(3) + paulis.Z( 4) + paulis.Z(5) E = ExpectationValue(H=H, U=U) randvals = numpy.random.uniform(0.0, 2.0, 10) variables = {(i, ): randvals[i] for i in range(10)} e0 = simulate(E, variables=variables, backend=backend) E2 = E * E for i in range(99): E2 += E * E compiled = tq.compile(E2, variables=variables, backend=backend) e2 = compiled(variables=variables) assert (E2.count_expectationvalues(unique=True) == 1) assert (compiled.count_expectationvalues(unique=True) == 1) assert numpy.isclose(100 * e0**2, e2)
def test_basic_gates(): I = sympy.I cos = sympy.cos sin = sympy.sin exp = sympy.exp BS = QubitWaveFunction.from_int angle = sympy.pi gates = [ X(0), Y(0), Z(0), Rx(target=0, angle=angle), Ry(target=0, angle=angle), Rz(target=0, angle=angle), H(0) ] results = [ BS(1), I * BS(1), BS(0), cos(-angle / 2) * BS(0) + I * sin(-angle / 2) * BS(1), cos(-angle / 2) * BS(0) + I * sin(-angle / 2) * I * BS(1), exp(-I * angle / 2) * BS(0), 1 / sympy.sqrt(2) * (BS(0) + BS(1)) ] for i, g in enumerate(gates): wfn = simulate(g, backend="symbolic", variables={angle: sympy.pi}) assert (wfn == strip_sympy_zeros(results[i]))
def test_unitary_gate_u1(gate, angle): """ Test some equivalences for u1 gate """ c_u1 = u1(lambd=angle, target=gate.gates[0].target, control=None if len(gate.gates[0].control) == 0 else gate.gates[0].control) if len(gate.gates[0].control) > 0: c_u1 = X(target=gate.gates[0].control) + c_u1 gate = X(target=gate.gates[0].control) + gate wfn1 = simulate(c_u1, backend="symbolic") wfn2 = simulate(gate, backend="symbolic") assert (numpy.isclose(wfn1.inner(wfn2), 1.0))
def test_heterogeneous_operations_l(simulator, op, value1=(numpy.random.randint(1, 1000) / 1000.0 * (numpy.pi / 2.0)), value2=(numpy.random.randint(1, 1000) / 1000.0 * (numpy.pi / 2.0))): angle1 = Variable(name="angle1") angle2 = Variable(name="angle2") variables = {angle1: value1, angle2: value2} qubit = 0 control = 1 H2 = paulis.X(qubit=qubit) U2 = gates.X(target=control) + gates.Ry(target=qubit, control=control, angle=angle2) e2 = ExpectationValue(U=U2, H=H2) added = Objective(args=[angle1, e2.args[0]], transformation=op) val = simulate(added, variables=variables, backend=simulator) en2 = simulate(e2, variables=variables, backend=simulator) an1 = angle1(variables=variables) an2 = np.sin(angle2(variables=variables)) assert np.isclose(val, float(op(an1, en2)), atol=1.e-4) assert np.isclose(en2, an2, atol=1.e-4)
def test_heterogeneous_operations_r(simulator, op, value1=(numpy.random.randint(1, 999) / 1000.0 * (numpy.pi / 2.0)), value2=(numpy.random.randint(1, 999) / 1000.0 * (numpy.pi / 2.0))): angle1 = Variable(name="angle1") angle2 = Variable(name="angle2") variables = {angle1: value1, angle2: value2} qubit = 0 control = 1 H1 = paulis.Y(qubit=qubit) U1 = gates.X(target=control) + gates.Rx(target=qubit, control=control, angle=angle1) e1 = ExpectationValue(U=U1, H=H1) added = Objective(args=[e1.args[0], angle2], transformation=op) val = simulate(added, variables=variables, backend=simulator) en1 = simulate(e1, variables=variables, backend=simulator) an1 = -np.sin(angle1(variables=variables)) an2 = angle2(variables=variables) assert np.isclose(val, float(op(en1, an2)), atol=1.e-4) assert np.isclose(en1, an1, atol=1.e-4)