12994743540

Committed 27 Jan 2025 05:29PM UTC coverage: 88.94% (-0.01%) from 88.95%

Build # 12994743540

Build Type

Pull #13743

github

Committed by

web-flow

Commit Message

Merge b3ec92919 into c085ec50a

Pull Request Pull Request #13743: Remove use of deprecated objects in `BasicSimulator`

Coverage Stats

90 of 91 new or added lines in 1 file covered. (98.9%)

35 existing lines in 9 files now uncovered.

79685 of 89594 relevant lines covered (88.94%)

350886.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.08

/qiskit/providers/basic_provider/basic_simulator.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

"""Contains a (slow) Python simulator.

It simulates a quantum circuit (an experiment) that has been compiled
to run on the simulator. It is exponential in the number of qubits.

The simulator is run using

.. plot::
   :include-source:
   :nofigs:

   BasicSimulator().run(run_input)

Where the input is a :class:`.QuantumCircuit` object and the output is a
:class:`.BasicProviderJob` object,
which can later be queried for the Result object. The result will contain a 'memory' data
field, which is a result of measurements for each shot.
"""

from __future__ import annotations

import math
import uuid
import time
import logging
import warnings

from collections import Counter
import numpy as np

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import UnitaryGate
from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping, GlobalPhaseGate
from qiskit.providers import Provider
from qiskit.providers.backend import BackendV2
from qiskit.providers.options import Options
from qiskit.result import Result
from qiskit.transpiler import Target

from .basic_provider_job import BasicProviderJob
from .basic_provider_tools import single_gate_matrix
from .basic_provider_tools import (
    SINGLE_QUBIT_GATES,
    TWO_QUBIT_GATES,
    TWO_QUBIT_GATES_WITH_PARAMETERS,
    THREE_QUBIT_GATES,
)
from .basic_provider_tools import einsum_vecmul_index
from .exceptions import BasicProviderError

logger = logging.getLogger(__name__)


