### Initialize QD Simulator device

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/qdsim.html

Configures the quantum device using the 'QD_SIM' identifier and initializes the FullStateSimulator. This setup is required before executing quantum kernels on the QD Simulator.

```cpp
iqsdk::DeviceConfig qd_sim_config("QD_SIM");
iqsdk::FullStateSimulator qd_sim_device(qd_sim_config);
```

--------------------------------

### Compiling with Quantum Dot Simulator Backend

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/qdsim.html

Example command for compiling a quantum program (qd_GHZ.cpp) using the Intel Quantum Compiler, specifying the Quantum Dot Simulator as the backend via a configuration file and applying placement and scheduling flags.

```bash
$ intel-quantum-compiler \-c /<path to config file>/intel-quantum-sdk-QDSIM.json \-p trivial \-S greedy qd_GHZ.cpp
```

--------------------------------

### Initialize FullStateSimulator

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Provides the class definition for the FullStateSimulator, which allows for quantum simulator setup and state access. Note that copy and move operations are deleted to manage simulator resources correctly.

```cpp
#include <quantum_full_state_simulator_backend.h>

class FullStateSimulator : public iqsdk::SimulatorDevice {
public:
    FullStateSimulator();
    FullStateSimulator(DeviceConfig &device_config);
    FullStateSimulator(const FullStateSimulator&) = delete;
    FullStateSimulator& operator=(const FullStateSimulator&) = delete;
    FullStateSimulator(FullStateSimulator&&) = delete;
    FullStateSimulator& operator=(FullStateSimulator&&) = delete;
    virtual ~FullStateSimulator() = default;
};
```

--------------------------------

### Simulate Quantum Dot Hardware with FullStateSimulator

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Provides a physics-level simulation of quantum dot qubits. This example shows how to configure the device, execute a basic Bell pair circuit, and display probability distributions.

```cpp
#include <clang/Quantum/quintrinsics.h>
#include <quantum_full_state_simulator_backend.h>

const int num_qubits = 2;
qbit q[num_qubits];

quantum_kernel void qd_circuit() {
    PrepZ(q[0]);
    PrepZ(q[1]);
    H(q[0]);
    CNOT(q[0], q[1]);
}

int main() {
    iqsdk::DeviceConfig qd_config("QD_SIM");
    iqsdk::FullStateSimulator sim(qd_config);

    if (iqsdk::QRT_ERROR_SUCCESS != sim.ready())
        return 1;

    qd_circuit();

    std::vector<std::reference_wrapper<qbit>> qids;
    qids.push_back(std::ref(q[0]));
    qids.push_back(std::ref(q[1]));

    auto probs = sim.getProbabilities(qids);
    sim.displayProbabilities(probs, qids);

    return 0;
}
```

--------------------------------

### Implement Variational Quantum Algorithm in C++

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Demonstrates a variational quantum algorithm using the Intel Quantum SDK. It defines a parameterized ansatz circuit and a measurement kernel, then uses the FullStateSimulator for optimization. This example requires the 'clang/Quantum/quintrinsics.h' and 'quantum_full_state_simulator_backend.h' headers.

```cpp
#include <clang/Quantum/quintrinsics.h>
#include <quantum_full_state_simulator_backend.h>
#include <cmath>

const int num_qubits = 2;
qbit q[num_qubits];

// Parameterized ansatz circuit
quantum_kernel void variational_ansatz(double theta0, double theta1, double theta2) {
    PrepZ(q[0]);
    PrepZ(q[1]);

    RX(q[0], theta0);
    RY(q[1], theta1);
    S(q[1]);
    CNOT(q[0], q[1]);
    RZ(q[1], theta2);
    CNOT(q[0], q[1]);
    Sdag(q[1]);
}

quantum_kernel double measure_expectation(cbit* c) {
    CNOT(q[0], q[1]);
    MeasX(q[0], c[0]);  // XX term
    MeasZ(q[1], c[1]);  // ZZ term

    // Return eigenvalue from measurement
    return (c[0] ? -1.0 : 1.0) * (c[1] ? -1.0 : 1.0);
}

int main() {
    iqsdk::IqsConfig settings(num_qubits, "noiseless");
    iqsdk::FullStateSimulator sim(settings);
    sim.ready();

    // Variational optimization loop
    double theta[3] = {0.1, 0.2, 0.3};
    double learning_rate = 0.1;

    for (int iteration = 0; iteration < 100; iteration++) {
        // Run ansatz
        variational_ansatz(theta[0], theta[1], theta[2]);

        // Get expectation value via sampling
        std::vector<std::reference_wrapper<qbit>> qids;
        qids.push_back(std::ref(q[0]));
        qids.push_back(std::ref(q[1]));

        auto samples = sim.getSamples(1000, qids);
        auto probs = sim.samplesToProbabilities(samples);

        // Update parameters (simplified gradient descent)
        // In practice, use parameter shift rule or finite differences
        theta[0] += learning_rate * 0.01;
        theta[1] -= learning_rate * 0.01;
    }

    return 0;
}

```

--------------------------------

### Main Function for Optimization Setup and Execution

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/tutorials.html

