randomized_measure_v1

EchoListenRandomizedV1 - Wave Function Overlap by Randomized Measure (qurry.qurrech.randomized_measure_v1)

arguments

EchoListenRandomizedV1 - Arguments (qurry.qurrech.randomized_measure_v1.arguments)

This is a deprecated version of the randomized measure module.

class qurry.qurrech.randomized_measure_v1.arguments.EchoListenRandomizedV1AnalyzeArgs[source]

The input of the analyze method.

backend: Literal['Cython', 'Rust', 'Python'] | str

The backend for the process.

counts_used: Iterable[int] | None

The index of the counts used.

degree: tuple[int, int] | int | None

The degree range.

independent_all_system: bool

If True, then calculate the all system independently.

workers_num: int | None

The number of workers for multiprocessing.

class qurry.qurrech.randomized_measure_v1.arguments.EchoListenRandomizedV1Arguments(exp_name: str = 'exps', times: int = 100, measure: tuple[int, int] | None = None, unitary_loc: tuple[int, int] | None = None, random_unitary_seeds: dict[int, dict[int, int]] | None = None, workers_num: int = 16)[source]

Arguments for the experiment.

exp_name: str = 'exps'

The name of the experiment. Naming this experiment to recognize it when the jobs are pending to IBMQ Service. This name is also used for creating a folder to store the exports. Defaults to ‘experiment’.

measure: tuple[int, int] | None = None

The measure range.

random_unitary_seeds: dict[int, dict[int, int]] | None = None

The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

times: int = 100

The number of random unitary operator. It will denote as N_U in the experiment name.

unitary_loc: tuple[int, int] | None = None

The range of the unitary operator.

workers_num: int = 16

The number of workers for multiprocessing.

class qurry.qurrech.randomized_measure_v1.arguments.EchoListenRandomizedV1MeasureArgs[source]

Output arguments for output().

measure: int | tuple[int, int] | None

The measure range.

random_unitary_seeds: dict[int, dict[int, int]] | None

The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

times: int

The number of random unitary operator. It will denote as N_U in the experiment name.

unitary_loc: int | tuple[int, int] | None

The range of the unitary operator.

wave1: QuantumCircuit | Hashable | None

The key or the circuit to execute.

wave2: QuantumCircuit | Hashable | None

The key or the circuit to execute.

class qurry.qurrech.randomized_measure_v1.arguments.EchoListenRandomizedV1OutputArgs[source]

Output arguments for output().

measure: int | tuple[int, int] | None

The measure range.

random_unitary_seeds: dict[int, dict[int, int]] | None

The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

times: int

The number of random unitary operator. It will denote as N_U in the experiment name.

unitary_loc: int | tuple[int, int] | None

The range of the unitary operator.

analysis

EchoListenRandomizedV1 - Analysis (qurry.qurrech.randomized_measure_v1.analysis)

class qurry.qurrech.randomized_measure_v1.analysis.ELRV1AnalysisContent(echo: float, echoSD: float, echoCells: dict[int, float], bitStringRange: tuple[int, int], measureActually: tuple[int, int] | None = None, countsNum: int | None = None, takingTime: float | None = None, counts_used: Iterable[int] | None = None)[source]

The content of the analysis.

bitStringRange: tuple[int, int]

The qubit range of the subsystem.

countsNum: int | None

The number of counts of the experiment.

counts_used: Iterable[int] | None

The index of the counts used. If not specified, then use all counts.

echo: float

The purity of the system.

echoCells: dict[int, float]

The echo of each cell of the system.

echoSD: float

The standard deviation of the purity of the system.

measureActually: tuple[int, int] | None

The qubit range of the measurement actually used.

takingTime: float | None

The taking time of the selected system.

class qurry.qurrech.randomized_measure_v1.analysis.ELRV1AnalysisInput(degree: tuple[int, int], shots: int, unitary_loc: tuple[int, int] | None = None)[source]

To set the analysis.

degree: tuple[int, int]

The range of partition.

shots: int

The number of shots.

unitary_loc: tuple[int, int] | None

The location of the random unitary operator.

class qurry.qurrech.randomized_measure_v1.analysis.EchoListenRandomizedV1Analysis(*, serial: int, log: dict[str, Any] | None = None, datatime: str | None = None, **other_kwargs)[source]

The analysis of loschmidt echo.

classmethod content_type() → Type[ELRV1AnalysisContent][source]

The content instance type.

classmethod input_type() → Type[ELRV1AnalysisInput][source]

The input instance type.

property side_product_fields: Iterable[str]

The fields that will be stored as side product.

experiment

EchoListenRandomizedV1 - Experiment (qurry.qurrech.randomized_measure_v1.experiment)

The deprecated version of the randomized measure experiment.

