add pulse support

Author: albertlee

.gitignore

@@ -193,3 +193,4 @@ cython_debug/
 .cursorignore
 .cursorindexingignore
 uv.lock
+local_docs/

examples/pulse_demo.py

@@ -0,0 +1,121 @@
+import sys
+import os
+import getpass
+import matplotlib.pyplot as plt
+# Add the directory containing your module to Python's search path
+module_path = ".."
+sys.path.insert(0, module_path)
+
+from tyxonq import Circuit, Param, gates, waveforms
+from tyxonq.cloud import apis
+import re
+
+shots_const = 1000
+
+token = getpass.getpass("Enter your token: ")
+apis.set_token(token)
+apis.set_provider("tencent")
+
+ds = apis.list_devices()
+print(ds)
+
+
+
+# TQASM 0.2;
+# QREG a[1];
+# defcal rabi_test a {
+# frame drive_frame = newframe(a);
+# play(drive_frame, cosine_drag($formatted_t, 0.2, 0.0, 0.0)); }
+# rabi_test a[0];
+# MEASZ a[0];
+
+def gen_parametric_waveform_circuit(t):
+    qc = Circuit(1)
+
+    param0 = Param("a")
+
+    builder = qc.calibrate("rabi_test", [param0])
+    builder.new_frame("drive_frame", param0)
+    builder.play("drive_frame", waveforms.CosineDrag(t, 0.2, 0.0, 0.0))
+    print("defcal rabi_test , instructions: ")
+    for instruction in builder.instructions:
+        print(instruction)
+
+    # 这段的代码设计有问题，！
+    builder.build()   # 注册 calibration
+    qc.add_calibration('rabi_test', ['q[0]'])    # 添加调用
+
+    tqasm_code = qc.to_tqasm()
+
+    print(tqasm_code)
+    return qc
+
+def run_circuit(qc):
+    device_name = "tianji_m2"
+    t = apis.submit_task(
+        circuit=qc,
+        shots=shots_const,
+        device=device_name,
+        enable_qos_gate_decomposition=False,
+        enable_qos_qubit_mapping=False,
+    )
+    print(t)
+    rf = t.results()
+    return rf
+
+def exp_rabi():
+    result_lst = []
+    for t in range(1, 4, 2):
+        qc = gen_parametric_waveform_circuit(t)
+        result = run_circuit(qc)
+        result['duration'] = t
+        result_lst.append(result)
+    return result_lst
+
+
+
+def draw_rabi(result_lst):
+    data = {
+        'duration': [],
+        '0': [],
+        '1': []
+    }
+
+    for result in result_lst:
+        data['0'].append(int(result['0']) / shots_const)
+        data['1'].append(int(result['1']) / shots_const)
+        data['duration'].append(result['duration'])
+
+
+    plt.figure(figsize=(10,6))
+    plt.plot(data['duration'], data['0'], 'b-o', label='State |0>')
+    plt.plot(data['duration'], data['1'], 'r--s', label='State |1>')
+
+
+    plt.title('Rabi Oscillation Experiment')
+    plt.xlabel('Duration (dt)')
+    plt.ylabel('Probability')
+    plt.grid(alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+
+
+    plt.savefig('rabi.png', dpi=300)
+    plt.show()
+
+
+def run_rabi():
+    qc =gen_parametric_waveform_circuit(1)
+    print(qc)
+    print("-------------------------------- QC TQASM --------------------------------")
+    print(qc.to_tqasm())
+    print("-------------------------------- QC TQASM END --------------------------------")
+
+    result = run_circuit(qc)
+# data: , duration: 1, 3
+# 1: {'0': 970, '1': 30, 'duration': 1}
+# 3: {'0': 979, '1': 21, 'duration': 3}
+
+
+{'0': 970, '1': 30, 'duration': 1}
+{'0': 979, '1': 21, 'duration': 3}

pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "tyxonq"
-version = "0.1.1"
+version = "0.3.0"
 description = "Quantum computing framework with multi-backend support"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.10,<3.13"
 authors = [
     { name = "Albert Lee", email = "code@quregenai.com" },
 ]
@@ -36,6 +36,7 @@ dependencies = [
     "tensorflow>=2.19.0",
     "tensornetwork>=0.4.6",
     "torch>=2.7.1",
+    "matplotlib",
 ]
 
 [project.optional-dependencies]

src/tyxonq/__init__.py

@@ -1,6 +1,6 @@
-__version__ = "0.1.1"
-__author__ = "TensorCircuit Authors"
-__creator__ = "refraction-ray"
+__version__ = "0.3.0"
+__author__ = "TyxonQ Authors"
+__creator__ = "TyxonQ Authors"
 
 from .utils import gpu_memory_share
 
@@ -24,8 +24,9 @@
 )  # prerun of set hooks
 from . import gates
 from . import basecircuit
+from . import waveforms
 from .gates import Gate
-from .circuit import Circuit, expectation
+from .circuit import Circuit, expectation, Param
 from .mpscircuit import MPSCircuit
 from .densitymatrix import DMCircuit as DMCircuit_reference
 from .densitymatrix import DMCircuit2

src/tyxonq/abstractcircuit.py

@@ -79,6 +79,15 @@ class AbstractCircuit:
     mpogates = mpogates
     gate_aliases = gate_aliases
 