The `main` function initializes the IQSDK backend, constructs the cost expression, and initiates the optimization process using dlib's `find_min_bobyqa`. It defines a lambda function `ansatz_run_lambda` to adapt the quantum kernel for dlib's requirements.

```C++
int main() {
    // Setup quantum device
    iqsdk::IqsConfig sim_config(N, "noiseless", false);
    iqsdk::FullStateSimulator sim_device(sim_config);
    assert(sim_device.ready() == iqsdk::QRT_ERROR_SUCCESS);

    // initial starting point.
    column_vector starting_point = {0, 0, 0, 0};

    // calculate the actual inverse temperature
    double inv_temp = 1.0;

    // Fully formulated Cost Function Expression
    hqcl::SymbolicOperator cost_expr = constructFullSymbOp(inv_temp);

    // Qubitwise Commutation (QWC) Groups Formation
    hqcl::QWCMap qwc_groups = hqcl::SymbolicOperatorUtils::getQubitwiseCommutationGroups(cost_expr);

    // Construct a function to be used for a single optimization iteration
    auto ansatz_run_lambda = [&]() {
      // Set all the variational angles to input values.
      for (int q_index = 0; q_index < N_map_angles; q_index++)
          QVarParams[q_index] = var_angs(q_index);

      // run the kernel to compute the total cost
      double total_cost = runQuantumKernel(sim_device, var_angs, cost_expr, qwc_groups);

      return total_cost;
    };

    // run the full optimization for a given temperature
    auto result = dlib::find_min_bobyqa(
                        ansatz_run_lambda, starting_point,
                        2 * N_var_angles + 1, // number of interpolation points
                        dlib::uniform_matrix<double>(N_var_angles, 1, -7.0), // lower bound constraint
                        dlib::uniform_matrix<double>(N_var_angles, 1, 7.0), // upper bound constraint
                        1.5, // initial trust region radius
                        1e-5, // stopping trust region radius
                        10000 // max number of objective function evaluations
    );

    return 0;
}
```

--------------------------------

### Demonstrate QBB Optimization and Barrier Behavior

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/barriers.html

Examples showing how separate evaluation calls create distinct QBBs to prevent compiler optimization, compared to a single call where gates may be cancelled.

```C++
qexpr::eval_hold(qexpr::_X(q)); // 1 QBB with 1 gate
qexpr::eval_hold(qexpr::_X(q)); // 1 QBB with 1 gate

// Single evaluation call allows optimization
qexpr::eval_hold(qexpr::_X(q) + qexpr::_X(q)); // 1 optimized QBB with 0 gates
```

--------------------------------

### Conditional Qubit State Preparation Example

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/utils.html

This C++ code snippet demonstrates the use of `qexpr::cIf` in conjunction with `qexpr::exitAtCompile` to prepare a qubit in a specific state based on a character input. If the input character does not match '0', '1', '+', or '-', a compile-time error is raised.

```C++
QExpr stateToQExpr(qbit& q, const char c) {
  return
      qexpr::cIf(c == '0', qexpr::_PrepZ(q),
      qexpr::cIf(c == '1', qexpr::_PrepZ(q) + qexpr::_X(q),
      qexpr::cIf(c == '+', qexpr::_PrepZ(q) + qexpr::_H(q),
      qexpr::cIf(c == '-', qexpr::_PrepZ(q) + qexpr::_X(q) + qexpr::_H(q),
      qexpr::exitAtCompile("Invalid character input for state preparation.")
      )))));
}
```

--------------------------------

### Prepare and Measure Bell State using Intel® Quantum SDK (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/overview.html

This C++ code snippet demonstrates how to prepare and measure a Bell state using the Intel® Quantum SDK. It includes qubit declaration, quantum gate operations (Hadamard, CNOT), and measurement. The example also shows how to configure and use the FullStateSimulator backend and interpret measurement results.

```C++
/* Gate definitions and key words */
#include <clang/Quantum/quintrinsics.h>

/* Quantum Runtime APIs */
#include <quantum_full_state_simulator_backend.h>

#include <iostream>

const int num_qubits = 2;
/* Declare 2 qubits */
qbit q[num_qubits];

/* The quantum logic must be in a function with the keyword quantum_kernel */
/* pre-pended to the signature */
quantum_kernel void prep_and_meas_bell(cbit read_out) {
    /* Prepare both qubits in the |0> state */
    PrepZ(q[0]);
    PrepZ(q[1]);

    /* Apply a Hadamard gate to the top qubit */
    H(q[0]);

    /* Apply a Controlled-NOT gate with the top qubit as
     * the control and the bottom qubit as the target */
    CNOT(q[0], q[1]);

    /* Measure qubit 0 */
    MeasZ(q[0], read_out);
}

int main() {
    /* Configure the simulator */
    iqsdk::IqsConfig settings(num_qubits, "noiseless");
    iqsdk::FullStateSimulator quantum_8086(settings);
    if (iqsdk::QRT_ERROR_SUCCESS != quantum_8086.ready()) return 1;

    /* Declare 2 measurement readouts */
    /* Measurements are stored here as "classical bits" */
    cbit classical_bit;

    prep_and_meas_bell(classical_bit);

    /* Here we can use the FullStateSimulator APIs to get data */
    /* or we can write classical logic that interacts with our measurement */
    /* results, as below. */
    bool result = classical_bit;
    if (result) {
        std::cout << "True\n";
    }
    else {
        std::cout << "False\n";
    }

    return 0;
}
```

--------------------------------

### Prepare Bell State using Quantum Kernel Function in C++

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Demonstrates how to define and execute a quantum kernel function to prepare a Bell state using the Intel Quantum SDK. It includes qubit declaration, gate operations (H, CNOT), and measurement, along with simulator setup and execution.

```cpp
#include <clang/Quantum/quintrinsics.h>
#include <quantum_full_state_simulator_backend.h>

// Declare qubits in global namespace
const int num_qubits = 2;
qbit q[num_qubits];

// quantum_kernel function to prepare a Bell state
quantum_kernel void prepare_bell_state(cbit read_out) {
    // Initialize qubits to |0> state
    PrepZ(q[0]);
    PrepZ(q[1]);

    // Apply Hadamard to first qubit
    H(q[0]);

    // Apply CNOT to create entanglement
    CNOT(q[0], q[1]);

    // Measure qubit 0
    MeasZ(q[0], read_out);
}

int main() {
    // Configure the Full State Simulator
    iqsdk::IqsConfig settings(num_qubits, "noiseless");
    iqsdk::FullStateSimulator sim(settings);

    if (iqsdk::QRT_ERROR_SUCCESS != sim.ready())
        return 1;

    // Execute the quantum kernel
    cbit result;
    prepare_bell_state(result);

    return 0;
}

```

--------------------------------

### Get Slice After Index in DataList (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Retrieves a slice of the current DataList starting from the element immediately after the specified index. This function is part of the DataList class.

```cpp
inline const DataList WRAP_ATTR last_block (const DataList d) const
```

--------------------------------

### Initialize and Configure FullStateSimulator

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/full_state.html

Demonstrates how to create an IqsConfig object, instantiate the FullStateSimulator, and verify the simulator's readiness before execution.

```cpp
// configure to use N qubits; accepts defaults for remaining
iqsdk::IqsConfig iqs_config(/*num_qubits*/ N);

// setup quantum device
iqsdk::FullStateSimulator iqs_device(iqs_config);
iqs_device.printVerbose(true);

// ensure setup was successful
if (iqsdk::QRT_ERROR_SUCCESS != iqs_device.ready()) return 1;
```

--------------------------------

### Sublist Extraction Based on Delimiters

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Methods to extract DataLists starting from or after specific delimiter sequences.

```APIDOC
## Sublist Extraction Based on Delimiters

### Description
These functions extract portions of a DataList based on the position of specified delimiter sequences.

### Methods

- **`next(const DataList d)`**
  - **Description**: Returns the DataList sliced beginning at the first occurrence of `d`. Example: `DataList("find this 123 or this 345").next("this")` returns `"this 123 or this 345"`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`next(const DataList d, Args... ds)`**
  - **Description**: Returns the DataList sliced beginning at the next occurrence of any of the given arguments (`ds`). Example: `DataList("The quick brown fox.").next("fox", "quick")` returns `"quick brown fox."`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`after_next(const DataList d)`**
  - **Description**: Returns the DataList occurring directly after the first occurrence of `d`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`after_next(const DataList d, Args... ds)`**
  - **Description**: Returns the DataList sliced starting after the next occurrence of any of the given arguments (`ds`). Example: `DataList("find this 123").after_next("this")` returns `" 123"`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`next_not(const DataList d)`**
  - **Description**: Returns the DataList occurring after the index found by `find_not(d)`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`next_block(const DataList d)`**
  - **Description**: Returns the first DataList block whose elements all match any character in `d`. Example: `next_block("0123456789")` returns the first integer.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`last(const DataList d)`**
  - **Description**: Returns the DataList sliced beginning at the last occurrence of `d`. Example: `DataList("find this 123 or this 345").last("this")` returns `"this 345"`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`last(const DataList d, Args... ds)`**
  - **Description**: Returns the DataList sliced beginning at the last occurrence of any of the given arguments (`ds`). Example: `DataList("find this or this 123").last("1", "2", "3")` returns `"3"`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`after_last(const DataList d)`**
  - **Description**: Returns the slice of the DataList after the last instance of `d`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`after_last(const DataList d, Args... ds)`**
  - **Description**: Returns the DataList sliced immediately after the last occurrence of any of the given arguments (`ds`). Example: `DataList("find this 123 or this 345").after_last("this")` returns `" 345"`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)

- **`last_not(const DataList d)`**
  - **Description**: Returns the DataList sliced beginning at the last character not matching `d`.
  - **Method**: `const DataList` (implicit)
  - **Endpoint**: N/A (Member function)
```

--------------------------------

### Initialize Clifford Simulator

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/clifford.html

Demonstrates how to declare a configuration object with an optional seed, instantiate the CliffordSimulator, and prepare the device for quantum kernel execution.

```cpp
iqsdk::CliffordSimulatorConfig clifford_config(seed);
iqsdk::CliffordSimulator clifford_device(clifford_config);
clifford_device.ready();
```

--------------------------------

### Get Size of DataList (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Returns the number of elements contained within a DataList. This is a friend function.

```cpp
inline friend unsigned long WRAP_ATTR size (const DataList a)
```

--------------------------------

### SimulatorDevice::displaySamples

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Displays samples to standard output.

```APIDOC
## SimulatorDevice::displaySamples

### Description
Displays samples to standard output.

### Method
POST (assumed, as it displays data)

### Endpoint
`/simulator/samples/display` (assumed)

### Parameters
#### Request Body
- **samples** (vector<vector<bool>>) - Required - A vector of samples, where each sample is a vector of booleans.

### Response
#### Success Response (200)
(No response body, output is to standard output)

### Request Example
```json
{
  "samples": [
    [true, false],
    [false, true]
  ]
}
```
```

--------------------------------

### Qubit Comparison and Size

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Includes utility functions for comparing two individual qubits for equality and for getting the size of a qubit register.

```cpp
bool WRAP_ATTR qbits_equal(qbit &q1, qbit &q2); // Compare two qbits for equality

unsigned long WRAP_ATTR size(qbit *reg); // Get the size of a qbit register
```

--------------------------------

### Instantiate Full-State Simulator with Custom IQS Configuration (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/iqs.html

Instantiates a full-state simulator backend using a custom IQS configuration. This allows for noisy simulations with user-defined noise models. The backend is then prepared for use.

```cpp
iqsdk::FullStateSimulator custom_iqs_device(custom_iqs_config);

if (iqsdk::QRT_ERROR_SUCCESS != custom_iqs_device.ready()) return 1;
```

--------------------------------

### Use Bind Functionality for Explicit Barriers

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/barriers.html

Examples of using the qexpr::bind function and its shorthand operators to insert barriers between quantum kernel expressions.

```C++
// Sequential order (e1 then e2)
qexpr::bind(e1, e2);
e1 << e2;

// Composition order (e2 then e1)
e1 >> e2;

// Fence (identity barrier before expression)
qexpr::fence(e);
```

--------------------------------

### Set Up and Run Quantum Simulation in Python

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/python_model.html

This Python script demonstrates setting up a noiseless quantum simulation device with a specified number of qubits. It then prepares qubits, applies quantum gates (QFT and its inverse), and retrieves measurement results and probabilities.

```python
# number of qubits
N = 4
iqs_config = IqsConfig()
# set the number of qubits for the simulation config
iqs_config.num_qubits = N
# choose the type of noise model
iqs_config.simulation_type = "noiseless"
iqs_config.synchronous = False
iqs_device = FullStateSimulator(iqs_config)
iqs_device.ready()

qids = RefVec()
cbits = []
for i in range(N):
    cbits.append(CbitRef("CReg", i, sdk_name))
    qids.append(QbitRef("QubitReg", i, sdk_name).get_ref())

# Prepare all qubits in the 0 state
callCppFunction("prepZAll", sdk_name)
# Apply QFT
callCppFunction("qft", sdk_name)
# Apply the inverse of QFT, effectively applying an Identity
callCppFunction("qft_inverse", sdk_name)

probs = iqs_device.getProbabilities(qids)
amplitudes = iqs_device.getAmplitudes(qids)
callCppFunction("measZAll", sdk_name)

print("\nMeasurements:")
for cbit in cbits:
    print(cbit.value())

print("\nProbabilities printed with QRT API")
# Expect to see |0000> to have a probability of 1
# since an identity has been applied
FullStateSimulator.displayProbabilities(probs, qids)

# Required wait since device is asynchronous
iqs_device.wait()
```

--------------------------------

### Get Current Quantum Kernel as QExpr (QExpr, C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Returns the contents of the current quantum_kernel function as a QExpr. Requires the use of the PROTECT function attribute.

```cpp
this_as_expr
```

--------------------------------

### Configure Quantum Dot Simulator Backend in C++

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/tutorials.html

Shows how to initialize the FullStateSimulator with a specific device configuration to target the Quantum Dot Simulator (QD_SIM) backend instead of the default simulator.

```cpp
int main() {
  iqsdk::DeviceConfig qd_config("QD_SIM");
  iqsdk::FullStateSimulator quantum_8086(qd_config);
}
```

--------------------------------

### Trim Leading/Trailing Characters from DataList (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Removes specified starting and ending characters from a DataList. The trimming only occurs if the specified characters are indeed at the beginning and end of the DataList.

```cpp
inline const DataList WRAP_ATTR trim (const DataList start=DataList(" "), const DataList end=DataList(" ")) const
```

--------------------------------

### Quantum Assembly VQE Stub

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/tutorials.html

An example of a quantum function stub for the VQE Heisenberg algorithm. It demonstrates qubit preparation, rotation, controlled-phase gates, and measurement operations.

