{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "4a5da921",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:25.362861Z",
"iopub.status.busy": "2025-10-02T01:29:25.362690Z",
"iopub.status.idle": "2025-10-02T01:29:25.366073Z",
"shell.execute_reply": "2025-10-02T01:29:25.365543Z"
},
"nbsphinx": "hidden"
},
"outputs": [],
"source": [
"# Copyright 2025 Keysight Technologies Inc."
]
},
{
"cell_type": "raw",
"id": "0340db77",
"metadata": {
"raw_mimetype": "text/restructuredtext"
},
"source": [
"Real-time decision logic\n",
"========================\n",
"\n",
"Using the basic program structure as outlined in :doc:`program_basics`\\, we now show\n",
"how to add branching logic to a :py:class:`~keysight.qcs.programs.Program` using\n",
"a :py:class:`~keysight.qcs.programs.ConditionalOperation`\\.\n",
"\n",
"There are two ways decision logic can be implemented:\n",
"\n",
"#. Specifying a measurement in a program with ``reset=True``, e.g.\n",
" ``program.add_measurement(qubits, reset=True)``.\n",
"\n",
"#. Implementing an :py:class:`~keysight.qcs.channels.Acquisition` that uses a\n",
" :py:class:`~keysight.qcs.channels.Classifier` with a\n",
" :py:class:`~keysight.qcs.channels.Register` to which the results are written,\n",
" followed by a :py:class:`~keysight.qcs.programs.ConditionalOperation` that uses\n",
" the outcome of the register to determine which operation to execute.\n",
"\n",
"We begin by demonstrating the basic use case of qubit reset and then show how\n",
"the reset operations can be customized.\n",
"\n",
"Qubit reset\n",
"-----------\n",
"\n",
"For quantum systems with long T1 times and no direct ground state initialization\n",
"method, it is common practice to reset the qubit state to zero after a\n",
"single execution of an experiment when it is not in that state. This\n",
"requires a measurement and an optional subsequent\n",
"reset operation.\n",
"\n",
"In its simplest form, this can be done with an argument to the\n",
":py:meth:`~keysight.qcs.programs.Program.add_measurement` method:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "d37fbf31",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:25.368095Z",
"iopub.status.busy": "2025-10-02T01:29:25.367924Z",
"iopub.status.idle": "2025-10-02T01:29:28.597222Z",
"shell.execute_reply": "2025-10-02T01:29:28.596454Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {
"text/html": {
"isolated": true
}
},
"output_type": "display_data"
}
],
"source": [
"import keysight.qcs as qcs\n",
"\n",
"# generate a simple quantum circuit on two qubits\n",
"qubits = qcs.Qudits(range(2))\n",
"\n",
"circuit = qcs.Program()\n",
"circuit.add_gate(qcs.GATES.h, qubits[0])\n",
"circuit.add_gate(qcs.GATES.cx, (qubits[0], qubits[1]))\n",
"\n",
"# add a measurement on both qubits with reset\n",
"circuit.add_measurement(qubits, reset=True)\n",
"\n",
"circuit.draw()"
]
},
{
"cell_type": "raw",
"id": "3999f203",
"metadata": {
"raw_mimetype": "text/restructuredtext"
},
"source": [
"When setting ``reset=True``, a new empty layer (the data transaction\n",
"layer) gets inserted after the measurement layer, followed by another layer with the\n",
"conditional operation. The data transaction layer contains a list of\n",
":py:class:`~keysight.qcs.channels.DataTransaction` objects that map\n",
"measurements to operations, as can be seen in the tooltip when hovering over the\n",
"layer column header.\n",
"If we hover over the conditional operations in the last layer, we can inspect which\n",
"operations are played depending on the outcome of the measurement.\n",
"Let's take a closer look at those:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "38597e79",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:28.600143Z",
"iopub.status.busy": "2025-10-02T01:29:28.599549Z",
"iopub.status.idle": "2025-10-02T01:29:28.606941Z",
"shell.execute_reply": "2025-10-02T01:29:28.606169Z"
},
"lines_to_next_cell": 2
},
"outputs": [
{
"data": {
"text/plain": [
"{Qudits(labels=[0, 1], name=qudits, dim=2): [ConditionalOperation(operations=[Gate(matrix=[[(1+0j), 0j], [0j, (1+0j)]], name=ID), Gate(matrix=[[0j, (1+0j)], [(1+0j), 0j]], name=X)], register=Register(name=qudits_results, num_bits=2, dim=2))]}"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# print the program layer that contains the conditional operation:\n",
"circuit[-1].operations"
]
},
{
"cell_type": "raw",
"id": "94e138e5",
"metadata": {
"raw_mimetype": "text/restructuredtext"
},
"source": [
"This conditional operation will execute the first operation, the identity gate, if the\n",
"outcome of the measurement is ``0``, and the second operation, an X gate, if the\n",
"outcome is ``1``, thereby resetting the qubit state to zero after each\n",
"execution of the program. It is also possible to pass a list of operations to the\n",
"``reset`` argument whose length should match the dimension of the measurement:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "7dcc9a88",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:28.609285Z",
"iopub.status.busy": "2025-10-02T01:29:28.609001Z",
"iopub.status.idle": "2025-10-02T01:29:28.634133Z",
"shell.execute_reply": "2025-10-02T01:29:28.633450Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {
"text/html": {
"isolated": true
}
},
"output_type": "display_data"
}
],
"source": [
"# first, define two waveforms to be played for either outcome (0 or 1)\n",
"waveform_0 = qcs.RFWaveform(30e-9, qcs.GaussianEnvelope(), 1, frequency)\n",
"waveform_1 = qcs.RFWaveform(30e-9, qcs.GaussianEnvelope(), 0.5, frequency)\n",
"\n",
"# add the conditional operation using those waveforms and targeting the awg\n",
"# channel\n",
"program.add_conditional_operation(\n",
" operations=[waveform_0, waveform_1], target=awg, register=classifier.register\n",
")\n",
"\n",
"program.draw()"
]
},
{
"cell_type": "raw",
"id": "8e101743",
"metadata": {
"raw_mimetype": "text/restructuredtext"
},
"source": [
"This program contains a conditional operation with two waveforms that will be\n",
"played depending on the outcome stored in the register. If the outcome is ``0``, the\n",
"waveform at index `0` of the ``operations`` list will be played, and if it is\n",
"``1``, the waveform at the index `1` will be played."
]
},
{
"cell_type": "raw",
"id": "112c7c25",
"metadata": {
"lines_to_next_cell": 0,
"raw_mimetype": "text/restructuredtext"
},
"source": [
"Rendering programs with conditional operations\n",
"----------------------------------------------\n",
"Operations such as :py:class:`~keysight.qcs.programs.ConditionalOperation` split the\n",
"program into multiple group of layers. The ``render`` by default displays\n",
"the last group of layers.\n",
"To view a different layer, use the ``program_layer`` argument. Note that the\n",
"render function displays all the layers in a group at a time.\n",
"\n",
"Additionally, the user can specify the ``condition`` argument to select the measured\n",
"state outcome to visualize (in the following example it can be ``0`` or ``1``)."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "b0f11c36",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:28.752621Z",
"iopub.status.busy": "2025-10-02T01:29:28.749233Z",
"iopub.status.idle": "2025-10-02T01:29:28.769442Z",
"shell.execute_reply": "2025-10-02T01:29:28.768560Z"
},
"lines_to_next_cell": 0
},
"outputs": [],
"source": [
"register = qcs.Register(name=\"results\", num_outcomes=1)\n",
"classifier = qcs.Classifier([0, 0.1], register)\n",
"\n",
"# define two channels for the readout waveform and acquisition\n",
"awg = qcs.Channels(0, \"awg\")\n",
"dig = qcs.Channels(0, \"dig\")\n",
"\n",
"# define the readout pulse and the integration filter, and the waveforms to be played\n",
"# for either outcome (0 or 1)\n",
"frequency = 5e9\n",
"waveform_0 = qcs.RFWaveform(30e-9, qcs.GaussianEnvelope(), 1, frequency + 0.2e9)\n",
"waveform_1 = qcs.RFWaveform(30e-9, qcs.GaussianEnvelope(), -0.5, frequency)\n",
"readout_pulse = qcs.RFWaveform(30e-9, qcs.GaussianEnvelope(), 1, frequency)\n",
"integration_filter = qcs.RFWaveform(30e-9, qcs.ConstantEnvelope(), 1, 0)\n",
"\n",
"program = qcs.Program()\n",
"\n",
"program.add_waveform(readout_pulse, awg)\n",
"program.add_waveform(readout_pulse, awg, new_layer=True)\n",
"program.add_acquisition(integration_filter, dig, classifier)\n",
"\n",
"# add the conditional operation using those waveforms and targeting the awg\n",
"# channel\n",
"program.add_conditional_operation(\n",
" operations=[waveform_0, waveform_1], target=awg, register=classifier.register\n",
")\n",
"program.add_waveform(readout_pulse, awg)\n",
"program.add_waveform(readout_pulse, awg)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "f8199345",
"metadata": {
"execution": {
"iopub.execute_input": "2025-10-02T01:29:28.772296Z",
"iopub.status.busy": "2025-10-02T01:29:28.772044Z",
"iopub.status.idle": "2025-10-02T01:29:28.794981Z",
"shell.execute_reply": "2025-10-02T01:29:28.794116Z"
},
"lines_to_next_cell": 0
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"\n",
"