class BasicSimulator(BackendV2):
    """Python implementation of a basic (non-efficient) quantum simulator."""

    # Formerly calculated as `int(log2(local_hardware_info()["memory"]*(1024**3)/16))`.
    # After the removal of `local_hardware_info()`, it's hardcoded to 24 qubits,
    # which matches the ~268 MB of required memory.
    MAX_QUBITS_MEMORY = 24

    def __init__(
        self,
        provider: Provider | None = None,
        target: Target | None = None,
        **fields,
    ) -> None:
        """
        Args:
            provider: An optional backwards reference to the
                :class:`~qiskit.providers.Provider` object that the backend
                is from.
            target: An optional target to configure the simulator.
            fields: kwargs for the values to use to override the default
                options.

        Raises:
            AttributeError: If a field is specified that's outside the backend's
                options.
        """

        super().__init__(
            provider=provider,
            name="basic_simulator",
            description="A python simulator for quantum experiments",
            backend_version="0.1",
            **fields,
        )

        self._target = target
        # Internal simulator variables
        self._local_random = None
        self._classical_memory = 0
        self._classical_register = 0
        self._statevector = 0
        self._number_of_cmembits = 0
        self._number_of_qubits = 0
        self._shots = self.options.get("shots")
        self._memory = self.options.get("memory")
        self._initial_statevector = self.options.get("initial_statevector")
        self._chop_threshold = self.options.get("chop_threashold")
        self._sample_measure = False

    @property
    def max_circuits(self) -> None:
        return None

    @property
    def target(self) -> Target:
        if not self._target:
            self._target = self._build_basic_target()
        return self._target

    def _build_basic_target(self) -> Target:
        """Helper method that returns a minimal target with a basis gate set but
        no coupling map, instruction properties or calibrations.

        Returns:
            The configured target.
        """
        # Set num_qubits to None to signal the transpiler not to
        # resize the circuit to fit a specific (potentially too large)
        # number of qubits. The number of qubits in the circuits given to the
        # `run` method will determine the size of the simulated statevector.
        target = Target(
            description="Basic Target",
            num_qubits=None,
        )
        basis_gates = [
            "ccx",
            "ccz",
            "ch",
            "cp",
            "crx",
            "cry",
            "crz",
            "cs",
            "csdg",
            "cswap",
            "csx",
            "cu",
            "cu1",
            "cu3",
            "cx",
            "cy",
            "cz",
            "dcx",
            "delay",
            "ecr",
            "global_phase",
            "h",
            "id",
            "iswap",
            "measure",
            "p",
            "r",
            "rccx",
            "reset",
            "rx",
            "rxx",
            "ry",
            "ryy",
            "rz",
            "rzx",
            "rzz",
            "s",
            "sdg",
            "swap",
            "sx",
            "sxdg",
            "t",
            "tdg",
            "u",
            "u1",
            "u2",
            "u3",
            "unitary",
            "x",
            "xx_minus_yy",
            "xx_plus_yy",
            "y",
            "z",
        ]
        inst_mapping = get_standard_gate_name_mapping()
        for name in basis_gates:
            if name in inst_mapping:
                instruction = inst_mapping[name]
                target.add_instruction(instruction, properties=None, name=name)
            elif name == "unitary":
                # This is a placeholder for a UnitaryGate instance,
                # to signal the transpiler not to decompose unitaries
                # in the circuit.
                target.add_instruction(UnitaryGate, name="unitary")
            else:
                raise BasicProviderError(
                    f"Gate is not a valid basis gate for this simulator: {name}"
                )
        return target

    @classmethod
    def _default_options(cls) -> Options:
        return Options(
            shots=1024,
            memory=False,
            initial_statevector=None,
            chop_threshold=1e-15,
            allow_sample_measuring=True,
            seed_simulator=None,
            parameter_binds=None,
        )

    def _add_unitary(self, gate: np.ndarray, qubits: list[int]) -> None:
        """Apply an N-qubit unitary matrix.

        Args:
            gate (matrix_like): an N-qubit unitary matrix
            qubits (list): the list of N-qubits.
        """
        # Get the number of qubits
        num_qubits = len(qubits)
        # Compute einsum index string for 1-qubit matrix multiplication
        indexes = einsum_vecmul_index(qubits, self._number_of_qubits)
        # Convert to complex rank-2N tensor
        gate_tensor = np.reshape(np.array(gate, dtype=complex), num_qubits * [2, 2])
        # Apply matrix multiplication
        self._statevector = np.einsum(
            indexes, gate_tensor, self._statevector, dtype=complex, casting="no"
        )

    def _get_measure_outcome(self, qubit: int) -> tuple[str, int]:
        """Simulate the outcome of measurement of a qubit.

        Args:
            qubit: the qubit to measure

        Return:
            pair (outcome, probability) where outcome is '0' or '1' and
            probability is the probability of the returned outcome.
        """
        # Axis for numpy.sum to compute probabilities
        axis = list(range(self._number_of_qubits))
        axis.remove(self._number_of_qubits - 1 - qubit)
        probabilities = np.sum(np.abs(self._statevector) ** 2, axis=tuple(axis))
        # Compute einsum index string for 1-qubit matrix multiplication
        random_number = self._local_random.random()
        if random_number < probabilities[0]:
            return "0", probabilities[0]
        # Else outcome was '1'
        return "1", probabilities[1]

    def _add_sample_measure(
        self, measure_params: list[list[int, int]], num_samples: int
    ) -> list[hex]:
        """Generate memory samples from current statevector.

        Args:
            measure_params: List of (qubit, cmembit) values for
                                   measure instructions to sample.
            num_samples: The number of memory samples to generate.

        Returns:
            A list of memory values in hex format.
        """
        # Get unique qubits that are actually measured and sort in
        # ascending order
        measured_qubits = sorted({qubit for qubit, cmembit in measure_params})
        num_measured = len(measured_qubits)
        # We use the axis kwarg for numpy.sum to compute probabilities
        # this sums over all non-measured qubits to return a vector
        # of measure probabilities for the measured qubits
        axis = list(range(self._number_of_qubits))
        for qubit in reversed(measured_qubits):
            # Remove from largest qubit to smallest so list position is correct
            # with respect to position from end of the list
            axis.remove(self._number_of_qubits - 1 - qubit)
        probabilities = np.reshape(
            np.sum(np.abs(self._statevector) ** 2, axis=tuple(axis)), 2**num_measured
        )
        # Generate samples on measured qubits as ints with qubit
        # position in the bit-string for each int given by the qubit
        # position in the sorted measured_qubits list
        samples = self._local_random.choice(range(2**num_measured), num_samples, p=probabilities)
        # Convert the ints to bitstrings
        memory = []
        for sample in samples:
            classical_memory = self._classical_memory
            for qubit, cmembit in measure_params:
                pos = measured_qubits.index(qubit)
                qubit_outcome = int((sample & (1 << pos)) >> pos)
                membit = 1 << cmembit
                classical_memory = (classical_memory & (~membit)) | (qubit_outcome << cmembit)
            value = bin(classical_memory)[2:]
            memory.append(hex(int(value, 2)))
        return memory

    def _add_measure(self, qubit: int, cmembit: int, cregbit: int | None = None) -> None:
        """Apply a measure instruction to a qubit.

        Args:
            qubit: qubit is the qubit measured.
            cmembit: is the classical memory bit to store outcome in.
            cregbit: is the classical register bit to store outcome in.
        """
        # get measure outcome
        outcome, probability = self._get_measure_outcome(qubit)
        # update classical state
        membit = 1 << cmembit
        self._classical_memory = (self._classical_memory & (~membit)) | (int(outcome) << cmembit)

        if cregbit is not None:
            regbit = 1 << cregbit
            self._classical_register = (self._classical_register & (~regbit)) | (
                int(outcome) << cregbit
            )

        # update quantum state
        if outcome == "0":
            update_diag = [[1 / math.sqrt(probability), 0], [0, 0]]
        else:
            update_diag = [[0, 0], [0, 1 / math.sqrt(probability)]]
        # update classical state
        self._add_unitary(update_diag, [qubit])

    def _add_reset(self, qubit: int) -> None:
        """Apply a reset instruction to a qubit.

        Args:
            qubit: the qubit being rest

        This is done by doing a simulating a measurement
        outcome and projecting onto the outcome state while
        renormalizing.
        """
        # get measure outcome
        outcome, probability = self._get_measure_outcome(qubit)
        # update quantum state
        if outcome == "0":
            update = [[1 / math.sqrt(probability), 0], [0, 0]]
            self._add_unitary(update, [qubit])
        else:
            update = [[0, 1 / math.sqrt(probability)], [0, 0]]
            self._add_unitary(update, [qubit])

    def _validate_initial_statevector(self) -> None:
        """Validate an initial statevector"""
        # If the initial statevector isn't set we don't need to validate
        if self._initial_statevector is None:
            return
        # Check statevector is correct length for number of qubits
        length = len(self._initial_statevector)
        required_dim = 2**self._number_of_qubits
        if length != required_dim:
            raise BasicProviderError(
                f"initial statevector is incorrect length: {length} != {required_dim}"
            )

    def _set_options(self, backend_options: dict | None = None) -> None:
        """Set the backend options for all experiments"""
        # Reset default options
        self._initial_statevector = self.options.get("initial_statevector")
        self._chop_threshold = self.options.get("chop_threshold")
        if "backend_options" in backend_options and backend_options["backend_options"]:
            backend_options = backend_options["backend_options"]

        # Check for custom initial statevector in backend_options first,
        # then config second
        if (
            "initial_statevector" in backend_options
            and backend_options["initial_statevector"] is not None
        ):
            self._initial_statevector = np.array(
                backend_options["initial_statevector"], dtype=complex
            )

        if self._initial_statevector is not None:
            # Check the initial statevector is normalized
            norm = np.linalg.norm(self._initial_statevector)
            if round(norm, 12) != 1:
                raise BasicProviderError(f"initial statevector is not normalized: norm {norm} != 1")
        # Check for custom chop threshold
        # Replace with custom options
        if "chop_threshold" in backend_options:
            self._chop_threshold = backend_options["chop_threshold"]

    def _initialize_statevector(self) -> None:
        """Set the initial statevector for simulation"""
        if self._initial_statevector is None:
            # Set to default state of all qubits in |0>
            self._statevector = np.zeros(2**self._number_of_qubits, dtype=complex)
            self._statevector[0] = 1
        else:
            self._statevector = self._initial_statevector.copy()
        # Reshape to rank-N tensor
        self._statevector = np.reshape(self._statevector, self._number_of_qubits * [2])

    def run(
        self, run_input: QuantumCircuit | list[QuantumCircuit], **backend_options
    ) -> BasicProviderJob:
        """Run on the backend.

        Args:
            run_input: payload of the experiment
            backend_options: backend options

        Returns:
            BasicProviderJob: derived from BaseJob

        Additional Information:
            backend_options: Is a dict of options for the backend. It may contain
                * "initial_statevector": vector_like

            The "initial_statevector" option specifies a custom initial
            initial statevector for the simulator to be used instead of the all
            zero state. This size of this vector must be correct for the number
            of qubits in ``run_input`` parameter.

            Example::

                backend_options = {
                    "initial_statevector": np.array([1, 0, 0, 1j]) / math.sqrt(2),
                }
        """
        out_options = {}
        for key, value in backend_options.items():
            if not hasattr(self.options, key):
                warnings.warn(
                    f"Option {key} is not used by this backend", UserWarning, stacklevel=2
                )
            else:
                out_options[key] = value
        self._set_options(backend_options=backend_options)
        job_id = str(uuid.uuid4())
        job = BasicProviderJob(self, job_id, self._run_job(job_id, run_input, **out_options))
        return job

    def _run_job(self, job_id: str, run_input, **backend_options) -> Result:
        """Run experiments in job

        Args:
            job_id: unique id for the job.
            run_input: circuits to be run.
            **backend_options: run options.

        Returns:
            Result object
        """
        if isinstance(run_input, QuantumCircuit):
            run_input = [run_input]

        self._validate(run_input)
        result_list = []
        self._memory = True
        start = time.time()
        for experiment in run_input:
            result_list.append(self._run_circuit(experiment, **backend_options))
        end = time.time()
        result = {
            "backend_name": self.name,
            "backend_version": self.backend_version,
            "qobj_id": None,
            "job_id": job_id,
            "results": result_list,
            "status": "COMPLETED",
            "success": True,
            "time_taken": (end - start),
        }

        return Result.from_dict(result)

    def _run_circuit(self, circuit, **backend_options):
        start = time.time()

        # from _assemble_circuit ==================
        num_qubits = 0
        memory_slots = 0
        qubit_labels = []
        clbit_labels = []

        qreg_sizes = []
        creg_sizes = []
        for qreg in circuit.qregs:
            qreg_sizes.append([qreg.name, qreg.size])
            for j in range(qreg.size):
                qubit_labels.append([qreg.name, j])
            num_qubits += qreg.size
        for creg in circuit.cregs:
            creg_sizes.append([creg.name, creg.size])
            for j in range(creg.size):
                clbit_labels.append([creg.name, j])
            memory_slots += creg.size

        metadata = circuit.metadata
        if metadata is None:
            metadata = {}

        is_conditional_experiment = any(
            getattr(instruction.operation, "_condition", None) for instruction in circuit.data
        )

        # till here ====================
        self._number_of_qubits = num_qubits
        self._number_of_cmembits = memory_slots
        self._statevector = 0
        self._classical_memory = 0
        self._classical_register = 0
        self._sample_measure = False
        global_phase = circuit.global_phase

        qubit_indices = {qubit: idx for idx, qubit in enumerate(circuit.qubits)}
        clbit_indices = {clbit: idx for idx, clbit in enumerate(circuit.clbits)}

        # Validate the dimension of initial statevector if set
        self._validate_initial_statevector()

        # Get the seed looking in user options, stored options, and then random.
        if "seed_simulator" in backend_options:
            seed_simulator = backend_options["seed_simulator"]
        elif hasattr(self.options, "seed_simulator"):
            seed_simulator = self.options["seed_simulator"]
        else:
            # For compatibility on Windows force dyte to be int32
            # and set the maximum value to be (2 ** 31) - 1
            seed_simulator = np.random.randint(2147483647, dtype="int32")

        self._local_random = np.random.default_rng(seed=seed_simulator)
        # Check if measure sampling is supported for current circuit

        # From self._validate_measure_sampling ====================

        if "shots" in backend_options:
            self._shots = backend_options["shots"]

        # If shots=1 we should disable measure sampling.
        # This is also required for statevector simulator to return the
        # correct final statevector without silently dropping final measurements.
        if self._shots <= 1:
            measure_flag = False
        else:
            measure_flag = False
            for instruction in circuit.data:
                # If circuit contains reset operations we cannot sample
                if instruction.name == "reset":
                    measure_flag = False
                # If circuit contains a measure option then we can
                # sample only if all following operations are measures
                if measure_flag:
                    # If we find a non-measure instruction
                    # we cannot do measure sampling
                    if instruction.name not in ["measure", "barrier", "id", "u0"]:
                        measure_flag = False
                elif instruction.name == "measure":
                    measure_flag = True
        # measure sampling is allowed
        self._sample_measure = measure_flag

        # ========================================== up till here

        # List of final counts for all shots
        memory = []
        # Check if we can sample measurements, if so we only perform 1 shot
        # and sample all outcomes from the final state vector
        if self._sample_measure:
            shots = 1
            # Store (qubit, cmembit) pairs for all measure ops in circuit to
            # be sampled
            measure_sample_ops = []
        else:
            shots = self._shots

        for _ in range(shots):
            self._initialize_statevector()
            # apply global_phase
            self._statevector *= np.exp(1j * global_phase)
            # Initialize classical memory to all 0
            self._classical_memory = 0
            self._classical_register = 0

            for operation in circuit.data:
                if operation.name == "unitary":
                    qargs = operation.qubits
                    qubits = [qubit_indices[qubit] for qubit in qargs]
                    gate = operation.params[0]
                    self._add_unitary(gate, qubits)
                elif operation.name in ("id", "u0", "delay"):
                    pass
                elif operation.name == "global_phase":
                    params = getattr(operation, "params", None)
                    gate = GlobalPhaseGate(*params).to_matrix()
                    self._add_unitary(gate, [])
                # Check if single qubit gate
                elif operation.name in SINGLE_QUBIT_GATES:
                    params = getattr(operation, "params", None)
                    qargs = operation.qubits
                    qubit = [qubit_indices[qubit] for qubit in qargs][0]
                    gate = single_gate_matrix(operation.name, params)
                    self._add_unitary(gate, [qubit])
                elif operation.name in TWO_QUBIT_GATES_WITH_PARAMETERS:
                    params = getattr(operation, "params", None)
                    qargs = operation.qubits
                    qubits = [qubit_indices[qubit] for qubit in qargs]
                    qubit0 = qubits[0]
                    qubit1 = qubits[1]
                    gate = TWO_QUBIT_GATES_WITH_PARAMETERS[operation.name](*params).to_matrix()
                    self._add_unitary(gate, [qubit0, qubit1])
                elif operation.name in ("id", "u0"):
                    pass
                elif operation.name in TWO_QUBIT_GATES:
                    qargs = operation.qubits
                    qubits = [qubit_indices[qubit] for qubit in qargs]
                    qubit0 = qubits[0]
                    qubit1 = qubits[1]
                    gate = TWO_QUBIT_GATES[operation.name]
                    self._add_unitary(gate, [qubit0, qubit1])
                elif operation.name in THREE_QUBIT_GATES:
                    qargs = operation.qubits
                    qubits = [qubit_indices[qubit] for qubit in qargs]
                    qubit0 = qubits[0]
                    qubit1 = qubits[1]
                    qubit2 = qubits[2]
                    gate = THREE_QUBIT_GATES[operation.name]
                    self._add_unitary(gate, [qubit0, qubit1, qubit2])
                # Check if reset
                elif operation.name == "reset":
                    qargs = operation.qubits
                    qubits = [qubit_indices[qubit] for qubit in qargs]
                    qubit = qubits[0]
                    self._add_reset(qubit)
                # Check if barrier
                elif operation.name == "barrier":
                    pass
                # Check if measure
                elif operation.name == "measure":
                    qargs = operation.qubits
                    qubit = [qubit_indices[qubit] for qubit in qargs][0]
                    cargs = operation.clbits
                    cmembit = [clbit_indices[clbit] for clbit in cargs][0]
                    cregbit = (
                        [clbit_indices[clbit] for clbit in cargs][0]
                        if is_conditional_experiment
                        else None
                    )

                    if self._sample_measure:
                        # If sampling measurements record the qubit and cmembit
                        # for this measurement for later sampling
                        measure_sample_ops.append((qubit, cmembit))
                    else:
                        # If not sampling perform measurement as normal
                        self._add_measure(qubit, cmembit, cregbit)
                else:
                    backend = self.name
                    err_msg = '{0} encountered unrecognized operation "{1}"'
                    raise BasicProviderError(err_msg.format(backend, operation.name))

            # Add final creg data to memory list
            if self._number_of_cmembits > 0:
                if self._sample_measure:
                    # If sampling we generate all shot samples from the final statevector
                    memory = self._add_sample_measure(measure_sample_ops, self._shots)
                else:
                    # Turn classical_memory (int) into bit string and pad zero for unused cmembits
                    outcome = bin(self._classical_memory)[2:]
                    memory.append(hex(int(outcome, 2)))

        # Add data
        data = {"counts": dict(Counter(memory))}
        # Optionally add memory list
        if self._memory:
            data["memory"] = memory
        end = time.time()

        header = {
            "qubit_labels": qubit_labels,
            "n_qubits": circuit.num_qubits,
            "qreg_sizes": qreg_sizes,
            "creg_sizes": creg_sizes,
            "clbit_labels": clbit_labels,
            "memory_slots": memory_slots,
            "name": circuit.name,
            "global_phase": circuit.global_phase,
            "metadata": circuit.metadata,
        }

        return {
            "name": circuit.name,
            "seed_simulator": seed_simulator,
            "shots": self._shots,
            "data": data,
            "status": "DONE",
            "success": True,
            "header": header,
            "time_taken": (end - start),
        }

    def _validate(self, run_input: list[QuantumCircuit]) -> None:
        """Semantic validations of the input."""
        max_qubits = self.MAX_QUBITS_MEMORY

        for circuit in run_input:
            if circuit.num_qubits > max_qubits:
                raise BasicProviderError(
                    f"Number of qubits {circuit.num_qubits} is greater than maximum ({max_qubits}) "
                    f'for "{self.name}".'
                )
            name = circuit.name
            if len(circuit.cregs) == 0:
                logger.warning(
                    'No classical registers in circuit "%s", counts will be empty.', name
                )
            elif "measure" not in [op.name for op in circuit.data]:
                logger.warning(
                    'No measurements in circuit "%s", classical register will remain all zeros.',
                    name,
                )

Qiskit / qiskit / 12994743540

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous