revise to cloud 3rd phase.

Author: tencentqlab

tensorcircuit/circuit.py

@@ -128,23 +128,23 @@ def def_calibration(
         })
 
     def add_calibration(
-        self, name: str, parameters: List[str]
+        self, builder: DefcalBuilder, parameters: List[str]
     ) -> None:
         self.calibration_invokes.append({
-            "name": name,
-            "parameters": parameters
+            "name": builder.name,
+            "parameters": parameters,
+            "pos": len(self._qir)
         })
 
 
-    def to_tqasm(self) -> str:
+    def to_tqasm(self, pragma: str) -> str:
         qasm_lines = []
+        if pragma:
+            qasm_lines.append(pragma)
+
         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};")
+        qasm_lines.append(f"QREG q[{self._nqubits}];")
 
         for cal in getattr(self, "calibrations", []):
             pname = ", ".join(cal["parameters"])
@@ -158,12 +158,42 @@ def to_tqasm(self) -> str:
                     qasm_lines.append(f"  play({inst['frame']}, {wf_type}({args_str}));")
             qasm_lines.append("}")
 
+
+        # 先把 calibration_invokes 按 pos 分组，并保留同 pos 内的插入顺序
+        from collections import defaultdict
+        cals_by_pos = defaultdict(list)
         for cal in getattr(self, "calibration_invokes", []):
-            pname = ", ".join(cal["parameters"])
-            qasm_lines.append(f"\n {cal['name']} {pname};")
+            # pos 记录的是加入时的 len(self._qir)
+            pos = cal.get("pos", len(self._qir))
+            cals_by_pos[pos].append(cal)
+
+        # 交错输出：在第 i 个门之前输出所有 pos == i 的校准
+        for i, gate in enumerate(self._qir):
+            for cal in cals_by_pos.get(i, []):
+                # print(cal)
+                pname = ", ".join(cal.get("parameters", []))
+                qasm_lines.append(f"{cal['name']} {pname};")
+
+            # print(gate)
+            gname = gate["name"]
+            gname = gname.upper()
+            if gname == "CNOT":
+                gname = "CX"
+            targets = ", ".join(f"q[{idx}]" for idx in gate["index"])
+            if (gname == "RX") or (gname == "RY") or (gname == "RZ"):
+                theta = gate["parameters"]["theta"]
+                qasm_lines.append(f"{gname} ({theta}) {targets};")
+            else:
+                qasm_lines.append(f"{gname} {targets};")
+
+        # 收尾：把 pos == len(self._qir) 的校准放在最后
+        for cal in cals_by_pos.get(len(self._qir), []):
+            # print(cal)
+            pname = ", ".join(cal.get("parameters", []))
+            qasm_lines.append(f"{cal['name']} {pname};")
+
+        return ("\n".join(qasm_lines))
 
-        return "\n".join(qasm_lines)
-    
     def calibrate(self, name: str, parameters: List["Param"]) -> "DefcalBuilder":
         return DefcalBuilder(self, name, parameters)
 
