diff --git a/examples/matrix_search/Makefile b/examples/matrix_search/Makefile index a49c75c..34f9bd8 100644 --- a/examples/matrix_search/Makefile +++ b/examples/matrix_search/Makefile @@ -9,26 +9,6 @@ matrix_search.qpl: matrix_search.traq $(PROJ_DEPS) -p 0.001 \ --arg N=20 --arg M=10 -matrix_search.py: matrix_search.traq $(PROJ_DEPS) - cd ../../ && cabal run traq -- \ - -t Qualtran \ - -i examples/matrix_search/$< \ - -o examples/matrix_search/$@ \ - -p 0.001 \ - --arg N=20 --arg M=10 - python -m py_compile $@ - black $@ - -matrix_search-qiskit.py: matrix_search.traq $(PROJ_DEPS) - cd ../../ && cabal run traq -- \ - -t Qiskit \ - -i examples/matrix_search/$< \ - -o examples/matrix_search/$@ \ - -p 0.1 \ - --arg N=6 --arg M=6 - python -m py_compile $@ - black $@ - depth3_NAND_formula.qpl: depth3_NAND_formula.traq $(PROJ_DEPS) cd ../../ && cabal run traq -- \ -i examples/matrix_search/$< \ diff --git a/examples/matrix_search/matrix_search-qiskit.py b/examples/matrix_search/matrix_search-qiskit.py deleted file mode 100644 index 10f6451..0000000 --- a/examples/matrix_search/matrix_search-qiskit.py +++ /dev/null @@ -1,565 +0,0 @@ -import random -import numpy as np -import qiskit -import qiskit.circuit - - -def Matrix_U(): - q_1 = qiskit.circuit.QuantumRegister(3, "q_1") - q_2 = qiskit.circuit.QuantumRegister(3, "q_2") - q_3 = qiskit.circuit.QuantumRegister(1, "q_3") - qc = qiskit.circuit.QuantumCircuit(q_1, q_2, q_3, name="Matrix_U") - return qc - - -def Matrix(): - c_1 = qiskit.circuit.ClassicalRegister(3, "c_1") - c_2 = qiskit.circuit.ClassicalRegister(3, "c_2") - c_3 = qiskit.circuit.ClassicalRegister(1, "c_3") - qc = qiskit.circuit.QuantumCircuit(c_1, c_2, c_3, name="Matrix") - return qc - - -def IsEntryZero_U(): - i0 = qiskit.circuit.QuantumRegister(3, "i0") - j0 = qiskit.circuit.QuantumRegister(3, "j0") - e_ = qiskit.circuit.QuantumRegister(1, "e_") - e = qiskit.circuit.QuantumRegister(1, "e") - e_1 = qiskit.circuit.QuantumRegister(1, "e_1") - e__1 = qiskit.circuit.QuantumRegister(1, "e__1") - qc = qiskit.circuit.QuantumCircuit(i0, j0, e_, e, e_1, e__1, name="IsEntryZero_U") - qc.append(Matrix_U().to_gate(), [*i0, *j0, *e_1]) - qc.append(qiskit.circuit.Gate("BasicGateU SWAP", 2, []), [*e, *e_1]) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [e] (UnOpE {un_op = NotOp, operand = VarE {var = e}})", 2, [] - ), - [*e, *e__1], - ) - qc.append(qiskit.circuit.Gate("BasicGateU SWAP", 2, []), [*e_, *e__1]) - return qc - - -def IsEntryZero(): - i0 = qiskit.circuit.ClassicalRegister(3, "i0") - j0 = qiskit.circuit.ClassicalRegister(3, "j0") - e_ = qiskit.circuit.ClassicalRegister(1, "e_") - e = qiskit.circuit.ClassicalRegister(1, "e") - qc = qiskit.circuit.QuantumCircuit(i0, j0, e_, e, name="IsEntryZero") - qc.append(Matrix().to_instruction(), [], [*i0, *j0, *e]) - e_ = not (e) - return qc - - -# UAny[Fin 6, 3.737551674300331e-8] -def UAny(): - i = qiskit.circuit.QuantumRegister(3, "i") - ret = qiskit.circuit.QuantumRegister(1, "ret") - s_result = qiskit.circuit.QuantumRegister(3, "s_result") - aux = qiskit.circuit.QuantumRegister(1, "aux") - aux_1 = qiskit.circuit.QuantumRegister(1, "aux_1") - aux_2 = qiskit.circuit.QuantumRegister(1, "aux_2") - aux_3 = qiskit.circuit.QuantumRegister(1, "aux_3") - ctrl = qiskit.circuit.QuantumRegister(35, "ctrl") - pred_out = qiskit.circuit.QuantumRegister(35, "pred_out") - n_iter = qiskit.circuit.QuantumRegister(35, "n_iter") - s_arg = qiskit.circuit.QuantumRegister(105, "s_arg") - qc = qiskit.circuit.QuantumCircuit( - i, - ret, - s_result, - aux, - aux_1, - aux_2, - aux_3, - ctrl, - pred_out, - n_iter, - s_arg, - name="UAny", - ) - qc.append(qiskit.circuit.Gate("UForInRangeS", qc.num_qubits, []), qc.qubits) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a] (UnOpE {un_op = AnyOp, operand = VarE {var = a}})", 36, [] - ), - [*pred_out, *ret], - ) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a,f] (BinOpE {bin_op = VecSelectOp, lhs = VarE {var = a}, rhs = VarE {var = f}})", - 143, - [], - ), - [*s_arg, *pred_out, *s_result], - ) - return qc - - -def IsRowAllOnes_U(): - i = qiskit.circuit.QuantumRegister(3, "i") - okr = qiskit.circuit.QuantumRegister(1, "okr") - hasZero = qiskit.circuit.QuantumRegister(1, "hasZero") - hasZero_1 = qiskit.circuit.QuantumRegister(1, "hasZero_1") - s_result = qiskit.circuit.QuantumRegister(3, "s_result") - aux = qiskit.circuit.QuantumRegister(1, "aux") - aux_1 = qiskit.circuit.QuantumRegister(1, "aux_1") - aux_2 = qiskit.circuit.QuantumRegister(1, "aux_2") - aux_3 = qiskit.circuit.QuantumRegister(1, "aux_3") - ctrl = qiskit.circuit.QuantumRegister(35, "ctrl") - pred_out = qiskit.circuit.QuantumRegister(35, "pred_out") - n_iter = qiskit.circuit.QuantumRegister(35, "n_iter") - s_arg = qiskit.circuit.QuantumRegister(105, "s_arg") - aux_prim = qiskit.circuit.QuantumRegister(3, "aux_prim") - aux_prim_1 = qiskit.circuit.QuantumRegister(1, "aux_prim_1") - aux_prim_2 = qiskit.circuit.QuantumRegister(1, "aux_prim_2") - aux_prim_3 = qiskit.circuit.QuantumRegister(1, "aux_prim_3") - aux_prim_4 = qiskit.circuit.QuantumRegister(1, "aux_prim_4") - aux_prim_5 = qiskit.circuit.QuantumRegister(35, "aux_prim_5") - aux_prim_6 = qiskit.circuit.QuantumRegister(35, "aux_prim_6") - aux_prim_7 = qiskit.circuit.QuantumRegister(35, "aux_prim_7") - aux_prim_8 = qiskit.circuit.QuantumRegister(105, "aux_prim_8") - okr_1 = qiskit.circuit.QuantumRegister(1, "okr_1") - qc = qiskit.circuit.QuantumCircuit( - i, - okr, - hasZero, - hasZero_1, - s_result, - aux, - aux_1, - aux_2, - aux_3, - ctrl, - pred_out, - n_iter, - s_arg, - aux_prim, - aux_prim_1, - aux_prim_2, - aux_prim_3, - aux_prim_4, - aux_prim_5, - aux_prim_6, - aux_prim_7, - aux_prim_8, - okr_1, - name="IsRowAllOnes_U", - ) - qc.append( - UAny().to_gate(), - [ - *i, - *hasZero_1, - *aux_prim, - *aux_prim_1, - *aux_prim_2, - *aux_prim_3, - *aux_prim_4, - *aux_prim_5, - *aux_prim_6, - *aux_prim_7, - *aux_prim_8, - ], - ) - qc.append(qiskit.circuit.Gate("BasicGateU SWAP", 2, []), [*hasZero, *hasZero_1]) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [hasZero] (UnOpE {un_op = NotOp, operand = VarE {var = hasZero}})", - 2, - [], - ), - [*hasZero, *okr_1], - ) - qc.append(qiskit.circuit.Gate("BasicGateU SWAP", 2, []), [*okr, *okr_1]) - return qc - - -# Grover[...] -def Grover(): - k = qiskit.circuit.Parameter("k") - i = qiskit.circuit.QuantumRegister(3, "i") - x = qiskit.circuit.QuantumRegister(3, "x") - ret_1 = qiskit.circuit.QuantumRegister(1, "ret_1") - aux_4 = qiskit.circuit.QuantumRegister(1, "aux_4") - aux_5 = qiskit.circuit.QuantumRegister(1, "aux_5") - aux_6 = qiskit.circuit.QuantumRegister(1, "aux_6") - qc = qiskit.circuit.QuantumCircuit(i, x, ret_1, aux_4, aux_5, aux_6, name="Grover") - qc.append(qiskit.circuit.Gate("BasicGateU XGate", 1, []), [*ret_1]) - qc.append(qiskit.circuit.Gate("BasicGateU HGate", 1, []), [*ret_1]) - qc.append(qiskit.circuit.Gate("DistrU (UniformE {sample_ty = Fin 6})", 3, []), [*x]) - qc.append(qiskit.circuit.Gate("URepeatS", qc.num_qubits, []), qc.qubits) - qc.append(qiskit.circuit.Gate("BasicGateU HGate", 1, []), [*ret_1]) - qc.append(qiskit.circuit.Gate("BasicGateU XGate", 1, []), [*ret_1]) - return qc - - -def QAny(): - i = qiskit.circuit.ClassicalRegister(3, "i") - ret_1 = qiskit.circuit.ClassicalRegister(1, "ret_1") - s_result_1 = qiskit.circuit.ClassicalRegister(3, "s_result_1") - not_done = qiskit.circuit.ClassicalRegister(1, "not_done") - Q_sum = qiskit.circuit.ClassicalRegister(5, "Q_sum") - j = qiskit.circuit.ClassicalRegister(5, "j") - j_lim = qiskit.circuit.ClassicalRegister(5, "j_lim") - qc = qiskit.circuit.QuantumCircuit( - i, ret_1, s_result_1, not_done, Q_sum, j, j_lim, name="QAny" - ) - for _ in range(16): - Q_sum = 0 - for j_lim in [1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]: - j = random.randrange(j_lim) - Q_sum = Q_sum + j - not_done = not_done and (Q_sum <= j_lim) - if not_done: - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - not_done = not_done and ret_1 - else: - pass - return qc - - -def IsRowAllOnes(): - i = qiskit.circuit.ClassicalRegister(3, "i") - okr = qiskit.circuit.ClassicalRegister(1, "okr") - hasZero = qiskit.circuit.ClassicalRegister(1, "hasZero") - qc = qiskit.circuit.QuantumCircuit(i, okr, hasZero, name="IsRowAllOnes") - qc.append(QAny().to_instruction(), [], [*i, *hasZero]) - okr = not (hasZero) - return qc - - -# UAny[Fin 6, 5.0e-2] -def UAny_1(): - ret_2 = qiskit.circuit.QuantumRegister(1, "ret_2") - s_result_2 = qiskit.circuit.QuantumRegister(3, "s_result_2") - aux_7 = qiskit.circuit.QuantumRegister(1, "aux_7") - aux_8 = qiskit.circuit.QuantumRegister(1, "aux_8") - aux_9 = qiskit.circuit.QuantumRegister(3, "aux_9") - aux_10 = qiskit.circuit.QuantumRegister(1, "aux_10") - aux_11 = qiskit.circuit.QuantumRegister(1, "aux_11") - aux_12 = qiskit.circuit.QuantumRegister(1, "aux_12") - aux_13 = qiskit.circuit.QuantumRegister(1, "aux_13") - aux_14 = qiskit.circuit.QuantumRegister(35, "aux_14") - aux_15 = qiskit.circuit.QuantumRegister(35, "aux_15") - aux_16 = qiskit.circuit.QuantumRegister(35, "aux_16") - aux_17 = qiskit.circuit.QuantumRegister(105, "aux_17") - aux_18 = qiskit.circuit.QuantumRegister(3, "aux_18") - aux_19 = qiskit.circuit.QuantumRegister(1, "aux_19") - aux_20 = qiskit.circuit.QuantumRegister(1, "aux_20") - aux_21 = qiskit.circuit.QuantumRegister(1, "aux_21") - aux_22 = qiskit.circuit.QuantumRegister(1, "aux_22") - aux_23 = qiskit.circuit.QuantumRegister(35, "aux_23") - aux_24 = qiskit.circuit.QuantumRegister(35, "aux_24") - aux_25 = qiskit.circuit.QuantumRegister(35, "aux_25") - aux_26 = qiskit.circuit.QuantumRegister(105, "aux_26") - aux_27 = qiskit.circuit.QuantumRegister(1, "aux_27") - aux_28 = qiskit.circuit.QuantumRegister(1, "aux_28") - ctrl_1 = qiskit.circuit.QuantumRegister(7, "ctrl_1") - pred_out_1 = qiskit.circuit.QuantumRegister(7, "pred_out_1") - n_iter_1 = qiskit.circuit.QuantumRegister(7, "n_iter_1") - s_arg_1 = qiskit.circuit.QuantumRegister(21, "s_arg_1") - qc = qiskit.circuit.QuantumCircuit( - ret_2, - s_result_2, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - aux_28, - ctrl_1, - pred_out_1, - n_iter_1, - s_arg_1, - name="UAny_1", - ) - qc.append(qiskit.circuit.Gate("UForInRangeS", qc.num_qubits, []), qc.qubits) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a] (UnOpE {un_op = AnyOp, operand = VarE {var = a}})", 8, [] - ), - [*pred_out_1, *ret_2], - ) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a,f] (BinOpE {bin_op = VecSelectOp, lhs = VarE {var = a}, rhs = VarE {var = f}})", - 31, - [], - ), - [*s_arg_1, *pred_out_1, *s_result_2], - ) - return qc - - -def HasAllOnesRow_U(): - ok = qiskit.circuit.QuantumRegister(1, "ok") - ok_1 = qiskit.circuit.QuantumRegister(1, "ok_1") - s_result_2 = qiskit.circuit.QuantumRegister(3, "s_result_2") - aux_7 = qiskit.circuit.QuantumRegister(1, "aux_7") - aux_8 = qiskit.circuit.QuantumRegister(1, "aux_8") - aux_9 = qiskit.circuit.QuantumRegister(3, "aux_9") - aux_10 = qiskit.circuit.QuantumRegister(1, "aux_10") - aux_11 = qiskit.circuit.QuantumRegister(1, "aux_11") - aux_12 = qiskit.circuit.QuantumRegister(1, "aux_12") - aux_13 = qiskit.circuit.QuantumRegister(1, "aux_13") - aux_14 = qiskit.circuit.QuantumRegister(35, "aux_14") - aux_15 = qiskit.circuit.QuantumRegister(35, "aux_15") - aux_16 = qiskit.circuit.QuantumRegister(35, "aux_16") - aux_17 = qiskit.circuit.QuantumRegister(105, "aux_17") - aux_18 = qiskit.circuit.QuantumRegister(3, "aux_18") - aux_19 = qiskit.circuit.QuantumRegister(1, "aux_19") - aux_20 = qiskit.circuit.QuantumRegister(1, "aux_20") - aux_21 = qiskit.circuit.QuantumRegister(1, "aux_21") - aux_22 = qiskit.circuit.QuantumRegister(1, "aux_22") - aux_23 = qiskit.circuit.QuantumRegister(35, "aux_23") - aux_24 = qiskit.circuit.QuantumRegister(35, "aux_24") - aux_25 = qiskit.circuit.QuantumRegister(35, "aux_25") - aux_26 = qiskit.circuit.QuantumRegister(105, "aux_26") - aux_27 = qiskit.circuit.QuantumRegister(1, "aux_27") - aux_28 = qiskit.circuit.QuantumRegister(1, "aux_28") - ctrl_1 = qiskit.circuit.QuantumRegister(7, "ctrl_1") - pred_out_1 = qiskit.circuit.QuantumRegister(7, "pred_out_1") - n_iter_1 = qiskit.circuit.QuantumRegister(7, "n_iter_1") - s_arg_1 = qiskit.circuit.QuantumRegister(21, "s_arg_1") - aux_prim_9 = qiskit.circuit.QuantumRegister(3, "aux_prim_9") - aux_prim_10 = qiskit.circuit.QuantumRegister(1, "aux_prim_10") - aux_prim_11 = qiskit.circuit.QuantumRegister(1, "aux_prim_11") - aux_prim_12 = qiskit.circuit.QuantumRegister(3, "aux_prim_12") - aux_prim_13 = qiskit.circuit.QuantumRegister(1, "aux_prim_13") - aux_prim_14 = qiskit.circuit.QuantumRegister(1, "aux_prim_14") - aux_prim_15 = qiskit.circuit.QuantumRegister(1, "aux_prim_15") - aux_prim_16 = qiskit.circuit.QuantumRegister(1, "aux_prim_16") - aux_prim_17 = qiskit.circuit.QuantumRegister(35, "aux_prim_17") - aux_prim_18 = qiskit.circuit.QuantumRegister(35, "aux_prim_18") - aux_prim_19 = qiskit.circuit.QuantumRegister(35, "aux_prim_19") - aux_prim_20 = qiskit.circuit.QuantumRegister(105, "aux_prim_20") - aux_prim_21 = qiskit.circuit.QuantumRegister(3, "aux_prim_21") - aux_prim_22 = qiskit.circuit.QuantumRegister(1, "aux_prim_22") - aux_prim_23 = qiskit.circuit.QuantumRegister(1, "aux_prim_23") - aux_prim_24 = qiskit.circuit.QuantumRegister(1, "aux_prim_24") - aux_prim_25 = qiskit.circuit.QuantumRegister(1, "aux_prim_25") - aux_prim_26 = qiskit.circuit.QuantumRegister(35, "aux_prim_26") - aux_prim_27 = qiskit.circuit.QuantumRegister(35, "aux_prim_27") - aux_prim_28 = qiskit.circuit.QuantumRegister(35, "aux_prim_28") - aux_prim_29 = qiskit.circuit.QuantumRegister(105, "aux_prim_29") - aux_prim_30 = qiskit.circuit.QuantumRegister(1, "aux_prim_30") - aux_prim_31 = qiskit.circuit.QuantumRegister(1, "aux_prim_31") - aux_prim_32 = qiskit.circuit.QuantumRegister(7, "aux_prim_32") - aux_prim_33 = qiskit.circuit.QuantumRegister(7, "aux_prim_33") - aux_prim_34 = qiskit.circuit.QuantumRegister(7, "aux_prim_34") - aux_prim_35 = qiskit.circuit.QuantumRegister(21, "aux_prim_35") - qc = qiskit.circuit.QuantumCircuit( - ok, - ok_1, - s_result_2, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - aux_28, - ctrl_1, - pred_out_1, - n_iter_1, - s_arg_1, - aux_prim_9, - aux_prim_10, - aux_prim_11, - aux_prim_12, - aux_prim_13, - aux_prim_14, - aux_prim_15, - aux_prim_16, - aux_prim_17, - aux_prim_18, - aux_prim_19, - aux_prim_20, - aux_prim_21, - aux_prim_22, - aux_prim_23, - aux_prim_24, - aux_prim_25, - aux_prim_26, - aux_prim_27, - aux_prim_28, - aux_prim_29, - aux_prim_30, - aux_prim_31, - aux_prim_32, - aux_prim_33, - aux_prim_34, - aux_prim_35, - name="HasAllOnesRow_U", - ) - qc.append( - UAny_1().to_gate(), - [ - *ok_1, - *aux_prim_9, - *aux_prim_10, - *aux_prim_11, - *aux_prim_12, - *aux_prim_13, - *aux_prim_14, - *aux_prim_15, - *aux_prim_16, - *aux_prim_17, - *aux_prim_18, - *aux_prim_19, - *aux_prim_20, - *aux_prim_21, - *aux_prim_22, - *aux_prim_23, - *aux_prim_24, - *aux_prim_25, - *aux_prim_26, - *aux_prim_27, - *aux_prim_28, - *aux_prim_29, - *aux_prim_30, - *aux_prim_31, - *aux_prim_32, - *aux_prim_33, - *aux_prim_34, - *aux_prim_35, - ], - ) - qc.append(qiskit.circuit.Gate("BasicGateU SWAP", 2, []), [*ok, *ok_1]) - return qc - - -# Grover[...] -def Grover_1(): - k = qiskit.circuit.Parameter("k") - x_1 = qiskit.circuit.QuantumRegister(3, "x_1") - ret_3 = qiskit.circuit.QuantumRegister(1, "ret_3") - aux_29 = qiskit.circuit.QuantumRegister(1, "aux_29") - aux_30 = qiskit.circuit.QuantumRegister(1, "aux_30") - aux_31 = qiskit.circuit.QuantumRegister(3, "aux_31") - aux_32 = qiskit.circuit.QuantumRegister(1, "aux_32") - aux_33 = qiskit.circuit.QuantumRegister(1, "aux_33") - aux_34 = qiskit.circuit.QuantumRegister(1, "aux_34") - aux_35 = qiskit.circuit.QuantumRegister(1, "aux_35") - aux_36 = qiskit.circuit.QuantumRegister(35, "aux_36") - aux_37 = qiskit.circuit.QuantumRegister(35, "aux_37") - aux_38 = qiskit.circuit.QuantumRegister(35, "aux_38") - aux_39 = qiskit.circuit.QuantumRegister(105, "aux_39") - aux_40 = qiskit.circuit.QuantumRegister(3, "aux_40") - aux_41 = qiskit.circuit.QuantumRegister(1, "aux_41") - aux_42 = qiskit.circuit.QuantumRegister(1, "aux_42") - aux_43 = qiskit.circuit.QuantumRegister(1, "aux_43") - aux_44 = qiskit.circuit.QuantumRegister(1, "aux_44") - aux_45 = qiskit.circuit.QuantumRegister(35, "aux_45") - aux_46 = qiskit.circuit.QuantumRegister(35, "aux_46") - aux_47 = qiskit.circuit.QuantumRegister(35, "aux_47") - aux_48 = qiskit.circuit.QuantumRegister(105, "aux_48") - aux_49 = qiskit.circuit.QuantumRegister(1, "aux_49") - qc = qiskit.circuit.QuantumCircuit( - x_1, - ret_3, - aux_29, - aux_30, - aux_31, - aux_32, - aux_33, - aux_34, - aux_35, - aux_36, - aux_37, - aux_38, - aux_39, - aux_40, - aux_41, - aux_42, - aux_43, - aux_44, - aux_45, - aux_46, - aux_47, - aux_48, - aux_49, - name="Grover_1", - ) - qc.append(qiskit.circuit.Gate("BasicGateU XGate", 1, []), [*ret_3]) - qc.append(qiskit.circuit.Gate("BasicGateU HGate", 1, []), [*ret_3]) - qc.append( - qiskit.circuit.Gate("DistrU (UniformE {sample_ty = Fin 6})", 3, []), [*x_1] - ) - qc.append(qiskit.circuit.Gate("URepeatS", qc.num_qubits, []), qc.qubits) - qc.append(qiskit.circuit.Gate("BasicGateU HGate", 1, []), [*ret_3]) - qc.append(qiskit.circuit.Gate("BasicGateU XGate", 1, []), [*ret_3]) - return qc - - -def QAny_1(): - ret_3 = qiskit.circuit.ClassicalRegister(1, "ret_3") - s_result_3 = qiskit.circuit.ClassicalRegister(3, "s_result_3") - not_done_1 = qiskit.circuit.ClassicalRegister(1, "not_done_1") - Q_sum_1 = qiskit.circuit.ClassicalRegister(5, "Q_sum_1") - j_1 = qiskit.circuit.ClassicalRegister(5, "j_1") - j_lim_1 = qiskit.circuit.ClassicalRegister(5, "j_lim_1") - qc = qiskit.circuit.QuantumCircuit( - ret_3, s_result_3, not_done_1, Q_sum_1, j_1, j_lim_1, name="QAny_1" - ) - for _ in range(3): - Q_sum_1 = 0 - for j_lim_1 in [1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]: - j_1 = random.randrange(j_lim_1) - Q_sum_1 = Q_sum_1 + j_1 - not_done_1 = not_done_1 and (Q_sum_1 <= j_lim_1) - if not_done_1: - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - not_done_1 = not_done_1 and ret_3 - else: - pass - return qc - - -def HasAllOnesRow(): - ok = qiskit.circuit.ClassicalRegister(1, "ok") - qc = qiskit.circuit.QuantumCircuit(ok, name="HasAllOnesRow") - qc.append(QAny_1().to_instruction(), [], [*ok]) - return qc diff --git a/examples/matrix_search/matrix_search.py b/examples/matrix_search/matrix_search.py deleted file mode 100644 index 0ebcba1..0000000 --- a/examples/matrix_search/matrix_search.py +++ /dev/null @@ -1,1332 +0,0 @@ -import random -import attrs -import numpy as np - -import qualtran as qlt -import qualtran.bloqs.basic_gates as qlt_gates -import qualtran.bloqs.arithmetic as qlt_arith -from qualtran.bloqs.qft.qft_text_book import QFTTextBook - - -def add_bloq(bb: qlt.BloqBuilder, bloq: qlt.Bloq, regs: list[qlt.SoquetT]): - reg_names = [r.name for r in bloq.signature] - return bb.add(bloq, **dict(zip(reg_names, regs))) - - -@attrs.frozen -class MultiSwap(qlt.Bloq): - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - def __attrs_post_init__(self): - assert len(self.regs) % 2 == 0, "MultiSwap requires an even number of registers" - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - def build_composite_bloq(self, bb, **soqs): - n = len(self.regs) - half = n // 2 - names = [r.name for r in self.regs] - for i in range(half): - a, b = names[i], names[half + i] - soqs[a], soqs[b] = bb.add( - qlt_gates.Swap(self.regs[i].bitsize), x=soqs[a], y=soqs[b] - ) - return soqs - - -@attrs.frozen -class MultiCopy(qlt.Bloq): - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - def __attrs_post_init__(self): - assert len(self.regs) % 2 == 0, "MultiCopy requires an even number of registers" - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - def build_composite_bloq(self, bb, **soqs): - n = len(self.regs) - half = n // 2 - names = [r.name for r in self.regs] - for i in range(half): - a, b = names[i], names[half + i] - soqs[a], soqs[b] = bb.add( - qlt_arith.Xor(self.regs[i].dtype), x=soqs[a], y=soqs[b] - ) - return soqs - - -@attrs.frozen -class PhaseOnZero(qlt.Bloq): - phase: complex - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - -@attrs.frozen -class Toffoli(qlt.Bloq): - """modified Toffoli to have 3 regs""" - - @property - def signature(self): - return qlt.Signature.build(q1=1, q2=1, targ=1) - - def build_composite_bloq(self, bb, q1, q2, targ): - [q1, q2], targ = bb.add(qlt_gates.Toffoli(), ctrl=[q1, q2], target=targ) - return dict(q1=q1, q2=q2, targ=targ) - - -@attrs.frozen -class NamedBloq(qlt.Bloq): - """Generic named high-level bloq""" - - name: str - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - -def bloq_call_and_meas(bloq: qlt.Bloq, *args): - # convert bloq to cirq circuit - # initialize input registers in basis state of args - # run the circuit and measure the first len(args) output registers - # return the measurement outcomes - raise NotImplementedError("bloq_call_and_meas") - - -@attrs.frozen -class Matrix_U(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("q_1", qlt.BQUInt(5, 20)), - qlt.Register("q_2", qlt.BQUInt(4, 10)), - qlt.Register("q_3", qlt.BQUInt(1, 2)), - ] - ) - - -def Matrix(arg_1: int, arg_2: int, arg_3: int): - NotImplementedError("external function - implement here") - - -@attrs.frozen -class IsEntryZero_U(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("i0", qlt.BQUInt(5, 20)), - qlt.Register("j0", qlt.BQUInt(4, 10)), - qlt.Register("e_", qlt.BQUInt(1, 2)), - qlt.Register("e", qlt.BQUInt(1, 2)), - qlt.Register("e_1", qlt.BQUInt(1, 2)), - qlt.Register("e__1", qlt.BQUInt(1, 2)), - ] - ) - - def build_composite_bloq(self, bb: qlt.BloqBuilder, i0, j0, e_, e, e_1, e__1): - i0, j0, e_1 = add_bloq(bb, Matrix_U(), [i0, j0, e_1]) - e, e_1 = add_bloq( - bb, - MultiSwap( - [ - qlt.Register("q_1", qlt.BQUInt(1, 2)), - qlt.Register("q_2", qlt.BQUInt(1, 2)), - ] - ), - [e, e_1], - ) - e, e__1 = add_bloq( - bb, qlt_gates.XGate().controlled(qlt.CtrlSpec(cvs=0)), [e, e__1] - ) - e_, e__1 = add_bloq( - bb, - MultiSwap( - [ - qlt.Register("q_1", qlt.BQUInt(1, 2)), - qlt.Register("q_2", qlt.BQUInt(1, 2)), - ] - ), - [e_, e__1], - ) - return {"i0": i0, "j0": j0, "e_": e_, "e": e, "e_1": e_1, "e__1": e__1} - - -def IsEntryZero(i0: int, j0: int, e_: int): - i0, j0, e = Matrix(i0, j0, e) - e_ = not (e) - return i0, j0, e_ - - -# UAny[Fin 10, 2.6774112591424054e-13] -@attrs.frozen -class UAny(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("i", qlt.BQUInt(5, 20)), - qlt.Register("ret", qlt.BQUInt(1, 2)), - qlt.Register("s_result", qlt.BQUInt(4, 10)), - qlt.Register("aux", qlt.BQUInt(1, 2)), - qlt.Register("aux_1", qlt.BQUInt(1, 2)), - qlt.Register("aux_2", qlt.BQUInt(1, 2)), - qlt.Register("aux_3", qlt.BQUInt(1, 2)), - qlt.Register("ctrl", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("pred_out", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("n_iter", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("s_arg", qlt.BQUInt(4, 10), shape=(59)), - ] - ) - - def build_composite_bloq( - self, - bb: qlt.BloqBuilder, - i, - ret, - s_result, - aux, - aux_1, - aux_2, - aux_3, - ctrl, - pred_out, - n_iter, - s_arg, - ): - for run_ix in range(59): - n_iter[run_ix] = add_bloq(bb, QFTTextBook(2), [n_iter[run_ix]]) - pred_out[run_ix] = add_bloq(bb, qlt_gates.XGate(), [pred_out[run_ix]]) - pred_out[run_ix] = add_bloq(bb, qlt_gates.Hadamard(), [pred_out[run_ix]]) - s_arg[run_ix] = add_bloq(bb, QFTTextBook(4), [s_arg[run_ix]]) - for LIM in range(3): - n_iter[run_ix], ctrl[run_ix] = add_bloq( - bb, - qlt_arith.LessThanConstant(2, (LIM - 1)), - [n_iter[run_ix], ctrl[run_ix]], - ) - i, s_arg[run_ix], aux_3, aux, aux_1, aux_2 = add_bloq( - bb, IsEntryZero_U(), [i, s_arg[run_ix], aux_3, aux, aux_1, aux_2] - ) - ctrl[run_ix], aux_3, pred_out[run_ix] = add_bloq( - bb, Toffoli(), [ctrl[run_ix], aux_3, pred_out[run_ix]] - ) - i, s_arg[run_ix], aux_3, aux, aux_1, aux_2 = add_bloq( - bb, - IsEntryZero_U().adjoint(), - [i, s_arg[run_ix], aux_3, aux, aux_1, aux_2], - ) - s_arg[run_ix] = add_bloq(bb, QFTTextBook(4).adjoint(), [s_arg[run_ix]]) - s_arg[run_ix] = add_bloq( - bb, - PhaseOnZero( - 3.141592653589793, [qlt.Register("q_1", qlt.BQUInt(4, 10))] - ), - [s_arg[run_ix]], - ) - s_arg[run_ix] = add_bloq(bb, QFTTextBook(4), [s_arg[run_ix]]) - n_iter[run_ix], ctrl[run_ix] = add_bloq( - bb, - qlt_arith.LessThanConstant(2, (LIM - 1)), - [n_iter[run_ix], ctrl[run_ix]], - ) - pred_out[run_ix] = add_bloq(bb, qlt_gates.Hadamard(), [pred_out[run_ix]]) - pred_out[run_ix] = add_bloq(bb, qlt_gates.XGate(), [pred_out[run_ix]]) - n_iter[run_ix] = add_bloq(bb, QFTTextBook(2).adjoint(), [n_iter[run_ix]]) - ctrl[run_ix] = add_bloq(bb, qlt_gates.XGate(), [ctrl[run_ix]]) - i, s_arg[run_ix], aux_3, aux, aux_1, aux_2 = add_bloq( - bb, IsEntryZero_U(), [i, s_arg[run_ix], aux_3, aux, aux_1, aux_2] - ) - ctrl[run_ix], aux_3, pred_out[run_ix] = add_bloq( - bb, Toffoli(), [ctrl[run_ix], aux_3, pred_out[run_ix]] - ) - i, s_arg[run_ix], aux_3, aux, aux_1, aux_2 = add_bloq( - bb, - IsEntryZero_U().adjoint(), - [i, s_arg[run_ix], aux_3, aux, aux_1, aux_2], - ) - ctrl[run_ix] = add_bloq(bb, qlt_gates.XGate(), [ctrl[run_ix]]) - pred_out, ret = add_bloq( - bb, - NamedBloq( - "AnyOp", - [ - qlt.Register("x_0", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("x_1", qlt.BQUInt(1, 2)), - ], - ), - [pred_out, ret], - ) - s_arg, pred_out, s_result = add_bloq( - bb, - NamedBloq( - "VecSelectOp", - [ - qlt.Register("x_0", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("x_1", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("x_2", qlt.BQUInt(4, 10)), - ], - ), - [s_arg, pred_out, s_result], - ) - return { - "i": i, - "ret": ret, - "s_result": s_result, - "aux": aux, - "aux_1": aux_1, - "aux_2": aux_2, - "aux_3": aux_3, - "ctrl": ctrl, - "pred_out": pred_out, - "n_iter": n_iter, - "s_arg": s_arg, - } - - -@attrs.frozen -class IsRowAllOnes_U(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("i", qlt.BQUInt(5, 20)), - qlt.Register("okr", qlt.BQUInt(1, 2)), - qlt.Register("hasZero", qlt.BQUInt(1, 2)), - qlt.Register("hasZero_1", qlt.BQUInt(1, 2)), - qlt.Register("s_result", qlt.BQUInt(4, 10)), - qlt.Register("aux", qlt.BQUInt(1, 2)), - qlt.Register("aux_1", qlt.BQUInt(1, 2)), - qlt.Register("aux_2", qlt.BQUInt(1, 2)), - qlt.Register("aux_3", qlt.BQUInt(1, 2)), - qlt.Register("ctrl", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("pred_out", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("n_iter", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("s_arg", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_prim", qlt.BQUInt(4, 10)), - qlt.Register("aux_prim_1", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_2", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_3", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_4", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_5", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_6", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_7", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_prim_8", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("okr_1", qlt.BQUInt(1, 2)), - ] - ) - - def build_composite_bloq( - self, - bb: qlt.BloqBuilder, - i, - okr, - hasZero, - hasZero_1, - s_result, - aux, - aux_1, - aux_2, - aux_3, - ctrl, - pred_out, - n_iter, - s_arg, - aux_prim, - aux_prim_1, - aux_prim_2, - aux_prim_3, - aux_prim_4, - aux_prim_5, - aux_prim_6, - aux_prim_7, - aux_prim_8, - okr_1, - ): - ( - i, - hasZero_1, - aux_prim, - aux_prim_1, - aux_prim_2, - aux_prim_3, - aux_prim_4, - aux_prim_5, - aux_prim_6, - aux_prim_7, - aux_prim_8, - ) = add_bloq( - bb, - UAny(), - [ - i, - hasZero_1, - aux_prim, - aux_prim_1, - aux_prim_2, - aux_prim_3, - aux_prim_4, - aux_prim_5, - aux_prim_6, - aux_prim_7, - aux_prim_8, - ], - ) - hasZero, hasZero_1 = add_bloq( - bb, - MultiSwap( - [ - qlt.Register("q_1", qlt.BQUInt(1, 2)), - qlt.Register("q_2", qlt.BQUInt(1, 2)), - ] - ), - [hasZero, hasZero_1], - ) - hasZero, okr_1 = add_bloq( - bb, qlt_gates.XGate().controlled(qlt.CtrlSpec(cvs=0)), [hasZero, okr_1] - ) - okr, okr_1 = add_bloq( - bb, - MultiSwap( - [ - qlt.Register("q_1", qlt.BQUInt(1, 2)), - qlt.Register("q_2", qlt.BQUInt(1, 2)), - ] - ), - [okr, okr_1], - ) - return { - "i": i, - "okr": okr, - "hasZero": hasZero, - "hasZero_1": hasZero_1, - "s_result": s_result, - "aux": aux, - "aux_1": aux_1, - "aux_2": aux_2, - "aux_3": aux_3, - "ctrl": ctrl, - "pred_out": pred_out, - "n_iter": n_iter, - "s_arg": s_arg, - "aux_prim": aux_prim, - "aux_prim_1": aux_prim_1, - "aux_prim_2": aux_prim_2, - "aux_prim_3": aux_prim_3, - "aux_prim_4": aux_prim_4, - "aux_prim_5": aux_prim_5, - "aux_prim_6": aux_prim_6, - "aux_prim_7": aux_prim_7, - "aux_prim_8": aux_prim_8, - "okr_1": okr_1, - } - - -# Grover[...] -@attrs.frozen -class Grover(qlt.Bloq): - k: int - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("i", qlt.BQUInt(5, 20)), - qlt.Register("x", qlt.BQUInt(4, 10)), - qlt.Register("ret_1", qlt.BQUInt(1, 2)), - qlt.Register("aux_4", qlt.BQUInt(1, 2)), - qlt.Register("aux_5", qlt.BQUInt(1, 2)), - qlt.Register("aux_6", qlt.BQUInt(1, 2)), - ] - ) - - def build_composite_bloq( - self, bb: qlt.BloqBuilder, i, x, ret_1, aux_4, aux_5, aux_6 - ): - ret_1 = add_bloq(bb, qlt_gates.XGate(), [ret_1]) - ret_1 = add_bloq(bb, qlt_gates.Hadamard(), [ret_1]) - x = add_bloq(bb, QFTTextBook(4), [x]) - for _ in range(k): - i, x, ret_1, aux_4, aux_5, aux_6 = add_bloq( - bb, IsEntryZero_U(), [i, x, ret_1, aux_4, aux_5, aux_6] - ) - x = add_bloq(bb, QFTTextBook(4).adjoint(), [x]) - x = add_bloq( - bb, - PhaseOnZero( - 3.141592653589793, [qlt.Register("q_1", qlt.BQUInt(4, 10))] - ), - [x], - ) - x = add_bloq(bb, QFTTextBook(4), [x]) - ret_1 = add_bloq(bb, qlt_gates.Hadamard(), [ret_1]) - ret_1 = add_bloq(bb, qlt_gates.XGate(), [ret_1]) - return { - "i": i, - "x": x, - "ret_1": ret_1, - "aux_4": aux_4, - "aux_5": aux_5, - "aux_6": aux_6, - } - - -def QAny(i: int, ret_1: int): - for _ in range(27): - Q_sum = 0 - for j_lim in [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3]: - j = random.randrange(j_lim) - Q_sum = Q_sum + j - not_done = not_done and (Q_sum <= j_lim) - if not_done: - i, s_result_1, ret_1 = bloq_call_and_meas( - Grover(j), i, s_result_1, ret_1 - ) - i, s_result_1, ret_1 = bloq_call_and_meas( - IsEntryZero_U(), i, s_result_1, ret_1 - ) - not_done = not_done and ret_1 - else: - pass - return i, ret_1 - - -def IsRowAllOnes(i: int, okr: int): - i, hasZero = QAny(i, hasZero) - okr = not (hasZero) - return i, okr - - -# UAny[Fin 20, 5.0e-4] -@attrs.frozen -class UAny_1(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("ret_2", qlt.BQUInt(1, 2)), - qlt.Register("s_result_2", qlt.BQUInt(5, 20)), - qlt.Register("aux_7", qlt.BQUInt(1, 2)), - qlt.Register("aux_8", qlt.BQUInt(1, 2)), - qlt.Register("aux_9", qlt.BQUInt(4, 10)), - qlt.Register("aux_10", qlt.BQUInt(1, 2)), - qlt.Register("aux_11", qlt.BQUInt(1, 2)), - qlt.Register("aux_12", qlt.BQUInt(1, 2)), - qlt.Register("aux_13", qlt.BQUInt(1, 2)), - qlt.Register("aux_14", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_15", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_16", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_17", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_18", qlt.BQUInt(4, 10)), - qlt.Register("aux_19", qlt.BQUInt(1, 2)), - qlt.Register("aux_20", qlt.BQUInt(1, 2)), - qlt.Register("aux_21", qlt.BQUInt(1, 2)), - qlt.Register("aux_22", qlt.BQUInt(1, 2)), - qlt.Register("aux_23", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_24", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_25", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_26", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_27", qlt.BQUInt(1, 2)), - qlt.Register("aux_28", qlt.BQUInt(1, 2)), - qlt.Register("ctrl_1", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("pred_out_1", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("n_iter_1", qlt.BQUInt(2, 4), shape=(16)), - qlt.Register("s_arg_1", qlt.BQUInt(5, 20), shape=(16)), - ] - ) - - def build_composite_bloq( - self, - bb: qlt.BloqBuilder, - ret_2, - s_result_2, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - aux_28, - ctrl_1, - pred_out_1, - n_iter_1, - s_arg_1, - ): - for run_ix in range(16): - n_iter_1[run_ix] = add_bloq(bb, QFTTextBook(2), [n_iter_1[run_ix]]) - pred_out_1[run_ix] = add_bloq(bb, qlt_gates.XGate(), [pred_out_1[run_ix]]) - pred_out_1[run_ix] = add_bloq( - bb, qlt_gates.Hadamard(), [pred_out_1[run_ix]] - ) - s_arg_1[run_ix] = add_bloq(bb, QFTTextBook(5), [s_arg_1[run_ix]]) - for LIM in range(4): - n_iter_1[run_ix], ctrl_1[run_ix] = add_bloq( - bb, - qlt_arith.LessThanConstant(2, (LIM - 1)), - [n_iter_1[run_ix], ctrl_1[run_ix]], - ) - ( - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ) = add_bloq( - bb, - IsRowAllOnes_U(), - [ - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ], - ) - ctrl_1[run_ix], aux_28, pred_out_1[run_ix] = add_bloq( - bb, Toffoli(), [ctrl_1[run_ix], aux_28, pred_out_1[run_ix]] - ) - ( - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ) = add_bloq( - bb, - IsRowAllOnes_U().adjoint(), - [ - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ], - ) - s_arg_1[run_ix] = add_bloq( - bb, QFTTextBook(5).adjoint(), [s_arg_1[run_ix]] - ) - s_arg_1[run_ix] = add_bloq( - bb, - PhaseOnZero( - 3.141592653589793, [qlt.Register("q_1", qlt.BQUInt(5, 20))] - ), - [s_arg_1[run_ix]], - ) - s_arg_1[run_ix] = add_bloq(bb, QFTTextBook(5), [s_arg_1[run_ix]]) - n_iter_1[run_ix], ctrl_1[run_ix] = add_bloq( - bb, - qlt_arith.LessThanConstant(2, (LIM - 1)), - [n_iter_1[run_ix], ctrl_1[run_ix]], - ) - pred_out_1[run_ix] = add_bloq( - bb, qlt_gates.Hadamard(), [pred_out_1[run_ix]] - ) - pred_out_1[run_ix] = add_bloq(bb, qlt_gates.XGate(), [pred_out_1[run_ix]]) - n_iter_1[run_ix] = add_bloq( - bb, QFTTextBook(2).adjoint(), [n_iter_1[run_ix]] - ) - ctrl_1[run_ix] = add_bloq(bb, qlt_gates.XGate(), [ctrl_1[run_ix]]) - ( - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ) = add_bloq( - bb, - IsRowAllOnes_U(), - [ - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ], - ) - ctrl_1[run_ix], aux_28, pred_out_1[run_ix] = add_bloq( - bb, Toffoli(), [ctrl_1[run_ix], aux_28, pred_out_1[run_ix]] - ) - ( - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ) = add_bloq( - bb, - IsRowAllOnes_U().adjoint(), - [ - s_arg_1[run_ix], - aux_28, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - ], - ) - ctrl_1[run_ix] = add_bloq(bb, qlt_gates.XGate(), [ctrl_1[run_ix]]) - pred_out_1, ret_2 = add_bloq( - bb, - NamedBloq( - "AnyOp", - [ - qlt.Register("x_0", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("x_1", qlt.BQUInt(1, 2)), - ], - ), - [pred_out_1, ret_2], - ) - s_arg_1, pred_out_1, s_result_2 = add_bloq( - bb, - NamedBloq( - "VecSelectOp", - [ - qlt.Register("x_0", qlt.BQUInt(5, 20), shape=(16)), - qlt.Register("x_1", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("x_2", qlt.BQUInt(5, 20)), - ], - ), - [s_arg_1, pred_out_1, s_result_2], - ) - return { - "ret_2": ret_2, - "s_result_2": s_result_2, - "aux_7": aux_7, - "aux_8": aux_8, - "aux_9": aux_9, - "aux_10": aux_10, - "aux_11": aux_11, - "aux_12": aux_12, - "aux_13": aux_13, - "aux_14": aux_14, - "aux_15": aux_15, - "aux_16": aux_16, - "aux_17": aux_17, - "aux_18": aux_18, - "aux_19": aux_19, - "aux_20": aux_20, - "aux_21": aux_21, - "aux_22": aux_22, - "aux_23": aux_23, - "aux_24": aux_24, - "aux_25": aux_25, - "aux_26": aux_26, - "aux_27": aux_27, - "aux_28": aux_28, - "ctrl_1": ctrl_1, - "pred_out_1": pred_out_1, - "n_iter_1": n_iter_1, - "s_arg_1": s_arg_1, - } - - -@attrs.frozen -class HasAllOnesRow_U(qlt.Bloq): - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("ok", qlt.BQUInt(1, 2)), - qlt.Register("ok_1", qlt.BQUInt(1, 2)), - qlt.Register("s_result_2", qlt.BQUInt(5, 20)), - qlt.Register("aux_7", qlt.BQUInt(1, 2)), - qlt.Register("aux_8", qlt.BQUInt(1, 2)), - qlt.Register("aux_9", qlt.BQUInt(4, 10)), - qlt.Register("aux_10", qlt.BQUInt(1, 2)), - qlt.Register("aux_11", qlt.BQUInt(1, 2)), - qlt.Register("aux_12", qlt.BQUInt(1, 2)), - qlt.Register("aux_13", qlt.BQUInt(1, 2)), - qlt.Register("aux_14", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_15", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_16", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_17", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_18", qlt.BQUInt(4, 10)), - qlt.Register("aux_19", qlt.BQUInt(1, 2)), - qlt.Register("aux_20", qlt.BQUInt(1, 2)), - qlt.Register("aux_21", qlt.BQUInt(1, 2)), - qlt.Register("aux_22", qlt.BQUInt(1, 2)), - qlt.Register("aux_23", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_24", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_25", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_26", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_27", qlt.BQUInt(1, 2)), - qlt.Register("aux_28", qlt.BQUInt(1, 2)), - qlt.Register("ctrl_1", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("pred_out_1", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("n_iter_1", qlt.BQUInt(2, 4), shape=(16)), - qlt.Register("s_arg_1", qlt.BQUInt(5, 20), shape=(16)), - qlt.Register("aux_prim_9", qlt.BQUInt(5, 20)), - qlt.Register("aux_prim_10", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_11", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_12", qlt.BQUInt(4, 10)), - qlt.Register("aux_prim_13", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_14", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_15", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_16", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_17", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_18", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_19", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_prim_20", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_prim_21", qlt.BQUInt(4, 10)), - qlt.Register("aux_prim_22", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_23", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_24", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_25", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_26", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_27", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_prim_28", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_prim_29", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_prim_30", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_31", qlt.BQUInt(1, 2)), - qlt.Register("aux_prim_32", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("aux_prim_33", qlt.BQUInt(1, 2), shape=(16)), - qlt.Register("aux_prim_34", qlt.BQUInt(2, 4), shape=(16)), - qlt.Register("aux_prim_35", qlt.BQUInt(5, 20), shape=(16)), - ] - ) - - def build_composite_bloq( - self, - bb: qlt.BloqBuilder, - ok, - ok_1, - s_result_2, - aux_7, - aux_8, - aux_9, - aux_10, - aux_11, - aux_12, - aux_13, - aux_14, - aux_15, - aux_16, - aux_17, - aux_18, - aux_19, - aux_20, - aux_21, - aux_22, - aux_23, - aux_24, - aux_25, - aux_26, - aux_27, - aux_28, - ctrl_1, - pred_out_1, - n_iter_1, - s_arg_1, - aux_prim_9, - aux_prim_10, - aux_prim_11, - aux_prim_12, - aux_prim_13, - aux_prim_14, - aux_prim_15, - aux_prim_16, - aux_prim_17, - aux_prim_18, - aux_prim_19, - aux_prim_20, - aux_prim_21, - aux_prim_22, - aux_prim_23, - aux_prim_24, - aux_prim_25, - aux_prim_26, - aux_prim_27, - aux_prim_28, - aux_prim_29, - aux_prim_30, - aux_prim_31, - aux_prim_32, - aux_prim_33, - aux_prim_34, - aux_prim_35, - ): - ( - ok_1, - aux_prim_9, - aux_prim_10, - aux_prim_11, - aux_prim_12, - aux_prim_13, - aux_prim_14, - aux_prim_15, - aux_prim_16, - aux_prim_17, - aux_prim_18, - aux_prim_19, - aux_prim_20, - aux_prim_21, - aux_prim_22, - aux_prim_23, - aux_prim_24, - aux_prim_25, - aux_prim_26, - aux_prim_27, - aux_prim_28, - aux_prim_29, - aux_prim_30, - aux_prim_31, - aux_prim_32, - aux_prim_33, - aux_prim_34, - aux_prim_35, - ) = add_bloq( - bb, - UAny_1(), - [ - ok_1, - aux_prim_9, - aux_prim_10, - aux_prim_11, - aux_prim_12, - aux_prim_13, - aux_prim_14, - aux_prim_15, - aux_prim_16, - aux_prim_17, - aux_prim_18, - aux_prim_19, - aux_prim_20, - aux_prim_21, - aux_prim_22, - aux_prim_23, - aux_prim_24, - aux_prim_25, - aux_prim_26, - aux_prim_27, - aux_prim_28, - aux_prim_29, - aux_prim_30, - aux_prim_31, - aux_prim_32, - aux_prim_33, - aux_prim_34, - aux_prim_35, - ], - ) - ok, ok_1 = add_bloq( - bb, - MultiSwap( - [ - qlt.Register("q_1", qlt.BQUInt(1, 2)), - qlt.Register("q_2", qlt.BQUInt(1, 2)), - ] - ), - [ok, ok_1], - ) - return { - "ok": ok, - "ok_1": ok_1, - "s_result_2": s_result_2, - "aux_7": aux_7, - "aux_8": aux_8, - "aux_9": aux_9, - "aux_10": aux_10, - "aux_11": aux_11, - "aux_12": aux_12, - "aux_13": aux_13, - "aux_14": aux_14, - "aux_15": aux_15, - "aux_16": aux_16, - "aux_17": aux_17, - "aux_18": aux_18, - "aux_19": aux_19, - "aux_20": aux_20, - "aux_21": aux_21, - "aux_22": aux_22, - "aux_23": aux_23, - "aux_24": aux_24, - "aux_25": aux_25, - "aux_26": aux_26, - "aux_27": aux_27, - "aux_28": aux_28, - "ctrl_1": ctrl_1, - "pred_out_1": pred_out_1, - "n_iter_1": n_iter_1, - "s_arg_1": s_arg_1, - "aux_prim_9": aux_prim_9, - "aux_prim_10": aux_prim_10, - "aux_prim_11": aux_prim_11, - "aux_prim_12": aux_prim_12, - "aux_prim_13": aux_prim_13, - "aux_prim_14": aux_prim_14, - "aux_prim_15": aux_prim_15, - "aux_prim_16": aux_prim_16, - "aux_prim_17": aux_prim_17, - "aux_prim_18": aux_prim_18, - "aux_prim_19": aux_prim_19, - "aux_prim_20": aux_prim_20, - "aux_prim_21": aux_prim_21, - "aux_prim_22": aux_prim_22, - "aux_prim_23": aux_prim_23, - "aux_prim_24": aux_prim_24, - "aux_prim_25": aux_prim_25, - "aux_prim_26": aux_prim_26, - "aux_prim_27": aux_prim_27, - "aux_prim_28": aux_prim_28, - "aux_prim_29": aux_prim_29, - "aux_prim_30": aux_prim_30, - "aux_prim_31": aux_prim_31, - "aux_prim_32": aux_prim_32, - "aux_prim_33": aux_prim_33, - "aux_prim_34": aux_prim_34, - "aux_prim_35": aux_prim_35, - } - - -# Grover[...] -@attrs.frozen -class Grover_1(qlt.Bloq): - k: int - - @property - def signature(self): - return qlt.Signature( - [ - qlt.Register("x_1", qlt.BQUInt(5, 20)), - qlt.Register("ret_3", qlt.BQUInt(1, 2)), - qlt.Register("aux_29", qlt.BQUInt(1, 2)), - qlt.Register("aux_30", qlt.BQUInt(1, 2)), - qlt.Register("aux_31", qlt.BQUInt(4, 10)), - qlt.Register("aux_32", qlt.BQUInt(1, 2)), - qlt.Register("aux_33", qlt.BQUInt(1, 2)), - qlt.Register("aux_34", qlt.BQUInt(1, 2)), - qlt.Register("aux_35", qlt.BQUInt(1, 2)), - qlt.Register("aux_36", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_37", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_38", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_39", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_40", qlt.BQUInt(4, 10)), - qlt.Register("aux_41", qlt.BQUInt(1, 2)), - qlt.Register("aux_42", qlt.BQUInt(1, 2)), - qlt.Register("aux_43", qlt.BQUInt(1, 2)), - qlt.Register("aux_44", qlt.BQUInt(1, 2)), - qlt.Register("aux_45", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_46", qlt.BQUInt(1, 2), shape=(59)), - qlt.Register("aux_47", qlt.BQUInt(2, 3), shape=(59)), - qlt.Register("aux_48", qlt.BQUInt(4, 10), shape=(59)), - qlt.Register("aux_49", qlt.BQUInt(1, 2)), - ] - ) - - def build_composite_bloq( - self, - bb: qlt.BloqBuilder, - x_1, - ret_3, - aux_29, - aux_30, - aux_31, - aux_32, - aux_33, - aux_34, - aux_35, - aux_36, - aux_37, - aux_38, - aux_39, - aux_40, - aux_41, - aux_42, - aux_43, - aux_44, - aux_45, - aux_46, - aux_47, - aux_48, - aux_49, - ): - ret_3 = add_bloq(bb, qlt_gates.XGate(), [ret_3]) - ret_3 = add_bloq(bb, qlt_gates.Hadamard(), [ret_3]) - x_1 = add_bloq(bb, QFTTextBook(5), [x_1]) - for _ in range(k): - ( - x_1, - ret_3, - aux_29, - aux_30, - aux_31, - aux_32, - aux_33, - aux_34, - aux_35, - aux_36, - aux_37, - aux_38, - aux_39, - aux_40, - aux_41, - aux_42, - aux_43, - aux_44, - aux_45, - aux_46, - aux_47, - aux_48, - aux_49, - ) = add_bloq( - bb, - IsRowAllOnes_U(), - [ - x_1, - ret_3, - aux_29, - aux_30, - aux_31, - aux_32, - aux_33, - aux_34, - aux_35, - aux_36, - aux_37, - aux_38, - aux_39, - aux_40, - aux_41, - aux_42, - aux_43, - aux_44, - aux_45, - aux_46, - aux_47, - aux_48, - aux_49, - ], - ) - x_1 = add_bloq(bb, QFTTextBook(5).adjoint(), [x_1]) - x_1 = add_bloq( - bb, - PhaseOnZero( - 3.141592653589793, [qlt.Register("q_1", qlt.BQUInt(5, 20))] - ), - [x_1], - ) - x_1 = add_bloq(bb, QFTTextBook(5), [x_1]) - ret_3 = add_bloq(bb, qlt_gates.Hadamard(), [ret_3]) - ret_3 = add_bloq(bb, qlt_gates.XGate(), [ret_3]) - return { - "x_1": x_1, - "ret_3": ret_3, - "aux_29": aux_29, - "aux_30": aux_30, - "aux_31": aux_31, - "aux_32": aux_32, - "aux_33": aux_33, - "aux_34": aux_34, - "aux_35": aux_35, - "aux_36": aux_36, - "aux_37": aux_37, - "aux_38": aux_38, - "aux_39": aux_39, - "aux_40": aux_40, - "aux_41": aux_41, - "aux_42": aux_42, - "aux_43": aux_43, - "aux_44": aux_44, - "aux_45": aux_45, - "aux_46": aux_46, - "aux_47": aux_47, - "aux_48": aux_48, - "aux_49": aux_49, - } - - -def QAny_1(ret_3: int): - for _ in range(7): - Q_sum_1 = 0 - for j_lim_1 in [1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 4, 4]: - j_1 = random.randrange(j_lim_1) - Q_sum_1 = Q_sum_1 + j_1 - not_done_1 = not_done_1 and (Q_sum_1 <= j_lim_1) - if not_done_1: - s_result_3, ret_3 = bloq_call_and_meas(Grover_1(j_1), s_result_3, ret_3) - s_result_3, ret_3 = bloq_call_and_meas( - IsRowAllOnes_U(), s_result_3, ret_3 - ) - not_done_1 = not_done_1 and ret_3 - else: - pass - return ret_3 - - -def HasAllOnesRow(ok: int): - ok = QAny_1(ok) - return ok diff --git a/examples/matrix_search/run.py b/examples/matrix_search/run.py deleted file mode 100644 index df6e84e..0000000 --- a/examples/matrix_search/run.py +++ /dev/null @@ -1,21 +0,0 @@ -def main(): - from matrix_search import HasAllOnesRow_U - bloq = HasAllOnesRow_U() - _, counts = bloq.call_graph() - print(counts) - -def main_qiskit(): - import importlib - mod = importlib.import_module("matrix_search-qiskit") - - # qc = mod.HasAllOnesRow_U() - qc = mod.IsEntryZero() - - # print(qc.draw(output="text")) - print(f"qubits: {qc.num_qubits}, cbits: {qc.num_clbits}") - - qc.draw(output="mpl", filename="matrix_search-qiskit.png") - print("Saved to matrix_search-qiskit.png") - -if __name__ == '__main__': - main_qiskit() diff --git a/examples/primitives/Makefile b/examples/primitives/Makefile index 8ef631a..ff71d4f 100644 --- a/examples/primitives/Makefile +++ b/examples/primitives/Makefile @@ -4,18 +4,8 @@ all: any.qpl max.qpl \ amplify.qpl camplify.qpl \ any_det.qpl any_rand.qpl -full: all any-qiskit.py - %.qpl: %.traq $(PROJ_DEPS) cd ../../ && cabal run traq -- \ -i examples/primitives/$< \ -o examples/primitives/$@ \ -p 0.01 - -%-qiskit.py: %.traq - cd ../../ && cabal run traq -- \ - -i examples/primitives/$< \ - -o examples/primitives/$@ \ - -p 0.01 \ - --target Qiskit - black $@ diff --git a/examples/primitives/any-qiskit.py b/examples/primitives/any-qiskit.py deleted file mode 100644 index 0ee62de..0000000 --- a/examples/primitives/any-qiskit.py +++ /dev/null @@ -1,199 +0,0 @@ -import random -import numpy as np -import qiskit -import qiskit.circuit -from qiskit.circuit import ClassicalRegister, QuantumRegister - - -def Oracle_U(): - q_1 = qiskit.circuit.QuantumRegister(5, "q_1") - q_2 = qiskit.circuit.QuantumRegister(1, "q_2") - qc = qiskit.circuit.QuantumCircuit(q_1, q_2, name="Oracle_U") - return qc - - -def Oracle(): - c_1 = qiskit.circuit.ClassicalRegister(5, "c_1") - c_2 = qiskit.circuit.ClassicalRegister(1, "c_2") - qc = qiskit.circuit.QuantumCircuit(c_1, c_2, name="Oracle") - return qc - - -def UAny(): - ret = qiskit.circuit.QuantumRegister(1, "ret") - s_result = qiskit.circuit.QuantumRegister(5, "s_result") - aux = qiskit.circuit.QuantumRegister(1, "aux") - ctrl = qiskit.circuit.QuantumRegister(10, "ctrl") - pred_out = qiskit.circuit.QuantumRegister(10, "pred_out") - n_iter = qiskit.circuit.QuantumRegister(20, "n_iter") - s_arg = qiskit.circuit.QuantumRegister(50, "s_arg") - - qc = qiskit.circuit.QuantumCircuit( - ret, s_result, aux, ctrl, pred_out, n_iter, s_arg, name="UAny" - ) - - qc.append(qiskit.circuit.Gate("UForInRangeS", qc.num_qubits, []), qc.qubits) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a] (UnOpE {un_op = AnyOp, operand = VarE {var = a}})", 11, [] - ), - [*pred_out, *ret], - ) - qc.append( - qiskit.circuit.Gate( - "RevEmbedU [a,f] (BinOpE {bin_op = VecSelectOp, lhs = VarE {var = a}, rhs = VarE {var = f}})", - 65, - [], - ), - [*s_arg, *pred_out, *s_result], - ) - - return qc - - -def main_U(): - ok = qiskit.circuit.QuantumRegister(1, "ok") - ok_1 = qiskit.circuit.QuantumRegister(1, "ok_1") - s_result = qiskit.circuit.QuantumRegister(5, "s_result") - aux = qiskit.circuit.QuantumRegister(1, "aux") - ctrl = qiskit.circuit.QuantumRegister(10, "ctrl") - pred_out = qiskit.circuit.QuantumRegister(10, "pred_out") - n_iter = qiskit.circuit.QuantumRegister(20, "n_iter") - s_arg = qiskit.circuit.QuantumRegister(50, "s_arg") - aux_prim = qiskit.circuit.QuantumRegister(5, "aux_prim") - aux_prim_1 = qiskit.circuit.QuantumRegister(1, "aux_prim_1") - aux_prim_2 = qiskit.circuit.QuantumRegister(10, "aux_prim_2") - aux_prim_3 = qiskit.circuit.QuantumRegister(10, "aux_prim_3") - aux_prim_4 = qiskit.circuit.QuantumRegister(20, "aux_prim_4") - aux_prim_5 = qiskit.circuit.QuantumRegister(50, "aux_prim_5") - - qc = qiskit.circuit.QuantumCircuit( - ok, - ok_1, - s_result, - aux, - ctrl, - pred_out, - n_iter, - s_arg, - aux_prim, - aux_prim_1, - aux_prim_2, - aux_prim_3, - aux_prim_4, - aux_prim_5, - name="main_U", - ) - - qc.append( - UAny().to_gate(), - [ - *ok_1, - *aux_prim, - *aux_prim_1, - *aux_prim_2, - *aux_prim_3, - *aux_prim_4, - *aux_prim_5, - ], - ) - qc.append(qiskit.circuit.library.SwapGate(), [*ok, *ok_1]) - - return qc - - -def Grover(): - k = qiskit.circuit.Parameter("k") - x = qiskit.circuit.QuantumRegister(5, "x") - ret_1 = qiskit.circuit.QuantumRegister(1, "ret_1") - - qc = qiskit.circuit.QuantumCircuit(x, ret_1, name="Grover") - - qc.append(qiskit.circuit.library.XGate(), [*ret_1]) - qc.append(qiskit.circuit.library.HGate(), [*ret_1]) - qc.append( - qiskit.circuit.Gate("DistrU (UniformE {sample_ty = Fin 20})", 5, []), [*x] - ) - with qc.for_loop(range(k)): - qc.append(Oracle_U().to_gate(), [*x, *ret_1]) - qc.append( - qiskit.circuit.Gate( - "DistrU (UniformE {sample_ty = Fin 20})", 5, [] - ).inverse(), - [*x], - ) - qc.append(qiskit.circuit.Gate("PhaseOnZero(3.141592653589793)", 5, []), [*x]) - qc.append( - qiskit.circuit.Gate("DistrU (UniformE {sample_ty = Fin 20})", 5, []), [*x] - ) - qc.append(qiskit.circuit.library.HGate(), [*ret_1]) - qc.append(qiskit.circuit.library.XGate(), [*ret_1]) - - return qc - - -def QAny(): - ret_1 = qiskit.circuit.ClassicalRegister(1, "ret_1") - s_result_1 = qiskit.circuit.ClassicalRegister(5, "s_result_1") - not_done = qiskit.circuit.ClassicalRegister(1, "not_done") - Q_sum = qiskit.circuit.ClassicalRegister(6, "Q_sum") - j = qiskit.circuit.ClassicalRegister(6, "j") - j_lim = qiskit.circuit.ClassicalRegister(6, "j_lim") - qc = qiskit.circuit.QuantumCircuit( - ret_1, s_result_1, not_done, Q_sum, j, j_lim, name="QAny" - ) - for _ in range(5): - Q_sum = 0 - for j_lim in [1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 4, 4, 4, 4]: - j = random.randrange(j_lim) - Q_sum = Q_sum + j - not_done = not_done and (Q_sum <= j_lim) - if not_done: - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - qc.append( - qiskit.circuit.Gate("UProcAndMeas", qc.num_qubits, []), qc.qubits - ) - not_done = not_done and ret_1 - else: - pass - return qc - - -def main(): - ok = qiskit.circuit.ClassicalRegister(1, "ok") - qc = qiskit.circuit.QuantumCircuit(ok, name="main") - qc.append(QAny().to_instruction(), [], [*ok]) - return qc - - -EXTERN_DEFS = () -ENTRY_POINT = "main" - - -def cli(): - import argparse - - parser = argparse.ArgumentParser() - parser.add_argument( - "--draw", type=str, metavar="FILE", help="Render the main circuit to a PDF file" - ) - parser.add_argument( - "--qasm", action="store_true", help="Output OpenQASM 3 for the main circuit" - ) - args = parser.parse_args() - - qc = main() - - if args.draw: - qc.draw("mpl", filename=args.draw) - - if args.qasm: - from qiskit.qasm3 import dumps - - print(dumps(qc)) - - -if __name__ == "__main__": - cli() diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 8feeb31..0000000 --- a/requirements.txt +++ /dev/null @@ -1,5 +0,0 @@ -cirq==1.6.1 -qualtran==0.7.0 -qiskit==2.3.0 -qiskit-aer==0.17.2 -black==26.1.0 diff --git a/src/Traq/Experimental/Compiler/Python.hs b/src/Traq/Experimental/Compiler/Python.hs deleted file mode 100644 index fbf286a..0000000 --- a/src/Traq/Experimental/Compiler/Python.hs +++ /dev/null @@ -1,187 +0,0 @@ -{-# LANGUAGE DuplicateRecordFields #-} -{-# LANGUAGE TypeApplications #-} - -{- HLINT ignore "Use camelCase" -} - -module Traq.Experimental.Compiler.Python ( - Py, - withEnv, - py_indent, - py_sanitizeIdent, - py_typedArg, - py_comment, - py_pass, - py_ifte, - py_return, - py_raise_s, - py_notImplemented, - py_def, - py_class, - py_decorator, - py_property, - py_metaParam, - py_arg, - py_expr, - py_val, - py_defaultVal, - py_unOp, - py_binOp, - py_naryOp, - py_tupled, - toPyType, -) where - -import Prettyprinter ((<+>)) -import qualified Prettyprinter as PP -import Text.Printf (printf) - -import Lens.Micro.GHC - -import Traq.Control.Monad - -import qualified Traq.CPL as CPL -import Traq.Prelude -import qualified Traq.QPL as QPL - --- ============================================================ --- Helpers for building python syntax --- ============================================================ - -type Py ann = PP.Doc ann - -py_indent :: Py ann -> Py ann -py_indent = PP.indent tabwidth - where - tabwidth :: Int - tabwidth = 4 - --- ------------------------------------------------------------ --- variables and types --- ------------------------------------------------------------ -py_sanitizeIdent :: Ident -> Py ann -py_sanitizeIdent s = PP.pretty $ map conv s - where - conv '\'' = '_' - conv c = c - -py_typedArg :: String -> Py ann -> Py ann -py_typedArg x t = py_sanitizeIdent x <+> PP.colon <+> t - --- ------------------------------------------------------------ --- statements --- ------------------------------------------------------------ - -py_comment :: String -> Py ann -py_comment c = PP.vsep $ lines c <&> \l -> PP.pretty $ "# " <> l - -py_pass :: Py ann -py_pass = PP.pretty "pass" - --- | Python tuple literal, handling the singleton case with a trailing comma. -py_tupled :: [Py ann] -> Py ann -py_tupled [x] = PP.parens (x <> PP.comma) -py_tupled xs = PP.tupled xs - -py_ifte :: String -> Py ann -> Py ann -> Py ann -py_ifte b s_t s_f = - PP.vsep - [ PP.pretty $ "if (" <> b <> "):" - , py_indent s_t - , PP.pretty "else:" - , py_indent s_f - ] - -py_return :: [Py ann] -> Py ann -py_return args = PP.pretty "return" <+> PP.hsep (PP.punctuate PP.comma args) - -py_raise_s :: String -> Py ann -py_raise_s e = PP.pretty @String $ printf "raise Exception('%s')" e - -py_notImplemented :: String -> Py ann -py_notImplemented msg = PP.pretty "NotImplementedError" <> PP.parens (PP.dquotes $ PP.pretty msg) - -py_def :: Ident -> [Py ann] -> Py ann -> Py ann -py_def name params body = - PP.vsep - [ PP.pretty "def" <+> PP.pretty name <> PP.tupled params <> PP.pretty ":" - , py_indent body - ] - -py_class :: Ident -> Ident -> Py ann -> Py ann -py_class name parent body = - PP.vsep - [ PP.pretty "class" <+> PP.pretty name <> PP.parens (PP.pretty parent) <> PP.colon - , py_indent body - ] - -py_decorator :: String -> Py ann -py_decorator s = PP.pretty $ "@" <> s - -py_property :: Ident -> Py ann -> Py ann -py_property name body = - PP.vsep - [ py_decorator "property" - , py_def name [PP.pretty "self"] body - ] - -py_metaParam :: (Show size) => Either (CPL.MetaParam size) Ident -> Py ann -py_metaParam (Left (CPL.MetaName n)) = py_sanitizeIdent n -py_metaParam (Left (CPL.MetaSize s)) = PP.pretty (show s) -py_metaParam (Right name) = py_sanitizeIdent name - -py_arg :: (Show size) => QPL.Arg size -> Py ann -py_arg (QPL.Arg x) = py_sanitizeIdent x -py_arg (QPL.ArrElemArg a i) = py_arg a <> PP.brackets (py_metaParam (Left i)) - --- | Emit a python expression -py_expr :: (Show size) => CPL.BasicExpr size -> Py ann -py_expr CPL.VarE{var} = py_sanitizeIdent var -py_expr CPL.ParamE{param} = py_sanitizeIdent param -py_expr CPL.DefaultE{ty} = py_defaultVal ty -py_expr CPL.ConstE{val} = py_val val -py_expr CPL.UnOpE{un_op, operand} = py_unOp un_op <> PP.parens (py_expr operand) -py_expr CPL.BinOpE{bin_op, lhs, rhs} = PP.parens $ py_expr lhs <+> py_binOp bin_op <+> py_expr rhs -py_expr CPL.TernaryE{branch, lhs, rhs} = PP.parens $ py_expr lhs <+> PP.pretty "if" <+> py_expr branch <+> PP.pretty "else" <+> py_expr rhs -py_expr CPL.NAryE{op, operands} = py_naryOp op <> PP.tupled (map py_expr operands) -py_expr CPL.IndexE{arr_expr, ix_val} = py_expr arr_expr <> PP.brackets (PP.pretty (show ix_val)) -py_expr CPL.DynIndexE{arr_expr, ix_expr} = py_expr arr_expr <> PP.brackets (py_expr ix_expr) -py_expr CPL.UpdateArrE{} = error "TODO UpdateArrE" -py_expr CPL.ProjectE{tup_expr, tup_ix_val} = py_expr tup_expr <> PP.brackets (PP.pretty (show tup_ix_val)) - -py_val :: (Show size) => CPL.Value size -> Py ann -py_val (CPL.FinV n) = PP.pretty (show n) -py_val (CPL.ArrV vs) = PP.list (map py_val vs) -py_val (CPL.TupV vs) = PP.tupled (map py_val vs) - -py_defaultVal :: (Show size) => CPL.VarType size -> Py ann -py_defaultVal (CPL.Fin _) = PP.pretty "0" -py_defaultVal (CPL.Bitvec _) = PP.pretty "0" -py_defaultVal (CPL.Arr n t) = PP.brackets (py_defaultVal t) <+> PP.pretty "*" <+> PP.pretty (show n) -py_defaultVal (CPL.Tup ts) = PP.tupled (map py_defaultVal ts) - -py_unOp :: CPL.UnOp -> Py ann -py_unOp CPL.NotOp = PP.pretty "not " - -py_binOp :: CPL.BinOp -> Py ann -py_binOp CPL.AddOp = PP.pretty "+" -py_binOp CPL.MulOp = PP.pretty "*" -py_binOp CPL.SubOp = PP.pretty "-" -py_binOp CPL.XorOp = PP.pretty "^" -py_binOp CPL.LEqOp = PP.pretty "<=" -py_binOp CPL.LtOp = PP.pretty "<" -py_binOp CPL.AndOp = PP.pretty "and" -py_binOp CPL.EqOp = PP.pretty "==" -py_binOp CPL.VecSelectOp = error "TODO VecSelectOp" - -py_naryOp :: CPL.NAryOp -> Py ann -py_naryOp CPL.MultiOrOp = PP.pretty "any" - --- ------------------------------------------------------------ --- Classical python types --- ------------------------------------------------------------ - -toPyType :: CPL.VarType size -> Py ann -toPyType (CPL.Fin _) = PP.pretty "int" -toPyType (CPL.Bitvec _) = PP.pretty "int" -toPyType (CPL.Tup ts) = PP.pretty "tuple" <+> PP.brackets (PP.tupled (map toPyType ts)) -toPyType (CPL.Arr _ t) = PP.pretty "list" <+> PP.brackets (toPyType t) diff --git a/src/Traq/Experimental/Compiler/Qiskit.hs b/src/Traq/Experimental/Compiler/Qiskit.hs deleted file mode 100644 index 3ecf33d..0000000 --- a/src/Traq/Experimental/Compiler/Qiskit.hs +++ /dev/null @@ -1,407 +0,0 @@ -{-# LANGUAGE DuplicateRecordFields #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE RecordWildCards #-} - -{- HLINT ignore "Use camelCase" -} - -module Traq.Experimental.Compiler.Qiskit ( - toPy, -) where - -import Control.Monad.Except (runExceptT) -import Control.Monad.RWS (RWS, runRWS) -import Data.List (intersperse) -import qualified Data.Set as Set -import Prettyprinter ((<+>)) -import qualified Prettyprinter as PP - -import Lens.Micro.GHC -import Lens.Micro.Mtl - -import qualified Traq.Data.Context as Ctx -import Traq.Data.Default - -import qualified Traq.CPL as CPL -import Traq.Experimental.Compiler.Python -import Traq.Prelude -import qualified Traq.QPL as QPL - --- ============================================================ --- Compile QPL -> py (+Qiskit) --- ============================================================ - -newtype QiskitState = QiskitState (Set.Set Ident) - deriving (HasDefault) - -_externDefNames :: Lens' QiskitState (Set.Set Ident) -_externDefNames focus (QiskitState s) = focus s <&> QiskitState - --- | Build python code string. -class ToQiskitPy a where - type Ctx a - - mkPy :: a -> RWS (Ctx a) () QiskitState (Py ann) - --- | Convert a QPL program to a python code string. -toPy :: QPL.Program SizeT -> String -toPy prog = - let (pyDoc, _, _) = runRWS (mkPy prog) () default_ - in show pyDoc - --- ============================================================ --- Basic Instances --- ============================================================ - -instance (Show size, Integral size) => ToQiskitPy (QPL.Program size) where - type Ctx (QPL.Program size) = () - - mkPy (QPL.Program ps) = do - code <- PP.vsep . intersperse PP.line <$> mapM mkPy ps - exts <- py_tupled . map (PP.dquotes . PP.pretty) . Set.toList <$> use _externDefNames - pure $ - PP.vsep - [ code - , PP.pretty "EXTERN_DEFS" <+> PP.equals <+> exts - , PP.pretty "ENTRY_POINT" <+> PP.equals <+> (PP.dquotes . PP.pretty . QPL.proc_name $ last ps) - ] - -instance (Show size, Integral size) => ToQiskitPy (QPL.ProcDef size) where - type Ctx (QPL.ProcDef size) = () - - mkPy QPL.ProcDef{proc_name, proc_meta_params, proc_param_types, proc_body} = - PP.vsep - <$> sequence - [ withEnv - (ProcBuildCtx{..}) - (mkPy proc_body) - ] - -data ProcBuildCtx size = ProcBuildCtx - { proc_name :: Ident - , proc_meta_params :: [Ident] - , proc_param_types :: [CPL.VarType size] - } - deriving (Read, Show, Eq) - -instance (Show size, Integral size) => ToQiskitPy (QPL.ProcBody size) where - type Ctx (QPL.ProcBody size) = ProcBuildCtx size - - mkPy (QPL.ProcBodyU ubody) = mkPy ubody - mkPy (QPL.ProcBodyC cbody) = mkPy cbody - --- ============================================================ --- Qiskit helpers --- ============================================================ - --- | Emit a black-box gate spanning all qubits. TODO: implement properly. -blackbox :: String -> Py ann -blackbox name = - PP.pretty "qc.append" - <> PP.tupled - [ PP.pretty "qiskit.circuit.Gate" <> PP.tupled [PP.dquotes (PP.pretty name), PP.pretty "qc.num_qubits", PP.pretty "[]"] - , PP.pretty "qc.qubits" - ] - --- | Emit a custom named gate with a given qubit count. -customGate :: (Show size) => String -> size -> Py ann -customGate name n = - PP.pretty "qiskit.circuit.Gate" - <> PP.tupled [PP.dquotes (PP.pretty name), PP.pretty (show n), PP.pretty "[]"] - --- | Emit a Qiskit library gate constructor. -libGate :: String -> Py ann -libGate name = PP.pretty $ "qiskit.circuit.library." <> name <> "()" - --- | Emit a parameterized Qiskit library gate constructor. -libGateParam :: String -> String -> Py ann -libGateParam name param = PP.pretty $ "qiskit.circuit.library." <> name <> "(" <> param <> ")" - -{- | Generate qubit reference for a QPL argument with type-aware slicing. -For whole registers: *reg -For array elements: *reg[start:end] (slice for the element's qubit range) --} -py_qarg :: (Show size, Integral size) => QPL.Arg size -> CPL.VarType size -> Py ann -py_qarg (QPL.Arg x) _ = PP.pretty "*" <> py_sanitizeIdent x -py_qarg (QPL.ArrElemArg (QPL.Arg x) (CPL.MetaSize i)) elemTy = - let s = CPL.bestBitsize elemTy - start = fromIntegral i * fromIntegral s :: Integer - end = (fromIntegral i + 1) * fromIntegral s :: Integer - in PP.pretty "*" <> py_sanitizeIdent x <> PP.brackets (PP.pretty (show start) <> PP.colon <> PP.pretty (show end)) -py_qarg (QPL.ArrElemArg (QPL.Arg x) (CPL.MetaName n)) elemTy = - let s = CPL.bestBitsize elemTy - in if s == 1 - then PP.pretty "*" <> py_sanitizeIdent x <> PP.brackets (py_sanitizeIdent n <> PP.colon <> py_sanitizeIdent n <+> PP.pretty "+" <+> PP.pretty "1") - else - PP.pretty "*" - <> py_sanitizeIdent x - <> PP.brackets - ( py_sanitizeIdent n - <+> PP.pretty "*" - <+> PP.pretty (show s) - <> PP.colon - <> PP.parens (py_sanitizeIdent n <+> PP.pretty "+" <+> PP.pretty "1") - <+> PP.pretty "*" - <+> PP.pretty (show s) - ) -py_qarg arg _ = PP.pretty "*" <> py_arg arg - --- ============================================================ --- Unitary: Emit Qiskit unitary circuits --- ============================================================ - -instance (Show size, Integral size) => ToQiskitPy (QPL.UProcBody size) where - type Ctx (QPL.UProcBody size) = ProcBuildCtx size - - mkPy QPL.UProcDecl = do - ProcBuildCtx{..} <- view id - let uproc_param_names = ["q_" <> show i | i <- [1 .. length proc_param_types]] - let param_defs = - [ py_sanitizeIdent p - <+> PP.equals - <+> PP.pretty "qiskit.circuit.Parameter" - <> PP.parens (PP.dquotes (py_sanitizeIdent p)) - | p <- proc_meta_params - ] - let reg_defs = - [ py_sanitizeIdent n - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumRegister" - <> PP.tupled [PP.pretty (show $ CPL.bestBitsize ty), PP.dquotes (py_sanitizeIdent n)] - | (n, ty) <- zip uproc_param_names proc_param_types - ] - let reg_names = map py_sanitizeIdent uproc_param_names - let qc_def = - PP.pretty "qc" - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumCircuit" - <> PP.tupled (reg_names ++ [PP.pretty "name=" <> PP.dquotes (py_sanitizeIdent proc_name)]) - let body = - PP.vsep $ - param_defs - ++ reg_defs - ++ [ qc_def - , PP.pretty "return qc" - ] - pure $ py_def proc_name [] body - mkPy QPL.UProcBody{uproc_param_names, uproc_body_stmt} = do - ProcBuildCtx{..} <- view id - let param_defs = - [ py_sanitizeIdent p - <+> PP.equals - <+> PP.pretty "qiskit.circuit.Parameter" - <> PP.parens (PP.dquotes (py_sanitizeIdent p)) - | p <- proc_meta_params - ] - let reg_defs = - [ py_sanitizeIdent n - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumRegister" - <> PP.tupled [PP.pretty (show $ CPL.bestBitsize ty), PP.dquotes (py_sanitizeIdent n)] - | (n, ty) <- zip uproc_param_names proc_param_types - ] - let reg_names = map py_sanitizeIdent uproc_param_names - let qc_def = - PP.pretty "qc" - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumCircuit" - <> PP.tupled (reg_names ++ [PP.pretty "name=" <> PP.dquotes (py_sanitizeIdent proc_name)]) - let typCtx = Ctx.fromList (zip uproc_param_names proc_param_types) - stmt_body <- withEnv typCtx $ mkPy uproc_body_stmt - let body = - PP.vsep $ - param_defs - ++ reg_defs - ++ [ mempty - , qc_def - , mempty - , stmt_body - , mempty - , PP.pretty "return qc" - ] - pure $ py_def proc_name [] body - -instance (Show size, Integral size) => ToQiskitPy (QPL.UStmt size) where - type Ctx (QPL.UStmt size) = CPL.TypingCtx size - - mkPy QPL.USkipS = pure mempty - mkPy (QPL.UCommentS s) = pure $ py_comment s - mkPy QPL.UnitaryS{qargs, unitary} = do - tys <- fmap (either (error . show) id) . runExceptT $ do - mapM QPL.getArgTy qargs - gateExpr <- withEnv tys $ mkPy unitary - let qubits = PP.hsep $ PP.punctuate PP.comma $ zipWith py_qarg qargs tys - pure $ PP.pretty "qc.append" <> PP.tupled [gateExpr, PP.brackets qubits] - mkPy QPL.UCallS{uproc_id, dagger, qargs} = do - let gate = py_sanitizeIdent uproc_id <> PP.pretty "().to_gate()" - let gateExpr = if dagger then gate <> PP.pretty ".inverse()" else gate - let qubits = PP.hsep $ PP.punctuate PP.comma [PP.pretty "*" <> py_arg q | q <- qargs] - pure $ PP.pretty "qc.append" <> PP.tupled [gateExpr, PP.brackets qubits] - mkPy (QPL.USeqS ss) = PP.vsep <$> mapM mkPy ss - mkPy QPL.URepeatS{n_iter, uloop_body} = do - body <- mkPy uloop_body - let n = py_metaParam (Left n_iter) - pure $ - PP.vsep - [ PP.pretty "with qc.for_loop" <> PP.parens (PP.pretty "range" <> PP.parens n) <> PP.colon - , py_indent body - ] - mkPy QPL.UForInRangeS{} = pure $ blackbox "UForInRangeS" - mkPy QPL.UForInDomainS{} = pure $ blackbox "UForInDomainS" - mkPy QPL.UWithComputedS{} = pure $ blackbox "UWithComputedS" - -instance (Show size, Integral size) => ToQiskitPy (QPL.Unitary Double size) where - type Ctx (QPL.Unitary Double size) = [CPL.VarType size] - - mkPy (QPL.BasicGateU g) = mkPy g - mkPy (QPL.DistrU d) = do - tys <- view id - let n = sum $ map CPL.bestBitsize tys - let name = filter (\c -> c /= '"' && c /= '\\') $ show d - pure $ customGate ("DistrU (" ++ name ++ ")") n - mkPy (QPL.Controlled u) = do - inner <- mkPy u - pure $ inner <> PP.pretty ".control(1)" - mkPy (QPL.Adjoint u) = do - inner <- mkPy u - pure $ inner <> PP.pretty ".inverse()" - mkPy (QPL.RevEmbedU xs e) = do - tys <- view id - let n = sum $ map CPL.bestBitsize tys - let name = filter (\c -> c /= '"' && c /= '\\') $ show (QPL.RevEmbedU xs e :: QPL.Unitary Double size) - pure $ customGate name n - mkPy (QPL.NamedGateU name) = do - tys <- view id - let n = sum $ map CPL.bestBitsize tys - pure $ customGate name n - -instance (Show size, Integral size) => ToQiskitPy (QPL.BasicGate size) where - type Ctx (QPL.BasicGate size) = [CPL.VarType size] - - mkPy QPL.XGate = pure $ libGate "XGate" - mkPy QPL.HGate = pure $ libGate "HGate" - mkPy QPL.ZGate = pure $ libGate "ZGate" - mkPy QPL.CNOT = pure $ libGate "CXGate" - mkPy QPL.Toffoli = pure $ libGate "CCXGate" - mkPy QPL.SWAP = pure $ libGate "SwapGate" - mkPy QPL.COPY = pure $ libGate "CXGate" - mkPy (QPL.Rz theta) = pure $ libGateParam "RZGate" (show theta) - mkPy (QPL.PhaseOnZero theta) = do - tys <- view id - let n = sum $ map CPL.bestBitsize tys - pure $ customGate ("PhaseOnZero(" ++ show theta ++ ")") n - mkPy QPL.Unif = error "TODO Unif" - --- ============================================================ --- Classical: Emit Qiskit circuits with control-flow --- ============================================================ - -instance (Show size, Integral size) => ToQiskitPy (QPL.CProcBody size) where - type Ctx (QPL.CProcBody size) = ProcBuildCtx size - - -- external - mkPy QPL.CProcDecl = do - ProcBuildCtx{..} <- view id - let cproc_param_names = ["c_" <> show i | i <- [1 .. length proc_param_types]] - let param_defs = - [ py_sanitizeIdent p - <+> PP.equals - <+> PP.pretty "qiskit.circuit.Parameter" - <> PP.parens (PP.dquotes (py_sanitizeIdent p)) - | p <- proc_meta_params - ] - let reg_defs = - [ py_sanitizeIdent n - <+> PP.equals - <+> PP.pretty "qiskit.circuit.ClassicalRegister" - <> PP.tupled [PP.pretty (show $ CPL.bestBitsize ty), PP.dquotes (py_sanitizeIdent n)] - | (n, ty) <- zip cproc_param_names proc_param_types - ] - let reg_names = map py_sanitizeIdent cproc_param_names - let qc_def = - PP.pretty "qc" - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumCircuit" - <> PP.tupled (reg_names ++ [PP.pretty "name=" <> PP.dquotes (py_sanitizeIdent proc_name)]) - let body = - PP.vsep $ - param_defs - ++ reg_defs - ++ [ qc_def - , PP.pretty "return qc" - ] - pure $ py_def proc_name [] body - - -- defined - mkPy QPL.CProcBody{cproc_param_names, cproc_local_vars, cproc_body_stmt} = do - ProcBuildCtx{..} <- view id - let param_defs = - [ py_sanitizeIdent p - <+> PP.equals - <+> PP.pretty "qiskit.circuit.Parameter" - <> PP.parens (PP.dquotes (py_sanitizeIdent p)) - | p <- proc_meta_params - ] - let all_vars = zip cproc_param_names proc_param_types ++ cproc_local_vars - let reg_defs = - [ py_sanitizeIdent n - <+> PP.equals - <+> PP.pretty "qiskit.circuit.ClassicalRegister" - <> PP.tupled [PP.pretty (show $ CPL.bestBitsize ty), PP.dquotes (py_sanitizeIdent n)] - | (n, ty) <- all_vars - ] - let reg_names = map (py_sanitizeIdent . fst) all_vars - let qc_def = - PP.pretty "qc" - <+> PP.equals - <+> PP.pretty "qiskit.circuit.QuantumCircuit" - <> PP.tupled (reg_names ++ [PP.pretty "name=" <> PP.dquotes (py_sanitizeIdent proc_name)]) - stmt_body <- withEnv () $ mkPy cproc_body_stmt - let body = - PP.vsep $ - param_defs - ++ reg_defs - ++ [ qc_def - , stmt_body - , PP.pretty "return qc" - ] - pure $ py_def proc_name [] body - -instance (Show size) => ToQiskitPy (QPL.Stmt size) where - type Ctx (QPL.Stmt size) = () - - mkPy QPL.SkipS = pure py_pass - mkPy (QPL.CommentS s) = pure $ py_comment s - mkPy QPL.AssignS{rets, expr} = do - let lhs = PP.hsep $ PP.punctuate PP.comma (map py_sanitizeIdent rets) - pure $ lhs <+> PP.equals <+> py_expr expr - mkPy QPL.RandomS{} = pure $ blackbox "RandomS" - mkPy QPL.RandomDynS{ret, max_var} = - pure $ PP.pretty ret <+> PP.equals <+> PP.pretty "random.randrange" <> PP.parens (PP.pretty max_var) - mkPy QPL.CallS{fun = QPL.FunctionCall proc_id, args} = do - let instr = py_sanitizeIdent proc_id <> PP.pretty "().to_instruction()" - let cbits = PP.hsep $ PP.punctuate PP.comma [PP.pretty "*" <> py_arg q | q <- args] - pure $ PP.pretty "qc.append" <> PP.tupled [instr, PP.pretty "[]", PP.brackets cbits] - mkPy QPL.CallS{fun = QPL.UProcAndMeas{}} = pure $ blackbox "UProcAndMeas" - mkPy (QPL.SeqS ss) = PP.vsep <$> mapM mkPy ss - mkPy QPL.IfThenElseS{cond, s_true, s_false} = py_ifte cond <$> mkPy s_true <*> mkPy s_false - mkPy QPL.RepeatS{n_iter, loop_body} = do - body <- mkPy loop_body - let n = py_metaParam (Left n_iter) - pure $ - PP.vsep - [ PP.pretty "for _ in range" <> PP.parens n <> PP.colon - , py_indent body - ] - mkPy QPL.WhileK{} = pure $ blackbox "WhileK" - mkPy QPL.WhileKWithCondExpr{} = pure $ blackbox "WhileKWithCondExpr" - mkPy QPL.ForInArray{loop_index, loop_values, loop_body} = do - body <- mkPy loop_body - let vals = PP.list (map py_expr loop_values) - pure $ - PP.vsep - [ PP.pretty "for" <+> PP.pretty loop_index <+> PP.pretty "in" <+> vals <> PP.colon - , py_indent body - ] - mkPy QPL.ForInRangeS{} = pure $ blackbox "ForInRangeS" - mkPy QPL.BlackBoxS{} = pure $ blackbox "BlackBoxS" diff --git a/src/Traq/Experimental/Compiler/Qualtran.hs b/src/Traq/Experimental/Compiler/Qualtran.hs deleted file mode 100644 index 3497b80..0000000 --- a/src/Traq/Experimental/Compiler/Qualtran.hs +++ /dev/null @@ -1,383 +0,0 @@ -{-# LANGUAGE DuplicateRecordFields #-} -{-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE TypeApplications #-} - -{- HLINT ignore "Use camelCase" -} - -module Traq.Experimental.Compiler.Qualtran ( - toPy, -) where - -import Control.Monad.Except (runExceptT) -import Control.Monad.Reader (Reader, runReader) -import Data.List (intersperse) -import Prettyprinter ((<+>)) -import qualified Prettyprinter as PP -import Text.Printf (printf) - -import Lens.Micro.Mtl - -import qualified Traq.Data.Context as Ctx - -import qualified Traq.CPL as CPL -import Traq.Experimental.Compiler.Python -import Traq.Prelude -import qualified Traq.QPL as QPL - --- ============================================================ --- Compile QPL -> py (+Qualtran) --- ============================================================ - --- | Build python code string. -class ToQualtranPy a where - type Ctx a - - mkPy :: a -> Reader (Ctx a) (Py ann) - --- | Convert a QPL program to a python code string. -toPy :: QPL.Program SizeT -> String -toPy prog = - let pyDoc = runReader (mkPy prog) () - in show pyDoc - --- ============================================================ --- Qualtran helpers --- ============================================================ - -bitsize :: (Integral a) => a -> a -bitsize n - | n <= 1 = 1 - | otherwise = ceiling $ logBase (2 :: Double) (fromIntegral n) - --- | Map a VarType to a Qualtran QDType expression -toQltDType :: (Show size, Integral size) => CPL.VarType size -> Py ann -toQltDType (CPL.Fin n) = - PP.pretty "qlt.BQUInt" <> PP.tupled [PP.pretty (show $ bitsize n), PP.pretty (show n)] -toQltDType (CPL.Bitvec n) = PP.pretty "qlt.QAny" <> PP.parens (PP.pretty (show n)) -toQltDType (CPL.Tup _) = error "TODO toQltDType Tup" -toQltDType (CPL.Arr _ t) = toQltDType t -- base dtype; shape handled in py_register - --- | Build shape tuple for a VarType (only Arr adds dimensions) -toQltShape :: (Show size) => CPL.VarType size -> [Py ann] -toQltShape (CPL.Arr n t) = PP.pretty (show n) : toQltShape t -toQltShape _ = [] - --- | Build a qlt.Register(...) expression -py_register :: (Show size, Integral size) => Ident -> CPL.VarType size -> Py ann -py_register name ty = - let dtype = toQltDType ty - shape = toQltShape ty - shapeArg = case shape of - [] -> [] - _ -> [PP.pretty "shape=" <> PP.tupled shape] - in PP.pretty "qlt.Register" <> PP.tupled ([PP.dquotes (py_sanitizeIdent name), dtype] ++ shapeArg) - --- ============================================================ --- Basic Instances --- ============================================================ - -instance (Show size, Integral size) => ToQualtranPy (QPL.Program size) where - type Ctx (QPL.Program size) = () - - mkPy (QPL.Program ps) = - PP.vsep . intersperse PP.line <$> mapM mkPy ps - -instance (Show size, Integral size) => ToQualtranPy (QPL.ProcDef size) where - type Ctx (QPL.ProcDef size) = () - - mkPy QPL.ProcDef{proc_name, proc_meta_params, proc_param_types, proc_body} = - PP.vsep - <$> sequence - [ withEnv - (ProcBuildCtx{..}) - (mkPy proc_body) - ] - -data ProcBuildCtx size = ProcBuildCtx - { proc_name :: Ident - , proc_meta_params :: [Ident] - , proc_param_types :: [CPL.VarType size] - } - deriving (Read, Show, Eq) - -instance (Show size, Integral size) => ToQualtranPy (QPL.ProcBody size) where - type Ctx (QPL.ProcBody size) = ProcBuildCtx size - - mkPy (QPL.ProcBodyU ubody) = mkPy ubody - mkPy (QPL.ProcBodyC cbody) = mkPy cbody - --- ============================================================ --- Unitary: Emit Qualtran Bloqs --- ============================================================ - -instance (Show size, Integral size) => ToQualtranPy (QPL.UProcBody size) where - type Ctx (QPL.UProcBody size) = ProcBuildCtx size - - mkPy QPL.UProcDecl = do - ProcBuildCtx{..} <- view id - let meta_attrs = map (\p -> py_sanitizeIdent p <> PP.pretty ": int") proc_meta_params - let regs = zipWith py_register uproc_param_names proc_param_types - where - uproc_param_names = ["q_" <> show i | i <- [1 .. length proc_param_types]] - let sig_body = PP.pretty "return qlt.Signature" <> PP.parens (PP.list regs) - let class_body = - PP.vsep $ - intersperse - PP.line - [ PP.vsep meta_attrs - , py_property "signature" sig_body - ] - pure $ - PP.vsep - [ py_decorator "attrs.frozen" - , py_class proc_name "qlt.Bloq" class_body - ] - mkPy QPL.UProcBody{uproc_param_names, uproc_body_stmt} = do - ProcBuildCtx{..} <- view id - let meta_attrs = map (\p -> py_sanitizeIdent p <> PP.pretty ": int") proc_meta_params - let regs = zipWith py_register uproc_param_names proc_param_types - let sig_body = PP.pretty "return qlt.Signature" <> PP.parens (PP.list regs) - - let typCtx = Ctx.fromList (zip uproc_param_names proc_param_types) - stmt_body <- withEnv typCtx $ mkPy uproc_body_stmt - let bcb_params = PP.pretty "self" : PP.pretty "bb: qlt.BloqBuilder" : map py_sanitizeIdent uproc_param_names - let bcb_body = - PP.vsep - [ stmt_body - , PP.pretty "return" - <+> PP.braces - ( PP.hsep $ - PP.punctuate - PP.comma - [ PP.dquotes (py_sanitizeIdent n) <> PP.colon <+> py_sanitizeIdent n - | n <- uproc_param_names - ] - ) - ] - - let class_body = - PP.vsep $ - intersperse - PP.line - [ PP.vsep meta_attrs - , py_property "signature" sig_body - , py_def "build_composite_bloq" bcb_params bcb_body - ] - pure $ - PP.vsep - [ py_decorator "attrs.frozen" - , py_class proc_name "qlt.Bloq" class_body - ] - -instance (Show size, Integral size) => ToQualtranPy (QPL.UStmt size) where - type Ctx (QPL.UStmt size) = CPL.TypingCtx size - - mkPy QPL.USkipS = pure mempty - mkPy (QPL.UCommentS s) = pure $ py_comment s - mkPy QPL.UnitaryS{qargs, unitary} = do - tys <- fmap (either (error . show) id) . runExceptT $ do - mapM QPL.getArgTy qargs - bloqExpr <- withEnv tys $ mkPy unitary - let argVals = PP.list [py_arg q | q <- qargs] - let lhs = PP.hsep $ PP.punctuate PP.comma [py_arg q | q <- qargs] - pure $ lhs <+> PP.equals <+> PP.pretty "add_bloq" <> PP.tupled [PP.pretty "bb", bloqExpr, argVals] - mkPy QPL.UCallS{uproc_id, dagger, qargs} = do - let bloq = py_sanitizeIdent uproc_id <> PP.pretty "()" - let bloqExpr = if dagger then bloq <> PP.pretty ".adjoint()" else bloq - let argVals = PP.list [py_arg q | q <- qargs] - let lhs = PP.hsep $ PP.punctuate PP.comma [py_arg q | q <- qargs] - pure $ lhs <+> PP.equals <+> PP.pretty "add_bloq" <> PP.tupled [PP.pretty "bb", bloqExpr, argVals] - -- compound statements - mkPy (QPL.USeqS ss) = PP.vsep <$> mapM mkPy ss - mkPy QPL.URepeatS{n_iter, uloop_body} = do - body <- mkPy uloop_body - let n = py_metaParam (Left n_iter) - pure $ - PP.vsep - [ PP.pretty "for _ in range" <> PP.parens n <> PP.colon - , py_indent body - ] - mkPy QPL.UForInRangeS{iter_meta_var, iter_lim, dagger, uloop_body} = do - body <- mkPy (if dagger then QPL.adjoint uloop_body else uloop_body) - let n = py_metaParam (Left iter_lim) - let range_expr = - if dagger - then PP.pretty "reversed(range" <> PP.parens n <> PP.pretty ")" - else PP.pretty "range" <> PP.parens n - pure $ - PP.vsep - [ PP.pretty "for" <+> py_sanitizeIdent iter_meta_var <+> PP.pretty "in" <+> range_expr <> PP.colon - , py_indent body - ] - mkPy QPL.UForInDomainS{} = pure $ py_notImplemented "TODO UForInDomainS" - mkPy QPL.UWithComputedS{with_ustmt, body_ustmt} = do - mkPy with_ustmt - mkPy body_ustmt - mkPy (QPL.adjoint with_ustmt) - -instance (Show size, Integral size, RealFloat prec) => ToQualtranPy (QPL.Unitary prec size) where - type Ctx (QPL.Unitary prec size) = [CPL.VarType size] - - mkPy (QPL.BasicGateU g) = mkPy g - mkPy (QPL.DistrU (CPL.UniformE ty)) = do - let bs = CPL.bestBitsize ty - pure $ PP.pretty "QFTTextBook" <> PP.tupled [PP.pretty (show bs)] - mkPy (QPL.DistrU (CPL.BernoulliE p)) = do - let theta = PP.pretty @String $ printf "%f" (realToFrac @_ @Double $ 2 * asin (sqrt p)) - pure $ PP.pretty "qlt_gates.Ry" <> PP.tupled [PP.pretty "angle=" <> theta] - mkPy (QPL.Controlled u) = do - bloq <- mkPy u - pure $ bloq <> PP.pretty ".controlled()" - mkPy (QPL.Adjoint u) = do - bloq <- mkPy u - pure $ bloq <> PP.pretty ".adjoint()" - - -- embed classical gates as unitaries - mkPy (QPL.RevEmbedU xs e) = do - tys <- view id - let ctx = Ctx.fromList $ zip xs tys - withEnv ctx $ exprToBloq e - mkPy (QPL.NamedGateU name) = pure $ PP.pretty name <> PP.pretty "()" - -namedBloq :: (Show size, Integral size) => Ident -> [CPL.VarType size] -> Py ann -namedBloq b ts = - PP.pretty "NamedBloq" - <> PP.tupled - [ PP.dquotes $ PP.pretty b - , PP.list [py_register ("x_" <> show i) t | (t, i) <- zip ts [0 :: Int ..]] - ] - -exprToBloq :: (Show size, Integral size) => CPL.BasicExpr size -> Reader (CPL.TypingCtx size) (Py ann) -exprToBloq CPL.VarE{var} = do - ty <- Ctx.unsafeLookupE var - pure $ PP.pretty "qlt_arith.Xor" <> PP.tupled [toQltDType ty] -exprToBloq CPL.UnOpE{un_op = CPL.NotOp, operand = CPL.VarE{}} = do - pure $ PP.pretty "qlt_gates.XGate().controlled(qlt.CtrlSpec(cvs=0))" -exprToBloq CPL.BinOpE{bin_op = CPL.LEqOp, lhs = CPL.VarE{var}, rhs = CPL.ParamE{param}} = do - ty <- Ctx.unsafeLookupE var - let v = py_sanitizeIdent param - pure $ - PP.pretty "qlt_arith.LessThanConstant" - <> PP.tupled - [ PP.pretty $ show $ CPL.bestBitsize ty - , PP.parens (v <> PP.pretty " - 1") - ] -exprToBloq CPL.BinOpE{bin_op = CPL.VecSelectOp, lhs = CPL.VarE{var = x}, rhs = CPL.VarE{var = y}} = do - tx <- Ctx.unsafeLookupE x - let etx = case tx of - CPL.Arr _ t -> t - CPL.Bitvec _ -> CPL.tbool - _ -> error "invalid type" - ty <- Ctx.unsafeLookupE y - pure $ namedBloq "VecSelectOp" [tx, ty, etx] -exprToBloq e = error $ "TODO Unitary embedding: " <> show e - -instance (Show size, Integral size) => ToQualtranPy (QPL.BasicGate size) where - type Ctx (QPL.BasicGate size) = [CPL.VarType size] - - -- simple gates - mkPy QPL.Toffoli = pure $ PP.pretty "Toffoli()" - mkPy QPL.CNOT = pure $ PP.pretty "qlt_gates.CNOT()" - mkPy QPL.XGate = pure $ PP.pretty "qlt_gates.XGate()" - mkPy QPL.HGate = pure $ PP.pretty "qlt_gates.Hadamard()" - mkPy QPL.ZGate = pure $ PP.pretty "qlt_gates.ZGate()" - mkPy (QPL.Rz theta) = pure $ PP.pretty @String $ printf "qlt_gates.Rz(%f)" theta - -- generic gates - mkPy QPL.COPY = do - tys <- view id - let n = length tys - let regs = zipWith py_register ["q_" <> show i | i <- [1 .. n]] tys - pure $ PP.pretty "MultiCopy" <> PP.parens (PP.list regs) - mkPy QPL.SWAP = do - tys <- view id - let n = length tys - let regs = zipWith py_register ["q_" <> show i | i <- [1 .. n]] tys - pure $ PP.pretty "MultiSwap" <> PP.parens (PP.list regs) - mkPy (QPL.PhaseOnZero theta) = do - tys <- view id - let n = length tys - let regs = zipWith py_register ["q_" <> show i | i <- [1 .. n]] tys - pure $ PP.pretty "PhaseOnZero" <> PP.tupled [PP.pretty theta, PP.list regs] - mkPy QPL.Unif = error "TODO Unif" - --- ============================================================ --- Classical: Emit native python --- ============================================================ - -instance (Show size) => ToQualtranPy (QPL.CProcBody size) where - type Ctx (QPL.CProcBody size) = ProcBuildCtx size - - -- external - mkPy QPL.CProcDecl = do - ProcBuildCtx{..} <- view id - let n_args = length proc_param_types - let cproc_param_names = ["arg_" <> show i | i <- [1 .. n_args]] - let tys = map toPyType proc_param_types - - let typed_args = map py_sanitizeIdent proc_meta_params ++ zipWith py_typedArg cproc_param_names tys - pure $ - py_def proc_name typed_args $ - py_notImplemented "external function - implement here" - - -- defined - mkPy QPL.CProcBody{cproc_param_names, cproc_body_stmt} = do - ProcBuildCtx{..} <- view id - let tys = map toPyType proc_param_types - - let untyped_args = map py_sanitizeIdent (proc_meta_params ++ cproc_param_names) - let typed_args = map py_sanitizeIdent proc_meta_params ++ zipWith py_typedArg cproc_param_names tys - - py_def proc_name typed_args . PP.vsep <$> do - body <- withEnv () $ mkPy cproc_body_stmt - return - [ body - , py_return untyped_args - ] - -instance (Show size) => ToQualtranPy (QPL.Stmt size) where - type Ctx (QPL.Stmt size) = () - - mkPy QPL.SkipS = pure py_pass - mkPy (QPL.CommentS s) = pure $ py_comment s - mkPy QPL.AssignS{rets, expr} = do - let lhs = PP.hsep $ PP.punctuate PP.comma (map py_sanitizeIdent rets) - pure $ lhs <+> PP.equals <+> py_expr expr - mkPy QPL.RandomS{} = error "TODO RandomS" - mkPy QPL.RandomDynS{ret, max_var} = - pure $ PP.pretty ret <+> PP.equals <+> PP.pretty "random.randrange" <> PP.parens (PP.pretty max_var) - mkPy QPL.CallS{fun = QPL.FunctionCall proc_id, meta_params, args} = do - let fname = py_sanitizeIdent proc_id - let py_mps = map py_metaParam meta_params - let py_args = map py_arg args - let all_args = py_mps ++ py_args - let arg_vars = map py_arg args - let lhs = PP.hsep $ PP.punctuate PP.comma arg_vars - pure $ lhs <+> PP.equals <+> fname <> PP.tupled all_args - mkPy QPL.CallS{fun = QPL.UProcAndMeas proc_id, meta_params, args} = do - let py_mps = map py_metaParam meta_params - let bloq = py_sanitizeIdent proc_id <> PP.tupled py_mps - let py_args = map py_arg args - let lhs = PP.hsep $ PP.punctuate PP.comma py_args - pure $ lhs <+> PP.equals <+> PP.pretty "bloq_call_and_meas" <> PP.tupled (bloq : py_args) - mkPy (QPL.SeqS ss) = PP.vsep <$> mapM mkPy ss - mkPy QPL.IfThenElseS{cond, s_true, s_false} = py_ifte cond <$> mkPy s_true <*> mkPy s_false - mkPy QPL.RepeatS{n_iter, loop_body} = do - body <- mkPy loop_body - let n = py_metaParam (Left n_iter) - pure $ - PP.vsep - [ PP.pretty "for _ in range" <> PP.parens n <> PP.colon - , py_indent body - ] - mkPy QPL.WhileK{} = error "TODO WhileK" - mkPy QPL.WhileKWithCondExpr{} = error "TODO WhileKWithCondExpr" - mkPy QPL.ForInArray{loop_index, loop_values, loop_body} = do - body <- mkPy loop_body - let vals = PP.list (map py_expr loop_values) - pure $ - PP.vsep - [ PP.pretty "for" <+> PP.pretty loop_index <+> PP.pretty "in" <+> vals <> PP.colon - , py_indent body - ] - mkPy QPL.ForInRangeS{} = error "TODO ForInRangeS" - mkPy QPL.BlackBoxS{} = error "TODO BlackBoxS" diff --git a/test/Traq/Examples/BasicSpec.hs b/test/Traq/Examples/BasicSpec.hs index 8984e9e..491a2df 100644 --- a/test/Traq/Examples/BasicSpec.hs +++ b/test/Traq/Examples/BasicSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.BasicSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import Traq.CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import qualified Traq.QPL as QPL import qualified Traq.Utils.Printing as PP @@ -67,13 +63,3 @@ spec = do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/ClusteringAlgorithmSpec.hs b/test/Traq/Examples/ClusteringAlgorithmSpec.hs index 8d38d10..74b9044 100644 --- a/test/Traq/Examples/ClusteringAlgorithmSpec.hs +++ b/test/Traq/Examples/ClusteringAlgorithmSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.ClusteringAlgorithmSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives (DefaultPrims) import qualified Traq.QPL as QPL @@ -73,13 +69,3 @@ spec = describe "Clustering Algorithm" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/DepthThreeNandFormulaSpec.hs b/test/Traq/Examples/DepthThreeNandFormulaSpec.hs index a9e46c9..5295432 100644 --- a/test/Traq/Examples/DepthThreeNandFormulaSpec.hs +++ b/test/Traq/Examples/DepthThreeNandFormulaSpec.hs @@ -4,8 +4,6 @@ module Traq.Examples.DepthThreeNandFormulaSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -16,8 +14,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives (DefaultPrims) import qualified Traq.QPL as QPL @@ -67,13 +63,3 @@ spec = describe "Depth 3 NAND Formula" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/EvenMansourSpec.hs b/test/Traq/Examples/EvenMansourSpec.hs index d7cb4a1..4711672 100644 --- a/test/Traq/Examples/EvenMansourSpec.hs +++ b/test/Traq/Examples/EvenMansourSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.EvenMansourSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (..)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives.Class import Traq.Primitives.Simons.Quantum @@ -105,13 +101,3 @@ spec = describe "FindXorPeriod" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/GroverMeetsSimonSpec.hs b/test/Traq/Examples/GroverMeetsSimonSpec.hs index 3b19b7e..b8403ac 100644 --- a/test/Traq/Examples/GroverMeetsSimonSpec.hs +++ b/test/Traq/Examples/GroverMeetsSimonSpec.hs @@ -4,8 +4,6 @@ module Traq.Examples.GroverMeetsSimonSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -16,8 +14,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives import qualified Traq.QPL as QPL @@ -75,13 +71,3 @@ spec = describe "Grover Meets Simon" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/MatrixSearchSpec.hs b/test/Traq/Examples/MatrixSearchSpec.hs index 5b9046b..916699e 100644 --- a/test/Traq/Examples/MatrixSearchSpec.hs +++ b/test/Traq/Examples/MatrixSearchSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.MatrixSearchSpec (spec) where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import qualified Data.Map as Map import qualified Traq.Data.Symbolic as Sym @@ -13,8 +11,6 @@ import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler import Traq.Examples.MatrixSearch -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Primitives (Primitive (..)) import Traq.Primitives.Search.Prelude import Traq.Primitives.Search.QSearchCFNW (_EQSearchWorst, _QSearchZalka) @@ -114,16 +110,6 @@ spec = describe "MatrixSearch" $ do let cost_from_analysis = getCost $ A.costQProg ex' getCost cost `shouldBeLE` cost_from_analysis - xit "target-py-qualtran" $ \ex' -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex' - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex' -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex' - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () - describe "symbolic" $ do let n = Sym.var "n" :: Sym.Sym Int let m = Sym.var "m" :: Sym.Sym Int diff --git a/test/Traq/Examples/NonDetSpec.hs b/test/Traq/Examples/NonDetSpec.hs index c007386..747740e 100644 --- a/test/Traq/Examples/NonDetSpec.hs +++ b/test/Traq/Examples/NonDetSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.NonDetSpec (spec) where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Data.Either (fromRight, isRight) import qualified Data.Map as Map import Text.Parsec.String (parseFromFile) @@ -17,8 +15,6 @@ import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.CPL.Parser as CPLParser import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives (DefaultPrims) import qualified Traq.QPL as QPL @@ -101,13 +97,3 @@ spec = do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/PeriodFindingSpec.hs b/test/Traq/Examples/PeriodFindingSpec.hs index 26a5ebf..313470d 100644 --- a/test/Traq/Examples/PeriodFindingSpec.hs +++ b/test/Traq/Examples/PeriodFindingSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.PeriodFindingSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (..)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives.Class import Traq.Primitives.Simons.Quantum @@ -105,13 +101,3 @@ spec = describe "FindXorPeriod" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/SearchSpec.hs b/test/Traq/Examples/SearchSpec.hs index fcedcb6..54049a8 100644 --- a/test/Traq/Examples/SearchSpec.hs +++ b/test/Traq/Examples/SearchSpec.hs @@ -3,8 +3,6 @@ module Traq.Examples.SearchSpec (spec) where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import qualified Data.Map as Map import Text.Parsec.String (parseFromFile) @@ -17,8 +15,6 @@ import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (..)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler import Traq.Examples.Search -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives import Traq.Primitives.Search.QSearchCFNW (_EQSearch, _QSearchZalka) @@ -108,16 +104,6 @@ spec = describe "SearchSpec" $ do let cost_from_analysis = getCost $ A.costQProg ex' getCost cost `shouldBeLE` cost_from_analysis - xit "target-py-qualtran" $ \ex' -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex' - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex' -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex' - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () - describe "arraySearch (returning solution)" $ do let n = 10 let ex = arraySearchIx n @@ -134,18 +120,3 @@ spec = describe "SearchSpec" $ do let res = CPL.runProgram @_ @Double ex interpCtx [] res `shouldBeDistribution` [([CPL.FinV 1, CPL.FinV i], 1 / 3) | i <- planted_sols] - - describe "any" $ do - let load = - parseFromFile (CPL.programParser @(DefaultPrims (Sym.Sym SizeT) (Sym.Sym Double))) "examples/primitives/any.traq" - >>= expectRight - <&> CPL.mapSize Sym.unSym - <&> CPL.mapPrec Sym.unSym - <&> A.annotateProgWith (CPL._exts (A.annSinglePrim (A.failProb 0.01))) - >>= expectRight - - beforeAll load $ do - xit "target-qiskit" $ \ex -> do - ex_qpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_qpl - return () diff --git a/test/Traq/Examples/SteepMaxKSatSpec.hs b/test/Traq/Examples/SteepMaxKSatSpec.hs index dd06fa0..3b0180f 100644 --- a/test/Traq/Examples/SteepMaxKSatSpec.hs +++ b/test/Traq/Examples/SteepMaxKSatSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.SteepMaxKSatSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives import qualified Traq.QPL as QPL @@ -75,13 +71,3 @@ spec = describe "Steep max-k-sat" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/ThreeRoundFeistelAttackSpec.hs b/test/Traq/Examples/ThreeRoundFeistelAttackSpec.hs index 697131b..c7abff2 100644 --- a/test/Traq/Examples/ThreeRoundFeistelAttackSpec.hs +++ b/test/Traq/Examples/ThreeRoundFeistelAttackSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.ThreeRoundFeistelAttackSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives import qualified Traq.QPL as QPL @@ -76,13 +72,3 @@ spec = describe "3 round feistel attack" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/TreeGeneratorSpec.hs b/test/Traq/Examples/TreeGeneratorSpec.hs index 2629528..425109a 100644 --- a/test/Traq/Examples/TreeGeneratorSpec.hs +++ b/test/Traq/Examples/TreeGeneratorSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.TreeGeneratorSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import qualified Data.Map as Map import Text.Parsec.String @@ -16,8 +14,6 @@ import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import Traq.CPL import qualified Traq.Compiler as Compiler import Traq.Examples.TreeGenerator -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives import qualified Traq.QPL as QPL @@ -110,13 +106,3 @@ spec = do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test/Traq/Examples/TriangleCycleSpec.hs b/test/Traq/Examples/TriangleCycleSpec.hs index b7ee3b0..33dbba5 100644 --- a/test/Traq/Examples/TriangleCycleSpec.hs +++ b/test/Traq/Examples/TriangleCycleSpec.hs @@ -2,8 +2,6 @@ module Traq.Examples.TriangleCycleSpec where -import Control.DeepSeq (force) -import Control.Exception (evaluate) import Text.Parsec.String import Lens.Micro.GHC @@ -14,8 +12,6 @@ import qualified Traq.Analysis as A import Traq.Analysis.CostModel.QueryCost (SimpleQueryCost (getCost)) import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import Traq.Primitives (DefaultPrims) import qualified Traq.QPL as QPL @@ -73,13 +69,3 @@ spec = describe "Triangle Cycle Finding" $ do let cost = fst (QPL.programCost ex_cqpl) :: SimpleQueryCost Double let cost_from_analysis = getCost $ A.costQProg ex getCost cost `shouldBeLE` cost_from_analysis - - xit "target-py-qualtran" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qualtran.toPy ex_cqpl - return () - - xit "target-py-qiskit" $ \ex -> do - ex_cqpl <- expectRight $ Compiler.lowerProgram ex - _ <- evaluate $ force $ Qiskit.toPy ex_cqpl - return () diff --git a/test_qiskit.png b/test_qiskit.png deleted file mode 100644 index b2edcf6..0000000 Binary files a/test_qiskit.png and /dev/null differ diff --git a/tools/qiskit_prelude.py b/tools/qiskit_prelude.py deleted file mode 100644 index 32c112d..0000000 --- a/tools/qiskit_prelude.py +++ /dev/null @@ -1,30 +0,0 @@ -import random -import numpy as np -import qiskit -import qiskit.circuit -from qiskit.circuit import ClassicalRegister, QuantumRegister - -# ===CODE-HERE=== - - -def cli(): - import argparse - - parser = argparse.ArgumentParser() - parser.add_argument("--draw", type=str, metavar="FILE", help="Render the main circuit to a PDF file") - parser.add_argument("--qasm", action="store_true", help="Output OpenQASM 3 for the main circuit") - args = parser.parse_args() - - qc = main() - - if args.draw: - qc.draw("mpl", filename=args.draw) - - if args.qasm: - from qiskit.qasm3 import dumps - - print(dumps(qc)) - - -if __name__ == "__main__": - cli() diff --git a/tools/qualtran_prelude.py b/tools/qualtran_prelude.py deleted file mode 100644 index cce08e8..0000000 --- a/tools/qualtran_prelude.py +++ /dev/null @@ -1,103 +0,0 @@ -import random -import attrs -import numpy as np - -import qualtran as qlt -import qualtran.bloqs.basic_gates as qlt_gates -import qualtran.bloqs.arithmetic as qlt_arith -from qualtran.bloqs.qft.qft_text_book import QFTTextBook - - - -def add_bloq(bb: qlt.BloqBuilder, bloq: qlt.Bloq, regs: list[qlt.SoquetT]): - reg_names = [r.name for r in bloq.signature] - return bb.add(bloq, **dict(zip(reg_names, regs))) - - -@attrs.frozen -class MultiSwap(qlt.Bloq): - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - def __attrs_post_init__(self): - assert len(self.regs) % 2 == 0, "MultiSwap requires an even number of registers" - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - def build_composite_bloq(self, bb, **soqs): - n = len(self.regs) - half = n // 2 - names = [r.name for r in self.regs] - for i in range(half): - a, b = names[i], names[half + i] - soqs[a], soqs[b] = bb.add( - qlt_gates.Swap(self.regs[i].bitsize), x=soqs[a], y=soqs[b] - ) - return soqs - - -@attrs.frozen -class MultiCopy(qlt.Bloq): - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - def __attrs_post_init__(self): - assert len(self.regs) % 2 == 0, "MultiCopy requires an even number of registers" - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - def build_composite_bloq(self, bb, **soqs): - n = len(self.regs) - half = n // 2 - names = [r.name for r in self.regs] - for i in range(half): - a, b = names[i], names[half + i] - soqs[a], soqs[b] = bb.add( - qlt_arith.Xor(self.regs[i].dtype), x=soqs[a], y=soqs[b] - ) - return soqs - -@attrs.frozen -class PhaseOnZero(qlt.Bloq): - phase: complex - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - -@attrs.frozen -class Toffoli(qlt.Bloq): - """modified Toffoli to have 3 regs""" - - @property - def signature(self): - return qlt.Signature.build(q1=1, q2=1, targ=1) - - def build_composite_bloq(self, bb, q1, q2, targ): - [q1, q2], targ = bb.add(qlt_gates.Toffoli(), ctrl=[q1, q2], target=targ) - return dict(q1=q1, q2=q2, targ=targ) - - -@attrs.frozen -class NamedBloq(qlt.Bloq): - """Generic named high-level bloq""" - name: str - regs: tuple[qlt.Register, ...] = attrs.field(converter=tuple) - - @property - def signature(self): - return qlt.Signature(list(self.regs)) - - - -def bloq_call_and_meas(bloq: qlt.Bloq, *args): - # convert bloq to cirq circuit - # initialize input registers in basis state of args - # run the circuit and measure the first len(args) output registers - # return the measurement outcomes - raise NotImplementedError("bloq_call_and_meas") - -# ===CODE-HERE=== diff --git a/tools/traq.hs b/tools/traq.hs index 64c4d73..ef5f436 100644 --- a/tools/traq.hs +++ b/tools/traq.hs @@ -2,10 +2,8 @@ module Main (main) where -import Control.Monad (unless) import Control.Monad.Reader (ReaderT, runReaderT) import Control.Monad.Trans (lift) -import Data.List (isPrefixOf) import Options.Applicative import System.FilePath (takeExtension) import Text.Printf (printf) @@ -20,8 +18,6 @@ import qualified Traq.Data.Symbolic as Sym import qualified Traq.Analysis as Analysis import qualified Traq.CPL as CPL import qualified Traq.Compiler as Compiler -import qualified Traq.Experimental.Compiler.Qiskit as Qiskit -import qualified Traq.Experimental.Compiler.Qualtran as Qualtran import Traq.Prelude import qualified Traq.Primitives as P import qualified Traq.QPL as QPL @@ -31,17 +27,12 @@ import qualified Traq.Utils.Printing as PP -- CLI -- ============================================================ -data Backend = QPL | Qualtran | Qiskit - deriving (Read, Show, Eq) - data Options = Options - { target :: Backend - , in_file :: FilePath + { in_file :: FilePath , out_file :: Maybe FilePath , eps :: Maybe Double , params :: [(Ident, SizeT)] , paramsf :: [(Ident, Double)] - , experimental :: Bool } deriving (Show) @@ -93,21 +84,6 @@ emitQPL qpl_prog = do let nqubits = QPL.numQubits qpl_prog pure $ unlines [PP.toCodeString qpl_prog, printf "// qubits: %d" nqubits] --- | Insert generated code at the ===CODE-HERE=== marker in a template file. -emitWithTemplate :: FilePath -> String -> IO String -emitWithTemplate templatePath code = do - template <- readFile templatePath - let marker = "# ===CODE-HERE===" - pure $ case break (marker `isPrefixOf`) (lines template) of - (before, _ : after) -> unlines $ before ++ [code] ++ after - _ -> unlines [template, code] - -emitQualtran :: QPL.Program SizeT -> IO String -emitQualtran = emitWithTemplate "tools/qualtran_prelude.py" . Qualtran.toPy - -emitQiskit :: QPL.Program SizeT -> IO String -emitQiskit = emitWithTemplate "tools/qiskit_prelude.py" . Qiskit.toPy - -- ============================================================ -- CLI parser -- ============================================================ @@ -124,18 +100,9 @@ opts :: ParserInfo Options opts = info (options <**> helper) - (fullDesc <> header "Traq: Compile CPL programs to QPL, Qualtran, or Qiskit.") + (fullDesc <> header "Traq: Compile CPL programs to QPL.") where options = do - target <- - option auto $ - long "target" - <> short 't' - <> metavar "TARGET" - <> help "Output target: QPL | Qualtran (experimental) | Qiskit (experimental)" - <> value QPL - <> showDefault - in_file <- strOption $ long "input" @@ -173,22 +140,12 @@ opts = <> help "float parameters..." <> metavar "NAME=VALUE" - experimental <- - switch $ - long "experimental" - <> help "Enable experimental features" - pure Options{..} main :: IO () main = do options@Options{..} <- execParser opts - let guardExperimental feat = - unless experimental $ - fail $ - "feature " <> feat <> " is experimental; pass --experimental to run it anyway" - qpl_prog <- (runReaderT ?? options) $ do case takeExtension in_file of ".traq" -> do @@ -199,8 +156,5 @@ main = do ".qpl" -> loadQPLProgram ext -> fail $ "Unsupported file extension: " ++ ext - out_str <- case target of - QPL -> emitQPL qpl_prog - Qualtran -> guardExperimental "backend:Qualtran" >> emitQualtran qpl_prog - Qiskit -> guardExperimental "backend:Qiskit" >> emitQiskit qpl_prog + out_str <- emitQPL qpl_prog maybe putStr writeFile out_file out_str diff --git a/traq.cabal b/traq.cabal index 1405a63..bb788d8 100644 --- a/traq.cabal +++ b/traq.cabal @@ -63,9 +63,6 @@ library Traq.Examples.MatrixSearch Traq.Examples.Search Traq.Examples.TreeGenerator - Traq.Experimental.Compiler.Python - Traq.Experimental.Compiler.Qiskit - Traq.Experimental.Compiler.Qualtran Traq.Numeric.Floating Traq.Prelude Traq.Primitives