class qurry.qurrech.randomized_measure_v1.experiment.EchoListenRandomizedV1Experiment(arguments: _A | dict[str, Any], commonparams: Commonparams | dict[str, Any], outfields: dict[str, Any], beforewards: Before | None = None, afterwards: After | None = None, reports: AnalysesContainer | None = None)[source]

The instance of experiment.

property analysis_instance: Type[EchoListenRandomizedV1Analysis]

The analysis instance for this experiment.

analyze(degree: tuple[int, int] | int | None = None, counts_used: Iterable[int] | None = None, workers_num: int | None = None, backend: Literal['Cython', 'Rust', 'Python'] | str = 'Rust', pbar: tqdm | None = None) → EchoListenRandomizedV1Analysis[source]

Calculate entangled entropy with more information combined.

Parameters:

  • degree (Union[tuple[int, int], int]) – Degree of the subsystem.

  • counts_used (Optional[Iterable[int]], optional) – The index of the counts used. If not specified, then use all counts. Defaults to None.

  • workers_num (Optional[int], optional) – Number of multi-processing workers, if sets to 1, then disable to using multi-processing; if not specified, then use the number of all cpu counts - 2 by cpu_count() - 2. Defaults to None.

  • backend (PostProcessingBackendLabel, optional) – Backend for the process. Defaults to DEFAULT_PROCESS_BACKEND.

  • pbar (Optional[tqdm.tqdm], optional) – Progress bar. Defaults to None.

Returns:

A dictionary contains

purity, entropy, a list of each overlap, puritySD, purity of all system, entropy of all system, a list of each overlap in all system, puritySD of all system, degree, actual measure range, actual measure range in all system, bitstring range.

Return type:

dict[str, float]

property arguments_instance: Type[EchoListenRandomizedV1Arguments]

The arguments instance for this experiment.

classmethod method(targets: list[tuple[Hashable, QuantumCircuit]], arguments: EchoListenRandomizedV1Arguments, pbar: tqdm | None = None, multiprocess: bool = True) → tuple[list[QuantumCircuit], dict[str, Any]][source]

The method to construct circuit.

Parameters:

  • targets (list[tuple[Hashable, QuantumCircuit]]) – The circuits of the experiment.

  • arguments (EchoListenRandomizedArguments) – The arguments of the experiment.

  • pbar (Optional[tqdm.tqdm], optional) – The progress bar for showing the progress of the experiment. Defaults to None.

  • multiprocess (bool, optional) – Whether to use multiprocessing. Defaults to True.

Returns:

The circuits of the experiment and the side products.

Return type:

tuple[list[QuantumCircuit], dict[str, Any]]

classmethod params_control(targets: list[tuple[Hashable, QuantumCircuit]], exp_name: str = 'exps', times: int = 100, measure: tuple[int, int] | int | None = None, unitary_loc: tuple[int, int] | int | None = None, random_unitary_seeds: dict[int, dict[int, int]] | None = None, **custom_kwargs: Any) → tuple[EchoListenRandomizedV1Arguments, Commonparams, dict[str, Any]][source]

Handling all arguments and initializing a single experiment.

Parameters:

  • targets (list[tuple[Hashable, QuantumCircuit]]) – The circuits of the experiment.

  • exp_name (str, optional) – The name of the experiment. Naming this experiment to recognize it when the jobs are pending to IBMQ Service. This name is also used for creating a folder to store the exports. Defaults to ‘experiment’.

  • times (int) – The number of random unitary operator. Defaults to 100. It will denote as N_U in the experiment name.

  • measure (Optional[Union[tuple[int, int], int]]) – The measure range. Defaults to None.

  • unitary_loc (Optional[Union[tuple[int, int], int]]) – The range of the unitary operator. Defaults to None.

  • random_unitary_seeds (Optional[dict[int, dict[int, int]]], optional) –

    The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

    If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

  • custom_kwargs (Any) – The custom parameters.

Raises:

  • ValueError – If the number of target circuits is not two.

  • TypeError – If times is not an integer.

  • ValueError – If the number of qubits in two circuits is not the same.

Returns:

The arguments of the experiment, the common parameters, and the custom parameters.

Return type:

tuple[EntropyMeasureRandomizedArguments, Commonparams, dict[str, Any]]

classmethod quantities(shots: int | None = None, counts: list[dict[str, int]] | None = None, degree: tuple[int, int] | int | None = None, measure: tuple[int, int] | None = None, backend: Literal['Cython', 'Rust', 'Python'] | str = 'Rust', workers_num: int | None = None, pbar: tqdm | None = None) → dict[str, float][source]

Calculate entangled entropy with more information combined.