@@ -1057,7 +1087,11 @@ def expectation(
 class Param:
     def __init__(self, name: str):
         self.name = name
-    
+
+class Frame:
+    def __init__(self, name: str):
+        self.name = name
+
 class DefcalBuilder:
     def __init__(self, circuit, name: str, parameters: List["Param"]):
         self.circuit = circuit
@@ -1066,14 +1100,15 @@ def __init__(self, circuit, name: str, parameters: List["Param"]):
         self.instructions = []
 
     def new_frame(self, frame_name: str, param: "Param"):
+        frame = Frame(frame_name)
         self.instructions.append({
             "type": "frame",
-            "frame": frame_name,
+            "frame": frame,
             "qubit": param.name,
         })
-        return self
+        return frame
 
-    def play(self, frame_name: str, waveform: Any, start_time: int = None):
+    def play(self, frame: Frame, waveform: Any, start_time: int = None):
         if not hasattr(waveform, "__dataclass_fields__"):
             raise TypeError("Unsupported waveform type")
 
@@ -1084,7 +1119,7 @@ def play(self, frame_name: str, waveform: Any, start_time: int = None):
 
         self.instructions.append({
             "type": "play",
-            "frame": frame_name,
+            "frame": frame.name,
             "waveform_type": waveform_type,
             "args": args,
         })

tensorcircuit/cloud/abstraction.py

@@ -380,6 +380,57 @@ def resubmit(self) -> "Task":
         from .apis import resubmit_task
 
         return resubmit_task(self)
+    
+    @partial(arg_alias, alias_dict={"format": ["format_"], "blocked": ["wait"]})
+    def m_results(
+        self,
+        format: Optional[str] = None,
+        blocked: bool = True,
+        mitigated: bool = False,
+        calibriation_options: Optional[Dict[str, Any]] = None,
+        readout_mit: Optional[rem.ReadoutMit] = None,
+        mitigation_options: Optional[Dict[str, Any]] = None,
+    ) -> counts.ct:
+        """
+        get task results of the qjob
+
+        :param format: unsupported now, defaults to None, which is "count_dict_bin"
+        :type format: Optional[str], optional
+        :param blocked: whether blocked to wait until the result is returned, defaults to False,
+            which raise error when the task is unfinished
+        :type blocked: bool, optional
+        :param mitigated: whether enable readout error mitigation, defaults to False
+        :type mitigated: bool, optional
+        :param calibriation_options: option dict for ``ReadoutMit.cals_from_system``,
+            defaults to None
+        :type calibriation_options: Optional[Dict[str, Any]], optional
+        :param readout_mit: if given, directly use the calibriation info on ``readout_mit``,
+            defaults to None
+        :type readout_mit: Optional[rem.ReadoutMit], optional
+        :param mitigation_options: option dict for ``ReadoutMit.apply_correction``, defaults to None
+        :type mitigation_options: Optional[Dict[str, Any]], optional
+        :return: count dict results
+        :rtype: Any
+        """
+        if not blocked:
+            s = self.state()
+            if s != "completed":
+                raise TaskUnfinished(self.id_, s)
+            r = self.details()["multi_results"]
+            r = counts.sort_count(r)  # type: ignore
+        else:
+            s = self.state()
+            tries = 0
+            while s != "completed":
+                if s in ["failed"]:
+                    err = self.details().get("err", "")
+                    raise TaskFailed(self.id_, s, err)
+                time.sleep(0.5 + tries / 10)
+                tries += 1
+                s = self.state()
+            r = self.m_results(format=format, blocked=False, mitigated=False)
+        
+        return r  # type: ignore
 
     @partial(arg_alias, alias_dict={"format": ["format_"], "blocked": ["wait"]})
     def results(

tensorcircuit/cloud/tencent.py

@@ -19,6 +19,84 @@
 logger = logging.getLogger(__name__)
 
 
+class Topology:
+    def __init__(self, device: Device) -> None:
+        topology = device.topology()
+
+        self._qubits = list(set(num for row in topology for num in row))
+        self._qubit_pairs = topology
+
+        self._used_chip_qubits = []
+        self._used_user_qubits = []
+        self._used_user_pairs = []
+
+    def map_qubits(self, chip_addrs: Optional[List[int]], user_addrs: List[int] = None) -> None:
+        """
+        Map chip address to user address, and remove other unused chip addresses.
+        """
+        if user_addrs is None:
+            user_addrs = range(len(chip_addrs))
+        if len(user_addrs) != len(chip_addrs):
+            raise ValueError("user_addrs and chip_addrs should have the same length")
+        for addr in chip_addrs:
+            if addr not in self._qubits:
+                raise ValueError(f"chip_addr {addr} not in the device")
+            
+        self._used_chip_qubits = chip_addrs
+        self._used_user_qubits = user_addrs
+        self._used_user_pairs = [e for e in self._qubit_pairs if e[0] in chip_addrs and e[1] in user_addrs]
+
+    def map_qubit(self, chip_addr: int, user_addr: int) -> None:
+        if chip_addr not in self._qubits:
+            raise ValueError(f"chip_addr {chip_addr} not in the device")
+        try:
+            subscript = self._used_chip_qubits.index(chip_addr)
+            if self._used_user_qubits[subscript] != user_addr:
+                raise ValueError(f"chip_addr {chip_addr} is already mapped to user_addr {self._used_user_qubits[subscript]}")
+        except ValueError: # not found, so add it.
+            self._used_chip_qubits.append(chip_addr)
+            self._used_user_qubits.append(user_addr)
+        return
+    
+    def pair_qubit(self, user_addr1: int, user_addr2: int, dual: bool = True, add_remove: bool = True) -> None:
+        original_pair = (user_addr1, user_addr2)
+        
+        def update_pairs(user_addr1: int, user_addr2: int, add_remove: bool = True):
+            if add_remove:
+                if original_pair in getattr(self, "_used_user_pairs", []):
+                    return
+                self._qubit_mapping = getattr(self, "_used_user_pairs", []) + [original_pair]
+            else:
+                try:
+                    self._qubit_mapping = getattr(self, "_used_user_pairs", []) - [original_pair]
+                except ValueError:
+                    raise ValueError(f"Qubit pair {user_addr1}-{user_addr2} does not exist to remove")
+        update_pairs(user_addr1, user_addr2, add_remove)
+        if dual:
+            update_pairs(user_addr2, user_addr1, add_remove)
+        return
+    
+    def pragmam(self) -> str:
+        lines = []
+        if self._used_chip_qubits == [] or self._used_user_qubits == []:
+            return None
+        if len(self._used_user_pairs) == 0:
+            raise ValueError("No qubit pairs are defined, please use pair_qubit to define qubit pairs")
+        
+        pragma = "#pragma qubits.mapping ["
+        for c, u in zip(self._used_chip_qubits, self._used_user_qubits):
+            pragma += f"[{u}, {c}], "
+        pragma = pragma[:-2] + "]"
+        lines.append(pragma)
+
+        pragma = "#pragma qubits.coupling []"
+        for u1, u2 in getattr(self, "_used_user_pairs", []):
+            pragma += f"[{u1}, {u2}], "
+        pragma = pragma[:-2] + "]"
+        lines.append(pragma)
+        
+        return "\n".join(lines)
+
 def tencent_headers(token: Optional[str] = None) -> Dict[str, str]:
     if token is None:
         token = "ANY;0"
@@ -133,6 +211,7 @@ def submit_task(
     enable_qos_gate_decomposition: bool = True,
     enable_qos_initial_mapping: bool = False,
     qos_dry_run: bool = False,
+    topology: Optional[Topology] = None,
     **kws: Any
 ) -> List[Task]:
     """
@@ -211,10 +290,14 @@ def c2qasm(c: Any, compiling: bool) -> str:
             else:
                 if isinstance(c, QuantumCircuit):
                     s = c.qasm()
+                    lang = "OPENQASM"
                     # nq = c.num_qubits
                 else:
-                    s = c.to_tqasm()
-                    print(s)
+                    prag = None
+                    if topology is not None:
+                        prag = topology.praggam()
+                    s = c.to_tqasm(prag)
+                    lang = "TQASM"
                     #s = c.to_openqasm()
                     # nq = c._nqubits
             # s = _free_pi(s) # tQuk translation now supports this
@@ -227,13 +310,12 @@ def c2qasm(c: Any, compiling: bool) -> str:
             #     slist.append("")
             #     s = "\n".join(slist)
             s = _replace_rz_to_st(s)
-            return s  # type: ignore
+            return s, lang  # type: ignore
 
         if is_sequence(circuit):
             source = [c2qasm(c, compiling) for c in circuit]  # type: ignore
         else:
-            source = c2qasm(circuit, compiling)
-        lang = "OPENQASM"
+            source, lang = c2qasm(circuit, compiling)
 
     if len(device.name.split("?")) > 1:
         device_str = device.name
@@ -363,6 +445,10 @@ def get_task_details(
                 r["task"]["results"] = r["task"]["result"]["counts"]
             else:
                 r["task"]["results"] = r["task"]["result"]
+        if "multi_results" in r["task"]:
+            for i, res in enumerate(r["task"]["multi_results"]):
+                if "counts" in res:
+                    r["task"]["multi_results"][i] = counts.sort_count(res["counts"])
         if "optimization" in r["task"]:
             if (
                 "pairs" in r["task"]["optimization"]
@@ -413,4 +499,5 @@ def get_task_details(
     '101': 135,
     '110': 128,
     '111': 131}
+    'multi_results': [{'000': 123, '001': 126, ...}, {...}, ...]
     """

tests/01_test_gate.py

@@ -46,4 +46,5 @@ def run_circuit(qc):
     print(rf)
 
 qc = gen_gate_circuit(1.0)
-result = run_circuit(qc)
+result = run_circuit(qc)
+print(result)

tests/02_test_param_pulse.py

@@ -56,4 +56,5 @@ def run_circuit(qc):
     print(rf)
 
 qc = gen_parametric_waveform_circuit(1.0)
-result = run_circuit(qc)
+result = run_circuit(qc)
+print(result)

tests/03_test_gate_pulse_mix.py

@@ -57,4 +57,5 @@ def run_circuit(qc):
     print(rf)
 
 qc = gen_gate_pulse_mix_circuit(1.0)
-result = run_circuit(qc)
+result = run_circuit(qc)
+print(result)