Simulator

QuICT.simulation.Simulator

Simulator(device: str = 'CPU', backend: str = 'state_vector', precision: str = 'double', circuit_record: bool = False, amplitude_record: bool = False, output_path: str = None, hidden_empty_qubits: bool = False, **options)

The high-level simulation class, including all QuICT simulator mode.

Parameters:

• device (str, default: 'CPU' ) –

  The device of the simulator. One of [CPU, GPU]

• backend (str, default: 'state_vector' ) –

  The backend for the simulator. One of [unitary, state_vector, density_matrix]

• precision (str, default: 'double' ) –

  The precision of simulator, one of [single, double], default to double.

• circuit_record (bool, default: False ) –

  whether record circuit's qasm in output, default to False.

• amplitude_record (bool, default: False ) –

  whether record the amplitude of qubits, default to False.

• output_path (str, default: None ) –

  The output path for simulation result, default to None.

• **options (dict, default: {} ) –

  other optional parameters for the simulator. state_vector: [gpu_device_id] (only for gpu) density_matrix: [accumulated_mode] unitary: None

Source code in QuICT/simulation/simulator.py

def __init__(
    self,
    device: str = "CPU",
    backend: str = "state_vector",
    precision: str = "double",
    circuit_record: bool = False,
    amplitude_record: bool = False,
    output_path: str = None,
    hidden_empty_qubits: bool = False,
    **options
):
    """
    Args:
        device (str): The device of the simulator. One of [CPU, GPU]
        backend (str): The backend for the simulator. One of [unitary, state_vector, density_matrix]
        precision (str): The precision of simulator, one of [single, double], default to double.
        circuit_record (bool): whether record circuit's qasm in output, default to False.
        amplitude_record (bool): whether record the amplitude of qubits, default to False.
        output_path (str): The output path for simulation result, default to None.
        **options (dict): other optional parameters for the simulator.
            state_vector: [gpu_device_id] (only for gpu)
            density_matrix: [accumulated_mode]
            unitary: None
    """
    assert device in Simulator.__DEVICE, ValueError("Simulator.device", "[CPU, GPU]", device)
    self._device = device
    assert backend in Simulator.__BACKEND, \
        ValueError("Simulator.backend", "[unitary, state_vector, density_matrix]", backend)
    self._backend = backend
    assert precision in Simulator.__PRECISION, ValueError("Simulator.precision", "[single, double]", precision)
    self._precision = precision
    self._hidden_empty_qubits = hidden_empty_qubits

    self._options = options
    if options:
        if not self._options_validation(options):
            raise SimulatorOptionsUnmatchedError(
                f"Unmatched options arguments depending on {self._device} and {self._backend}."
            )

    # load simulator
    self._simulator = self._load_simulator()

    # Result's arguments
    self._result_recorder = Result(
        device, backend, precision, circuit_record, amplitude_record, self._options, output_path
    )

run

run(circuit: Union[Circuit, ndarray], shots: int = 1, quantum_state: ndarray = None, quantum_machine_model: Union[NoiseModel, VirtualQuantumMachine] = None, use_previous: bool = False)

start simulator with given circuit

Parameters:

• circuit (Union[Circuit, ndarray]) –

  The quantum Circuit or Unitary Matrix.

• shots (int, default: 1 ) –

  The sample times for current Circuit.

• quantum_state (ndarray, default: None ) –

  The initial Quantum State Vector/Density Matrix.

• quantum_machine_model (Union[NoiseModel, VirtualQuantumMachine], default: None ) –

  The model of quantum machine

• use_previous (bool, default: False ) –

  Using the previous state vector. Defaults to False.

Yields:

• –

  [dict]: The Result Dict.

Source code in QuICT/simulation/simulator.py

def run(
    self,
    circuit: Union[Circuit, np.ndarray],
    shots: int = 1,
    quantum_state: np.ndarray = None,
    quantum_machine_model: Union[NoiseModel, VirtualQuantumMachine] = None,
    use_previous: bool = False
):
    """ start simulator with given circuit

    Args:
        circuit Union[Circuit, np.ndarray]: The quantum Circuit or Unitary Matrix.
        shots (int): The sample times for current Circuit.
        quantum_state (ndarray): The initial Quantum State Vector/Density Matrix.
        quantum_machine_model (Union[NoiseModel, VirtualQuantumMachine]): The model of quantum machine
        use_previous (bool, optional): Using the previous state vector. Defaults to False.

    Yields:
        [dict]: The Result Dict.
    """
    # Deal with unitary matrix as input
    if isinstance(circuit, np.ndarray) and self._backend != "unitary":
        raise SimulatorOptionsUnmatchedError(
            f"The unitary matrix input only allows in the unitary backend, not {self._backend}."
        )

    if quantum_machine_model is not None and self._backend == "unitary":
        raise SimulatorOptionsUnmatchedError(
            "The Quantum Machine Model input only allows in the Unitary Simulator backend, " +
            f"not {self._backend}."
        )

    if quantum_state is not None:
        ndim = quantum_state.ndim
        if ndim == 2 and self._backend != "density_matrix":
            raise SimulatorOptionsUnmatchedError(
                f"The Density Matrix input only allows in the Density Matrix backend, not {self._backend}."
            )

        if ndim == 1 and self._backend == "density_matrix":
            raise SimulatorOptionsUnmatchedError(
                f"The State Vector input only allows in the Unitary/SV backend, not {self._backend}."
            )

    if isinstance(circuit, Circuit):
        self._result_recorder.record_circuit(circuit)

    if quantum_machine_model is not None:
        amplitude = self._simulator.run(circuit, quantum_state, quantum_machine_model, use_previous)
    else:
        amplitude = self._simulator.run(circuit, quantum_state, use_previous=use_previous)

    self._result_recorder.record_amplitude(amplitude)

    sample_result = self._simulator.sample(shots)
    self._result_recorder.record_sample(sample_result)

    return self._result_recorder.__dict__()