Parameters:

  • shots (int) – Shots of the experiment on quantum machine.

  • counts (list[dict[str, int]]) – Counts of the experiment on quantum machine.

  • degree (Union[tuple[int, int], int]) – Degree of the subsystem.

  • measure (tuple[int, int], optional) – Measuring range on quantum circuits. Defaults to None.

  • backend (PostProcessingBackendLabel, optional) – Backend for the process. Defaults to DEFAULT_PROCESS_BACKEND.

  • workers_num (Optional[int], optional) – Number of multi-processing workers, if sets to 1, then disable to using multi-processing; if not specified, then use the number of all cpu counts - 2 by cpu_count() - 2. Defaults to None.

  • pbar (Optional[tqdm.tqdm], optional) – Progress bar. Defaults to None.

Returns:

A dictionary contains

purity, entropy, a list of each overlap, puritySD, purity of all system, entropy of all system, a list of each overlap in all system, puritySD of all system, degree, actual measure range, actual measure range in all system, bitstring range.

Return type:

dict[str, float]

qurry

EchoListenRandomizedV1 - Qurrium (qurry.qurrech.randomized_measure_v1.qurry)

This is a deprecated version of the randomized measure module.

class qurry.qurrech.randomized_measure_v1.qurry.EchoListenRandomizedV1[source]

Randomized Measure for wave function overlap. a.k.a. loschmidt echo when processes time evolution system.

Reference:

Note

  • Statistical correlations between locally randomized measurements:

A toolbox for probing entanglement in many-body quantum states - A. Elben, B. Vermersch, C. F. Roos, and P. Zoller, [PhysRevA.99.052323](

)

property experiment_instance: Type[EchoListenRandomizedV1Experiment]

The container class responding to this Qurrium class.

measure(wave1: QuantumCircuit | Hashable | None = None, wave2: QuantumCircuit | Hashable | None = None, times: int = 100, measure: int | tuple[int, int] | None = None, unitary_loc: int | tuple[int, int] | None = None, random_unitary_seeds: dict[int, dict[int, int]] | None = None, shots: int = 1024, backend: Backend | None = None, exp_name: str = 'experiment', run_args: BaseRunArgs | dict[str, Any] | None = None, transpile_args: TranspileArgs | None = None, passmanager: str | PassManager | tuple[str, PassManager] | None = None, tags: tuple[str, ...] | None = None, qasm_version: Literal['qasm2', 'qasm3'] = 'qasm3', export: bool = False, save_location: Path | str | None = None, pbar: tqdm | None = None) → str[source]

Execute the experiment.

Parameters:

  • wave1 (Union[QuantumCircuit, Hashable]) – The key or the circuit to execute.

  • wave2 (Union[QuantumCircuit, Hashable]) – The key or the circuit to execute.

  • times (int, optional) – The number of random unitary operator. It will denote as N_U in the experiment name. Defaults to 100.

  • measure (Union[int, tuple[int, int], None], optional) – The measure range. Defaults to None.

  • unitary_loc (Union[int, tuple[int, int], None], optional) – The range of the unitary operator. Defaults to None.

  • random_unitary_seeds (Optional[dict[int, dict[int, int]]], optional) –

    The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

    If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

  • shots (int, optional) – Shots of the job. Defaults to 1024.

  • backend (Optional[Backend], optional) – The quantum backend. Defaults to None.

  • exp_name (str, optional) – The name of the experiment. Naming this experiment to recognize it when the jobs are pending to IBMQ Service. This name is also used for creating a folder to store the exports. Defaults to ‘exps’.

  • run_args (RunArgsType, optional) – Arguments for Backend.run(). Defaults to None.

  • transpile_args (Optional[TranspileArgs], optional) – Arguments of transpile() from qiskit.compiler.transpiler. Defaults to None.

  • passmanager (PassManagerType, optional) – The passmanager. Defaults to None.

  • tags (Optional[tuple[str, ...]], optional) – The tags of the experiment. Defaults to None.

  • qasm_version (Literal["qasm2", "qasm3"], optional) – The version of OpenQASM. Defaults to “qasm3”.

  • export (bool, optional) – Whether to export the experiment. Defaults to False.

  • save_location (Optional[Union[Path, str]], optional) – The location to save the experiment. Defaults to None.

  • pbar (Optional[tqdm.tqdm], optional) – The progress bar for showing the progress of the experiment. Defaults to None.

Returns:

The ID of the experiment.

Return type:

str