```assembly
	.globl	"_Z45VQE_Heisenberg(double, double, double).QBB.3.v.stub"
	.type	"_Z45VQE_Heisenberg(double, double, double).QBB.3.v.stub",@function
"_Z45VQE_Heisenberg(double, double, double).QBB.3.v.stub":
	quprep QUBIT[1] (slice_idx=1)
	quprep QUBIT[0] (slice_idx=0)
	qurotxy QUBIT[1], @shared_variable_array[4], @shared_variable_array[1] (slice_idx=0)
	qurotxy QUBIT[0], @shared_variable_array[5], @shared_variable_array[0] (slice_idx=0)
	qurotxy QUBIT[0], 1.570796e+00, 4.712389e+00 (slice_idx=0)
	qurotxy QUBIT[1], 1.570796e+00, 0.000000e+00 (slice_idx=0)
	qucphase QUBIT[0], QUBIT[1], 3.141593e+00 (slice_idx=0)
	qurotxy QUBIT[0], 1.570796e+00, 0.000000e+00 (slice_idx=0)
	qumeasz QUBIT[0] @shared_cbit_array[0] (slice_idx=0)
	qurotxy QUBIT[1], 1.570796e+00, 4.712389e+00 (slice_idx=0)
	qumeasz QUBIT[1] @shared_cbit_array[1] (slice_idx=2)
	return
```

--------------------------------

### QList Construction and Initialization

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Demonstrates various ways to construct and initialize a QList object. This includes creating an empty list, initializing from a qubit array, creating a list with a single qubit, and copying an existing QList.

```cpp
QList() = default; // Empty QList

inline WRAP_ATTR QList(qbit *qa); // From a qubit array

inline WRAP_ATTR QList(qbit &q); // Single qubit

QList(const QList &ql) = default; // Copy constructor
```

--------------------------------

### Recursive QExpr implementation

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/higher-order.html

An example of a manual recursive function that applies a PrepZ gate to every qubit in a QList. This approach is prone to boilerplate code and is replaced by higher-order functions.

```cpp
QExpr prepAll_recursive(qlist::QList qs) {
  return qexpr::cIf(qs.size() > 0,
                    qexpr::_PrepZ(qs[0]) + prepAll_recursive(qs + 1),
                    qexpr::identity()
  );
}
```

--------------------------------

### Command Line: Custom Pass Compilation Stages

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/user_passes.html

Example command-line invocation for the Intel Quantum Compiler to insert custom passes at specific compilation stages. It demonstrates how to specify shared libraries, stages, passes, and options.

```bash
intel-quantum-compiler \ 
-E path/to/libExampleMultiPass.so \ 
-e prelower \ 
-a print-all-gates,x-to-hzh,print-all-gates \ 
-A \ 
-example-pass-opt \ 
-A testing \ 
-e presplit \ 
-a print-all-gates \ 
-A \ 
-example-pass-opt \ 
-A testing-two <source_file>
```

--------------------------------

### Configure FullStateSimulator

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/tutorials.html

Initializes the FullStateSimulator with a noiseless configuration and verifies readiness.

```cpp
int main() {
  iqsdk::IqsConfig settings(total_qubits, "noiseless");
  settings.verbose = true;
  iqsdk::FullStateSimulator quantum_8086(settings);
  if (iqsdk::QRT_ERROR_SUCCESS != quantum_8086.ready())
    return 1;
```

--------------------------------

### Invoking the Intel Quantum Compiler with Placement Flags

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/compiler.html

Demonstrates how to compile a quantum algorithm using the Intel Quantum Compiler with specific placement strategies and configuration files.

```bash
# Default trivial placement
./intel-quantum-compiler quantum_algorithm.cpp

# Specific placement strategies
./intel-quantum-compiler -c configuration_file -p trivial quantum_algorithm.cpp
./intel-quantum-compiler -c configuration_file -p dense quantum_algorithm.cpp
./intel-quantum-compiler -c configuration_file -p local quantum_algorithm.cpp
./intel-quantum-compiler -c configuration_file -p custom quantum_algorithm.cpp
```

--------------------------------

### Simulate Quantum States with FullStateSimulator in C++

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Demonstrates how to configure the FullStateSimulator, execute a quantum kernel, and retrieve probabilities, amplitudes, and measurement samples. This backend is suitable for general-purpose quantum state simulation.

```cpp
#include <clang/Quantum/quintrinsics.h>
#include <quantum_full_state_simulator_backend.h>
#include <vector>
#include <iostream>

const int total_qubits = 4;
qbit qubit_register[total_qubits];

quantum_kernel void prepare_ghz_state() {
    for (int i = 0; i < total_qubits; i++) {
        PrepZ(qubit_register[i]);
    }
    H(qubit_register[0]);
    for (int i = 0; i < total_qubits - 1; i++) {
        CNOT(qubit_register[i], qubit_register[i + 1]);
    }
}

int main() {
    iqsdk::IqsConfig settings(total_qubits, "noiseless");
    settings.verbose = true;
    iqsdk::FullStateSimulator sim(settings);

    if (iqsdk::QRT_ERROR_SUCCESS != sim.ready())
        return 1;

    std::vector<std::reference_wrapper<qbit>> qids;
    for (int id = 0; id < total_qubits; ++id) {
        qids.push_back(std::ref(qubit_register[id]));
    }

    prepare_ghz_state();

    iqsdk::QssIndex state_a("|0000>");
    iqsdk::QssIndex state_b("|1111>");
    std::vector<iqsdk::QssIndex> bases = {state_a, state_b};

    iqsdk::QssMap<double> probability_map = sim.getProbabilities(qids, bases);
    sim.displayProbabilities(probability_map);

    std::vector<double> all_probs = sim.getProbabilities(qids);
    std::vector<std::complex<double>> amplitudes = sim.getAmplitudes(qids);
    sim.displayAmplitudes(amplitudes, qids);

    std::complex<double> amp = sim.getAmplitude(qids, state_a);
    unsigned int num_shots = 1000;
    std::vector<std::vector<bool>> samples = sim.getSamples(num_shots, qids);

    iqsdk::QssMap<unsigned int> histogram = iqsdk::FullStateSimulator::samplesToHistogram(samples);
    iqsdk::QssMap<double> sample_probs = iqsdk::FullStateSimulator::samplesToProbabilities(samples);

    return 0;
}
```

--------------------------------

### Map Function Over DataList with Tokens and Separator (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Maps a QExpr function over a DataList, supporting optional start and end tokens, and a separator for entries. Additional scalar arguments are passed to the function.

```cpp
template<typename QExprFun, typename... Args> PROTECT QExpr mapDataList (datalist::DataList startToken, datalist::DataList endToken, QExprFun f, datalist::DataList sep, datalist::DataList d, Args... args)
```

--------------------------------

### IQS Backend Configuration Initialization (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Constructor for the IQS configuration. Initializes the simulation with specified parameters such as the number of qubits, simulation type, verbosity, random seed, and depolarizing rate. It allows for custom noise models and state preparation.

```cpp
#include <quantum_full_state_simulator_backend.h>

// Example usage:
IqsConfig config(8, "depolarizing", true, 12345, true, 0.05);

// Default constructor:
IqsConfig defaultConfig;

```

--------------------------------

### QList Size and Utility Functions

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Covers functions for retrieving the size of a QList and performing utility operations. Includes getting the list size, returning an empty list, and incrementing the list by a specified amount.

```cpp
inline unsigned long WRAP_ATTR size() const; // Get the size of the QList

static inline const QList WRAP_ATTR empty_list(); // Returns an empty QList

inline const QList WRAP_ATTR operator+(unsigned i); // Increment QList by i (slice from i to end)

inline const QList WRAP_ATTR operator++() const; // Increment QList by 1
```

--------------------------------

### Manage Qubit Lifecycle and State Release in Quantum Kernels

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/tutorials.html

Demonstrates how to properly release quantum states using release_quantum_state() or measurement, and provides examples of improper state management that can lead to unreliable results.

```C++
qbit global_qbit;

void quantum_kernel exampleReleaseOnMeasurement(){
   qbit local_3[3];
   PrepZ(local_3[0]);
   PrepZ(local_3[1]);
   PrepZ(local_3[2]);
   RY(local_3[0], 0.5);
   RY(local_3[1], 0.5);
   RY(local_3[2], 0.5);
   MeasX(local_3[0]);
   MeasX(local_3[1]);
   MeasX(local_3[2]);
}

void quantum_kernel exampleExplicitRelease() {
   qbit q0, q1;
   PrepZ(q0); PrepZ(q1);
   RZ(q0); RZ(q1); RZ(global_qbit);
   release_quantum_state();
}

void quantum_kernel badExampleNoRelease() {
   qbit q0, q1;
   PrepZ(q0); PrepZ(q1);
   RZ(q0); RZ(q1);
}
```

--------------------------------

### QList operations: size, indexing, and concatenation

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/qlist.html

Demonstrates fundamental QList operations: getting the size, accessing elements by index using operator[], and concatenating two QLists. These operations are compile-time resolvable.

```cpp
unsigned int size = qs.size();
qbit& element = qs[i];
qlist::QList concatenated_list = qs1 + qs2;
```

--------------------------------

### Constructing DataList from Source and Files

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/datalist.html

Demonstrates how to initialize a DataList object using string literals or by importing content from external files using provided macros.

```C++
STRINGIFYDATA(
This is from a file!
)

const datalist::DataList str_src("This is from source!");

import_with_name_begin(file_str)
#include "test.txt"
import_with_name_end(file_str);
```

--------------------------------

### Register and Create Custom Quantum Backends

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/python_model.html

Explains how to implement a custom simulator by deriving from CustomInterface and registering it with the SDK. Provides methods for both explicit registration and shorthand simulator creation.

```python
custom_device_id = "custom device"
CustomSimulator.registerCustomInterface(MySimulator, custom_device_id, <args>)
config = DeviceConfig(custom_device_id)
device = CustomSimulator(config)

# Shortcut method
device = CustomSimulator.createSimulator(MySimulator, "custom_device", <args>)
sim_object = device.getCustomBackend()
```

--------------------------------

### QList Element Access and Slicing Operators

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Explains how to access individual elements and create sub-lists (slices) from a QList using overloaded operators. Supports indexing, accessing the first element, and creating slices based on start and end indices.

```cpp
inline qbit WRAP_ATTR & operator[](unsigned long i) const; // Access element by index

inline WRAP_ATTR qbit & operator*() const; // Access first element

inline const QList WRAP_ATTR operator()(unsigned long a, unsigned long b) const; // Create a slice from index a to b-1
```

--------------------------------

### Compile Quantum C++ Programs with intel-quantum-compiler

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Shows various ways to compile quantum C++ programs using the `intel-quantum-compiler`. Options include basic compilation, optimization levels, targeting specific backends like the Quantum Dot Simulator, enabling verbose output for gate decomposition, and generating human-readable `.qs` files.

```bash
# Basic compilation
intel-quantum-compiler my_quantum_program.cpp -o my_program

# Compile with optimization
intel-quantum-compiler -O1 my_quantum_program.cpp -o my_program

# Compile for Quantum Dot Simulator backend
intel-quantum-compiler -c intel-quantum-sdk-QDSIM.json -p trivial -S greedy qd_program.cpp

# Compile with verbose output to see gate decomposition
intel-quantum-compiler -v my_quantum_program.cpp

# Generate human-readable .qs file with compiled quantum instructions
intel-quantum-compiler --emit-qs my_quantum_program.cpp

```

--------------------------------

### SimulatorDevice::samplesToProbabilities

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Calculates probabilities from a collection of samples.

```APIDOC
## SimulatorDevice::samplesToProbabilities

### Description
Calculates probabilities from a collection of samples.

### Method
POST (assumed, as it transforms data)

### Endpoint
`/simulator/samples/to-probabilities` (assumed)

### Parameters
#### Request Body
- **samples** (vector<vector<bool>>) - Required - A vector of samples, where each sample is a vector of booleans.

### Response
#### Success Response (200)
- **probabilities** (QssMap<double>) - A map where keys are QssIndex and values are probabilities.

#### Response Example
```json
{
  "probabilities": {
    "00": 0.5,
    "11": 0.5
  }
}
```
```

--------------------------------

### Incorrect Quantum Teleportation Implementation

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/tutorial/qexpr-teleport.html

An example of a flawed teleportation implementation using the '+' operator. This fails because measurements in Alice's protocol do not propagate to classical variables before Bob's corrections are applied.

```C++
PROTECT QExpr teleport1_join(qbit& q, qbit& a, qbit& b) {
    bool x = false;
    bool y = false;
    return bell00(a,b)
            + alice(q, a, x, y)
            + bob(b,x,y);
}
```

--------------------------------

### Define and execute quantum kernels

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/programming.html

Demonstrates the usage of quantum_kernel functions, including classical variable initialization, quantum gate operations like PrepZ, X, and MeasZ, and the behavior of classical variable evaluation within the kernel.

```C++
qbit q0;
qbit q1;

quantum_kernel void myKernel() {
  bool b = false;
  std::cout << "b has value false (0) here after initialization: "
            << b << "\n";
  PrepZ(q0);
  X(q0);
  MeasZ(q0, b);
  std::cout << "b still has value 0 here since the quantum gates are not complete: "
            << (int)c << "\n";
  PrepZ(q1);
  std::cout << "After all gates in quantum_kernel have executed, b has value true (1): "
            << b << "\n";
}
```

--------------------------------

### QExpr Returning Function Example (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/basics.html

Defines a C++ function that returns a QExpr, which can then be evaluated. This promotes modularity and reusability of quantum logic. Requires a single return statement.

```C++
QExpr prep_plus_qexpr(qbit& q) {
    return qexpr::_PrepZ(q) + qexpr::_H(q);
}

int main() {
  ...
  qexpr::eval_hold(prep_plus_qexpr(q));
  ...
}
```

--------------------------------

### Inline QExpr Evaluation Example (C++)

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/basics.html

Demonstrates constructing and evaluating a quantum kernel expression inline within an evaluation call. This allows for concise definition of simple quantum operations.

```C++
qexpr::eval_hold(qexpr::_PrepZ(q) + qexpr::_H(q));
```

--------------------------------

### Demonstrate Quantum Gates API in C++

Source: https://context7.com/intel/quantum-sdk-docs/llms.txt

Illustrates the usage of various quantum gates provided by the Intel Quantum SDK's `quintrinsics.h` header. This snippet covers single-qubit, two-qubit, three-qubit gates, as well as measurement and preparation operations.

```cpp
#include <clang/Quantum/quintrinsics.h>

qbit q[3];

quantum_kernel void demonstrate_gates() {
    // Single-qubit gates
    PrepZ(q[0]);           // Initialize to |0>
    H(q[0]);               // Hadamard gate
    X(q[1]);               // Pauli-X gate
    Y(q[2]);               // Pauli-Y gate
    Z(q[0]);               // Pauli-Z gate
    S(q[1]);               // Phase gate (pi/2 rotation)
    Sdag(q[1]);            // Phase inverse
    T(q[2]);               // T gate (pi/4 rotation)
    Tdag(q[2]);            // T inverse

    // Rotation gates with angle parameter
    RX(q[0], 0.5);         // X-axis rotation by 0.5 radians
    RY(q[1], 1.57);        // Y-axis rotation
    RZ(q[2], 3.14);        // Z-axis rotation
    RXY(q[0], 0.5, 1.0);   // XY-plane rotation

    // Two-qubit gates
    CNOT(q[0], q[1]);      // Controlled-NOT
    CZ(q[0], q[1]);        // Controlled-Z
    SWAP(q[1], q[2]);      // SWAP gate
    CPhase(q[0], q[1], 0.5); // Controlled phase
    SwapA(q[1], q[2], 0.5);  // Swap alpha

    // Three-qubit gates
    Toffoli(q[0], q[1], q[2]); // Toffoli (CCNOT)

    // Measurement operations
    cbit c[3];
    MeasZ(q[0], c[0]);     // Measure in Z basis
    MeasX(q[1], c[1]);     // Measure in X basis
    MeasY(q[2], c[2]);     // Measure in Y basis
}

```

--------------------------------

### Device Management API

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Methods for initializing and controlling the state of a quantum device.

```APIDOC
## POST /device/initialize

### Description
Initialize the simulator instance with the provided configuration settings.

### Method
POST

### Parameters
#### Request Body
- **device_config** (DeviceConfig) - Required - The configuration object for the simulator.

### Response
#### Success Response (200)
- **status** (QRT_ERROR_T) - Returns success or error code.

---

## POST /device/ready

### Description
Specify that the next quantum_kernel called will be executed on the target device.

### Method
POST

### Response
#### Success Response (200)
- **status** (QRT_ERROR_T) - Returns success or error code.
```

--------------------------------

### CustomSimulator Initialization

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

Initializes the CustomSimulator. Can be initialized with default settings or a specific device configuration.

```APIDOC
## CustomSimulator Initialization

### Description
Initializes the CustomSimulator. Can be initialized with default settings or a specific device configuration.

### Method
POST

### Endpoint
/api/quantum/simulator/init

### Parameters
#### Request Body
- **device_config** (object) - Optional - Configuration for the device.
  - **field1** (type) - Description

### Request Example
```json
{
  "device_config": {
    "field1": "value1"
  }
}
```

### Response
#### Success Response (200)
- **simulator_id** (string) - A unique identifier for the initialized simulator.

#### Response Example
```json
{
  "simulator_id": "sim_12345"
}
```
```

--------------------------------

### QList slicing operations

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/fleq/qlist.html

Illustrates various slicing operations on QList objects: extracting a sublist by start and end indices, right shift, left shift, and right shift using the '+' operator. These operations return new QList objects representing the slices.

```cpp
qlist::QList slice = qs(start, end);
qlist::QList right_shifted = qs >> i;
qlist::QList left_shifted = qs << i;
qlist::QList right_shifted_plus = qs + i;
qlist::QList incremented_slice = ++qs;
```

--------------------------------

### createSimulator

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/custom_backend.html

Registers and initializes a new custom simulator instance.

```APIDOC
## POST createSimulator

### Description
Registers and creates a custom backend simulator instance for quantum operations.

### Method
POST

### Endpoint
createSimulator(std::string device_id, Ts... args)

### Parameters
#### Path Parameters
- **device_id** (string) - Required - The unique identifier for the custom backend.
- **args** (Ts...) - Required - Variadic arguments for simulator initialization.

### Request Example
{
  "device_id": "custom_simulator_01",
  "args": []
}

### Response
#### Success Response (200)
- **CustomSimulator*** (pointer) - A pointer to the created CustomSimulator object.

#### Response Example
{
  "simulator_ptr": "0x0045f2a1"
}
```

--------------------------------

### QList Constructors and Basic Operations

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/api/api.html

This section covers the constructors for the QList class, allowing for initialization with default values, qubit arrays, single qubits, and copy construction. It also includes basic operations like element access and size retrieval.

```APIDOC
## QList Constructors and Basic Operations

### Description
Provides constructors for creating and initializing QList objects, along with methods for accessing elements and determining the list's size.

### Method
Various (Constructors, Operators)

### Endpoint
N/A (Class methods)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```
// Default constructor
qlist::QList defaultList;

// Constructor from qubit array
qbit* qubitArray = ...;
qlist::QList listFromArray(qubitArray);

// Constructor from single qubit
qbit singleQubit = ...;
qlist::QList listFromQubit(singleQubit);

// Copy constructor
qlist::QList anotherList = listFromArray;

// Accessing elements
qbit element = listFromArray[0];

// Getting size
unsigned long size = listFromArray.size();
```

### Response
#### Success Response (N/A)
- **QList** (object) - A QList object.
- **qbit** (object) - A qubit reference.
- **unsigned long** (integer) - The size of the QList.

#### Response Example
```json
// Example of accessing an element
// Assuming qs = {a,b,c}, qs[1] would return b

// Example of size
// Assuming qs = {a,b,c}, qs.size() would return 3
```
```

--------------------------------

### Define Custom Quantum Operation with iqsdk::IqsCustomOp

Source: https://github.com/intel/quantum-sdk-docs/blob/main/docs/dgr/iqs.html

Demonstrates the initialization of `iqsdk::IqsCustomOp` to define a custom quantum operation. This includes setting pre- and post-operation noise parameters, the process matrix, and a unique label for the operation. An empty `process_matrix` can be used for ideal operations.

```cpp
IqsCustomOp op = {pre_dephasing, pre_depolarizing, pre_amplitude_damping, pre_bitflip,
                 process_matrix, label,
                 post_dephasing, post_depolarizing, post_amplitude_damping, post_bitflip};
```