+    def __init__(self, nqubits: int, *args, **kwargs):
+        self._nqubits = nqubits
+        self._qir = []
+        self._extra_qir = []
+        self.inputs = None
+        self.circuit_param = {}
+        self.is_mps = False
+
+
     def apply_general_gate(
         self,
         gate: Union[Gate, QuOperator],
@@ -114,6 +123,7 @@ def apply(self: "AbstractCircuit", *index: int, **vars: Any) -> None:
             gate_dict = {
                 "gatef": gatef,
                 "index": index,
+                "target": list(index),
                 "name": localname,
                 "split": split,
                 "mpo": mpo,
@@ -785,6 +795,7 @@ def to_openqasm(self, **kws: Any) -> str:
         """
         #return self.to_qiskit(enable_instruction=True).qasm(**kws)  # type: ignore
         "for new version of qiskit, use qiskit.qasm2.dump"
+
         from qiskit.qasm2 import dump, dumps
         q = self.to_qiskit(enable_instruction=True)
         return dumps(q)

src/tyxonq/basecircuit.py

@@ -39,6 +39,9 @@ class BaseCircuit(AbstractCircuit):
     split: Optional[Dict[str, Any]]
 
     is_mps = False
+    
+    def __init__(self, nqubits: int, *args, **kwargs):
+        super().__init__(nqubits, *args, **kwargs)
 
     @staticmethod
     def all_zero_nodes(n: int, d: int = 2, prefix: str = "qb-") -> List[tn.Node]:

src/tyxonq/circuit.py

@@ -60,6 +60,13 @@ def __init__(
             ``max_singular_values`` and ``max_truncation_err``.
         :type split: Optional[Dict[str, Any]]
         """
+
+        super().__init__(
+            nqubits=nqubits, inputs=inputs, mps_inputs=mps_inputs, split=split
+        )
+        self.calibrations = []
+        self.calibration_invokes = []
+
         self.inputs = inputs
         self.mps_inputs = mps_inputs
         self.split = split
@@ -112,6 +119,55 @@ def __init__(
         self._qir: List[Dict[str, Any]] = []
         self._extra_qir: List[Dict[str, Any]] = []
 
+
+    def def_calibration(
+        self, name: str, parameters: List[str], instructions: List[Dict]
+    ) -> None:
+        self.calibrations.append({
+            "name": name,
+            "parameters": parameters,
+            "instructions": instructions
+        })
+
+    def add_calibration(
+        self, name: str, parameters: List[str]
+    ) -> None:
+        self.calibration_invokes.append({
+            "name": name,
+            "parameters": parameters
+        })
+
+    def to_tqasm(self) -> str:
+        qasm_lines = []
+        qasm_lines.append("TQASM 0.2;")
+        qasm_lines.append(f"QREG q[{self._nqubits}];")
+
+        for gate in self._qir:
+            gname = gate["name"]
+            targets = ", ".join(f"q[{i}]" for i in gate["target"])
+            qasm_lines.append(f"{gname} {targets};")
+
+        for cal in getattr(self, "calibrations", []):
+            pname = ", ".join(cal["parameters"])
+            qasm_lines.append(f"\ndefcal {cal['name']} {pname} {{")
+            for inst in cal["instructions"]:
+                if inst["type"] == "frame":
+                    qasm_lines.append(f"  frame {inst['frame']} = newframe({inst['qubit']});")
+                elif inst["type"] == "play":
+                    args_str = ", ".join(str(x) for x in inst["args"])
+                    wf_type = inst["waveform_type"]
+                    qasm_lines.append(f"  play({inst['frame']}, {wf_type}({args_str}));")
+            qasm_lines.append("}")
+
+        for cal in getattr(self, "calibration_invokes", []):
+            pname = ", ".join(cal["parameters"])
+            qasm_lines.append(f"\n {cal['name']} {pname};")
+
+        return "\n".join(qasm_lines)
+    
+    def calibrate(self, name: str, parameters: List["Param"]) -> "DefcalBuilder":
+        return DefcalBuilder(self, name, parameters)
+
     def replace_mps_inputs(self, mps_inputs: QuOperator) -> None:
         """
         Replace the input state in MPS representation while keep the circuit structure unchanged.
@@ -998,3 +1054,46 @@ def expectation(
         else:
             den = 1.0
         return num / den
+
+class Param:
+    def __init__(self, name: str):
+        self.name = name
+    
+class DefcalBuilder:
+    def __init__(self, circuit, name: str, parameters: List["Param"]):
+        self.circuit = circuit
+        self.name = name
+        self.parameters = parameters
+        self.instructions = []
+
+    def new_frame(self, frame_name: str, param: "Param"):
+        self.instructions.append({
+            "type": "frame",
+            "frame": frame_name,
+            "qubit": param.name,
+        })
+        return self
+
+    def play(self, frame_name: str, waveform: Any, start_time: int = None):
+        if not hasattr(waveform, "__dataclass_fields__"):
+            raise TypeError("Unsupported waveform type")
+
+        waveform_type = waveform.qasm_name()
+        args = waveform.to_args()
+        if start_time is not None:
+            args = [start_time] + args
+
+        self.instructions.append({
+            "type": "play",
+            "frame": frame_name,
+            "waveform_type": waveform_type,
+            "args": args,
+        })
+        return self
+
+    def build(self):
+        self.circuit.def_calibration(
+            name=self.name,
+            parameters=[p.name for p in self.parameters],
+            instructions=self.instructions,
+        )