measure_to_output(wave1: QuantumCircuit | Hashable | None = None, wave2: QuantumCircuit | Hashable | None = None, times: int = 100, measure: int | tuple[int, int] | None = None, unitary_loc: int | tuple[int, int] | None = None, random_unitary_seeds: dict[int, dict[int, int]] | None = None, shots: int = 1024, backend: Backend | None = None, exp_name: str = 'experiment', run_args: BaseRunArgs | dict[str, Any] | None = None, transpile_args: TranspileArgs | None = None, passmanager: str | PassManager | tuple[str, PassManager] | None = None, tags: tuple[str, ...] | None = None, qasm_version: Literal['qasm2', 'qasm3'] = 'qasm3', export: bool = False, save_location: Path | str | None = None, pbar: tqdm | None = None) → EchoListenRandomizedV1OutputArgs[source]

Trasnform measure() arguments form into output() form.

Parameters:

  • wave1 (Union[QuantumCircuit, Hashable]) – The key or the circuit to execute.

  • wave2 (Union[QuantumCircuit, Hashable]) – The key or the circuit to execute.

  • times (int, optional) – The number of random unitary operator. It will denote as N_U in the experiment name. Defaults to 100.

  • measure (Union[int, tuple[int, int], None], optional) – The measure range. Defaults to None.

  • unitary_loc (Union[int, tuple[int, int], None], optional) – The range of the unitary operator. Defaults to None.

  • random_unitary_seeds (Optional[dict[int, dict[int, int]]], optional) –

    The seeds for all random unitary operator. This argument only takes input as type of dict[int, dict[int, int]]. The first key is the index for the random unitary operator. The second key is the index for the qubit.

    If you want to generate the seeds for all random unitary operator, you can use the function generate_random_unitary_seeds in qurry.qurrium.utils.random_unitary.

  • shots (int, optional) – Shots of the job. Defaults to 1024.

  • backend (Optional[Backend], optional) – The quantum backend. Defaults to None.

  • exp_name (str, optional) – The name of the experiment. Naming this experiment to recognize it when the jobs are pending to IBMQ Service. This name is also used for creating a folder to store the exports. Defaults to ‘exps’.

  • run_args (RunArgsType, optional) – Arguments for Backend.run(). Defaults to None.

  • transpile_args (Optional[TranspileArgs], optional) – Arguments of transpile() from qiskit.compiler.transpiler. Defaults to None.

  • passmanager (PassManagerType, optional) – The passmanager. Defaults to None.

  • tags (Optional[tuple[str, ...]], optional) – The tags of the experiment. Defaults to None.

  • qasm_version (Literal["qasm2", "qasm3"], optional) – The version of OpenQASM. Defaults to “qasm3”.

  • export (bool, optional) – Whether to export the experiment. Defaults to False.

  • save_location (Optional[Union[Path, str]], optional) – The location to save the experiment. Defaults to None.

  • pbar (Optional[tqdm.tqdm], optional) – The progress bar for showing the progress of the experiment. Defaults to None.

Returns:

The output arguments.

Return type:

EchoListenRandomizedOutputArgs

multiAnalysis(summoner_id: str, *, analysis_name: str = 'report', no_serialize: bool = False, specific_analysis_args: dict[Hashable, EchoListenRandomizedV1AnalyzeArgs | dict[str, Any] | bool] | None = None, skip_write: bool = False, multiprocess_write: bool = False, degree: tuple[int, int] | int | None = None, counts_used: Iterable[int] | None = None, workers_num: int | None = None, backend: Literal['Cython', 'Rust', 'Python'] | str = 'Rust', **analysis_args) → str[source]

Run the analysis for multiple experiments.

Parameters:

  • summoner_id (str) – The summoner_id of multimanager.

  • analysis_name (str, optional) – The name of analysis. Defaults to ‘report’.

  • no_serialize (bool, optional) – Whether to serialize the analysis. Defaults to False.

  • ( (specific_analysis_args) – SpecificAnalsisArgs[EchoListenRandomizedV1AnalyzeArgs], optional

  • ) – The specific arguments for analysis. Defaults to None.

  • compress (bool, optional) – Whether to compress the export file. Defaults to False.

  • skip_write (bool, optional) – Whether to skip the file writing during the analysis. Defaults to False.

  • multiprocess_write (bool, optional) – Whether use multiprocess for writing. Defaults to False.

  • degree (Union[tuple[int, int], int]) – Degree of the subsystem.

  • counts_used (Optional[Iterable[int]], optional) – The index of the counts used. If not specified, then use all counts. Defaults to None.

  • workers_num (Optional[int], optional) – Number of multi-processing workers, if sets to 1, then disable to using multi-processing; if not specified, then use the number of all cpu counts - 2 by cpu_count() - 2. Defaults to None.

  • backend (PostProcessingBackendLabel, optional) – Backend for the process. Defaults to DEFAULT_PROCESS_BACKEND.

Returns:

The summoner_id of multimanager.

Return type:

str

short_name = 'qurrech_randomized_v1'

The short name of Qurrium.