repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/unitaryfund/mitiq
|
unitaryfund
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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.
# pylint: disable=too-many-function-args, unexpected-keyword-arg
"""THIS FILE IS DEPRECATED AND WILL BE REMOVED IN RELEASE 0.9.
"""
import warnings
from qiskit.converters import dag_to_circuit, circuit_to_dag
from qiskit.transpiler import CouplingMap
from qiskit import compiler
from qiskit.transpiler.preset_passmanagers import (default_pass_manager_simulator,
default_pass_manager)
def transpile(circuits, backend=None, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""transpile one or more circuits.
Args:
circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile
backend (BaseBackend): a backend to compile for
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): coupling map (perhaps custom) to target in mapping
initial_layout (Layout or dict or list):
Initial position of virtual qubits on physical qubits. The final
layout is not guaranteed to be the same, as the transpiler may permute
qubits through swaps or other means.
seed_mapper (int): random seed for the swap_mapper
pass_manager (PassManager): a pass_manager for the transpiler stages
Returns:
QuantumCircuit or list[QuantumCircuit]: transpiled circuit(s).
Raises:
TranspilerError: in case of bad inputs to transpiler or errors in passes
"""
warnings.warn("qiskit.transpiler.transpile() has been deprecated and will be "
"removed in the 0.9 release. Use qiskit.compiler.transpile() instead.",
DeprecationWarning)
return compiler.transpile(circuits=circuits, backend=backend,
basis_gates=basis_gates, coupling_map=coupling_map,
initial_layout=initial_layout, seed_transpiler=seed_mapper,
pass_manager=pass_manager)
def transpile_dag(dag, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""Deprecated - Use qiskit.compiler.transpile for transpiling from
circuits to circuits.
Transform a dag circuit into another dag circuit
(transpile), through consecutive passes on the dag.
Args:
dag (DAGCircuit): dag circuit to transform via transpilation
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): A graph of coupling::
[
[control0(int), target0(int)],
[control1(int), target1(int)],
]
eg. [[0, 2], [1, 2], [1, 3], [3, 4]}
initial_layout (Layout or None): A layout object
seed_mapper (int): random seed_mapper for the swap mapper
pass_manager (PassManager): pass manager instance for the transpilation process
If None, a default set of passes are run.
Otherwise, the passes defined in it will run.
If contains no passes in it, no dag transformations occur.
Returns:
DAGCircuit: transformed dag
"""
warnings.warn("transpile_dag has been deprecated and will be removed in the "
"0.9 release. Circuits can be transpiled directly to other "
"circuits with the transpile function.", DeprecationWarning)
if basis_gates is None:
basis_gates = ['u1', 'u2', 'u3', 'cx', 'id']
if pass_manager is None:
# default set of passes
# if a coupling map is given compile to the map
if coupling_map:
pass_manager = default_pass_manager(basis_gates,
CouplingMap(coupling_map),
initial_layout,
seed_transpiler=seed_mapper)
else:
pass_manager = default_pass_manager_simulator(basis_gates)
# run the passes specified by the pass manager
# TODO return the property set too. See #1086
name = dag.name
circuit = dag_to_circuit(dag)
circuit = pass_manager.run(circuit)
dag = circuit_to_dag(circuit)
dag.name = name
return dag
|
https://github.com/noamsgl/IBMAscolaChallenge
|
noamsgl
|
import csv
import datetime
import os
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-education', group='technion-Weinste')
log_time = datetime.datetime.now()
def write_log_to_file(csv_writer):
for backend in provider.backends():
try:
for qubit_idx, qubit_prop in enumerate(backend.properties().qubits):
for prop in qubit_prop:
csv_writer.writerow(
[backend.name(), qubit_idx, prop.date.isoformat(), prop.name, prop.unit, prop.value,
log_time.isoformat()])
id_gate = [i for i in backend.properties().gates if i.gate == 'id' and qubit_idx in i.qubits][0]
id_gate_length = [p for p in id_gate.parameters if p.name == 'gate_length'][0]
csv_writer.writerow([backend.name(), qubit_idx, id_gate_length.date.isoformat(), 'id_length',
id_gate_length.unit, id_gate_length.value, log_time.isoformat()])
except Exception as e:
print("Cannot add backend", backend.name(), e)
path = '../docs/backend_properties/backend_properties_log.csv'
if not os.path.isfile(path):
with open(path, "w", newline='') as f:
csv_writer = csv.writer(f)
csv_writer.writerow(["backend", "qubit", "datetime", "name", "units", "value", "log_datetime"])
write_log_to_file(csv_writer)
else:
with open(path, "a", newline='') as f:
write_log_to_file(csv.writer(f))
|
https://github.com/C2QA/bosonic-qiskit
|
C2QA
|
import math
from pathlib import Path
import pytest
import random
import c2qa
import numpy as np
import qiskit
import qiskit_aer.noise as noise
from qiskit_aer.noise.noiseerror import NoiseError
from qiskit_aer.noise.passes.relaxation_noise_pass import RelaxationNoisePass
from qiskit.visualization import plot_histogram
def test_noise_model(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 2
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
qr = qiskit.QuantumRegister(2)
cr = qiskit.ClassicalRegister(size=1)
circuit = c2qa.CVCircuit(qmr, qr, cr)
for qumode in range(num_qumodes):
circuit.cv_initialize(0, qmr[qumode])
circuit.initialize([0, 1], qr[1]) # qr[0] will init to zero
alpha = random.random()
circuit.cv_c_d(alpha, qmr[0], qr[0])
circuit.cv_c_d(-alpha, qmr[0], qr[0])
circuit.cv_c_d(-alpha, qmr[0], qr[1])
circuit.cv_c_d(alpha, qmr[0], qr[1])
photon_loss_rate = 1000000 # per second
time = 5.0 # seconds
kraus_operators = c2qa.kraus.calculate_kraus(
photon_loss_rates=[photon_loss_rate, photon_loss_rate],
time=time,
circuit=circuit,
op_qubits=[0, 1, 2],
qumode_qubit_indices=[0, 1]
)
print("kraus")
print(kraus_operators)
state, result, fock_counts = c2qa.util.simulate(circuit)
def test_kraus_operators(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 2
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
qr = qiskit.QuantumRegister(2)
circuit = c2qa.CVCircuit(qmr, qr)
photon_loss_rate = 1000000 # per second
time = 1.0 # seconds
kraus_operators = c2qa.kraus.calculate_kraus(
photon_loss_rates=[photon_loss_rate, photon_loss_rate],
time=time,
circuit=circuit,
op_qubits=[0, 1, 2],
qumode_qubit_indices=[0, 1]
)
kraus = qiskit.quantum_info.operators.channel.Kraus(kraus_operators)
assert kraus.is_cp(), "Is not completely positive"
print()
print("Kraus Operators")
accum = 0j
for index, op in enumerate(kraus_operators):
print(f"op {index}")
print(op)
op_dag = np.transpose(np.conj(op))
print(f"op_dag {index}")
print(op_dag)
op_dot = np.dot(op_dag, op)
print(f"op_dot {index}")
print(op_dot)
accum += op_dot
print()
print("Sum")
print(accum)
is_identity = (accum.shape[0] == accum.shape[1]) and np.allclose(
accum, np.eye(accum.shape[0])
)
print(f"Sum is identity {is_identity}")
assert is_identity, "Sum is not identity"
assert kraus.is_tp(), "Is not trace preserving"
assert kraus.is_cptp(), "Is not CPTP"
def test_beamsplitter_kraus_operators(capsys):
with capsys.disabled():
num_qumodes = 2
qubits_per_mode = 2
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(2, qmr[0])
circuit.cv_bs(1, qmr[1], qmr[0], duration=100, unit="ns")
photon_loss_rate = 1000000 # per second
time = 1.0 # seconds
kraus_operators = c2qa.kraus.calculate_kraus(
photon_loss_rates=[photon_loss_rate, photon_loss_rate],
time=time,
circuit=circuit,
op_qubits=[2, 3, 0, 1],
qumode_qubit_indices=[0, 1, 2, 3]
)
kraus = qiskit.quantum_info.operators.channel.Kraus(kraus_operators)
assert kraus.is_cp(), "Is not completely positive"
print()
print("Kraus Operators")
accum = 0j
for index, op in enumerate(kraus_operators):
print(f"op {index}")
print(op)
op_dag = np.transpose(np.conj(op))
print(f"op_dag {index}")
print(op_dag)
op_dot = np.dot(op_dag, op)
print(f"op_dot {index}")
print(op_dot)
accum += op_dot
print()
print("Sum")
print(accum)
is_identity = (accum.shape[0] == accum.shape[1]) and np.allclose(
accum, np.eye(accum.shape[0])
)
print(f"Sum is identity {is_identity}")
assert is_identity, "Sum is not identity"
assert kraus.is_tp(), "Is not trace preserving"
assert kraus.is_cptp(), "Is not CPTP"
def test_invalid_photon_loss_rate_length(capsys):
with pytest.raises(Exception), capsys.disabled():
num_qumodes = 2
qubits_per_mode = 2
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
init_circuit = c2qa.CVCircuit(qmr)
init_circuit.cv_initialize(2, qmr[0])
init_circuit.cv_bs(1, qmr[1], qmr[0], duration=100, unit="ns")
photon_loss_rates = [1,2,3] # Should only have two loss rates
time_unit = "ns"
# Should raise Exception for not having proper number of loss rates
c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rates, circuit=init_circuit, time_unit=time_unit)
def test_valid_photon_loss_rate_length(capsys):
with capsys.disabled():
num_qumodes = 2
qubits_per_mode = 2
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
init_circuit = c2qa.CVCircuit(qmr)
init_circuit.cv_initialize(2, qmr[0])
init_circuit.cv_bs(1, qmr[1], qmr[0], duration=100, unit="ns")
photon_loss_rates = [1,2] # Should only have two loss rates
time_unit = "ns"
# Should not raise exception as has proper number of loss rates
c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rates, circuit=init_circuit, time_unit=time_unit)
def test_noise_with_beamsplitter(capsys):
with capsys.disabled():
num_qumodes = 2
qubits_per_mode = 2
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
init_circuit = c2qa.CVCircuit(qmr)
init_circuit.cv_initialize(2, qmr[0])
init_circuit.cv_bs(1, qmr[1], qmr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
def test_noise_with_beamsplitter_diff_cutoff(capsys):
with capsys.disabled():
qmr1 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=2)
qmr2 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=3)
init_circuit = c2qa.CVCircuit(qmr1, qmr2)
init_circuit.cv_initialize(2, qmr1[0])
init_circuit.cv_initialize(2, qmr2[0])
init_circuit.cv_bs(1, qmr1[0], qmr2[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
@pytest.mark.skip(reason="This test takes nearly 30 minutes to pass on Github...")
def test_noise_with_cbs_diff_cutoff(capsys):
with capsys.disabled():
qmr1 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=2)
qmr2 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=3)
qbr = qiskit.QuantumRegister(1)
init_circuit = c2qa.CVCircuit(qmr1, qmr2, qbr)
init_circuit.cv_initialize(2, qmr1[0])
init_circuit.cv_initialize(2, qmr2[0])
init_circuit.cv_c_bs(1, qmr1[0], qmr2[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
def test_noise_with_sq2_diff_cutoff(capsys):
with capsys.disabled():
qmr1 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=2)
qmr2 = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=3)
init_circuit = c2qa.CVCircuit(qmr1, qmr2)
init_circuit.cv_initialize(2, qmr1[0])
init_circuit.cv_initialize(2, qmr2[0])
init_circuit.cv_sq2(1, qmr1[0], qmr2[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
def test_noise_with_cnd_beamsplitter(capsys):
with capsys.disabled():
num_qumodes = 2
qubits_per_mode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
qbr = qiskit.QuantumRegister(size=num_qubits)
init_circuit = c2qa.CVCircuit(qmr, qbr)
init_circuit.cv_initialize(2, qmr[0])
init_circuit.cv_c_bs(1, qmr[1], qmr[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
def test_photon_loss_pass_with_conditional(capsys):
with capsys.disabled():
num_qumodes = 1
qubits_per_mode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
qbr = qiskit.QuantumRegister(size=num_qubits)
init_circuit = c2qa.CVCircuit(qmr, qbr)
init_circuit.cv_initialize(2, qmr[0])
init_circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=init_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(init_circuit, noise_passes=noise_pass)
def test_photon_loss_pass_delay_without_unit(capsys):
with capsys.disabled():
num_qumodes = 1
qubits_per_mode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
qbr = qiskit.QuantumRegister(size=num_qubits)
fail_circuit = c2qa.CVCircuit(qmr, qbr)
fail_circuit.cv_initialize(2, qmr[0])
fail_circuit.delay(duration=100) #, unit="ns")
fail_circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=fail_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(fail_circuit, noise_passes=noise_pass)
assert result.success
def test_photon_loss_pass_delay_with_unit(capsys):
with capsys.disabled():
num_qumodes = 1
qubits_per_mode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
qbr = qiskit.QuantumRegister(size=num_qubits)
pass_circuit = c2qa.CVCircuit(qmr, qbr)
pass_circuit.cv_initialize(2, qmr[0])
pass_circuit.delay(duration=100, unit="ns")
pass_circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=pass_circuit, time_unit=time_unit)
state, result, fock_counts = c2qa.util.simulate(pass_circuit, noise_passes=noise_pass)
assert result.success
def test_animate_photon_loss_pass(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 4
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_d(0, qmr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit)
wigner_filename = "tests/test_animate_photon_loss_pass.gif"
c2qa.animate.animate_wigner(
circuit,
animation_segments=10,
file=wigner_filename,
noise_passes=noise_pass,
)
assert Path(wigner_filename).is_file()
def test_animate_photon_loss_pass_with_epsilon(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 4
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_d(0, qmr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit)
wigner_filename = "tests/test_animate_photon_loss_pas_with_epsilon.gif"
c2qa.animate.animate_wigner(
circuit,
discretize_epsilon=0.1,
file=wigner_filename,
noise_passes=noise_pass,
)
assert Path(wigner_filename).is_file()
@pytest.mark.skip(reason="GitHub actions build environments do not have ffmpeg")
def test_photon_loss_pass_no_displacement(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 4
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_d(0, qmr[0], duration=100, unit="ns")
photon_loss_rate = 0.01
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit)
# state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
wigner_filename = "tests/test_photon_loss_pass_no_displacement.mp4"
c2qa.animate.animate_wigner(
circuit,
animation_segments=200,
file=wigner_filename,
noise_passes=noise_pass,
)
@pytest.mark.skip(reason="GitHub actions build environments do not have ffmpeg")
def test_photon_loss_pass_slow_displacement(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 4
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_d(1.5, qmr[0], duration=100, unit="ns")
photon_loss_rate = 0.02
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit)
# state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
wigner_filename = "tests/test_photon_loss_pass_slow_displacement.mp4"
c2qa.animate.animate_wigner(
circuit,
animation_segments=200,
file=wigner_filename,
noise_passes=noise_pass,
# draw_grid=True
)
@pytest.mark.skip(reason="GitHub actions build environments do not have ffmpeg")
def test_photon_loss_pass_slow_conditional_displacement(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 4
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.02
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit)
# state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
wigner_filename = "tests/test_photon_loss_pass_slow_conditional_displacement.mp4"
c2qa.animate.animate_wigner(
circuit,
animation_segments=200,
file=wigner_filename,
noise_passes=noise_pass,
)
def test_photon_loss_instruction(capsys):
with capsys.disabled():
num_qumodes = 2
num_qubits_per_qumode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(1, qmr[0])
circuit.cv_initialize(1, qmr[1])
circuit.cv_d(1, qmr[0], duration=100, unit="ns")
circuit.cv_c_d(1, qmr[1], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.02
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit, instructions=["cD"])
state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
assert result.success
def test_photon_loss_qumode(capsys):
with capsys.disabled():
num_qumodes = 2
num_qubits_per_qumode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(1, qmr[0])
circuit.cv_d(1, qmr[0], duration=100, unit="ns")
circuit.cv_c_d(1, qmr[1], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.02
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit, qumodes=qmr[1])
state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
assert result.success
def test_photon_loss_instruction_qumode(capsys):
with capsys.disabled():
num_qumodes = 2
num_qubits_per_qumode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(1, qmr[0])
circuit.cv_d(1, qmr[0], duration=100, unit="ns")
circuit.cv_c_d(1, qmr[1], qbr[0], duration=100, unit="ns")
photon_loss_rate = 0.02
time_unit = "ns"
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit=time_unit, instructions=["cD"], qumodes=qmr[0])
state, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
assert result.success
def test_photon_loss_and_phase_damping(capsys):
with capsys.disabled():
state_a, result_a, fock_counts = _build_photon_loss_and_amp_damping_circuit(0.0)
print(state_a)
assert result_a.success
state_b, result_b, fock_counts = _build_photon_loss_and_amp_damping_circuit(1.0)
print(state_b)
assert result_b.success
assert not allclose(state_a, state_b)
def _build_photon_loss_and_amp_damping_circuit(amp_damp = 0.3, photon_loss_rate = 0.01):
num_qumodes = 1
qubits_per_mode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=qubits_per_mode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(2, qmr[0])
circuit.x(qbr[0])
circuit.cv_d(1, qmr[0], duration=100, unit="ns")
# Initialize phase damping NoiseModel
noise_model = noise.NoiseModel()
phase_error = noise.amplitude_damping_error(amp_damp)
noise_model.add_quantum_error(phase_error, ["x"], [circuit.get_qubit_index(qbr[0])])
# Initialize PhotonLossNoisePass
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit="ns")
return c2qa.util.simulate(circuit, noise_model=noise_model, noise_passes=noise_pass)
def allclose(a, b) -> bool:
"""Convert SciPy sparse matrices to ndarray and test with Numpy"""
# If a and b are SciPy sparse matrices, they'll have a "toarray()" function
if hasattr(a, "toarray"):
a = a.toarray()
if hasattr(b, "toarray"):
b = b.toarray()
return np.allclose(a, b)
def test_relaxation_noise_pass(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
t1s = np.ones(circuit.num_qubits).tolist()
t2s = np.ones(circuit.num_qubits).tolist()
noise_pass = RelaxationNoisePass(t1s, t2s)
filename = "tests/test_relaxation_noise_pass.gif"
c2qa.animate.animate_wigner(
circuit,
animation_segments=200,
file=filename,
noise_passes=noise_pass,
)
assert Path(filename).is_file()
def test_relaxation_and_photon_loss_noise_passes(capsys):
with capsys.disabled():
num_qumodes = 1
num_qubits_per_qumode = 2
num_qubits = 1
qmr = c2qa.QumodeRegister(num_qumodes=num_qumodes, num_qubits_per_qumode=num_qubits_per_qumode)
qbr = qiskit.QuantumRegister(size=num_qubits)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_initialize(3, qmr[0])
circuit.cv_c_d(1, qmr[0], qbr[0], duration=100, unit="ns")
noise_passes = []
t1s = np.ones(circuit.num_qubits).tolist()
t2s = np.ones(circuit.num_qubits).tolist()
noise_passes.append(RelaxationNoisePass(t1s, t2s))
photon_loss_rate = 0.02
noise_passes.append(c2qa.kraus.PhotonLossNoisePass(photon_loss_rates=photon_loss_rate, circuit=circuit, time_unit="ns"))
filename = "tests/test_relaxation_and_photon_loss_noise_passes.gif"
c2qa.animate.animate_wigner(
circuit,
animation_segments=200,
file=filename,
noise_passes=noise_passes,
)
assert Path(filename).is_file()
def test_multi_qumode_loss_probability(capsys):
with capsys.disabled():
num_qumodes = 2
num_qubits_per_qumode = 2
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(1, qmr[0])
circuit.cv_initialize(1, qmr[1])
circuit.cv_bs(np.pi/4, qmr[0], qmr[1], duration=100, unit="ns")
circuit.cv_bs(-np.pi/4, qmr[0], qmr[1], duration=100, unit="ns")
photon_loss_rate = 10000000
noise_pass = c2qa.kraus.PhotonLossNoisePass(photon_loss_rate, circuit)
fifty_fifty = False
print()
for i in range(20):
print("----------------------")
print(f"Iteration {i}")
state_vector, result, fock_counts = c2qa.util.simulate(circuit, noise_passes=noise_pass)
# plot_histogram(result.get_counts(circuit), filename=f"tests/test_manual_validate_beamsplitter-{i}.png")
occupation, fock_states = c2qa.util.stateread(state_vector, 0, num_qumodes, 2**num_qubits_per_qumode,verbose=True)
for qumode_state, qubit_state, amplitude in fock_states:
# print(f"{qumode_state} {qubit_state} {amplitude}")
qumode1 = qumode_state[0]
qumode2 = qumode_state[1]
probability = amplitude**2
if (qumode1 == 1 and qumode2 == 0) or (qumode1 == 0 and qumode1 == 1) and math.isclose(probability, 0.5, 0.03):
fifty_fifty = True
assert fifty_fifty
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# 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.
"""Gate cancellation pass testing"""
import unittest
import numpy as np
from qiskit.test import QiskitTestCase
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit.library import U1Gate, RZGate, PhaseGate, CXGate, SXGate
from qiskit.circuit.parameter import Parameter
from qiskit.transpiler.target import Target
from qiskit.transpiler import PassManager, PropertySet
from qiskit.transpiler.passes import CommutationAnalysis, CommutativeCancellation, FixedPoint, Size
from qiskit.quantum_info import Operator
class TestCommutativeCancellation(QiskitTestCase):
"""Test the CommutativeCancellation pass."""
def setUp(self):
super().setUp()
self.com_pass_ = CommutationAnalysis()
self.pass_ = CommutativeCancellation()
self.pset = self.pass_.property_set = PropertySet()
def test_all_gates(self):
"""Test all gates on 1 and 2 qubits
q0:-[H]-[H]--[x]-[x]--[y]-[y]--[rz]-[rz]--[u1]-[u1]-[rx]-[rx]---.--.--.--.--.--.-
| | | | | |
q1:-------------------------------------------------------------X--X--Y--Y--.--.-
=
qr0:---[u1]---
qr1:----------
"""
qr = QuantumRegister(2, "q")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[0])
circuit.x(qr[0])
circuit.x(qr[0])
circuit.y(qr[0])
circuit.y(qr[0])
circuit.rz(0.5, qr[0])
circuit.rz(0.5, qr[0])
circuit.append(U1Gate(0.5), [qr[0]]) # TODO this should work with Phase gates too
circuit.append(U1Gate(0.5), [qr[0]])
circuit.rx(0.5, qr[0])
circuit.rx(0.5, qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cy(qr[0], qr[1])
circuit.cy(qr[0], qr[1])
circuit.cz(qr[0], qr[1])
circuit.cz(qr[0], qr[1])
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.append(RZGate(2.0), [qr[0]])
expected.rx(1.0, qr[0])
self.assertEqual(expected, new_circuit)
def test_commutative_circuit1(self):
"""A simple circuit where three CNOTs commute, the first and the last cancel.
qr0:----.---------------.-- qr0:------------
| |
qr1:---(+)-----(+)-----(+)- = qr1:-------(+)--
| |
qr2:---[H]------.---------- qr2:---[H]--.---
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[0], qr[1])
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.h(qr[2])
expected.cx(qr[2], qr[1])
self.assertEqual(expected, new_circuit)
def test_consecutive_cnots(self):
"""A simple circuit equals identity
qr0:----.- ----.-- qr0:------------
| |
qr1:---(+)----(+)- = qr1:------------
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_consecutive_cnots2(self):
"""
Two CNOTs that equals identity, with rotation gates inserted.
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.rx(np.pi, qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.rx(np.pi, qr[0])
passmanager = PassManager()
passmanager.append(
[CommutationAnalysis(), CommutativeCancellation(), Size(), FixedPoint("size")],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_2_alternating_cnots(self):
"""A simple circuit where nothing should be cancelled.
qr0:----.- ---(+)- qr0:----.----(+)-
| | | |
qr1:---(+)-----.-- = qr1:---(+)----.--
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.cx(qr[0], qr[1])
expected.cx(qr[1], qr[0])
self.assertEqual(expected, new_circuit)
def test_control_bit_of_cnot(self):
"""A simple circuit where nothing should be cancelled.
qr0:----.------[X]------.-- qr0:----.------[X]------.--
| | | |
qr1:---(+)-------------(+)- = qr1:---(+)-------------(+)-
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.x(qr[0])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.cx(qr[0], qr[1])
expected.x(qr[0])
expected.cx(qr[0], qr[1])
self.assertEqual(expected, new_circuit)
def test_control_bit_of_cnot1(self):
"""A simple circuit where the two cnots shoule be cancelled.
qr0:----.------[Z]------.-- qr0:---[Z]---
| |
qr1:---(+)-------------(+)- = qr1:---------
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.z(qr[0])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.z(qr[0])
self.assertEqual(expected, new_circuit)
def test_control_bit_of_cnot2(self):
"""A simple circuit where the two cnots shoule be cancelled.
qr0:----.------[T]------.-- qr0:---[T]---
| |
qr1:---(+)-------------(+)- = qr1:---------
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.t(qr[0])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.t(qr[0])
self.assertEqual(expected, new_circuit)
def test_control_bit_of_cnot3(self):
"""A simple circuit where the two cnots shoule be cancelled.
qr0:----.------[Rz]------.-- qr0:---[Rz]---
| |
qr1:---(+)-------- -----(+)- = qr1:----------
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(np.pi / 3, qr[0])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.rz(np.pi / 3, qr[0])
self.assertEqual(expected, new_circuit)
def test_control_bit_of_cnot4(self):
"""A simple circuit where the two cnots shoule be cancelled.
qr0:----.------[T]------.-- qr0:---[T]---
| |
qr1:---(+)-------------(+)- = qr1:---------
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.t(qr[0])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.t(qr[0])
self.assertEqual(expected, new_circuit)
def test_target_bit_of_cnot(self):
"""A simple circuit where nothing should be cancelled.
qr0:----.---------------.-- qr0:----.---------------.--
| | | |
qr1:---(+)-----[Z]-----(+)- = qr1:---(+)----[Z]------(+)-
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.z(qr[1])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.cx(qr[0], qr[1])
expected.z(qr[1])
expected.cx(qr[0], qr[1])
self.assertEqual(expected, new_circuit)
def test_target_bit_of_cnot1(self):
"""A simple circuit where nothing should be cancelled.
qr0:----.---------------.-- qr0:----.---------------.--
| | | |
qr1:---(+)-----[T]-----(+)- = qr1:---(+)----[T]------(+)-
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.t(qr[1])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.cx(qr[0], qr[1])
expected.t(qr[1])
expected.cx(qr[0], qr[1])
self.assertEqual(expected, new_circuit)
def test_target_bit_of_cnot2(self):
"""A simple circuit where nothing should be cancelled.
qr0:----.---------------.-- qr0:----.---------------.--
| | | |
qr1:---(+)-----[Rz]----(+)- = qr1:---(+)----[Rz]-----(+)-
"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(np.pi / 3, qr[1])
circuit.cx(qr[0], qr[1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
expected = QuantumCircuit(qr)
expected.cx(qr[0], qr[1])
expected.rz(np.pi / 3, qr[1])
expected.cx(qr[0], qr[1])
self.assertEqual(expected, new_circuit)
def test_commutative_circuit2(self):
"""
A simple circuit where three CNOTs commute, the first and the last cancel,
also two X gates cancel and two Rz gates combine.
qr0:----.---------------.-------- qr0:-------------
| |
qr1:---(+)---(+)--[X]--(+)--[X]-- = qr1:--------(+)--
| |
qr2:---[Rz]---.---[Rz]-[T]--[S]-- qr2:--[U1]---.---
"""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(np.pi / 3, qr[2])
circuit.cx(qr[2], qr[1])
circuit.rz(np.pi / 3, qr[2])
circuit.t(qr[2])
circuit.s(qr[2])
circuit.x(qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[1])
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.append(RZGate(np.pi * 17 / 12), [qr[2]])
expected.cx(qr[2], qr[1])
expected.global_phase = (np.pi * 17 / 12 - (2 * np.pi / 3)) / 2
self.assertEqual(expected, new_circuit)
def test_commutative_circuit3(self):
"""
A simple circuit where three CNOTs commute, the first and the last cancel,
also two X gates cancel and two Rz gates combine.
qr0:-------.------------------.------------- qr0:-------------
| |
qr1:------(+)------(+)--[X]--(+)-------[X]-- = qr1:--------(+)--
| |
qr2:------[Rz]--.---.----.---[Rz]-[T]--[S]-- qr2:--[U1]---.---
| |
qr3:-[Rz]--[X]-(+)------(+)--[X]-[Rz]------- qr3:--[Rz]-------
"""
qr = QuantumRegister(4, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.rz(np.pi / 3, qr[2])
circuit.rz(np.pi / 3, qr[3])
circuit.x(qr[3])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[2], qr[1])
circuit.cx(qr[2], qr[3])
circuit.rz(np.pi / 3, qr[2])
circuit.t(qr[2])
circuit.x(qr[3])
circuit.rz(np.pi / 3, qr[3])
circuit.s(qr[2])
circuit.x(qr[1])
circuit.cx(qr[0], qr[1])
circuit.x(qr[1])
passmanager = PassManager()
passmanager.append(
[CommutationAnalysis(), CommutativeCancellation(), Size(), FixedPoint("size")],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.append(RZGate(np.pi * 17 / 12), [qr[2]])
expected.append(RZGate(np.pi * 2 / 3), [qr[3]])
expected.cx(qr[2], qr[1])
self.assertEqual(
expected, new_circuit, msg=f"expected:\n{expected}\nnew_circuit:\n{new_circuit}"
)
def test_cnot_cascade(self):
"""
A cascade of CNOTs that equals identity.
"""
qr = QuantumRegister(10, "qr")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
passmanager = PassManager()
# passmanager.append(CommutativeCancellation())
passmanager.append(
[CommutationAnalysis(), CommutativeCancellation(), Size(), FixedPoint("size")],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_cnot_cascade1(self):
"""
A cascade of CNOTs that equals identity, with rotation gates inserted.
"""
qr = QuantumRegister(10, "qr")
circuit = QuantumCircuit(qr)
circuit.rx(np.pi, qr[0])
circuit.rx(np.pi, qr[1])
circuit.rx(np.pi, qr[2])
circuit.rx(np.pi, qr[3])
circuit.rx(np.pi, qr[4])
circuit.rx(np.pi, qr[5])
circuit.rx(np.pi, qr[6])
circuit.rx(np.pi, qr[7])
circuit.rx(np.pi, qr[8])
circuit.rx(np.pi, qr[9])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[8], qr[9])
circuit.cx(qr[7], qr[8])
circuit.cx(qr[6], qr[7])
circuit.cx(qr[5], qr[6])
circuit.cx(qr[4], qr[5])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
circuit.rx(np.pi, qr[0])
circuit.rx(np.pi, qr[1])
circuit.rx(np.pi, qr[2])
circuit.rx(np.pi, qr[3])
circuit.rx(np.pi, qr[4])
circuit.rx(np.pi, qr[5])
circuit.rx(np.pi, qr[6])
circuit.rx(np.pi, qr[7])
circuit.rx(np.pi, qr[8])
circuit.rx(np.pi, qr[9])
passmanager = PassManager()
# passmanager.append(CommutativeCancellation())
passmanager.append(
[CommutationAnalysis(), CommutativeCancellation(), Size(), FixedPoint("size")],
do_while=lambda property_set: not property_set["size_fixed_point"],
)
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(qr)
self.assertEqual(expected, new_circuit)
def test_conditional_gates_dont_commute(self):
"""Conditional gates do not commute and do not cancel"""
# ┌───┐┌─┐
# q_0: ┤ H ├┤M├─────────────
# └───┘└╥┘ ┌─┐
# q_1: ──■───╫────■───┤M├───
# ┌─┴─┐ ║ ┌─┴─┐ └╥┘┌─┐
# q_2: ┤ X ├─╫──┤ X ├──╫─┤M├
# └───┘ ║ └─╥─┘ ║ └╥┘
# ║ ┌──╨──┐ ║ ║
# c: 2/══════╩═╡ 0x0 ╞═╩══╩═
# 0 └─────┘ 0 1
circuit = QuantumCircuit(3, 2)
circuit.h(0)
circuit.measure(0, 0)
circuit.cx(1, 2)
circuit.cx(1, 2).c_if(circuit.cregs[0], 0)
circuit.measure([1, 2], [0, 1])
new_pm = PassManager(CommutativeCancellation())
new_circuit = new_pm.run(circuit)
self.assertEqual(circuit, new_circuit)
def test_basis_01(self):
"""Test basis priority change, phase gate"""
circuit = QuantumCircuit(1)
circuit.s(0)
circuit.z(0)
circuit.t(0)
circuit.rz(np.pi, 0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation(basis_gates=["cx", "p", "sx"]))
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(1)
expected.rz(11 * np.pi / 4, 0)
expected.global_phase = 11 * np.pi / 4 / 2 - np.pi / 2
self.assertEqual(new_circuit, expected)
def test_target_basis_01(self):
"""Test basis priority change, phase gate, with target."""
circuit = QuantumCircuit(1)
circuit.s(0)
circuit.z(0)
circuit.t(0)
circuit.rz(np.pi, 0)
theta = Parameter("theta")
target = Target(num_qubits=2)
target.add_instruction(CXGate())
target.add_instruction(PhaseGate(theta))
target.add_instruction(SXGate())
passmanager = PassManager()
passmanager.append(CommutativeCancellation(target=target))
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(1)
expected.rz(11 * np.pi / 4, 0)
expected.global_phase = 11 * np.pi / 4 / 2 - np.pi / 2
self.assertEqual(new_circuit, expected)
def test_basis_02(self):
"""Test basis priority change, Rz gate"""
circuit = QuantumCircuit(1)
circuit.s(0)
circuit.z(0)
circuit.t(0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation(basis_gates=["cx", "rz", "sx"]))
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(1)
expected.rz(7 * np.pi / 4, 0)
expected.global_phase = 7 * np.pi / 4 / 2
self.assertEqual(new_circuit, expected)
def test_basis_03(self):
"""Test no specified basis"""
circuit = QuantumCircuit(1)
circuit.s(0)
circuit.z(0)
circuit.t(0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
new_circuit = passmanager.run(circuit)
expected = QuantumCircuit(1)
expected.s(0)
expected.z(0)
expected.t(0)
self.assertEqual(new_circuit, expected)
def test_basis_global_phase_01(self):
"""Test no specified basis, rz"""
circ = QuantumCircuit(1)
circ.rz(np.pi / 2, 0)
circ.p(np.pi / 2, 0)
circ.p(np.pi / 2, 0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
ccirc = passmanager.run(circ)
self.assertEqual(Operator(circ), Operator(ccirc))
def test_basis_global_phase_02(self):
"""Test no specified basis, p"""
circ = QuantumCircuit(1)
circ.p(np.pi / 2, 0)
circ.rz(np.pi / 2, 0)
circ.p(np.pi / 2, 0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
ccirc = passmanager.run(circ)
self.assertEqual(Operator(circ), Operator(ccirc))
def test_basis_global_phase_03(self):
"""Test global phase preservation if cummulative z-rotation is 0"""
circ = QuantumCircuit(1)
circ.rz(np.pi / 2, 0)
circ.p(np.pi / 2, 0)
circ.z(0)
passmanager = PassManager()
passmanager.append(CommutativeCancellation())
ccirc = passmanager.run(circ)
self.assertEqual(Operator(circ), Operator(ccirc))
def test_basic_classical_wires(self):
"""Test that transpile runs without internal errors when dealing with commutable operations
with classical controls. Regression test for gh-8553."""
original = QuantumCircuit(2, 1)
original.x(0).c_if(original.cregs[0], 0)
original.x(1).c_if(original.cregs[0], 0)
# This transpilation shouldn't change anything, but it should succeed. At one point it was
# triggering an internal logic error and crashing.
transpiled = PassManager([CommutativeCancellation()]).run(original)
self.assertEqual(original, transpiled)
def test_simple_if_else(self):
"""Test that the pass is not confused by if-else."""
base_test1 = QuantumCircuit(3, 3)
base_test1.x(1)
base_test1.cx(0, 1)
base_test1.x(1)
base_test2 = QuantumCircuit(3, 3)
base_test2.rz(0.1, 1)
base_test2.rz(0.1, 1)
test = QuantumCircuit(3, 3)
test.h(0)
test.x(0)
test.rx(0.2, 0)
test.measure(0, 0)
test.x(0)
test.if_else(
(test.clbits[0], True), base_test1.copy(), base_test2.copy(), test.qubits, test.clbits
)
expected = QuantumCircuit(3, 3)
expected.h(0)
expected.rx(np.pi + 0.2, 0)
expected.measure(0, 0)
expected.x(0)
expected_test1 = QuantumCircuit(3, 3)
expected_test1.cx(0, 1)
expected_test2 = QuantumCircuit(3, 3)
expected_test2.rz(0.2, 1)
expected.if_else(
(expected.clbits[0], True),
expected_test1.copy(),
expected_test2.copy(),
expected.qubits,
expected.clbits,
)
passmanager = PassManager([CommutationAnalysis(), CommutativeCancellation()])
new_circuit = passmanager.run(test)
self.assertEqual(new_circuit, expected)
def test_nested_control_flow(self):
"""Test that the pass does not add barrier into nested control flow."""
level2_test = QuantumCircuit(2, 1)
level2_test.cz(0, 1)
level2_test.cz(0, 1)
level2_test.cz(0, 1)
level2_test.measure(0, 0)
level1_test = QuantumCircuit(2, 1)
level1_test.for_loop((0,), None, level2_test.copy(), level1_test.qubits, level1_test.clbits)
level1_test.h(0)
level1_test.h(0)
level1_test.measure(0, 0)
test = QuantumCircuit(2, 1)
test.while_loop((test.clbits[0], True), level1_test.copy(), test.qubits, test.clbits)
test.measure(0, 0)
level2_expected = QuantumCircuit(2, 1)
level2_expected.cz(0, 1)
level2_expected.measure(0, 0)
level1_expected = QuantumCircuit(2, 1)
level1_expected.for_loop(
(0,), None, level2_expected.copy(), level1_expected.qubits, level1_expected.clbits
)
level1_expected.measure(0, 0)
expected = QuantumCircuit(2, 1)
expected.while_loop(
(expected.clbits[0], True), level1_expected.copy(), expected.qubits, expected.clbits
)
expected.measure(0, 0)
passmanager = PassManager([CommutationAnalysis(), CommutativeCancellation()])
new_circuit = passmanager.run(test)
self.assertEqual(new_circuit, expected)
def test_cancellation_not_crossing_block_boundary(self):
"""Test that the pass does cancel gates across control flow op block boundaries."""
test1 = QuantumCircuit(2, 2)
test1.x(1)
with test1.if_test((0, False)):
test1.cx(0, 1)
test1.x(1)
passmanager = PassManager([CommutationAnalysis(), CommutativeCancellation()])
new_circuit = passmanager.run(test1)
self.assertEqual(new_circuit, test1)
def test_cancellation_not_crossing_between_blocks(self):
"""Test that the pass does cancel gates in different control flow ops."""
test2 = QuantumCircuit(2, 2)
with test2.if_test((0, True)):
test2.x(1)
with test2.if_test((0, True)):
test2.cx(0, 1)
test2.x(1)
passmanager = PassManager([CommutationAnalysis(), CommutativeCancellation()])
new_circuit = passmanager.run(test2)
self.assertEqual(new_circuit, test2)
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library.standard_gates import CHGate, U2Gate, CXGate
from qiskit.converters import dag_to_circuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
dag = circuit_to_dag(circ)
circuit = dag_to_circuit(dag)
circuit.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer
from qiskit_optimization.translators import from_docplex_mp
from docplex.mp.model import Model
model = Model()
x0 = model.binary_var(name="x0")
x1 = model.binary_var(name="x1")
x2 = model.binary_var(name="x2")
model.minimize(-x0 + 2 * x1 - 3 * x2 - 2 * x0 * x2 - 1 * x1 * x2)
qp = from_docplex_mp(model)
print(qp.prettyprint())
grover_optimizer = GroverOptimizer(6, num_iterations=10, sampler=Sampler())
results = grover_optimizer.solve(qp)
print(results.prettyprint())
exact_solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
exact_result = exact_solver.solve(qp)
print(exact_result.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from sklearn.datasets import make_blobs
# example dataset
features, labels = make_blobs(n_samples=20, n_features=2, centers=2, random_state=3, shuffle=True)
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
features = MinMaxScaler(feature_range=(0, np.pi)).fit_transform(features)
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=15, shuffle=False
)
# number of qubits is equal to the number of features
num_qubits = 2
# number of steps performed during the training procedure
tau = 100
# regularization parameter
C = 1000
from qiskit import BasicAer
from qiskit.circuit.library import ZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.kernels import FidelityQuantumKernel
algorithm_globals.random_seed = 12345
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
qkernel = FidelityQuantumKernel(feature_map=feature_map)
from qiskit_machine_learning.algorithms import PegasosQSVC
pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=C, num_steps=tau)
# training
pegasos_qsvc.fit(train_features, train_labels)
# testing
pegasos_score = pegasos_qsvc.score(test_features, test_labels)
print(f"PegasosQSVC classification test score: {pegasos_score}")
grid_step = 0.2
margin = 0.2
grid_x, grid_y = np.meshgrid(
np.arange(-margin, np.pi + margin, grid_step), np.arange(-margin, np.pi + margin, grid_step)
)
meshgrid_features = np.column_stack((grid_x.ravel(), grid_y.ravel()))
meshgrid_colors = pegasos_qsvc.predict(meshgrid_features)
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 5))
meshgrid_colors = meshgrid_colors.reshape(grid_x.shape)
plt.pcolormesh(grid_x, grid_y, meshgrid_colors, cmap="RdBu", shading="auto")
plt.scatter(
train_features[:, 0][train_labels == 0],
train_features[:, 1][train_labels == 0],
marker="s",
facecolors="w",
edgecolors="r",
label="A train",
)
plt.scatter(
train_features[:, 0][train_labels == 1],
train_features[:, 1][train_labels == 1],
marker="o",
facecolors="w",
edgecolors="b",
label="B train",
)
plt.scatter(
test_features[:, 0][test_labels == 0],
test_features[:, 1][test_labels == 0],
marker="s",
facecolors="r",
edgecolors="r",
label="A test",
)
plt.scatter(
test_features[:, 0][test_labels == 1],
test_features[:, 1][test_labels == 1],
marker="o",
facecolors="b",
edgecolors="b",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Pegasos Classification")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates.x import MCXGate
# Class that creates and holds grover's circuit for some given expression
class GroverOperator:
def get_control_circuit(self, label="Grover"):
grit = self.main_circuit.to_gate()
grit.label = label
return grit.control()
def __init__(self, n, cnf_exp):
self.n_bits = n
eq = len(cnf_exp)
self.total_bits = n + eq + 1
main_circuit = QuantumCircuit(self.total_bits)
for i, e in enumerate(cnf_exp):
state = ''
target = n + i
pos = []
for qbit in e:
state += '0' if (qbit > 0) else '1'
pos.append(abs(qbit) - 1)
pos.append(target)
state = state[::-1]
main_circuit.append(MCXGate(len(e), None, state), pos)
oracle_rev = main_circuit.reverse_ops()
main_circuit.append(MCXGate(eq, None, '0' * eq), range(n, self.total_bits))
main_circuit = main_circuit.compose(oracle_rev)
# main_circuit.barrier()
main_circuit.h(range(n))
main_circuit.append(MCXGate(n, None, '0' * n), list(range(n)) + [self.total_bits - 1])
main_circuit.h(range(n))
# main_circuit.barrier()
self.main_circuit = main_circuit
self.control_circuit = self.get_control_circuit()
|
https://github.com/unitaryfund/mitiq
|
unitaryfund
|
# Copyright (C) Unitary Fund
#
# This source code is licensed under the GPL license (v3) found in the
# LICENSE file in the root directory of this source tree.
import json
import cirq
import numpy as np
import pytest
import qiskit
from mitiq import QPROGRAM, SUPPORTED_PROGRAM_TYPES
from mitiq.calibration import PEC_SETTINGS, ZNE_SETTINGS, Settings
from mitiq.calibration.settings import (
BenchmarkProblem,
MitigationTechnique,
Strategy,
)
from mitiq.pec import (
execute_with_pec,
represent_operation_with_local_depolarizing_noise,
)
from mitiq.raw import execute
from mitiq.zne.inference import LinearFactory, RichardsonFactory
from mitiq.zne.scaling import fold_global
light_pec_settings = Settings(
[
{
"circuit_type": "mirror",
"num_qubits": 1,
"circuit_depth": 1,
},
{
"circuit_type": "mirror",
"num_qubits": 2,
"circuit_depth": 1,
},
],
strategies=[
{
"technique": "pec",
"representation_function": (
represent_operation_with_local_depolarizing_noise
),
"is_qubit_dependent": False,
"noise_level": 0.001,
"num_samples": 200,
},
],
)
light_zne_settings = Settings(
[
{
"circuit_type": "mirror",
"num_qubits": 1,
"circuit_depth": 1,
},
{
"circuit_type": "mirror",
"num_qubits": 2,
"circuit_depth": 1,
},
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": LinearFactory([1.0, 2.0]),
},
],
)
basic_settings = Settings(
benchmarks=[
{
"circuit_type": "ghz",
"num_qubits": 2,
"circuit_depth": 999,
}
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
},
{
"technique": "pec",
"representation_function": (
represent_operation_with_local_depolarizing_noise
),
"is_qubit_dependent": False,
"noise_level": 0.001,
"num_samples": 200,
},
],
)
def test_MitigationTechnique():
pec_enum = MitigationTechnique.PEC
assert pec_enum.mitigation_function == execute_with_pec
assert pec_enum.name == "PEC"
raw_enum = MitigationTechnique.RAW
assert raw_enum.mitigation_function == execute
assert raw_enum.name == "RAW"
def test_BenchmarkProblem_make_problems():
settings = basic_settings
problems = settings.make_problems()
assert len(problems) == 1
ghz_problem = problems[0]
assert len(ghz_problem.circuit) == 2
assert ghz_problem.two_qubit_gate_count == 1
assert ghz_problem.ideal_distribution == {"00": 0.5, "11": 0.5}
def test_BenchmarkProblem_repr():
settings = basic_settings
problems = settings.make_problems()
problem_repr = repr(problems[0]).replace("'", '"')
assert isinstance(json.loads(problem_repr), dict)
def test_BenchmarkProblem_str():
settings = basic_settings
circuits = settings.make_problems()
problem = circuits[0]
lines = str(problem).split("\n")
problem_dict = problem.to_dict()
for line in lines:
[title, value] = line.split(":", 1)
key = title.lower().replace(" ", "_")
value = value.strip()
assert key in problem_dict
assert value == str(problem_dict[key])
assert "Ideal distribution: " not in str(problem)
def test_Strategy_repr():
settings = basic_settings
strategies = settings.make_strategies()
strategy_repr = repr(strategies[0]).replace("'", '"')
assert isinstance(json.loads(strategy_repr), dict)
def test_Strategy_str():
settings = basic_settings
strategies = settings.make_strategies()
strategy_str = str(strategies[0])
strategy_pretty_dict = strategies[0].to_pretty_dict()
for line in strategy_str.split("\n"):
[title, value] = line.split(":")
key = title.lower().replace(" ", "_")
value = value.strip()
assert key in strategy_pretty_dict
assert value == str(strategy_pretty_dict[key])
def test_Strategy_pretty_dict():
settings = basic_settings
strategies = settings.make_strategies()
strategy_dict = strategies[0].to_dict()
strategy_pretty_dict = strategies[0].to_pretty_dict()
if strategy_pretty_dict["technique"] == "ZNE":
assert strategy_pretty_dict["factory"] == strategy_dict["factory"][:-7]
assert (
strategy_pretty_dict["scale_factors"]
== str(strategy_dict["scale_factors"])[1:-1]
)
elif strategy_pretty_dict["technique"] == "PEC":
assert strategy_pretty_dict["noise_bias"] == strategy_dict.get(
"noise_bias", "N/A"
)
assert (
strategy_pretty_dict["representation_function"]
== strategy_dict["representation_function"][25:]
)
def test_make_circuits_rotated_rb_circuits():
settings = Settings(
benchmarks=[
{
"circuit_type": "rotated_rb",
"num_qubits": 1,
"circuit_depth": 10,
"theta": np.pi / 3,
}
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
},
],
)
problems = settings.make_problems()
assert len(problems) == 1
assert problems[0].type == "rotated_rb"
def test_make_circuits_rotated_rb_circuits_invalid_qubits():
settings = Settings(
benchmarks=[
{
"circuit_type": "rotated_rb",
"num_qubits": 2,
"circuit_depth": 10,
"theta": np.pi / 3,
}
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
},
],
)
with pytest.raises(NotImplementedError, match="rotated rb circuits"):
settings.make_problems()
def test_make_circuits_qv_circuits():
settings = Settings(
[
{
"circuit_type": "qv",
"num_qubits": 2,
"circuit_depth": 999,
}
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
}
],
)
with pytest.raises(NotImplementedError, match="quantum volume circuits"):
settings.make_problems()
def test_make_circuits_invalid_circuit_type():
settings = Settings(
[{"circuit_type": "foobar", "num_qubits": 2, "circuit_depth": 999}],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
}
],
)
with pytest.raises(
ValueError, match="invalid value passed for `circuit_types`"
):
settings.make_problems()
def test_make_strategies_invalid_technique():
with pytest.raises(KeyError, match="DESTROY"):
Settings(
[{"circuit_types": "shor", "num_qubits": 2, "circuit_depth": 999}],
strategies=[
{
"technique": "destroy_my_errors",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
}
],
)
def test_unsupported_technique_error():
strategy = Strategy(1, MitigationTechnique.RAW, {})
with pytest.raises(
ValueError,
match="Specified technique is not supported by calibration.",
):
strategy.mitigation_function()
def test_ZNE_SETTINGS():
circuits = ZNE_SETTINGS.make_problems()
strategies = ZNE_SETTINGS.make_strategies()
repr_string = repr(circuits[0])
assert all(
s in repr_string
for s in ("type", "ideal_distribution", "num_qubits", "circuit_depth")
)
assert len(circuits) == 4
assert len(strategies) == 2 * 2 * 2
def test_PEC_SETTINGS():
circuits = PEC_SETTINGS.make_problems()
strategies = PEC_SETTINGS.make_strategies()
repr_string = repr(circuits[0])
assert all(
s in repr_string
for s in ("type", "ideal_distribution", "num_qubits", "circuit_depth")
)
assert len(circuits) == 4
assert len(strategies) == 2
@pytest.mark.parametrize("circuit_type", SUPPORTED_PROGRAM_TYPES)
def test_benchmark_problem_class(circuit_type):
qubit = cirq.LineQubit(0)
circuit = cirq.Circuit(cirq.X(qubit))
circuit_with_measurements = circuit.copy()
circuit_with_measurements.append(cirq.measure(qubit))
problem = BenchmarkProblem(
id=7,
circuit=circuit,
type="",
ideal_distribution={},
)
assert problem.circuit == circuit
conv_circ = problem.converted_circuit(circuit_type)
assert any([isinstance(conv_circ, q) for q in QPROGRAM.__args__])
# For at least one case, test the circuit is correct and has measurements
if circuit_type == "qiskit":
qreg = qiskit.QuantumRegister(1, name="q")
creg = qiskit.ClassicalRegister(1, name="m0")
expected = qiskit.QuantumCircuit(qreg, creg)
expected.x(0)
expected.measure(0, 0)
assert conv_circ == expected
def test_settings_make_problems():
"""Test the `make_problems` method of `Settings`"""
settings = Settings(
[
{
"circuit_type": "w",
"num_qubits": 2,
}
],
strategies=[
{
"technique": "zne",
"scale_noise": fold_global,
"factory": RichardsonFactory([1.0, 2.0, 3.0]),
}
],
)
problems = settings.make_problems()
assert len(problems) == 1
ideal_distribution = {"01": 0.5, "10": 0.5}
problem = problems[0]
assert problem.ideal_distribution == ideal_distribution
assert problem.two_qubit_gate_count == 2
assert problem.num_qubits == 2
assert problem.circuit_depth == 2
def test_to_dict():
pec_strategy = light_pec_settings.make_strategies()[0]
assert pec_strategy.to_dict() == {
"technique": "PEC",
"representation_function": (
"represent_operation_with_local_depolarizing_noise"
),
"is_qubit_dependent": False,
"noise_level": 0.001,
"noise_bias": 0,
"num_samples": 200,
}
zne_strategy = light_zne_settings.make_strategies()[0]
assert zne_strategy.to_dict() == {
"technique": "ZNE",
"scale_method": "fold_global",
"factory": "LinearFactory",
"scale_factors": [1.0, 2.0],
}
def test_num_circuits_required_raw_execution():
undefine_strategy = Strategy(
id=1,
technique=MitigationTechnique.RAW,
technique_params={},
)
assert undefine_strategy.num_circuits_required() == 1
|
https://github.com/mcoggins96/Quantum-Computing-UK-Repository
|
mcoggins96
|
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute,IBMQ
from qiskit.tools.monitor import job_monitor
from qiskit.circuit.library import QFT
import numpy as np
pi = np.pi
IBMQ.enable_account(‘ENTER API KEY HERE’)
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(5,'q')
c = ClassicalRegister(5,'c')
circuit = QuantumCircuit(q,c)
circuit.x(q[4])
circuit.x(q[2])
circuit.x(q[0])
circuit += QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=False, name='qft')
circuit.measure(q,c)
circuit.draw(output='mpl', filename='qft1.png')
print(circuit)
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\n QFT Output")
print("-------------")
print(counts)
input()
q = QuantumRegister(5,'q')
c = ClassicalRegister(5,'c')
circuit = QuantumCircuit(q,c)
circuit.x(q[4])
circuit.x(q[2])
circuit.x(q[0])
circuit += QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=True, name='qft')
circuit += QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=True, insert_barriers=True, name='qft')
circuit.measure(q,c)
circuit.draw(output='mpl',filename='qft2.png')
print(circuit)
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\n QFT with inverse QFT Output")
print("------------------------------")
print(counts)
input()
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.wrapper import available_backends, get_backend
from qiskit.wrapper import execute as q_execute
q = QuantumRegister(2, name='q')
c = ClassicalRegister(2, name='c')
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.h(q[1])
qc.cx(q[0], q[1])
qc.measure(q, c)
z = 0.995004165 + 1j * 0.099833417
z = z / abs(z)
u_error = np.array([[1, 0], [0, z]])
noise_params = {'U':
{'gate_time': 1,
'p_depol': 0.001,
'p_pauli': [0, 0, 0.01],
'U_error': u_error
}
}
config = {"noise_params": noise_params}
ret = q_execute(qc, 'local_qasm_simulator_cpp', shots=1024, config=config)
ret = ret.result()
print(ret.get_counts())
|
https://github.com/vm6502q/qiskit-qrack-provider
|
vm6502q
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# 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.
"""
Test circuits and reference outputs for snapshot state instructions.
"""
from numpy import array
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.providers.aer.extensions.snapshot_probabilities import *
def snapshot_probabilities_labels_qubits():
"""Dictionary of labels and qubits for 3-qubit probability snapshots"""
return {
"[0]": [0],
"[1]": [1],
"[2]": [2],
"[0, 1]": [0, 1],
"[1, 0]": [1, 0],
"[0, 2]": [0, 2],
"[2, 0]": [2, 0],
"[1, 2]": [1, 2],
"[2, 1]": [2, 1],
"[0, 1, 2]": [0, 1, 2],
"[1, 2, 0]": [1, 2, 0],
"[2, 0, 1]": [2, 0, 1]
}
def snapshot_probabilities_circuits(post_measure=False):
"""Snapshot Probabilities test circuits with deterministic counts"""
circuits = []
num_qubits = 3
qr = QuantumRegister(num_qubits)
cr = ClassicalRegister(num_qubits)
regs = (qr, cr)
# State |01+>
circuit = QuantumCircuit(*regs)
circuit.h(0)
circuit.x(1)
if not post_measure:
for label, qubits in snapshot_probabilities_labels_qubits().items():
circuit.snapshot_probabilities(label, qubits)
circuit.barrier(qr)
circuit.measure(qr, cr)
circuit.barrier(qr)
if post_measure:
for label, qubits in snapshot_probabilities_labels_qubits().items():
circuit.snapshot_probabilities(label, qubits)
circuits.append(circuit)
# State |010> -i|101>
circuit = QuantumCircuit(*regs)
circuit.h(0)
circuit.sdg(0)
circuit.cx(0, 1)
circuit.cx(0, 2)
circuit.x(1)
if not post_measure:
for label, qubits in snapshot_probabilities_labels_qubits().items():
circuit.snapshot_probabilities(label, qubits)
circuit.barrier(qr)
circuit.measure(qr, cr)
circuit.barrier(qr)
if post_measure:
for label, qubits in snapshot_probabilities_labels_qubits().items():
circuit.snapshot_probabilities(label, qubits)
circuits.append(circuit)
return circuits
def snapshot_probabilities_counts(shots):
"""Snapshot Probabilities test circuits reference counts."""
targets = []
# State |01+>
targets.append({'0x2': shots / 2, '0x3': shots / 2})
# State |010> -i|101>
targets.append({'0x2': shots / 2, '0x5': shots / 2})
return targets
def snapshot_probabilities_pre_meas_probs():
"""Snapshot Probabilities test circuits reference final probs"""
targets = []
# State |01+>
probs = {
"[0]": {'0x0': {'0x0': 0.5, '0x1': 0.5}},
"[1]": {'0x0': {'0x1': 1.0}},
"[2]": {'0x0': {'0x0': 1.0}},
"[0, 1]": {'0x0': {'0x2': 0.5, '0x3': 0.5}},
"[1, 0]": {'0x0': {'0x1': 0.5, '0x3': 0.5}},
"[0, 2]": {'0x0': {'0x0': 0.5, '0x1': 0.5}},
"[2, 0]": {'0x0': {'0x0': 0.5, '0x2': 0.5}},
"[1, 2]": {'0x0': {'0x1': 1.0}},
"[2, 1]": {'0x0': {'0x2': 1.0}},
"[0, 1, 2]": {'0x0': {'0x2': 0.5, '0x3': 0.5}},
"[1, 2, 0]": {'0x0': {'0x1': 0.5, '0x5': 0.5}},
"[2, 0, 1]": {'0x0': {'0x4': 0.5, '0x6': 0.5}},
}
targets.append(probs)
# State |010> -i|101>
probs = {
"[0]": {'0x0': {'0x0': 0.5, '0x1': 0.5}},
"[1]": {'0x0': {'0x0': 0.5, '0x1': 0.5}},
"[2]": {'0x0': {'0x0': 0.5, '0x1': 0.5}},
"[0, 1]": {'0x0': {'0x1': 0.5, '0x2': 0.5}},
"[1, 0]": {'0x0': {'0x1': 0.5, '0x2': 0.5}},
"[0, 2]": {'0x0': {'0x0': 0.5, '0x3': 0.5}},
"[2, 0]": {'0x0': {'0x0': 0.5, '0x3': 0.5}},
"[1, 2]": {'0x0': {'0x1': 0.5, '0x2': 0.5}},
"[2, 1]": {'0x0': {'0x1': 0.5, '0x2': 0.5}},
"[0, 1, 2]": {'0x0': {'0x2': 0.5, '0x5': 0.5}},
"[1, 2, 0]": {'0x0': {'0x1': 0.5, '0x6': 0.5}},
"[2, 0, 1]": {'0x0': {'0x3': 0.5, '0x4': 0.5}},
}
targets.append(probs)
return targets
def snapshot_probabilities_post_meas_probs():
"""Snapshot Probabilities test circuits reference final statevector"""
targets = []
# State |01+>
probs = {
"[0]": {'0x2': {'0x0': 1.0}, '0x3': {'0x1': 1.0}},
"[1]": {'0x2': {'0x1': 1.0}, '0x3': {'0x1': 1.0}},
"[2]": {'0x2': {'0x0': 1.0}, '0x3': {'0x0': 1.0}},
"[0, 1]": {'0x2': {'0x2': 1.0}, '0x3': {'0x3': 1.0}},
"[1, 0]": {'0x2': {'0x1': 1.0}, '0x3': {'0x3': 1.0}},
"[0, 2]": {'0x2': {'0x0': 1.0}, '0x3': {'0x1': 1.0}},
"[2, 0]": {'0x2': {'0x0': 1.0}, '0x3': {'0x2': 1.0}},
"[1, 2]": {'0x2': {'0x1': 1.0}, '0x3': {'0x1': 1.0}},
"[2, 1]": {'0x2': {'0x2': 1.0}, '0x3': {'0x2': 1.0}},
"[0, 1, 2]": {'0x2': {'0x2': 1.0}, '0x3': {'0x3': 1.0}},
"[1, 2, 0]": {'0x2': {'0x1': 1.0}, '0x3': {'0x5': 1.0}},
"[2, 0, 1]": {'0x2': {'0x4': 1.0}, '0x3': {'0x6': 1.0}},
}
targets.append(probs)
# State |010> -i|101>
probs = {
"[0]": {'0x2': {'0x0': 1.0}, '0x5': {'0x1': 1.0}},
"[1]": {'0x2': {'0x1': 1.0}, '0x5': {'0x0': 1.0}},
"[2]": {'0x2': {'0x0': 1.0}, '0x5': {'0x1': 1.0}},
"[0, 1]": {'0x2': {'0x2': 1.0}, '0x5': {'0x1': 1.0}},
"[1, 0]": {'0x2': {'0x1': 1.0}, '0x5': {'0x2': 1.0}},
"[0, 2]": {'0x2': {'0x0': 1.0}, '0x5': {'0x3': 1.0}},
"[2, 0]": {'0x2': {'0x0': 1.0}, '0x5': {'0x3': 1.0}},
"[1, 2]": {'0x2': {'0x1': 1.0}, '0x5': {'0x2': 1.0}},
"[2, 1]": {'0x2': {'0x2': 1.0}, '0x5': {'0x1': 1.0}},
"[0, 1, 2]": {'0x2': {'0x2': 1.0}, '0x5': {'0x5': 1.0}},
"[1, 2, 0]": {'0x2': {'0x1': 1.0}, '0x5': {'0x6': 1.0}},
"[2, 0, 1]": {'0x2': {'0x4': 1.0}, '0x5': {'0x3': 1.0}},
}
targets.append(probs)
return targets
|
https://github.com/ronitd2002/IBM-Quantum-challenge-2024
|
ronitd2002
|
# qc-grader should be 0.18.10 (or higher)
import qc_grader
qc_grader.__version__
# Imports
import numpy as np
import matplotlib.pyplot as plt
from qiskit.circuit.library import EfficientSU2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_transpiler_service.transpiler_service import TranspilerService
# Import for grader
from qc_grader.challenges.iqc_2024 import grade_lab3_ait_ex1, grade_lab3_ait_ex2
NUM_QUBITS = 61
circuit = EfficientSU2(NUM_QUBITS, entanglement="circular", reps=1).decompose()
print(f"Original circuit -> Depth: {circuit.depth()}, CNOTs: {circuit.num_nonlocal_gates()}")
circuit.draw(fold=-1, output="mpl", style="iqp", scale=0.2)
# Load saved credentials
service = QiskitRuntimeService()
transpiler_ai_false = TranspilerService(
# Add your code here
backend_name="ibm_brisbane",
ai="false",
optimization_level=3,
)
# Submit your answer using following code
grade_lab3_ait_ex1(transpiler_ai_false) # Expected result type: TranspilerService
circuit_ai_false = transpiler_ai_false.run(circuit)
print(f"Transpiled without AI -> Depth: {circuit_ai_false.depth()}, CNOTs: {circuit_ai_false.num_nonlocal_gates()}")
circuit_ai_false.draw(fold=-1, output="mpl", scale=0.2)
transpiler_ai_true = TranspilerService(
# Add your code here
backend_name="ibm_brisbane",
ai="true",
optimization_level=3,
)
# Submit your answer using following code
grade_lab3_ait_ex2(transpiler_ai_true) # Expected result type: TranspilerService
circuit_ai_true = transpiler_ai_true.run(circuit)
print(f"Transpiled with AI -> Depth: {circuit_ai_true.depth()}, CNOTs: {circuit_ai_true.num_nonlocal_gates()}")
circuit_ai_true.draw(fold=-1, output="mpl", scale=0.2)
# Transpiling locally using Qiskit SDK
service = QiskitRuntimeService()
backend = service.backend("ibm_sherbrooke")
pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
# Run and compile results
num_qubits = [11, 21, 41, 61, 81]
num_cnots_local = []
num_cnots_with_ai = []
num_cnots_without_ai = []
for nq in num_qubits:
circuit = EfficientSU2(nq, entanglement="circular", reps=1).decompose()
# Using the Transpiler locally on Qiskit
circuit_local = pm.run(circuit)
# Using the transpiler service without AI
circuit_without_ai = transpiler_ai_false.run(circuit)
# Using the transpiler service with AI
circuit_with_ai = transpiler_ai_true.run(circuit)
num_cnots_local.append(circuit_local.num_nonlocal_gates())
num_cnots_without_ai.append(circuit_without_ai.num_nonlocal_gates())
num_cnots_with_ai.append(circuit_with_ai.num_nonlocal_gates())
plt.plot(num_qubits, num_cnots_with_ai, '.-')
plt.plot(num_qubits, num_cnots_without_ai, '.-')
plt.plot(num_qubits, num_cnots_local, '--')
plt.xlabel("Number of qubits")
plt.ylabel("CNOT count")
plt.legend(["Qiskit Transpiler Service with AI", "Qiskit Transpiler Service without AI", "Qiskit SDK"])
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 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.
"""Test Variational Quantum Imaginary Time Evolution algorithm."""
import unittest
from test.python.algorithms import QiskitAlgorithmsTestCase
from ddt import ddt
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit_algorithms.gradients import LinCombQGT, LinCombEstimatorGradient
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp, Pauli
from qiskit.utils import algorithm_globals
from qiskit_algorithms import TimeEvolutionProblem, VarQITE
from qiskit_algorithms.time_evolvers.variational import (
ImaginaryMcLachlanPrinciple,
)
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import Statevector
@ddt
class TestVarQITE(QiskitAlgorithmsTestCase):
"""Test Variational Quantum Imaginary Time Evolution algorithm."""
def setUp(self):
super().setUp()
self.seed = 11
np.random.seed(self.seed)
def test_run_d_1_with_aux_ops(self):
"""Test VarQITE for d = 1 and t = 1 with evaluating auxiliary operator and the Forward
Euler solver.."""
observable = SparsePauliOp.from_list(
[
("II", 0.2252),
("ZZ", 0.5716),
("IZ", 0.3435),
("ZI", -0.4347),
("YY", 0.091),
("XX", 0.091),
]
)
aux_ops = [Pauli("XX"), Pauli("YZ")]
d = 1
ansatz = EfficientSU2(observable.num_qubits, reps=d)
parameters = list(ansatz.parameters)
init_param_values = np.zeros(len(parameters))
for i in range(len(parameters)):
init_param_values[i] = np.pi / 2
init_param_values[0] = 1
time = 1
evolution_problem = TimeEvolutionProblem(observable, time, aux_operators=aux_ops)
thetas_expected = [
0.87984606025879,
2.04681975664763,
2.68980594039104,
2.75915988512186,
2.38796546567171,
1.78144857115127,
2.13109162826101,
1.9259609596416,
]
thetas_expected_shots = [
0.9392668013702317,
1.8756706968454864,
2.6915067128662398,
2.655420131540562,
2.174687086978046,
1.6997059390911056,
1.8056912289547045,
1.939353810908912,
]
with self.subTest(msg="Test exact backend."):
algorithm_globals.random_seed = self.seed
estimator = Estimator()
qgt = LinCombQGT(estimator)
gradient = LinCombEstimatorGradient(estimator)
var_principle = ImaginaryMcLachlanPrinciple(qgt, gradient)
var_qite = VarQITE(
ansatz, init_param_values, var_principle, estimator, num_timesteps=25
)
evolution_result = var_qite.evolve(evolution_problem)
aux_ops = evolution_result.aux_ops_evaluated
parameter_values = evolution_result.parameter_values[-1]
expected_aux_ops = (-0.2177982985749799, 0.2556790598588627)
for i, parameter_value in enumerate(parameter_values):
np.testing.assert_almost_equal(
float(parameter_value), thetas_expected[i], decimal=2
)
np.testing.assert_array_almost_equal(
[result[0] for result in aux_ops], expected_aux_ops
)
with self.subTest(msg="Test shot-based backend."):
algorithm_globals.random_seed = self.seed
estimator = Estimator(options={"shots": 4096, "seed": self.seed})
qgt = LinCombQGT(estimator)
gradient = LinCombEstimatorGradient(estimator)
var_principle = ImaginaryMcLachlanPrinciple(qgt, gradient)
var_qite = VarQITE(
ansatz, init_param_values, var_principle, estimator, num_timesteps=25
)
evolution_result = var_qite.evolve(evolution_problem)
aux_ops = evolution_result.aux_ops_evaluated
parameter_values = evolution_result.parameter_values[-1]
expected_aux_ops = (-0.24629853310903974, 0.2518122871921184)
for i, parameter_value in enumerate(parameter_values):
np.testing.assert_almost_equal(
float(parameter_value), thetas_expected_shots[i], decimal=2
)
np.testing.assert_array_almost_equal(
[result[0] for result in aux_ops], expected_aux_ops
)
def test_run_d_1_t_7(self):
"""Test VarQITE for d = 1 and t = 7 with RK45 ODE solver."""
observable = SparsePauliOp.from_list(
[
("II", 0.2252),
("ZZ", 0.5716),
("IZ", 0.3435),
("ZI", -0.4347),
("YY", 0.091),
("XX", 0.091),
]
)
d = 1
ansatz = EfficientSU2(observable.num_qubits, reps=d)
parameters = list(ansatz.parameters)
init_param_values = np.zeros(len(parameters))
for i in range(len(parameters)):
init_param_values[i] = np.pi / 2
init_param_values[0] = 1
var_principle = ImaginaryMcLachlanPrinciple()
time = 7
var_qite = VarQITE(
ansatz, init_param_values, var_principle, ode_solver="RK45", num_timesteps=25
)
thetas_expected = [
0.828917365718767,
1.88481074798033,
3.14111335991238,
3.14125849601269,
2.33768562678401,
1.78670990729437,
2.04214275514208,
2.04009918594422,
]
self._test_helper(observable, thetas_expected, time, var_qite, 2)
def test_run_d_2(self):
"""Test VarQITE for d = 2 and t = 1 with RK45 ODE solver."""
observable = SparsePauliOp.from_list(
[
("II", 0.2252),
("ZZ", 0.5716),
("IZ", 0.3435),
("ZI", -0.4347),
("YY", 0.091),
("XX", 0.091),
]
)
d = 2
ansatz = EfficientSU2(observable.num_qubits, reps=d)
parameters = list(ansatz.parameters)
init_param_values = np.zeros(len(parameters))
for i in range(len(parameters)):
init_param_values[i] = np.pi / 4
var_principle = ImaginaryMcLachlanPrinciple()
time = 1
var_qite = VarQITE(
ansatz, init_param_values, var_principle, ode_solver="RK45", num_timesteps=25
)
thetas_expected = [
1.29495364023786,
1.08970061333559,
0.667488228710748,
0.500122687902944,
1.4377736672043,
1.22881086103085,
0.729773048146251,
1.01698854755226,
0.050807780587492,
0.294828474947149,
0.839305697704923,
0.663689581255428,
]
self._test_helper(observable, thetas_expected, time, var_qite, 4)
def test_run_d_1_time_dependent(self):
"""Test VarQITE for d = 1 and a time-dependent Hamiltonian with the Forward Euler solver."""
t_param = Parameter("t")
time = 1
observable = SparsePauliOp(["I", "Z"], np.array([0, t_param]))
x, y, z = [Parameter(s) for s in "xyz"]
ansatz = QuantumCircuit(1)
ansatz.rz(x, 0)
ansatz.ry(y, 0)
ansatz.rz(z, 0)
parameters = list(ansatz.parameters)
init_param_values = np.zeros(len(parameters))
x_val = 0
y_val = np.pi / 2
z_val = 0
init_param_values[0] = x_val
init_param_values[1] = y_val
init_param_values[2] = z_val
evolution_problem = TimeEvolutionProblem(observable, time, t_param=t_param)
thetas_expected = [1.83881002737137e-18, 2.43224994794434, -3.05311331771918e-18]
thetas_expected_shots = [1.83881002737137e-18, 2.43224994794434, -3.05311331771918e-18]
state_expected = Statevector([0.34849948 + 0.0j, 0.93730897 + 0.0j]).to_dict()
# the expected final state is Statevector([0.34849948+0.j, 0.93730897+0.j])
with self.subTest(msg="Test exact backend."):
algorithm_globals.random_seed = self.seed
estimator = Estimator()
var_principle = ImaginaryMcLachlanPrinciple()
var_qite = VarQITE(
ansatz, init_param_values, var_principle, estimator, num_timesteps=100
)
evolution_result = var_qite.evolve(evolution_problem)
evolved_state = evolution_result.evolved_state
parameter_values = evolution_result.parameter_values[-1]
for key, evolved_value in Statevector(evolved_state).to_dict().items():
# np.allclose works with complex numbers
self.assertTrue(np.allclose(evolved_value, state_expected[key], 1e-02))
for i, parameter_value in enumerate(parameter_values):
np.testing.assert_almost_equal(
float(parameter_value), thetas_expected[i], decimal=2
)
with self.subTest(msg="Test shot-based backend."):
algorithm_globals.random_seed = self.seed
estimator = Estimator(options={"shots": 4 * 4096, "seed": self.seed})
var_principle = ImaginaryMcLachlanPrinciple()
var_qite = VarQITE(
ansatz, init_param_values, var_principle, estimator, num_timesteps=100
)
evolution_result = var_qite.evolve(evolution_problem)
evolved_state = evolution_result.evolved_state
parameter_values = evolution_result.parameter_values[-1]
for key, evolved_value in Statevector(evolved_state).to_dict().items():
# np.allclose works with complex numbers
self.assertTrue(np.allclose(evolved_value, state_expected[key], 1e-02))
for i, parameter_value in enumerate(parameter_values):
np.testing.assert_almost_equal(
float(parameter_value), thetas_expected_shots[i], decimal=2
)
def _test_helper(self, observable, thetas_expected, time, var_qite, decimal):
evolution_problem = TimeEvolutionProblem(observable, time)
evolution_result = var_qite.evolve(evolution_problem)
parameter_values = evolution_result.parameter_values[-1]
for i, parameter_value in enumerate(parameter_values):
np.testing.assert_almost_equal(
float(parameter_value), thetas_expected[i], decimal=decimal
)
if __name__ == "__main__":
unittest.main()
|
https://github.com/CQCL/pytket-qiskit
|
CQCL
|
# Copyright 2019-2024 Quantinuum
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from collections import Counter
from typing import List, Set, Union
from math import pi
import pytest
from sympy import Symbol
import numpy as np
from qiskit import ( # type: ignore
QuantumCircuit,
QuantumRegister,
ClassicalRegister,
transpile,
)
from qiskit.quantum_info import SparsePauliOp, Statevector, Operator # type: ignore
from qiskit.transpiler import PassManager # type: ignore
from qiskit.circuit.library import RYGate, MCMT, XXPlusYYGate, PauliEvolutionGate, UnitaryGate, RealAmplitudes # type: ignore
import qiskit.circuit.library.standard_gates as qiskit_gates # type: ignore
from qiskit.circuit import Parameter
from qiskit.synthesis import SuzukiTrotter # type: ignore
from qiskit_aer import Aer # type: ignore
from qiskit.transpiler.passes import BasisTranslator # type: ignore
from qiskit.circuit.equivalence_library import StandardEquivalenceLibrary # type: ignore
from qiskit_ibm_runtime.fake_provider import FakeGuadalupe # type: ignore
from qiskit.circuit.parameterexpression import ParameterExpression # type: ignore
from qiskit.circuit.library import TwoLocal
from qiskit import transpile
from pytket.circuit import (
Circuit,
CircBox,
Unitary1qBox,
Unitary2qBox,
Unitary3qBox,
OpType,
Qubit,
Bit,
CustomGateDef,
reg_eq,
StatePreparationBox,
)
from pytket.extensions.qiskit import tk_to_qiskit, qiskit_to_tk, IBMQBackend
from pytket.extensions.qiskit.backends import qiskit_aer_backend
from pytket.extensions.qiskit.qiskit_convert import _gate_str_2_optype
from pytket.extensions.qiskit.tket_pass import TketPass, TketAutoPass
from pytket.extensions.qiskit.result_convert import qiskit_result_to_backendresult
from pytket.passes import (
RebaseTket,
DecomposeBoxes,
FullPeepholeOptimise,
SequencePass,
CliffordSimp,
)
from pytket.utils.results import (
compare_statevectors,
permute_rows_cols_in_unitary,
compare_unitaries,
)
skip_remote_tests: bool = os.getenv("PYTKET_RUN_REMOTE_TESTS") is None
REASON = "PYTKET_RUN_REMOTE_TESTS not set (requires IBM configuration)"
# helper function for testing
def _get_qiskit_statevector(qc: QuantumCircuit) -> np.ndarray:
"""Given a QuantumCircuit, use aer_simulator_statevector to compute its
statevector, return the vector with its endianness adjusted"""
back = Aer.get_backend("aer_simulator_statevector")
qc.save_state()
job = back.run(qc)
return np.array(job.result().data()["statevector"].reverse_qargs().data)
def test_parameterised_circuit_global_phase() -> None:
pass_1 = BasisTranslator(
StandardEquivalenceLibrary,
target_basis=FakeGuadalupe().configuration().basis_gates,
)
pass_2 = CliffordSimp()
qc = QuantumCircuit(2)
qc.ryy(Parameter("MyParam"), 0, 1)
pm = PassManager(pass_1)
qc = pm.run(qc)
tket_qc = qiskit_to_tk(qc)
pass_2.apply(tket_qc)
qc_2 = tk_to_qiskit(tket_qc)
assert type(qc_2.global_phase) == ParameterExpression
def test_classical_barrier_error() -> None:
c = Circuit(1, 1)
c.add_barrier([0], [0])
with pytest.raises(NotImplementedError):
tk_to_qiskit(c)
def test_convert_circuit_with_complex_params() -> None:
with pytest.raises(ValueError):
qiskit_op = SparsePauliOp(["Z"], coeffs=[1.0j])
evolved_op = PauliEvolutionGate(
qiskit_op, time=1, synthesis=SuzukiTrotter(reps=1)
)
evolution_circ = QuantumCircuit(1)
evolution_circ.append(evolved_op, [0])
tk_circ = qiskit_to_tk(evolution_circ)
DecomposeBoxes().apply(tk_circ)
def get_test_circuit(measure: bool, reset: bool = True) -> QuantumCircuit:
qr = QuantumRegister(4)
cr = ClassicalRegister(4)
qc = QuantumCircuit(qr, cr, name="test_circuit")
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.h(qr[0])
qc.cx(qr[0], qr[3])
qc.barrier(qr[3])
if reset:
qc.reset(qr[3])
qc.rx(pi / 2, qr[3])
qc.ry(0, qr[1])
qc.z(qr[2])
qc.ccx(qr[0], qr[1], qr[2])
qc.ch(qr[0], qr[1])
qc.cp(pi / 4, qr[0], qr[1])
qc.cry(pi / 4, qr[0], qr[1])
qc.crz(pi / 4, qr[1], qr[2])
qc.cswap(qr[1], qr[2], qr[3])
qc.cp(pi / 5, qr[2], qr[3])
qc.cu(pi / 4, pi / 5, pi / 6, 0, qr[3], qr[0])
qc.cy(qr[0], qr[1])
qc.cz(qr[1], qr[2])
qc.ecr(qr[0], qr[1])
qc.id(qr[2])
qc.iswap(qr[3], qr[0])
qc.mcx([qr[0], qr[1], qr[2]], qr[3])
qc.mcx([qr[1], qr[2], qr[3]], qr[0])
qc.p(pi / 4, qr[1])
qc.r(pi / 5, pi / 6, qr[2])
qc.rxx(pi / 3, qr[2], qr[3])
qc.ryy(pi / 3, qr[3], qr[2])
qc.rz(pi / 4, qr[0])
qc.rzz(pi / 5, qr[1], qr[2])
qc.s(qr[3])
qc.sdg(qr[0])
qc.swap(qr[1], qr[2])
qc.t(qr[3])
qc.tdg(qr[0])
qc.u(pi / 3, pi / 4, pi / 5, qr[0])
qc.p(pi / 2, qr[1])
qc.u(pi / 2, pi / 2, pi / 3, qr[2])
qc.u(pi / 2, pi / 3, pi / 4, qr[3])
qc.x(qr[0])
qc.y(qr[1])
if measure:
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
qc.measure(qr[2], cr[2])
qc.measure(qr[3], cr[3])
return qc
def test_convert() -> None:
qc = get_test_circuit(False)
tkc = qiskit_to_tk(qc)
assert qc.name == tkc.name
qc1 = tk_to_qiskit(tkc)
assert qc1.name == tkc.name
backend = Aer.get_backend("aer_simulator_statevector")
qc.save_state()
qc = transpile(qc, backend)
job = backend.run([qc])
state0 = job.result().get_statevector(qc)
qc1.save_state()
qc1 = transpile(qc1, backend)
job1 = backend.run([qc1])
state1 = job1.result().get_statevector(qc1)
assert np.allclose(state0, state1, atol=1e-10)
def test_symbolic() -> None:
pi2 = Symbol("pi2")
pi3 = Symbol("pi3")
pi0 = Symbol("pi0")
tkc = Circuit(3, 3, name="test").Ry(pi2, 1).Rx(pi3, 1).CX(1, 0)
tkc.add_phase(Symbol("pi0") * 2)
RebaseTket().apply(tkc)
qc = tk_to_qiskit(tkc)
tkc2 = qiskit_to_tk(qc)
assert tkc2.free_symbols() == {pi2, pi3, pi0}
tkc2.symbol_substitution({pi2: pi / 2, pi3: pi / 3, pi0: 0.1})
backend = Aer.get_backend("aer_simulator_statevector")
qc = tk_to_qiskit(tkc2)
assert qc.name == tkc.name
qc.save_state()
job = backend.run([qc])
state1 = job.result().get_statevector(qc)
state0 = np.array(
[
0.41273953 - 0.46964269j,
0.0 + 0.0j,
-0.0 + 0.0j,
-0.49533184 + 0.60309882j,
0.0 + 0.0j,
0.0 + 0.0j,
-0.0 + 0.0j,
-0.0 + 0.0j,
]
)
assert np.allclose(state0, state1, atol=1e-10)
def test_measures() -> None:
qc = get_test_circuit(True)
backend = qiskit_aer_backend("aer_simulator")
qc = transpile(qc, backend)
job = backend.run([qc], seed_simulator=7)
counts0 = job.result().get_counts(qc)
tkc = qiskit_to_tk(qc)
qc = tk_to_qiskit(tkc)
qc = transpile(qc, backend)
job = backend.run([qc], seed_simulator=7)
counts1 = job.result().get_counts(qc)
for result, count in counts1.items():
result_str = result.replace(" ", "")
if counts0[result_str] != count:
assert False
def test_boxes() -> None:
c = Circuit(2)
c.S(0)
c.H(1)
c.CX(0, 1)
cbox = CircBox(c)
d = Circuit(3, name="d")
d.add_circbox(cbox, [0, 1])
d.add_circbox(cbox, [1, 2])
u = np.asarray([[0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0]])
ubox = Unitary2qBox(u)
d.add_unitary2qbox(ubox, 0, 1)
qsc = tk_to_qiskit(d)
d1 = qiskit_to_tk(qsc)
assert len(d1.get_commands()) == 3
DecomposeBoxes().apply(d)
DecomposeBoxes().apply(d1)
assert d == d1
def test_Unitary1qBox() -> None:
c = Circuit(1)
u = np.asarray([[0, 1], [1, 0]])
ubox = Unitary1qBox(u)
c.add_unitary1qbox(ubox, 0)
# Convert to qiskit
qc = tk_to_qiskit(c)
# Verify that unitary from simulator is correct
back = Aer.get_backend("aer_simulator_unitary")
qc.save_unitary()
job = back.run(qc).result()
a = job.get_unitary(qc)
u1 = np.asarray(a)
assert np.allclose(u1, u)
def test_Unitary2qBox() -> None:
c = Circuit(2)
u = np.asarray([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
ubox = Unitary2qBox(u)
c.add_unitary2qbox(ubox, 0, 1)
# Convert to qiskit
qc = tk_to_qiskit(c)
# Verify that unitary from simulator is correct
back = Aer.get_backend("aer_simulator_unitary")
qc.save_unitary()
job = back.run(qc).result()
a = job.get_unitary(qc)
u1 = permute_rows_cols_in_unitary(np.asarray(a), (1, 0)) # correct for endianness
assert np.allclose(u1, u)
def test_Unitary3qBox() -> None:
c = Circuit(3)
u = np.asarray(
[
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
]
)
ubox = Unitary3qBox(u)
c.add_unitary3qbox(ubox, 0, 1, 2)
# Convert to qiskit
qc = tk_to_qiskit(c)
# Verify that unitary from simulator is correct
back = Aer.get_backend("aer_simulator_unitary")
qc.save_unitary()
job = back.run(qc).result()
a = job.get_unitary(qc)
u1 = permute_rows_cols_in_unitary(
np.asarray(a), (2, 1, 0)
) # correct for endianness
assert np.allclose(u1, u)
def test_gates_phase() -> None:
c = Circuit(4).SX(0).V(1).V(2).Vdg(3).Phase(0.5)
qc = tk_to_qiskit(c)
qr = QuantumRegister(4, "q")
qc_correct = QuantumCircuit(qr)
qc_correct.sx(qr[0])
qc_correct.sx(qr[1])
qc_correct.sx(qr[2])
qc_correct.sxdg(qr[3])
qc_correct.global_phase = pi / 4
assert qc == qc_correct
def test_tketpass() -> None:
qc = get_test_circuit(False, False)
tkpass = FullPeepholeOptimise()
back = Aer.get_backend("aer_simulator_unitary")
for _ in range(12):
tkc = qiskit_to_tk(qc)
tkpass.apply(tkc)
qc1 = tk_to_qiskit(tkc)
qc1.save_unitary()
res = back.run(qc1).result()
u1 = res.get_unitary(qc1)
qispass = TketPass(tkpass)
pm = PassManager(qispass)
qc2 = pm.run(qc)
qc2.save_unitary()
res = back.run(qc2).result()
u2 = res.get_unitary(qc2)
assert np.allclose(u1, u2)
@pytest.mark.timeout(None)
@pytest.mark.skipif(skip_remote_tests, reason=REASON)
def test_tketautopass(brisbane_backend: IBMQBackend) -> None:
backends = [
Aer.get_backend("aer_simulator_statevector"),
qiskit_aer_backend("aer_simulator"),
Aer.get_backend("aer_simulator_unitary"),
]
backends.append(brisbane_backend._backend)
for back in backends:
for o_level in range(3):
tkpass = TketAutoPass(
back, o_level, token=os.getenv("PYTKET_REMOTE_QISKIT_TOKEN")
)
qc = get_test_circuit(True)
pm = PassManager(passes=tkpass)
pm.run(qc)
def test_instruction() -> None:
# TKET-446
op = SparsePauliOp(["XXI", "YYI", "ZZZ"], [0.3, 0.5, -0.4])
evo_instr = PauliEvolutionGate(op, time=1.2, synthesis=SuzukiTrotter(reps=1))
evolution_circ = QuantumCircuit(3)
evolution_circ.append(evo_instr, [0, 1, 2])
tk_circ = qiskit_to_tk(evolution_circ)
cmds = tk_circ.get_commands()
assert len(cmds) == 1
assert cmds[0].op.type == OpType.CircBox
def test_conditions() -> None:
box_c = Circuit(2, 2)
box_c.Z(0)
box_c.Y(1, condition_bits=[0, 1], condition_value=1)
box_c.Measure(0, 0, condition_bits=[0, 1], condition_value=0)
box = CircBox(box_c)
u = np.asarray([[0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0]])
ubox = Unitary2qBox(u)
c = Circuit(2, 2, name="c")
b = c.add_c_register("b", 1)
c.add_circbox(
box,
[Qubit(0), Qubit(1), Bit(0), Bit(1)],
condition_bits=[b[0]],
condition_value=1,
)
c.add_unitary2qbox(
ubox, Qubit(0), Qubit(1), condition_bits=[b[0]], condition_value=0
)
c2 = c.copy()
qc = tk_to_qiskit(c)
c1 = qiskit_to_tk(qc)
assert len(c1.get_commands()) == 2
DecomposeBoxes().apply(c)
DecomposeBoxes().apply(c1)
assert c == c1
c2.Z(1, condition=reg_eq(b, 1))
qc = tk_to_qiskit(c2)
c1 = qiskit_to_tk(qc)
assert len(c1.get_commands()) == 3
# conversion loses rangepredicates so equality comparison not valid
def test_condition_errors() -> None:
with pytest.raises(Exception) as errorinfo:
c = Circuit(2, 2)
b = c.add_c_register("b", 2)
c.X(Qubit(0), condition_bits=[b[0], Bit(0)], condition_value=1)
tk_to_qiskit(c)
assert "Conditions can only use a single register" in str(errorinfo.value)
with pytest.raises(Exception) as errorinfo:
c = Circuit(2, 2)
c.X(0, condition_bits=[1, 0], condition_value=1)
tk_to_qiskit(c)
assert "Conditions must be an entire register in order" in str(errorinfo.value)
def test_correction() -> None:
checked_x = Circuit(2, 1)
checked_x.CX(0, 1)
checked_x.X(0)
checked_x.CX(0, 1)
checked_x.Measure(1, 0)
x_box = CircBox(checked_x)
c = Circuit()
target = Qubit("t", 0)
ancilla = Qubit("a", 0)
success = Bit("s", 0)
c.add_qubit(target)
c.add_qubit(ancilla)
c.add_bit(success)
c.add_circbox(x_box, args=[target, ancilla, success])
c.add_circbox(
x_box,
args=[target, ancilla, success],
condition_bits=[success],
condition_value=0,
)
comp_pass = SequencePass([DecomposeBoxes(), RebaseTket()])
comp_pass.apply(c)
tk_to_qiskit(c)
def test_cnx() -> None:
qr = QuantumRegister(5)
qc = QuantumCircuit(qr, name="cnx_circuit")
qc.mcx([0, 1, 2, 3], 4)
c = qiskit_to_tk(qc)
cmds = c.get_commands()
assert len(cmds) == 1
cmd = cmds[0]
assert cmd.op.type == OpType.CnX
assert len(cmd.qubits) == 5
qregname = qc.qregs[0].name
assert cmd.qubits[4] == Qubit(qregname, 4)
def test_gate_str_2_optype() -> None:
samples = {
"barrier": OpType.Barrier,
"cx": OpType.CX,
"mcx": OpType.CnX,
"x": OpType.X,
}
print([(_gate_str_2_optype[key], val) for key, val in samples.items()])
assert all(_gate_str_2_optype[key] == val for key, val in samples.items())
def test_customgate() -> None:
a = Symbol("a")
def_circ = Circuit(2)
def_circ.CZ(0, 1)
def_circ.Rx(a, 1)
gate_def = CustomGateDef.define("MyCRx", def_circ, [a])
circ = Circuit(3)
circ.Rx(0.1, 0)
circ.Rx(0.4, 2)
circ.add_custom_gate(gate_def, [0.2], [0, 1])
qc1 = tk_to_qiskit(circ)
newcirc = qiskit_to_tk(qc1)
print(repr(newcirc))
qc2 = tk_to_qiskit(newcirc)
correct_circ = Circuit(3).Rx(0.1, 0).Rx(0.4, 2).CZ(0, 1).Rx(0.2, 1)
correct_qc = tk_to_qiskit(correct_circ)
backend = Aer.get_backend("aer_simulator_statevector")
states = []
for qc in (qc1, qc2, correct_qc):
qc.save_state()
qc = transpile(qc, backend)
job = backend.run([qc])
states.append(job.result().get_statevector(qc))
assert compare_statevectors(states[0], states[1])
assert compare_statevectors(states[1], states[2])
def test_convert_result() -> None:
# testing fix to register order bug TKET-752
qr1 = QuantumRegister(1, name="q1")
qr2 = QuantumRegister(2, name="q2")
cr = ClassicalRegister(5, name="z")
cr2 = ClassicalRegister(2, name="b")
qc = QuantumCircuit(qr1, qr2, cr, cr2)
qc.x(qr1[0])
qc.x(qr2[1])
# check statevector
simulator = Aer.get_backend("aer_simulator_statevector")
qc1 = qc.copy()
qc1.save_state()
qisk_result = simulator.run(qc1, shots=10).result()
tk_res = next(qiskit_result_to_backendresult(qisk_result))
state = tk_res.get_state([Qubit("q2", 1), Qubit("q1", 0), Qubit("q2", 0)])
correct_state = np.zeros(1 << 3, dtype=complex)
correct_state[6] = 1 + 0j
assert compare_statevectors(state, correct_state)
# check measured
qc.measure(qr1[0], cr[0])
qc.measure(qr2[1], cr2[0])
simulator = qiskit_aer_backend("aer_simulator")
qisk_result = simulator.run(qc, shots=10).result()
tk_res = next(qiskit_result_to_backendresult(qisk_result))
one_bits = [Bit("z", 0), Bit("b", 0)]
zero_bits = [Bit("z", i) for i in range(1, 5)] + [Bit("b", 1)]
assert tk_res.get_counts(one_bits) == Counter({(1, 1): 10})
assert tk_res.get_counts(zero_bits) == Counter({(0, 0, 0, 0, 0): 10})
def add_x(
qbit: int, qr: QuantumRegister, circuits: List[Union[Circuit, QuantumCircuit]]
) -> None:
"""Add an x gate to each circuit in a list,
each one being either a tket or qiskit circuit."""
for circ in circuits:
if isinstance(circ, Circuit):
circ.add_gate(OpType.X, [qbit])
else:
circ.x(qr[qbit])
def add_cnry(
param: float,
qbits: List[int],
qr: QuantumRegister,
circuits: List[Union[Circuit, QuantumCircuit]],
) -> None:
"""Add a CnRy gate to each circuit in a list,
each one being either a tket or qiskit circuit."""
assert len(qbits) >= 2
for circ in circuits:
if isinstance(circ, Circuit):
circ.add_gate(OpType.CnRy, param, qbits)
else:
# param was "raw", so needs an extra PI.
new_ry_gate = RYGate(param * pi)
new_gate = MCMT(
gate=new_ry_gate, num_ctrl_qubits=len(qbits) - 1, num_target_qubits=1
)
circ.append(new_gate, [qr[nn] for nn in qbits])
def assert_tket_circuits_identical(circuits: List[Circuit]) -> None:
"""Apart from the circuit names and qubit labels, assert that
all circuits in the list are identical (i.e., identical gates), not just equivalent
(having the same unitary matrix)."""
if len(circuits) <= 1:
return
circ_copies = []
for nn in range(len(circuits)):
assert type(circuits[nn]) == Circuit
circ = circuits[nn].copy()
circ.name = "tk_circ_must_be_same_name"
qbs = circ.qubits
qubit_map = {qbs[mm]: Qubit("node", mm) for mm in range(len(qbs))}
circ.rename_units(qubit_map) # type: ignore
circ_copies.append(circ)
for nn in range(1, len(circ_copies)):
assert circ_copies[0] == circ_copies[nn]
def assert_equivalence(
circuits: List[Union[Circuit, QuantumCircuit]],
require_qk_conversions_equality: bool = True,
require_tk_equality: bool = True,
) -> None:
"""Given a list of circuits (either tket or qiskit), simulate them to calculate
unitary matrices, and fail if they are not all almost equal.
Also, (unless require_tk_equality is false), assert that
all tket circuits are equal.
If require_qk_conversions_equality is true,
treat qk->tk conversions as if they were originally tk circuits and test
for equality (rather than just equivalence), if require_tk_equality is true.
"""
assert len(circuits) >= 2
tk_circuits = []
# We want unique circuit names, otherwise it confuses the Qiskit backend.
names: Set[str] = set()
for nn in range(len(circuits)):
if isinstance(circuits[nn], Circuit):
if require_tk_equality:
tk_circuits.append(circuits[nn])
# Of course, use the tket simulator directly once available.
# But not yet, so need to convert to qiskit circuits.
circuits[nn] = tk_to_qiskit(circuits[nn])
elif require_qk_conversions_equality and require_tk_equality:
tk_circuits.append(qiskit_to_tk(circuits[nn]))
names.add(circuits[nn].name) # type: ignore
assert len(names) == len(circuits)
assert_tket_circuits_identical(tk_circuits)
backend = Aer.get_backend("aer_simulator_unitary")
unitaries = []
for circ in circuits:
assert isinstance(circ, QuantumCircuit)
circ1 = circ.copy()
circ1.save_unitary()
circ1 = transpile(circ1, backend)
job = backend.run(circ1)
unitaries.append(job.result().get_unitary(circ1))
for nn in range(1, len(circuits)):
# Default np.allclose is very lax here, so use strict tolerances
assert np.allclose(unitaries[0], unitaries[nn], atol=1e-14, rtol=0.0)
def qcirc_to_tcirc(qcirc: QuantumCircuit) -> Circuit:
"""Changes the name also, to avoid backend result clashes."""
tcirc = qiskit_to_tk(qcirc)
tcirc.name = "new tket circ from " + qcirc.name
return tcirc
def test_cnry_conversion() -> None:
"""This is for TKET-991.
Maintain parallel circuits, check equivalence at each stage.
It would be good to subsume this as part of general
randomised tests, where we add random gates in sequence."""
tcirc = Circuit(3, name="parallel tcirc")
qr = QuantumRegister(3, "q")
qcirc = QuantumCircuit(qr, name="parallel qcirc")
add_x(0, qr, [tcirc, qcirc])
add_x(1, qr, [tcirc, qcirc])
# It seems like we can test tket circuits for equality,
# but not equivalence (since a direct tket simulator, with a
# circuit->unitary function, is not yet available in pytket.
# When it is available, we should add it here).
#
# Amusingly enough, it seems like we can test Qiskit circuits
# for equivalence, but not for equality!
#
# Note that loops tk->qk->tk and qk->tk->qk should preserve
# equivalence, but need not preserve equality because of different
# gate sets.
assert_equivalence([tcirc, qcirc])
add_x(2, qr, [tcirc, qcirc])
assert_equivalence([tcirc, qcirc])
new_tcirc = qcirc_to_tcirc(qcirc)
assert_equivalence([tcirc, qcirc, new_tcirc])
add_x(0, qr, [tcirc, qcirc, new_tcirc])
assert_equivalence([tcirc, qcirc, new_tcirc])
add_cnry(0.1, [0, 1], qr, [tcirc, qcirc, new_tcirc])
add_x(2, qr, [tcirc, qcirc, new_tcirc])
# Because adding the CnRy gate to Qiskit circuits involves
# circ.append(new_gate, ...),
# converting back to tket produces a CircBox rather than a CnRy gate.
# So we cannot get tket equality, even though we have equivalence
assert_equivalence([tcirc, qcirc, new_tcirc], require_qk_conversions_equality=False)
add_x(0, qr, [qcirc, tcirc, new_tcirc])
assert_equivalence([tcirc, qcirc, new_tcirc], require_qk_conversions_equality=False)
add_cnry(0.2, [1, 0, 2], qr, [tcirc, qcirc, new_tcirc])
assert_equivalence([tcirc, qcirc, new_tcirc], require_qk_conversions_equality=False)
add_x(2, qr, [tcirc, qcirc, new_tcirc])
add_x(1, qr, [tcirc, qcirc, new_tcirc])
add_x(0, qr, [tcirc, qcirc, new_tcirc])
assert_equivalence([tcirc, qcirc, new_tcirc], require_qk_conversions_equality=False)
new_tcirc = qcirc_to_tcirc(qcirc)
assert_equivalence(
[tcirc, qcirc, new_tcirc],
require_qk_conversions_equality=False,
# We've done qk->tk conversion to get new_tcirc, so
# we do not expect equality between new_tcirc and tcirc.
require_tk_equality=False,
)
# pytket-extensions issue #72
def test_parameter_equality() -> None:
param_a = Parameter("a")
param_b = Parameter("b")
circ = QuantumCircuit(2)
circ.rx(param_a, 0)
circ.ry(param_b, 1)
circ.cx(0, 1)
# fails with preserve_param_uuid=False
# as Parameter uuid attribute is not preserved
# and so fails equality check at assign_parameters
pytket_circ = qiskit_to_tk(circ, preserve_param_uuid=True)
final_circ = tk_to_qiskit(pytket_circ)
assert final_circ.parameters == circ.parameters
param_dict = dict(zip([param_a, param_b], [1, 2]))
final_circ.assign_parameters(param_dict, inplace=True)
assert len(final_circ.parameters) == 0
# https://github.com/CQCL/pytket-extensions/issues/275
def test_convert_multi_c_reg() -> None:
c = Circuit()
q0, q1 = c.add_q_register("q", 2)
c.add_c_register("c", 2)
[m0] = c.add_c_register("m", 1)
c.add_gate(OpType.X, [], [q1], condition_bits=[m0], condition_value=1)
c.CX(q0, q1)
c.add_gate(OpType.TK1, [0.5, 0.5, 0.5], [q0])
qcirc = tk_to_qiskit(c)
circ = qiskit_to_tk(qcirc)
assert circ.get_commands()[0].args == [m0, q1]
# test that tk_to_qiskit works after adding OpType.CRx and OpType.CRy
def test_crx_and_cry() -> None:
tk_circ = Circuit(2)
tk_circ.CRx(0.5, 0, 1)
tk_circ.CRy(0.2, 1, 0)
qiskit_circ = tk_to_qiskit(tk_circ)
ops_dict = qiskit_circ.count_ops()
assert ops_dict["crx"] == 1 and ops_dict["cry"] == 1
# test that tk_to_qiskit works for gates which don't have
# an exact substitution in qiskit e.g. ZZMax
# See issue "Add support for ZZMax gate in converters" #486
def test_rebased_conversion() -> None:
tket_circzz = Circuit(3)
tket_circzz.V(0).H(1).Vdg(2)
tket_circzz.CV(0, 2)
tket_circzz.add_gate(OpType.ZZMax, [0, 1])
tket_circzz.add_gate(OpType.TK1, [0.1, 0.2, 0.3], [2])
tket_circzz.add_gate(OpType.PhasedISWAP, [0.25, -0.5], [0, 2])
qiskit_circzz = tk_to_qiskit(tket_circzz)
tket_circzz2 = qiskit_to_tk(qiskit_circzz)
u1 = tket_circzz.get_unitary()
u2 = tket_circzz2.get_unitary()
assert compare_unitaries(u1, u2)
@pytest.mark.xfail(reason="PauliEvolutionGate with symbolic parameter not supported")
def test_parametrized_evolution() -> None:
operator = SparsePauliOp(["XXZ", "YXY"], coeffs=[1.0, 0.5]) * Parameter("x")
evolved_circ_op = PauliEvolutionGate(
operator, time=1, synthesis=SuzukiTrotter(reps=2, order=4)
)
qc = QuantumCircuit(3)
qc.append(evolved_circ_op, [0, 1, 2])
tk_qc: Circuit = qiskit_to_tk(qc)
assert len(tk_qc.free_symbols()) == 1
def test_multicontrolled_gate_conversion() -> None:
my_qc = QuantumCircuit(4)
my_qc.append(qiskit_gates.YGate().control(3), [0, 1, 2, 3])
my_qc.append(qiskit_gates.RYGate(0.25).control(3), [0, 1, 2, 3])
my_qc.append(qiskit_gates.ZGate().control(3), [0, 1, 2, 3])
my_tkc = qiskit_to_tk(my_qc)
my_tkc.add_gate(OpType.CnRy, [0.95], [0, 1, 2, 3])
my_tkc.add_gate(OpType.CnZ, [1, 2, 3, 0])
my_tkc.add_gate(OpType.CnY, [0, 1, 3, 2])
unitary_before = my_tkc.get_unitary()
assert my_tkc.n_gates_of_type(OpType.CnY) == 2
assert my_tkc.n_gates_of_type(OpType.CnZ) == 2
assert my_tkc.n_gates_of_type(OpType.CnRy) == 2
my_new_qc = tk_to_qiskit(my_tkc)
qiskit_ops = my_new_qc.count_ops()
assert qiskit_ops["c3y"] and qiskit_ops["c3z"] and qiskit_ops["c3ry"] == 2
tcirc = qiskit_to_tk(my_new_qc)
unitary_after = tcirc.get_unitary()
assert compare_unitaries(unitary_before, unitary_after)
def test_qcontrolbox_conversion() -> None:
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c2h_gate = qiskit_gates.HGate().control(2)
qc.append(c2h_gate, qr)
c = qiskit_to_tk(qc)
assert c.n_gates == 1
assert c.n_gates_of_type(OpType.QControlBox) == 1
c3rx_gate = qiskit_gates.RXGate(0.7).control(3)
c3rz_gate = qiskit_gates.RZGate(pi / 4).control(3)
c2rzz_gate = qiskit_gates.RZZGate(pi / 3).control(2)
qc2 = QuantumCircuit(4)
qc2.append(c3rz_gate, [0, 1, 3, 2])
qc2.append(c3rx_gate, [0, 1, 2, 3])
qc2.append(c2rzz_gate, [0, 1, 2, 3])
tkc2 = qiskit_to_tk(qc2)
assert tkc2.n_gates == 3
assert tkc2.n_gates_of_type(OpType.QControlBox) == 3
# Ensures that the tk_to_qiskit converter does not cancel redundant gates
def test_tk_to_qiskit_redundancies() -> None:
h_circ = Circuit(1).H(0).H(0)
qc_h = tk_to_qiskit(h_circ)
assert qc_h.count_ops()["h"] == 2
def test_ccx_conversion() -> None:
# https://github.com/CQCL/pytket-qiskit/issues/117
c00 = QuantumCircuit(3)
c00.ccx(0, 1, 2, 0) # 0 = "00" (little-endian)
assert compare_unitaries(
qiskit_to_tk(c00).get_unitary(),
Circuit(3).X(0).X(1).CCX(0, 1, 2).X(0).X(1).get_unitary(),
)
c10 = QuantumCircuit(3)
c10.ccx(0, 1, 2, 1) # 1 = "10" (little-endian)
assert compare_unitaries(
qiskit_to_tk(c10).get_unitary(),
Circuit(3).X(1).CCX(0, 1, 2).X(1).get_unitary(),
)
c01 = QuantumCircuit(3)
c01.ccx(0, 1, 2, 2) # 2 = "01" (little-endian)
assert compare_unitaries(
qiskit_to_tk(c01).get_unitary(),
Circuit(3).X(0).CCX(0, 1, 2).X(0).get_unitary(),
)
c11 = QuantumCircuit(3)
c11.ccx(0, 1, 2, 3) # 3 = "11" (little-endian)
assert compare_unitaries(
qiskit_to_tk(c11).get_unitary(),
Circuit(3).CCX(0, 1, 2).get_unitary(),
)
def test_conditional_conversion() -> None:
c = Circuit(1, 2, "conditional_circ")
c.X(0, condition_bits=[0], condition_value=1)
c_qiskit = tk_to_qiskit(c)
c_tket = qiskit_to_tk(c_qiskit)
assert c_tket.to_dict() == c.to_dict()
def test_conditional_conversion_2() -> None:
c = Circuit(1, 2, "conditional_circ_2")
c.X(0, condition_bits=[1], condition_value=1)
c_qiskit = tk_to_qiskit(c)
c_tket = qiskit_to_tk(c_qiskit)
assert c_tket.to_dict() == c.to_dict()
# https://github.com/CQCL/pytket-qiskit/issues/100
def test_state_prep_conversion_array_or_list() -> None:
# State prep with list of real amplitudes
ghz_state_permuted = np.array([0, 0, 1 / np.sqrt(2), 0, 0, 0, 0, 1 / np.sqrt(2)])
qc_sp = QuantumCircuit(3)
qc_sp.prepare_state(ghz_state_permuted)
tk_sp = qiskit_to_tk(qc_sp)
assert tk_sp.n_gates_of_type(OpType.StatePreparationBox) == 1
assert tk_sp.n_gates == 1
assert compare_statevectors(tk_sp.get_statevector(), ghz_state_permuted)
# State prep with ndarray of complex amplitudes
qc_sp2 = QuantumCircuit(2)
complex_statvector = np.array([1 / np.sqrt(2), 0, -1.0j / np.sqrt(2), 0])
qc_sp2.initialize(complex_statvector, qc_sp2.qubits)
tk_sp2 = qiskit_to_tk(qc_sp2)
assert tk_sp2.n_gates_of_type(OpType.StatePreparationBox) == 1
assert tk_sp2.n_gates == 1
# test tket -> qiskit conversion
converted_qiskit_qc = tk_to_qiskit(tk_sp2)
assert converted_qiskit_qc.count_ops()["initialize"] == 1
tk_sp3 = qiskit_to_tk(converted_qiskit_qc)
# check circuit decomposes as expected
DecomposeBoxes().apply(tk_sp3)
assert tk_sp3.n_gates_of_type(OpType.Reset) == 2
state_arr = 1 / np.sqrt(2) * np.array([1, 1, 0, 0])
sv = Statevector(state_arr)
qc_2 = QuantumCircuit(2)
qc_2.prepare_state(sv, [0, 1])
tkc_2 = qiskit_to_tk(qc_2)
assert tkc_2.n_gates_of_type(OpType.StatePreparationBox) == 1
def test_state_prep_conversion_with_int() -> None:
qc = QuantumCircuit(4)
qc.prepare_state(7, qc.qubits)
tkc7 = qiskit_to_tk(qc)
assert tkc7.n_gates_of_type(OpType.X) == 3
qc_sv = _get_qiskit_statevector(qc.decompose())
assert compare_statevectors(tkc7.get_statevector(), qc_sv)
int_statevector = Statevector.from_int(5, 8)
qc_s = QuantumCircuit(3)
qc_s.prepare_state(int_statevector)
# unfortunately Aer doesn't support state_preparation
# instructions so we decompose first
d_qc_s = qc_s.decompose(reps=5)
sv_int = _get_qiskit_statevector(d_qc_s)
tkc_int = qiskit_to_tk(qc_s)
tkc_int_sv = tkc_int.get_statevector()
assert compare_statevectors(tkc_int_sv, sv_int)
def test_state_prep_conversion_with_str() -> None:
qc = QuantumCircuit(5)
qc.initialize("rl+-1")
tk_circ = qiskit_to_tk(qc)
assert tk_circ.n_gates_of_type(OpType.Reset) == 5
assert tk_circ.n_gates_of_type(OpType.H) == 4
assert tk_circ.n_gates_of_type(OpType.X) == 2
qc_string_sp = QuantumCircuit(3)
qc_string_sp.prepare_state("r-l")
decomposed_qc = qc_string_sp.decompose(reps=4)
qiskit_sv = _get_qiskit_statevector(decomposed_qc)
tk_string_sp = qiskit_to_tk(qc_string_sp)
assert tk_string_sp.n_gates_of_type(OpType.H) == 3
assert tk_string_sp.n_gates_of_type(OpType.Sdg) == 1
assert compare_statevectors(qiskit_sv, tk_string_sp.get_statevector())
sv_str = Statevector.from_label("rr+-")
sv_qc = QuantumCircuit(4)
sv_qc.prepare_state(sv_str)
decomposed_sv_qc = sv_qc.decompose(reps=6)
sv_array = _get_qiskit_statevector(decomposed_sv_qc)
tkc_sv = qiskit_to_tk(sv_qc)
assert compare_statevectors(sv_array, tkc_sv.get_statevector())
def test_conversion_to_tket_with_and_without_resets() -> None:
test_state = 1 / np.sqrt(3) * np.array([1, 1, 0, 0, 0, 0, 1, 0])
tket_sp_reset = StatePreparationBox(test_state, with_initial_reset=True)
tk_circ_reset = Circuit(3).add_gate(tket_sp_reset, [0, 1, 2])
qiskit_qc_init = tk_to_qiskit(tk_circ_reset)
assert qiskit_qc_init.count_ops()["initialize"] == 1
tket_sp_no_reset = StatePreparationBox(test_state, with_initial_reset=False)
tket_circ_no_reset = Circuit(3).add_gate(tket_sp_no_reset, [0, 1, 2])
tkc_sv = tket_circ_no_reset.get_statevector()
qiskit_qc_sp = tk_to_qiskit(tket_circ_no_reset)
assert qiskit_qc_sp.count_ops()["state_preparation"] == 1
decomp_qc = qiskit_qc_sp.decompose(reps=5)
qiskit_state = _get_qiskit_statevector(decomp_qc)
assert compare_statevectors(tkc_sv, qiskit_state)
def test_unitary_gate() -> None:
# https://github.com/CQCL/pytket-qiskit/issues/122
qkc = QuantumCircuit(3)
for n in range(4):
u = np.eye(1 << n, dtype=complex)
gate = UnitaryGate(u)
qkc.append(gate, list(range(n)))
tkc = qiskit_to_tk(qkc)
cmds = tkc.get_commands()
assert len(cmds) == 3
assert cmds[0].op.type == OpType.Unitary1qBox
assert cmds[1].op.type == OpType.Unitary2qBox
assert cmds[2].op.type == OpType.Unitary3qBox
def test_ccz_conversion() -> None:
qc_ccz = QuantumCircuit(4)
qc_ccz.append(qiskit_gates.CCZGate(), [0, 1, 2])
qc_ccz.append(qiskit_gates.CCZGate(), [3, 1, 0])
tkc_ccz = qiskit_to_tk(qc_ccz)
assert tkc_ccz.n_gates_of_type(OpType.CnZ) == tkc_ccz.n_gates == 2
# bidirectional CnZ conversion already supported
qc_ccz2 = tk_to_qiskit(tkc_ccz)
assert qc_ccz2.count_ops()["ccz"] == 2
tkc_ccz2 = qiskit_to_tk(qc_ccz2)
assert compare_unitaries(tkc_ccz.get_unitary(), tkc_ccz2.get_unitary())
def test_csx_conversion() -> None:
qc_csx = QuantumCircuit(2)
qc_csx.append(qiskit_gates.CSXGate(), [0, 1])
qc_csx.append(qiskit_gates.CSXGate(), [1, 0])
converted_tkc = qiskit_to_tk(qc_csx)
assert converted_tkc.n_gates == 2
assert converted_tkc.n_gates_of_type(OpType.CSX) == 2
u1 = converted_tkc.get_unitary()
new_tkc_csx = Circuit(2)
new_tkc_csx.add_gate(OpType.CSX, [0, 1]).add_gate(OpType.CSX, [1, 0])
u2 = new_tkc_csx.get_unitary()
assert compare_unitaries(u1, u2)
converted_qc = tk_to_qiskit(new_tkc_csx)
assert converted_qc.count_ops()["csx"] == 2
qc_c3sx = QuantumCircuit(4)
qc_c3sx.append(qiskit_gates.C3SXGate(), [0, 1, 2, 3])
tkc_c3sx = qiskit_to_tk(qc_c3sx)
assert tkc_c3sx.n_gates == tkc_c3sx.n_gates_of_type(OpType.QControlBox) == 1
def test_CS_and_CSdg() -> None:
qiskit_qc = QuantumCircuit(2)
qiskit_qc.append(qiskit_gates.CSGate(), [0, 1])
qiskit_qc.append(qiskit_gates.CSdgGate(), [0, 1])
qiskit_qc.append(qiskit_gates.CSGate(), [1, 0])
qiskit_qc.append(qiskit_gates.CSdgGate(), [1, 0])
tkc = qiskit_to_tk(qiskit_qc)
assert tkc.n_gates_of_type(OpType.QControlBox) == 4
def test_failed_conversion_error() -> None:
qc = QuantumCircuit(2)
qc.append(XXPlusYYGate(0.1), [0, 1]) # add unsupported gate
with pytest.raises(
NotImplementedError, match=r"Conversion of qiskit's xx_plus_yy instruction"
):
qiskit_to_tk(qc)
# https://github.com/CQCL/pytket-qiskit/issues/200
def test_RealAmplitudes_numeric_params() -> None:
qc = QuantumCircuit(3)
params = [np.pi / 2] * 9
real_amps1 = RealAmplitudes(3, reps=2)
real_amps2 = real_amps1.assign_parameters(params)
qc.compose(real_amps2, qubits=[0, 1, 2], inplace=True)
# Unitary operator of the qiskit circuit. Order reversed from little -> big endian.
# The reversal means we can check it for equivalence with a tket unitary
qiskit_unitary = Operator(qc.reverse_bits()).data
converted_tkc = qiskit_to_tk(qc)
assert converted_tkc.n_gates == 1
assert converted_tkc.n_gates_of_type(OpType.CircBox) == 1
circbox_op = converted_tkc.get_commands()[0].op
assert isinstance(circbox_op, CircBox)
assert circbox_op.get_circuit().name == "RealAmplitudes"
DecomposeBoxes().apply(converted_tkc)
assert converted_tkc.n_gates_of_type(OpType.CX) == 4
assert converted_tkc.n_gates_of_type(OpType.Ry) == 9
unitary1 = converted_tkc.get_unitary()
qc2 = tk_to_qiskit(converted_tkc)
tkc2 = qiskit_to_tk(qc2)
unitary2 = tkc2.get_unitary()
assert compare_unitaries(qiskit_unitary, unitary1)
assert compare_unitaries(unitary1, unitary2)
# https://github.com/CQCL/pytket-qiskit/issues/256
def test_symbolic_param_conv() -> None:
qc = TwoLocal(1, "ry", "cz", reps=1, entanglement="linear")
qc_transpiled = transpile(
qc, basis_gates=["sx", "rz", "cx", "x"], optimization_level=3
)
tket_qc = qiskit_to_tk(qc_transpiled)
CliffordSimp().apply(tket_qc)
transformed_qc = tk_to_qiskit(tket_qc)
qc_transpiled_again = transpile(transformed_qc, basis_gates=["sx", "rz", "cx", "x"])
qc_transpiled_again = qc_transpiled_again.assign_parameters(
{
qc_transpiled_again.parameters[i]: 0
for i in range(len(qc_transpiled_again.parameters))
}
)
# https://github.com/CQCL/pytket-qiskit/issues/337
def test_nonregister_bits() -> None:
c = Circuit(1).X(0).measure_all()
c.rename_units({Bit(0): Bit(1)})
with pytest.raises(NotImplementedError):
tk_to_qiskit(c)
|
https://github.com/unitaryfund/mitiq
|
unitaryfund
|
import numpy as np
from pyquil import get_qc, Program
from pyquil.gates import RX, RY, S, T, Z, CNOT, MEASURE
from pyquil.paulis import PauliTerm, PauliSum, sZ
from pyquil.noise import pauli_kraus_map, append_kraus_to_gate
from typing import List, Union
from collections import Counter
from matplotlib import pyplot as plt
from scipy import optimize
import mitiq
from mitiq import zne
from mitiq.zne.scaling.folding import fold_gates_at_random
backend = get_qc("2q-qvm")
program = Program()
theta = program.declare("theta", memory_type="REAL")
program += RX(theta, 0)
program += T(0)
program += CNOT(1, 0)
program += S(0)
program += Z(0)
def add_noise_to_circuit(quil_prog):
"""Define pyQuil gates with a custom noise model via Kraus operators:
1. Generate Kraus operators at given survival probability
2. Append Kraus operators to the gate matrices
3. Add custom gates to circuit
Args:
quil_prog: the pyQuil quantum program to which the noise model will be added
Returns:
A quantum program with depolarizing noise on the static gates.
"""
prob = 0.8
num_qubits = 1
d = 4 ** num_qubits
d_sq = d ** 2
kraus_list = [(1 - prob) / d] * d
kraus_list[0] += prob
kraus_ops = pauli_kraus_map(kraus_list)
k_list = [(1 - prob) / d_sq] * d_sq
k_list[0] += prob
k_ops = pauli_kraus_map(k_list)
T_gate = np.array([[1, 0], [0, np.exp(1j * np.pi / 4)]])
CNOT_gate = np.block(
[[np.eye(2), np.zeros((2, 2))], [np.zeros((2, 2)), np.flip(np.eye(2), 1)]]
)
S_gate = np.array([[1, 0], [0, 1j]])
Z_gate = np.array([[1, 0], [0, -1]])
quil_prog.define_noisy_gate("T", [0], append_kraus_to_gate(kraus_ops, T_gate))
quil_prog.define_noisy_gate("CNOT", [1, 0], append_kraus_to_gate(k_ops, CNOT_gate))
quil_prog.define_noisy_gate("S", [0], append_kraus_to_gate(kraus_ops, S_gate))
quil_prog.define_noisy_gate("Z", [0], append_kraus_to_gate(kraus_ops, Z_gate))
return quil_prog
hamiltonian = sZ(0)
pauli_sum = PauliSum([hamiltonian])
for j, term in enumerate(pauli_sum.terms):
meas_basis_change = Program()
marked_qubits = []
for index, gate in term:
marked_qubits.append(index)
if gate == "X":
meas_basis_change.inst(RY(-np.pi / 2, index))
elif gate == "Y":
meas_basis_change.inst(RX(np.pi / 2, index))
program += meas_basis_change
readout_qubit = program.declare("ro", "BIT", max(marked_qubits) + 1)
samples = 3000
program.wrap_in_numshots_loop(samples)
def executor(
theta,
backend,
readout_qubit,
samples: int,
pauli_sum: Union[PauliSum, PauliTerm, np.ndarray],
pyquil_prog: Program,
) -> float:
"""
Compute the expectation value of pauli_sum over the distribution generated from
pyquil_prog.
"""
noisy = pyquil_prog.copy()
noisy += [
MEASURE(qubit, r) for qubit, r in zip(list(range(max(marked_qubits) + 1)), readout_qubit)
]
noisy = add_noise_to_circuit(noisy)
expectation = 0.0
pauli_sum = PauliSum([pauli_sum])
for j, term in enumerate(pauli_sum.terms):
qubits_to_measure = []
for index, gate in term:
qubits_to_measure.append(index)
meas_outcome = expectation_from_sampling(
theta, noisy, qubits_to_measure, backend, samples
)
expectation += term.coefficient * meas_outcome
return expectation.real
def expectation_from_sampling(
theta, executable: Program, marked_qubits: List[int], backend, samples: int
) -> float:
"""Calculate the expectation value of the Zi operator where i ranges over all
qubits given in marked_qubits.
"""
bitstring_samples = backend.run(
executable.write_memory(region_name="theta", value=theta)
).readout_data.get("ro")
bitstring_tuples = list(map(tuple, bitstring_samples))
freq = Counter(bitstring_tuples)
exp_val = 0
for bitstring, count in freq.items():
bitstring_int = int("".join([str(x) for x in bitstring[::-1]]), 2)
if parity_even_p(bitstring_int, marked_qubits):
exp_val += float(count) / samples
else:
exp_val -= float(count) / samples
return exp_val
def parity_even_p(state, marked_qubits):
mask = 0
for q in marked_qubits:
mask |= 1 << q
return bin(mask & state).count("1") % 2 == 0
thetas = np.linspace(0, 2 * np.pi, 51)
results = []
for theta in thetas:
results.append(executor(theta, backend, readout_qubit, samples, hamiltonian, program))
init_angle = [3.0]
res = optimize.minimize(
executor,
init_angle,
args=(backend, readout_qubit, samples, hamiltonian, program),
method="Nelder-Mead",
options={"xatol": 1.0e-3, "fatol": 1.0e-2},
)
print(res)
def mitigated_expectation(
thetas, backend, readout_qubit, samples, pauli_sum, executable: Program, factory
) -> float:
"""
This function is the ZNE-wrapped executor, which outputs the error-mitigated
expectation value.
Args:
thetas: the input parameter for the optimization
backend: the quantum computer that runs the quantum program
readout_qubit: declared memory for the readout
samples: number of times the experiment (or simulation) will be run
pauli_sum: the Hamiltonian expressed as
executable: the pyQuil quantum program
factory: factory object containing the type of inference and scaling parameters
Returns:
The error-mitigated expectation value as a float.
"""
mitigated_exp = zne.execute_with_zne(
executable,
lambda p: executor(thetas, backend, readout_qubit, samples, pauli_sum, p),
factory=factory,
scale_noise=fold_gates_at_random,
)
return mitigated_exp
fac = mitiq.zne.inference.LinearFactory(scale_factors=[1.0, 3.0])
results_zne = []
for theta in thetas:
results_zne.append(
mitigated_expectation(theta, backend, readout_qubit, samples, hamiltonian, program, fac)
)
_ = plt.figure()
_ = plt.plot(thetas, np.cos(thetas), "o-", label="Ideal landscape")
_ = plt.plot(thetas, results, "o-", label="Noisy landscape")
_ = plt.plot(thetas, results_zne, "o-", label="Mitigated landscape")
_ = plt.xlabel(r"$\theta$", fontsize=18)
_ = plt.ylabel(r"$\langle \Psi(\theta) | Z | \Psi(\theta) \rangle$", fontsize=18)
_ = plt.legend()
_ = plt.title("Mitigated Energy Landscape")
plt.show()
res_zne = optimize.minimize(
mitigated_expectation,
init_angle,
args=(backend, readout_qubit, samples, hamiltonian, program, fac),
method="Nelder-Mead",
options={"xatol": 1.0e-3, "fatol": 1.0e-2},
)
print(res_zne)
mitiq.about()
|
https://github.com/DRA-chaos/Solutions-to-the-Lab-Exercises---IBM-Qiskit-Summer-School-2021
|
DRA-chaos
|
# General Imports
import numpy as np
# Visualisation Imports
import matplotlib.pyplot as plt
# Scikit Imports
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler, MinMaxScaler
# Qiskit Imports
from qiskit import Aer, execute
from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap
from qiskit.circuit.library import TwoLocal, NLocal, RealAmplitudes, EfficientSU2
from qiskit.circuit.library import HGate, RXGate, RYGate, RZGate, CXGate, CRXGate, CRZGate
from qiskit_machine_learning.kernels import QuantumKernel
# Load digits dataset
digits = datasets.load_digits(n_class=2)
# Plot example '0' and '1'
fig, axs = plt.subplots(1, 2, figsize=(6,3))
axs[0].set_axis_off()
axs[0].imshow(digits.images[0], cmap=plt.cm.gray_r, interpolation='nearest')
axs[1].set_axis_off()
axs[1].imshow(digits.images[1], cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
# Split dataset
sample_train, sample_test, label_train, label_test = train_test_split(
digits.data, digits.target, test_size=0.2, random_state=22)
# Reduce dimensions
n_dim = 4
pca = PCA(n_components=n_dim).fit(sample_train)
sample_train = pca.transform(sample_train)
sample_test = pca.transform(sample_test)
# Normalise
std_scale = StandardScaler().fit(sample_train)
sample_train = std_scale.transform(sample_train)
sample_test = std_scale.transform(sample_test)
# Scale
samples = np.append(sample_train, sample_test, axis=0)
minmax_scale = MinMaxScaler((-1, 1)).fit(samples)
sample_train = minmax_scale.transform(sample_train)
sample_test = minmax_scale.transform(sample_test)
# Select
train_size = 100
sample_train = sample_train[:train_size]
label_train = label_train[:train_size]
test_size = 20
sample_test = sample_test[:test_size]
label_test = label_test[:test_size]
print(sample_train[0], label_train[0])
print(sample_test[0], label_test[0])
# 3 features, depth 2
map_z = ZFeatureMap(feature_dimension=3, reps=2)
map_z.draw('mpl')
# 3 features, depth 1
map_zz = ZZFeatureMap(feature_dimension=3, reps=1)
map_zz.draw('mpl')
# 3 features, depth 1, linear entanglement
map_zz = ZZFeatureMap(feature_dimension=3, reps=1, entanglement='linear')
map_zz.draw('mpl')
# 3 features, depth 1, circular entanglement
map_zz = ZZFeatureMap(feature_dimension=3, reps=1, entanglement='circular')
map_zz.draw('mpl')
# 3 features, depth 1
map_pauli = PauliFeatureMap(feature_dimension=3, reps=1, paulis = ['X', 'Y', 'ZZ'])
map_pauli.draw('mpl')
def custom_data_map_func(x):
coeff = x[0] if len(x) == 1 else reduce(lambda m, n: m * n, np.sin(np.pi - x))
return coeff
map_customdatamap = PauliFeatureMap(feature_dimension=3, reps=1, paulis=['Z','ZZ'],
data_map_func=custom_data_map_func)
#map_customdatamap.draw() # qiskit isn't able to draw the circuit with np.sin in the custom data map
twolocal = TwoLocal(num_qubits=3, reps=2, rotation_blocks=['ry','rz'],
entanglement_blocks='cx', entanglement='circular', insert_barriers=True)
twolocal.draw('mpl')
twolocaln = NLocal(num_qubits=3, reps=2,
rotation_blocks=[RYGate(Parameter('a')), RZGate(Parameter('a'))],
entanglement_blocks=CXGate(),
entanglement='circular', insert_barriers=True)
twolocaln.draw('mpl')
# rotation block:
rot = QuantumCircuit(2)
params = ParameterVector('r', 2)
rot.ry(params[0], 0)
rot.rz(params[1], 1)
# entanglement block:
ent = QuantumCircuit(4)
params = ParameterVector('e', 3)
ent.crx(params[0], 0, 1)
ent.crx(params[1], 1, 2)
ent.crx(params[2], 2, 3)
nlocal = NLocal(num_qubits=6, rotation_blocks=rot, entanglement_blocks=ent,
entanglement='linear', insert_barriers=True)
nlocal.draw('mpl')
qubits = 3
repeats = 2
x = ParameterVector('x', length=qubits)
var_custom = QuantumCircuit(qubits)
for _ in range(repeats):
for i in range(qubits):
var_custom.rx(x[i], i)
for i in range(qubits):
for j in range(i + 1, qubits):
var_custom.cx(i, j)
var_custom.p(x[i] * x[j], j)
var_custom.cx(i, j)
var_custom.barrier()
var_custom.draw('mpl')
print(sample_train[0])
encode_map = ZZFeatureMap(feature_dimension=4, reps=2, entanglement='linear', insert_barriers=True)
encode_circuit = encode_map.bind_parameters(sample_train[0])
encode_circuit.draw(output='mpl')
x = [-0.1,0.2]
# YOUR CODE HERE
encode_map_x =ZZFeatureMap(feature_dimension=2, reps=4)
ex1_circuit =encode_map_x.bind_parameters(x)
ex1_circuit.draw(output='mpl')
from qc_grader import grade_lab3_ex1
# Note that the grading function is expecting a quantum circuit
grade_lab3_ex1(ex1_circuit)
zz_map = ZZFeatureMap(feature_dimension=4, reps=2, entanglement='linear', insert_barriers=True)
zz_kernel = QuantumKernel(feature_map=zz_map, quantum_instance=Aer.get_backend('statevector_simulator'))
print(sample_train[0])
print(sample_train[1])
zz_circuit = zz_kernel.construct_circuit(sample_train[0], sample_train[1])
zz_circuit.decompose().decompose().draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
job = execute(zz_circuit, backend, shots=8192,
seed_simulator=1024, seed_transpiler=1024)
counts = job.result().get_counts(zz_circuit)
counts['0000']/sum(counts.values())
matrix_train = zz_kernel.evaluate(x_vec=sample_train)
matrix_test = zz_kernel.evaluate(x_vec=sample_test, y_vec=sample_train)
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].imshow(np.asmatrix(matrix_train),
interpolation='nearest', origin='upper', cmap='Blues')
axs[0].set_title("training kernel matrix")
axs[1].imshow(np.asmatrix(matrix_test),
interpolation='nearest', origin='upper', cmap='Reds')
axs[1].set_title("testing kernel matrix")
plt.show()
x = [-0.1,0.2]
y = [0.4,-0.6]
# YOUR CODE HERE
encode_map_x2 = ZZFeatureMap(feature_dimension=2, reps=4)
zz_kernel_x2 =QuantumKernel(feature_map=encode_map_x2,quantum_instance=Aer.get_backend('statevector_simulator'))
zz_circuit_x2 =zz_kernel_x2.construct_circuit(x,y)
backend =Aer.get_backend('qasm_simulator')
job = execute(zz_circuit_x2,backend,shots=8192,
seed_simulator=1024, seed_transpiler=1024)
counts_x2 = job.result().get_counts(zz_circuit_x2)
amplitude= counts_x2['00']/sum(counts_x2.values())
from qc_grader import grade_lab3_ex2
# Note that the grading function is expecting a floating point number
grade_lab3_ex2(amplitude)
zzpc_svc = SVC(kernel='precomputed')
zzpc_svc.fit(matrix_train, label_train)
zzpc_score = zzpc_svc.score(matrix_test, label_test)
print(f'Precomputed kernel classification test score: {zzpc_score}')
zzcb_svc = SVC(kernel=zz_kernel.evaluate)
zzcb_svc.fit(sample_train, label_train)
zzcb_score = zzcb_svc.score(sample_test, label_test)
print(f'Callable kernel classification test score: {zzcb_score}')
classical_kernels = ['linear', 'poly', 'rbf', 'sigmoid']
for kernel in classical_kernels:
classical_svc = SVC(kernel=kernel)
classical_svc.fit(sample_train, label_train)
classical_score = classical_svc.score(sample_test, label_test)
print('%s kernel classification test score: %0.2f' % (kernel, classical_score))
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
%load_ext autoreload
%autoreload 2
import nbimporter
from typing import Dict, Tuple, List
import numpy as np
from tqdm import tqdm
QUBITS_NUM = 4
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
simulator_backend = Aer.get_backend('qasm_simulator')
from scipy.optimize import minimize
from linear_entangelment_and_full_entangelment_ansatz_circuits import *
def get_ansatz_state(thetas, ansatz_entangelment, input_state):
if ansatz_entangelment=="full":
return get_full_entangelment_ansatz(QUBITS_NUM, thetas, input_state)
if ansatz_entangelment=="linear":
return get_linear_entangelment_ansatz(QUBITS_NUM, thetas, input_state)
def transfrom_hamiltonian_into_pauli_strings(hamiltonian) -> List:
pauli_operators = hamiltonian.to_pauli_op().settings['oplist']
pauli_coeffs = list(map(lambda pauli_operator: pauli_operator.coeff, pauli_operators))
pauli_strings = list(map(lambda pauli_operator: pauli_operator.primitive, pauli_operators))
return pauli_coeffs, pauli_strings
from qiskit.circuit.library.standard_gates import HGate, SGate
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
reducing_to_pauli_z_mapping = {
'I': 'I',
'Z': 'Z',
'X': 'Z',
'Y': 'Z'
}
def reduce_pauli_matrixes_into_sigma_z(pauli_string) -> str:
reduced_pauli_string = ""
for matrix_index in range(QUBITS_NUM):
pauli_matrix = str(pauli_string[matrix_index])
reduced_pauli_matrix = reducing_to_pauli_z_mapping[pauli_matrix]
reduced_pauli_string = reduced_pauli_matrix + reduced_pauli_string
return reduced_pauli_string
def add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string, quantum_circuit):
quantum_registers = QuantumRegister(QUBITS_NUM, name="qubit")
additional_circuit_layer = QuantumCircuit(quantum_registers)
for quantum_register_index, pauli_matrix in enumerate(pauli_string):
if pauli_matrix == "X":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
if pauli_string == "Y":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
additional_circuit_layer.append(SGate(), [quantum_registers[quantum_register_index]])
extended_quantum_circuit = quantum_circuit.compose(additional_circuit_layer)
return extended_quantum_circuit
def get_probability_distribution(counts: Dict) -> Dict:
proba_distribution = {state: (count / NUM_SHOTS) for state, count in counts.items()}
return proba_distribution
def calculate_probabilities_of_measurments_in_computational_basis(quantum_state_circuit) -> Dict:
quantum_state_circuit.measure_all()
transpiled_quantum_state_circuit = transpile(quantum_state_circuit, simulator_backend)
Qobj = assemble(transpiled_quantum_state_circuit)
result = simulator_backend.run(Qobj).result()
counts = result.get_counts(quantum_state_circuit)
return get_probability_distribution(counts)
def sort_probas_dict_by_qubits_string_keys(proba_distribution: Dict) -> Dict:
return dict(sorted(proba_distribution.items()))
def reset_power_of_minus_1(power_of_minus_1):
power_of_minus_1 = 0
return power_of_minus_1
def convert_pauli_string_into_str(pauli_string) -> str:
return str(pauli_string)
def calculate_expectation_value_of_pauli_string_by_measurments_probas(pauli_string, ansatz_circuit):
pauli_string_expectation_value = 0
power_of_minus_1 = 0
pauli_string_str = convert_pauli_string_into_str(pauli_string)
extended_ansatz_circuit = add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string_str, ansatz_circuit)
probas_distribution = calculate_probabilities_of_measurments_in_computational_basis(extended_ansatz_circuit)
reduced_pauli_string = reduce_pauli_matrixes_into_sigma_z(pauli_string)
sorted_probas_distribuition = sort_probas_dict_by_qubits_string_keys(probas_distribution)
for qubits_string, proba in sorted_probas_distribuition.items():
for string_index in range(QUBITS_NUM):
if(str(qubits_string[string_index])=="1" and str(reduced_pauli_string[string_index])=="Z"):
power_of_minus_1 += 1
pauli_string_expectation_value += pow(-1, power_of_minus_1)*proba
power_of_minus_1 = reset_power_of_minus_1(power_of_minus_1)
return pauli_string_expectation_value
def get_expectation_value(ansatz_circuit, pauli_coeffs, pauli_strings):
total_expection_value = 0
for pauli_coeff, pauli_string in tqdm(zip(pauli_coeffs, pauli_strings)):
total_expection_value += pauli_coeff*calculate_expectation_value_of_pauli_string_by_measurments_probas(
pauli_string, ansatz_circuit)
return total_expection_value
from qiskit import assemble, transpile
def cost_function(thetas, hamiltonian, ansatz_entangelment):
initial_eigenvector = np.identity(N)[0]
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
ansatz_state = get_ansatz_state(thetas, ansatz_entangelment, initial_eigenvector)
L = get_expectation_value(ansatz_state, pauli_coeffs, pauli_strings)
insert_approximated_energy_to_list_of_all_approximated_energies(L)
return L
def get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian, ansatz_entangelment):
initial_thetas = np.random.uniform(low=0, high=360, size=PARAMS_NUM)
optimizer_result = minimize(cost_function,
x0=initial_thetas,
args=(hamiltonian, ansatz_entangelment),
method="COBYLA",
options={"maxiter":NUM_ITERATIONS,
"disp": True})
optimal_thetas = optimizer_result.x
return optimal_thetas
def get_approximated_eigenvalue_of_hamiltonian(hamiltonian, ansatz_entangelment):
optimal_thetas = get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian, ansatz_entangelment)
print(optimal_thetas)
initial_eigenvector = np.identity(N)[0]
optimal_ansatz_state = get_ansatz_state(optimal_thetas, ansatz_entangelment, initial_eigenvector)
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
approximated_eigenvalue = get_expectation_value(optimal_ansatz_state, pauli_coeffs, pauli_strings)
return approximated_eigenvalue
from numpy import linalg as LA
def get_approximation_error(exact_eigenvalue, approximated_eigenvalue):
return abs(abs(exact_eigenvalue)-abs(approximated_eigenvalue))/abs(exact_eigenvalue)
def get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian):
eigen_values = LA.eigvals(hamiltonian.to_matrix())
print(sorted(eigen_values))
return min(sorted(eigen_values))
def compare_exact_and_approximated_eigenvalue(hamiltonian, approximated_eigenvalue):
exact_eigenvalue = get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian)
print("Exact Eigenvalue:")
print(exact_eigenvalue)
print("\nApproximated Eigenvalue:")
print(approximated_eigenvalue)
print("\nApproximation Error")
print(get_approximation_error(exact_eigenvalue, approximated_eigenvalue))
plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin=3)
approximated_energies = []
def insert_approximated_energy_to_list_of_all_approximated_energies(energy):
approximated_energies.append(energy)
import matplotlib.pyplot as plt
def plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin):
plt.title("convergence of optimization process to the exact eigenvalue")
plt.margins(0, margin)
plt.plot(approximated_energies[-NUM_ITERATIONS:])
plt.axhline(y = exact_eigenvalue, color = 'r', linestyle = '-')
plt.grid()
plt.xlabel("# of iterations")
plt.ylabel("Energy")
def plot_fidelity():
plt.plot(LiH_approximated_energies)
plt.xlabel("# of iterations")
plt.ylabel("Energy")
from qiskit.opflow import X, Z, I, H, Y
LiH_molecule_4_qubits = -7.49894690201071*(I^I^I^I) + \
-0.0029329964409502266*(X^X^Y^Y) + \
0.0029329964409502266*(X^Y^Y^X) + \
0.01291078027311749*(X^Z^X^I) + \
-0.0013743761078958677*(X^Z^X^Z) + \
0.011536413200774975*(X^I^X^I) + \
0.0029329964409502266*(Y^X^X^Y) + \
-0.0029329964409502266*(Y^Y^X^X) + \
0.01291078027311749*(Y^Z^Y^I) + \
-0.0013743761078958677*(Y^Z^Y^Z) + \
0.011536413200774975*(Y^I^Y^I) + \
0.16199475388004184*(Z^I^I^I) + \
0.011536413200774975*(Z^X^Z^X) + \
0.011536413200774975*(Z^Y^Z^Y) + \
0.12444770133137588*(Z^Z^I^I) + \
0.054130445793298836*(Z^I^Z^I) + \
0.05706344223424907*(Z^I^I^Z) + \
0.012910780273117487*(I^X^Z^X) + \
-0.0013743761078958677*(I^X^I^X) + \
0.012910780273117487*(I^Y^Z^Y) + \
-0.0013743761078958677*(I^Y^I^Y) + \
0.16199475388004186*(I^Z^I^I) + \
0.05706344223424907*(I^Z^Z^I) + \
0.054130445793298836*(I^Z^I^Z) + \
-0.013243698330265966*(I^I^Z^I) + \
0.08479609543670981*(I^I^Z^Z) + \
-0.013243698330265952*(I^I^I^Z)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
H2_molecule_Hamiltonian_4_qubits = -0.8105479805373279 * (I^I^I^I) \
+ 0.1721839326191554 * (I^I^I^Z) \
- 0.22575349222402372 * (I^I^Z^I) \
+ 0.17218393261915543 * (I^Z^I^I) \
- 0.2257534922240237 * (Z^I^I^I) \
+ 0.12091263261776627 * (I^I^Z^Z) \
+ 0.16892753870087907 * (I^Z^I^Z) \
+ 0.045232799946057826 * (Y^Y^Y^Y) \
+ 0.045232799946057826 * (X^X^Y^Y) \
+ 0.045232799946057826 * (Y^Y^X^X) \
+ 0.045232799946057826 * (X^X^X^X) \
+ 0.1661454325638241 * (Z^I^I^Z) \
+ 0.1661454325638241 * (I^Z^Z^I) \
+ 0.17464343068300453 * (Z^I^Z^I) \
+ 0.12091263261776627 * (Z^Z^I^I)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
transverse_ising_4_qubits = 0.0 * (I^I^I^I) \
+ 0.8398088405253477 * (X^I^I^I) \
+ 0.7989496312070936 * (I^X^I^I) \
+ 0.38189710487113193 * (Z^Z^I^I) \
+ 0.057753122422666725 * (I^I^X^I) \
+ 0.5633292636970458 * (Z^I^Z^I) \
+ 0.3152740621483513 * (I^Z^Z^I) \
+ 0.07209487981989715 * (I^I^I^X) \
+ 0.17892334004292654 * (Z^I^I^Z) \
+ 0.2273896497668042 * (I^Z^I^Z) \
+ 0.09762902934216211 * (I^I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 3
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit.opflow import X, Z, I
transverse_ising_3_qubits = 0.0 * (I^I^I) \
+ 0.012764169333459807 * (X^I^I) \
+ 0.7691573729160869 * (I^X^I) \
+ 0.398094746026449 * (Z^Z^I) \
+ 0.15250261906586637 * (I^I^X) \
+ 0.2094051920882264 * (Z^I^Z) \
+ 0.5131291860752999 * (I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_3_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_3_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_3_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_3_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 2
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
transverse_ising_2_qubits = 0.13755727363376802 * (I^X) \
+ 0.43305656297810435 * (X^I) \
+ 0.8538597608997253 * (Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_2_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_2_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_2_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_2_qubits, TI_approximated_eigenvalue)
from qiskit.opflow import X, Z, I
H2_molecule_Hamiltonian_2_qubits = -0.5053051899926562*(I^I) + \
-0.3277380754984016*(Z^I) + \
0.15567463610622564*(Z^Z) + \
-0.3277380754984016*(I^Z)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_2_qubits, "linear")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_2_qubits, H2_approximated_eigenvalue)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_2_qubits, "full")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_2_qubits, H2_approximated_eigenvalue)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# Testing Circuits
import warnings
warnings.simplefilter("ignore")
%run "mpl/circuit/test_circuit_matplotlib_drawer.py"
# Testing Graphs
%run "mpl/graph/test_graph_matplotlib_drawer.py"
%run -i "results.py"
RESULTS_CIRCUIT
RESULTS_GRAPH
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector(qc)
plot_state_qsphere(state)
|
https://github.com/taalexander/IEEE-Quantum-Week-2021
|
taalexander
|
import os
from typing import Any, List, Dict, Union
import numpy as np
import matplotlib.pyplot as plt
from qiskit import IBMQ, Aer, QuantumCircuit, QuantumRegister, ClassicalRegister, transpile, execute
from qiskit.tools.visualization import plot_histogram
from qiskit.result import marginal_counts
import qiskit.tools.jupyter
from run_openqasm3 import run_openqasm3
%matplotlib inline
import warnings
warnings.filterwarnings("ignore")
pi = np.pi
backend_sim = Aer.get_backend('aer_simulator')
hub = 'ibm-q-community'
group = 'ieee-session'
project = 'event-2021'
backend_name = 'ibm_perth'
IBMQ.load_account()
provider = IBMQ.get_provider(hub=hub, group=group, project=project)
backend_real = provider.get_backend(backend_name)
basis_gates = backend_real.configuration().basis_gates
import qiskit.tools.jupyter
backend_real
from qiskit import qasm3
def dump_qasm3(circuit, backend=backend_real):
return qasm3.Exporter(includes=[], basis_gates=basis_gates+["reset"], disable_constants=True).dumps(circuit)
q = QuantumRegister(1,'q')
c = ClassicalRegister(1,'c')
qc = QuantumCircuit(q, c)
qc.h(0)
qc.measure(0,0)
qc.x(0).c_if(c, 0)
qc.draw(output='mpl')
q = QuantumRegister(3,'q')
c = ClassicalRegister(3,'c')
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.h(q[1])
qc.h(q[2])
qc.barrier()
qc.measure(q,c)
qc.draw('mpl')
print(bin(3))
print(bin(7))
q = QuantumRegister(3,'q')
c = ClassicalRegister(3,'c')
qc = QuantumCircuit(q, c)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.measure(q,c)
qc.x(2).c_if(c, 3) # for the 011 case
qc.x(2).c_if(c, 7) # for the 111 case
qc.draw(output='mpl')
qubits = [1, 2]
def reset_conditional(qc, q, reset_reg):
"""Implement the conditional reset on the input circuit, qubit and classical register using c_if."""
qc.barrier(q)
# Add reset here
qc.barrier(q)
qr = QuantumRegister(2)
reset_reg0 = ClassicalRegister(1, "reset_reg0")
reset_reg1 = ClassicalRegister(1, "reset_reg1")
cr0 = ClassicalRegister(1, "reset_result0")
cr1 = ClassicalRegister(1, "reset_result1")
qc_reset = QuantumCircuit(qr, reset_reg0, reset_reg1, cr0, cr1)
reset_conditional(qc_reset, qr[0], reset_reg0)
reset_conditional(qc_reset, qr[1], reset_reg1)
qc_reset.measure(0, cr0)
qc_reset.measure(0, cr1)
qc_reset = transpile(qc_reset, backend_real, initial_layout=qubits)
qc_reset.draw(output="mpl")
# Hint use qiskit.result.marginal_counts to remove the first three classical register results
# from your counts
def pad_counts(counts):
new_counts = {}
for k, v in counts.items():
if len(k) < 4:
for _ in range(4-len(k)):
k = "0"+k
new_counts[k] = v
return new_counts
def remove_reset_results(counts):
return marginal_counts(pad_counts(counts), indices=[0, 1])
reset_job = run_openqasm3(qc_reset, backend_real, verbose=False)
print(f"Reset job id: {reset_job.job_id()}")
reset_result = reset_job.result()
reset_counts = remove_reset_results(reset_result.get_counts(0))
print(f"The results of your reset circuit are {reset_counts}")
assert reset_counts["00"] > 700
def init(qc, q):
"""Implement a qubit initialization using three rounds of qubit reset."""
qc.barrier(q)
# Add init here
qc.barrier(q)
qr = QuantumRegister(2)
cr0 = ClassicalRegister(1, "reset_result0")
cr1 = ClassicalRegister(1, "reset_result1")
qc_init = QuantumCircuit(qr, cr0, cr1)
init(qc_init, qr[0])
init(qc_init, qr[1])
qc_init.measure(0, cr0)
qc_init.measure(0, cr1)
qc_init = transpile(qc_init, backend_real, initial_layout=qubits)
qc_init.draw(output="mpl")
init_job = run_openqasm3(qc_init, backend_real, verbose=False)
print(f"Qubit init job id: {init_job.job_id()}")
init_result = init_job.result()
init_counts = init_result.get_counts()
print(f"The results of your reset circuit are {init_counts}")
assert init_counts["0 0"] > 900
# Compare your counts here.
q = QuantumRegister(nq,'q')
c0 = ClassicalRegister(1,'c0')
c1 = ClassicalRegister(1, 'c1')
qc_S = QuantumCircuit(q, c0, c1)
def init_ipe_circuit(qc):
"""Initialize the qubits in your IPE circuit."""
qc.barrier(0, 1)
# Place your code here
qc.barrier(0, 1)
init_ipe_circuit(qc_S)
qc_S.draw(output="mpl")
def initialize_eigenstate(qc):
"""Initialize the eigenstate and prepare our ancilla qubit"""
pass
initialize_eigenstate(qc_S)
qc_S.draw('mpl')
cu_circ = QuantumCircuit(2)
cu_circ.cp(theta,0,1)
cu_circ.draw('mpl')
theta = 1 * np.pi / 2
for _ in range(2**(m-1)):
qc_S.cp(theta,0,1)
qc_S.draw('mpl')
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
pass
x_measurement(qc_S, q[0], c0)
qc_S.draw('mpl')
def reset_auxiliary(qc):
"""Reset your auxiliary qubit and then reinitialize it to |+>."""
pass
reset_auxiliary(qc_S)
qc_S.draw('mpl')
qc_S.p(-np.pi/2,0).c_if(c0, 1)
qc_S.draw('mpl')
nq = 2
m = 2
## 2^t c-U operations (with t=m-2)
for _ in range(2**(m-2)):
qc_S.cp(theta,0,1)
x_measurement(qc_S, q[0], c1)
qc_S.draw('mpl')
count = execute(qc_S, backend_sim).result().get_counts()
count
count0 = remove_reset_results(execute(qc_S, backend_sim).result().get_counts())
key_new = [str(int(key,2)/2**m) for key in list(count0.keys())]
count1 = dict(zip(key_new, count0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(count0, ax=ax[0])
plot_histogram(count1, ax=ax[1])
plt.tight_layout()
qc_S_backend = transpile(qc_S, backend_real, initial_layout=qubits, optimization_level=3)
qc_S_backend.draw(output="mpl")
real_ipe_job = run_openqasm3(qc_S_backend, backend_real, verbose=False)
real_counts0 = remove_reset_results(real_ipe_job.result().get_counts())
real_key_new = [str(int(key,2)/2**m) for key in list(real_counts0.keys())]
real_counts1 = dict(zip(real_key_new, real_counts0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(real_counts0, ax=ax[0])
plot_histogram(real_counts1, ax=ax[1])
plt.tight_layout()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/InvictusWingsSRL/QiskitTutorials
|
InvictusWingsSRL
|
#Libraries needed to implement and simulate quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile, qasm2, qasm3
from qiskit_aer import Aer
from qiskit.primitives import BackendSampler
#Custem functions to simplify answers
import Our_Qiskit_Functions as oq #a part of the library presented in arXiv:1903.04359v1.
import numpy as np
import math as m
#Initialize backends simulators to visualize circuits
S_simulator = Aer.backends(name='statevector_simulator')[0]
M_simulator = Aer.backends(name='qasm_simulator')[0]
q = QuantumRegister(1, name='q')
qc = QuantumCircuit(1, name='qc')
qc.h(q[0])
oq.Wavefunction(qc);
q = QuantumRegister(1, name='q')
qc = QuantumCircuit(1, name='qc')
qc.x(q[0])
qc.h(q[0])
oq.Wavefunction(qc);
qc.x(q[0])
oq.Wavefunction(qc);
q = QuantumRegister(3, name='q')
anc = QuantumRegister(1, name='anc')
DJ_qc = QuantumCircuit(q, anc, name='qc')
DJ_qc.h(q[0])
DJ_qc.h(q[1])
DJ_qc.h(q[2])
DJ_qc.x(anc[0])
print('___________Before g___________________')
oq.Wavefunction(DJ_qc, systems=[3,1], show_systems=[True,False])
DJ_qc.h(anc[0])
f = oq.Blackbox_g_DJ(3, DJ_qc, q, anc)
if f[0] == 'constant':
A = 1
else:
A = 2
DJ_qc.h(anc[0])
print('\n______________After g___________')
oq.Wavefunction(DJ_qc, systems=[3,A], show_systems=[True,False])
print('\nf type: ', f[0])
if len(f) > 1:
print('States mapped to 1: ', f[1:])
q = QuantumRegister(3, name='q')
anc = QuantumRegister(1, name='anc')
c = ClassicalRegister(3, name='c')
DJ_qc = QuantumCircuit(q, anc, c, name='qc')
DJ_qc.h(q[0])
DJ_qc.h(q[1])
DJ_qc.h(q[2])
DJ_qc.x(anc[0])
print('___________Before g___________________')
oq.Wavefunction(DJ_qc, systems=[3,1], show_systems=[True,False])
DJ_qc.h(anc[0])
f = oq.Blackbox_g_DJ(3, DJ_qc, q, anc)
if f[0] == 'constant':
A = 1
else:
A = 2
DJ_qc.h(anc[0])
print('\n______________After g___________')
oq.Wavefunction(DJ_qc, systems=[3,A], show_systems=[True,False])
print('\nf type: ', f[0])
if len(f) > 1:
print('States mapped to 1: ', f[1:])
DJ_qc.h(q[0])
DJ_qc.h(q[1])
DJ_qc.h(q[2])
print('\n______________After H^3___________')
oq.Wavefunction(DJ_qc, systems=[3,A], show_systems=[True,False])
DJ_qc.measure(q, c)
print('\n______________Measured State____________')
oq.Measurement(DJ_qc, shots=1)
q = QuantumRegister(3, name='q')
anc = QuantumRegister(1, name='anc')
con1_qc = QuantumCircuit(q, anc, name='qc1')
con2_qc = QuantumCircuit(q, anc, name='qc2')
for i in range(2):
con1_qc.h(q[i])
con2_qc.h(q[i])
con1_qc.h(anc[0])
con1_qc.x(anc[0])
con2_qc.x(anc[0])
con2_qc.h(anc[0])
print('___________Before g___________________')
oq.Wavefunction(con1_qc)
con2_qc.x(q[0])
con2_qc.x(q[1])
con2_qc.x(anc[0])
print('\n______________After g, f type: balanced___________')
oq.Wavefunction(con1_qc)
print(' ');
oq.Wavefunction(con2_qc)
for i in range(2):
con1_qc.h(q[i])
con2_qc.h(q[i])
con1_qc.h(anc[0])
con2_qc.h(anc[0])
print('\n______________After H^3___________')
oq.Wavefunction(con1_qc)
print(' ');
oq.Wavefunction(con2_qc);
q = QuantumRegister(3, name='q')
anc = QuantumRegister(1, name='anc')
DJ_qc = QuantumCircuit(q, anc, name='qc')
DJ_qc.h(q[0])
DJ_qc.h(q[1])
DJ_qc.h(q[2])
DJ_qc.x(anc[0])
print('___________Before g___________________')
oq.Wavefunction(DJ_qc, systems=[3,1], show_systems=[True,False])
DJ_qc.h(anc[0])
f = oq.Blackbox_g_DJ(3, DJ_qc, q, anc)
if f[0] == 'constant':
A = 1
else:
A = 2
DJ_qc.h(anc[0])
print('\n______________After g___________')
oq.Wavefunction(DJ_qc, systems=[3,A], show_systems=[True,False])
DJ_qc.h(q[0])
DJ_qc.h(q[1])
DJ_qc.h(q[2])
print('\n______________After H^3___________')
oq.Wavefunction(DJ_qc, systems=[3,A], show_systems=[True,False])
print('\nf type: ', f[0])
if len(f) > 1:
print('States mapped to 1: ', f[1:])
print('Note that the state |000> is not in our final system!')
# example for |010>
q = QuantumRegister(3, name='q')
trgt = QuantumRegister(1, name='trgt')
anc = QuantumRegister(1, name='anc')
qc_010 = QuantumCircuit(q, trgt, anc, name='qc')
qc_010.h(q[1])
qc_010.x(trgt[0])
qc_010.h(trgt[0])
print('___________Initial state___________________')
oq.Wavefunction(qc_010, systems=[3,1,1], show_systems=[True,True,False])
qc_010.x(q[0])
qc_010.x(q[2])
oq.n_NOT(qc_010, q, trgt[0], anc)
qc_010.x(q[0])
qc_010.x(q[2])
print('\n______________After n_NOT____________')
oq.Wavefunction(qc_010, systems=[3,1,1], show_systems=[True,True,False]);
Q = 5
q = QuantumRegister(Q, name='q')
anc = QuantumRegister(1, name='anc')
c = ClassicalRegister(Q, name='c')
DJ_qc = QuantumCircuit(q, anc, c, name='qc')
DJ_qc.x(anc[0])
f = oq.Deutsch_Josza(Q, DJ_qc, q, anc)
DJ_qc.measure(q, c)
print('_______Measured state_______________')
M = oq.Measurement(DJ_qc, shots = 1, return_M=True)
M = list(list(M.keys())[0])
con = True
for i in range(len(M)):
if (list(M)[i] == '1'):
con = False
print(' ')
if con:
print('Conclusion: f is a constant function')
else:
print('Conclusion: f is a balanced function')
print(' ')
print('sneak peak: f is ', f[0])
q = QuantumRegister(3, name='q')
anc = QuantumRegister(1, name='anc')
BV_qc = QuantumCircuit(q, anc, name='qc')
for i in range(3):
BV_qc.h(q[i])
print('___________Before g___________________')
oq.Wavefunction(BV_qc, systems=[3,1], show_systems=[True,False])
BV_qc.x(anc[0])
BV_qc.h(anc[0])
a = oq.Blackbox_g_BV(3, BV_qc, q, anc)
BV_qc.h(anc[0])
print('\n______________After g___________')
oq.Wavefunction(BV_qc, systems=[3,2], show_systems=[True,False])
for i in range(3):
BV_qc.h(q[i])
print('\n______________After H^3___________')
oq.Wavefunction(BV_qc, systems=[3,2], show_systems=[True,False])
print(' ')
print('Hidden string a = ', a)
q = QuantumRegister(3, name='q')
H3_qc = QuantumCircuit(q, name='qc')
state=[1,0,1]
print('Quantum State: ',state)
print(' ');
for i in range(len(state)):
if state[i] == 1:
H3_qc.x(q[i])
H3_qc.h(q[i])
print('_____________Corresponding H^3 state_______________')
oq.Wavefunction(H3_qc);
Q = 4
q = QuantumRegister(Q, name='q')
anc = QuantumRegister(1, name='anc')
c = ClassicalRegister(Q, name='c')
BV_qc = QuantumCircuit(q, anc, c, name='qc')
BV_qc.x(anc[0])
a = oq.Bernstein_Vazirani(Q, BV_qc, q, anc)
BV_qc.measure(q, c)
print('_______Measured state_______________')
oq.Measurement(BV_qc, shots = 1)
print('\nsneak peak: a = ', a)
|
https://github.com/abbarreto/qiskit2
|
abbarreto
|
import numpy as np
import matplotlib
from matplotlib import pyplot as plt
import math
th = np.arange(0, 2*math.pi, 0.1)
prE3 = 2*(1-(math.sqrt(2)*(np.sin(th/2)**2))/(1+math.sqrt(2)))
matplotlib.rcParams.update({'font.size':10})
plt.figure(figsize = (5,3), dpi = 100)
plt.plot(th, prE3)
plt.xlabel(r'$\theta$')
plt.ylabel(r'$Pr(E_{3})$')
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
import matplotlib.pyplot as plt
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
n=2
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
step(circuit, qpos, qcoin)
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Draw the circuit
circuit.draw(output='mpl')
# Plot a histogram
plot_histogram(counts)
counts
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import QuantumCircuit, transpile
from qiskit.opflow import PauliSumOp
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.transpiler import Layout, CouplingMap, PassManager
from qiskit.transpiler.passes import FullAncillaAllocation
from qiskit.transpiler.passes import EnlargeWithAncilla
from qiskit.transpiler.passes import ApplyLayout
from qiskit.transpiler.passes import SetLayout
from qiskit.transpiler.passes.routing.commuting_2q_gate_routing import (
SwapStrategy,
FindCommutingPauliEvolutions,
Commuting2qGateRouter,
)
# Define the circuit on logical qubits
op = PauliSumOp.from_list([("IZZI", 1), ("ZIIZ", 2), ("ZIZI", 3)])
circ = QuantumCircuit(4)
circ.append(PauliEvolutionGate(op, 1), range(4))
circ.draw("mpl")
PassManager([FindCommutingPauliEvolutions()]).run(circ).draw("mpl")
swap_layers = (
((1, 3), ), # Layer 1: swap qubits 1 & 3
((0, 1), (3, 4)), # Layer 2: simultaneouosly swap qubits 0 & 1 and 3 & 4
((1, 3), ) # Layer 3: swap qubits 1 & 3
)
cmap = CouplingMap(couplinglist=[(0, 1), (1, 2), (1, 3), (3, 4)])
swap_strat = SwapStrategy(cmap, swap_layers)
print(f"Missing connectivity: {swap_strat.missing_couplings}")
backend_cmap = CouplingMap(couplinglist=[(0, 1), (1, 2), (1, 3), (3, 4)])
def make_passmanager(cmap, swap_strat, initial_layout):
"""Creates the passes needed."""
return PassManager(
[
FindCommutingPauliEvolutions(),
Commuting2qGateRouter(swap_strat),
SetLayout(initial_layout),
FullAncillaAllocation(backend_cmap),
EnlargeWithAncilla(),
ApplyLayout(),
]
)
# Define the swap strategy on qubits before the initial_layout is applied.
swap_cmap = CouplingMap(couplinglist=[(0, 1), (1, 2), (2, 3)])
swap_strat = SwapStrategy(swap_cmap, swap_layers=[[(1, 2)], [(0, 1), (2, 3)]])
# Chose qubits 0, 1, 3, and 4 from the backend coupling map shown above.
backend_cmap = CouplingMap(couplinglist=[(0, 1), (1, 2), (1, 3), (3, 4)])
initial_layout = Layout.from_intlist([0, 1, 3, 4], *circ.qregs)
pm = make_passmanager(backend_cmap, swap_strat, initial_layout)
# Insert swap gates, map to initial_layout and finally enlarge with ancilla.
pm.run(circ).draw("mpl")
pm.run(circ).decompose().decompose().draw("mpl")
op = PauliSumOp.from_list(
[
("IIIZZ", 1), ("IIZIZ", 1), ("IZIIZ", 1), ("ZIIIZ", 2),
("IIZZI", 3), ("IZIZI", 3), ("ZIIZI", 4),
("IZZII", 1), ("ZIZII", 2),
("ZZIII", 2),
]
)
circ = QuantumCircuit(5)
circ.append(PauliEvolutionGate(op, 1), range(5))
circ.draw("mpl")
swap_cmap = CouplingMap(couplinglist=[(0, 1), (1, 2), (1, 3), (3, 4)])
swap_strat = SwapStrategy(swap_cmap, swap_layers=[[(1, 3)], [(0, 1), (3, 4)], [(1, 3)]])
swap_strat.missing_couplings
initial_layout = Layout.from_intlist([0, 1, 2, 3, 4], *circ.qregs)
pm = make_passmanager(backend_cmap, swap_strat, initial_layout)
swapped_circ = pm.run(circ)
swapped_circ.draw("mpl")
tswapped = transpile(swapped_circ, basis_gates=["rz", "cx"], optimization_level=2)
n_cx = tswapped.count_ops()["cx"]
n_xsx = tswapped.count_ops().get("sx", 0) + tswapped.count_ops().get("x", 0)
print(f"Number of CNOTs: {n_cx}\nNumber of X and SX: {n_xsx}.")
print(f"Depth {tswapped.depth()}.")
tswapped.draw("mpl", fold=False)
opt3_circ = transpile(circ, basis_gates=["rz", "cx", "sx", "x"], optimization_level=3, coupling_map=backend_cmap)
n_cx = opt3_circ.count_ops()["cx"]
n_xsx = opt3_circ.count_ops().get("sx", 0) + tswapped.count_ops().get("x", 0)
print(f"Number of CNOTs: {n_cx}\nNumber of X and SX: {n_xsx}.")
print(f"Depth {opt3_circ.depth()}.")
opt3_circ.draw("mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.timeline import draw
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc)
|
https://github.com/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
qc.h(idx)
qc.cx(idx, idx+5)
qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
"""Prepare a quantum state from the state where all qubits are 0."""
from typing import Union, Optional
import math
import numpy as np
from qiskit.exceptions import QiskitError
from qiskit.circuit import QuantumCircuit, QuantumRegister, Qubit
from qiskit.circuit.gate import Gate
from qiskit.circuit.library.standard_gates.x import CXGate, XGate
from qiskit.circuit.library.standard_gates.h import HGate
from qiskit.circuit.library.standard_gates.s import SGate, SdgGate
from qiskit.circuit.library.standard_gates.ry import RYGate
from qiskit.circuit.library.standard_gates.rz import RZGate
from qiskit.circuit.exceptions import CircuitError
from qiskit.quantum_info import Statevector
_EPS = 1e-10 # global variable used to chop very small numbers to zero
class StatePreparation(Gate):
"""Complex amplitude state preparation.
Class that implements the (complex amplitude) state preparation of some
flexible collection of qubit registers.
"""
def __init__(
self,
params: Union[str, list, int, Statevector],
num_qubits: Optional[int] = None,
inverse: bool = False,
label: Optional[str] = None,
normalize: bool = False,
):
r"""
Args:
params:
* Statevector: Statevector to initialize to.
* list: vector of complex amplitudes to initialize to.
* string: labels of basis states of the Pauli eigenstates Z, X, Y. See
:meth:`.Statevector.from_label`.
Notice the order of the labels is reversed with respect to the qubit index to
be applied to. Example label '01' initializes the qubit zero to :math:`|1\rangle`
and the qubit one to :math:`|0\rangle`.
* int: an integer that is used as a bitmap indicating which qubits to initialize
to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2
to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`.
num_qubits: This parameter is only used if params is an int. Indicates the total
number of qubits in the `initialize` call. Example: `initialize` covers 5 qubits
and params is 3. This allows qubits 0 and 1 to be initialized to :math:`|1\rangle`
and the remaining 3 qubits to be initialized to :math:`|0\rangle`.
inverse: if True, the inverse state is constructed.
label: An optional label for the gate
normalize (bool): Whether to normalize an input array to a unit vector.
Raises:
QiskitError: ``num_qubits`` parameter used when ``params`` is not an integer
When a Statevector argument is passed the state is prepared using a recursive
initialization algorithm, including optimizations, from [1], as well
as some additional optimizations including removing zero rotations and double cnots.
**References:**
[1] Shende, Bullock, Markov. Synthesis of Quantum Logic Circuits (2004)
[`https://arxiv.org/abs/quant-ph/0406176v5`]
"""
self._params_arg = params
self._inverse = inverse
self._name = "state_preparation_dg" if self._inverse else "state_preparation"
if label is None:
self._label = "State Preparation Dg" if self._inverse else "State Preparation"
else:
self._label = f"{label} Dg" if self._inverse else label
if isinstance(params, Statevector):
params = params.data
if not isinstance(params, int) and num_qubits is not None:
raise QiskitError(
"The num_qubits parameter to StatePreparation should only be"
" used when params is an integer"
)
self._from_label = isinstance(params, str)
self._from_int = isinstance(params, int)
# if initialized from a vector, check that the parameters are normalized
if not self._from_label and not self._from_int:
norm = np.linalg.norm(params)
if normalize:
params = np.array(params, dtype=np.complex128) / norm
elif not math.isclose(norm, 1.0, abs_tol=_EPS):
raise QiskitError(f"Sum of amplitudes-squared is not 1, but {norm}.")
num_qubits = self._get_num_qubits(num_qubits, params)
params = [params] if isinstance(params, int) else params
super().__init__(self._name, num_qubits, params, label=self._label)
def _define(self):
if self._from_label:
self.definition = self._define_from_label()
elif self._from_int:
self.definition = self._define_from_int()
else:
self.definition = self._define_synthesis()
def _define_from_label(self):
q = QuantumRegister(self.num_qubits, "q")
initialize_circuit = QuantumCircuit(q, name="init_def")
for qubit, param in enumerate(reversed(self.params)):
if param == "1":
initialize_circuit.append(XGate(), [q[qubit]])
elif param == "+":
initialize_circuit.append(HGate(), [q[qubit]])
elif param == "-":
initialize_circuit.append(XGate(), [q[qubit]])
initialize_circuit.append(HGate(), [q[qubit]])
elif param == "r": # |+i>
initialize_circuit.append(HGate(), [q[qubit]])
initialize_circuit.append(SGate(), [q[qubit]])
elif param == "l": # |-i>
initialize_circuit.append(HGate(), [q[qubit]])
initialize_circuit.append(SdgGate(), [q[qubit]])
if self._inverse:
initialize_circuit = initialize_circuit.inverse()
return initialize_circuit
def _define_from_int(self):
q = QuantumRegister(self.num_qubits, "q")
initialize_circuit = QuantumCircuit(q, name="init_def")
# Convert to int since QuantumCircuit converted to complex
# and make a bit string and reverse it
intstr = f"{int(np.real(self.params[0])):0{self.num_qubits}b}"[::-1]
# Raise if number of bits is greater than num_qubits
if len(intstr) > self.num_qubits:
raise QiskitError(
"StatePreparation integer has %s bits, but this exceeds the"
" number of qubits in the circuit, %s." % (len(intstr), self.num_qubits)
)
for qubit, bit in enumerate(intstr):
if bit == "1":
initialize_circuit.append(XGate(), [q[qubit]])
# note: X is it's own inverse, so even if self._inverse is True,
# we don't need to invert anything
return initialize_circuit
def _define_synthesis(self):
"""Calculate a subcircuit that implements this initialization
Implements a recursive initialization algorithm, including optimizations,
from "Synthesis of Quantum Logic Circuits" Shende, Bullock, Markov
https://arxiv.org/abs/quant-ph/0406176v5
Additionally implements some extra optimizations: remove zero rotations and
double cnots.
"""
# call to generate the circuit that takes the desired vector to zero
disentangling_circuit = self._gates_to_uncompute()
# invert the circuit to create the desired vector from zero (assuming
# the qubits are in the zero state)
if self._inverse is False:
initialize_instr = disentangling_circuit.to_instruction().inverse()
else:
initialize_instr = disentangling_circuit.to_instruction()
q = QuantumRegister(self.num_qubits, "q")
initialize_circuit = QuantumCircuit(q, name="init_def")
initialize_circuit.append(initialize_instr, q[:])
return initialize_circuit
def _get_num_qubits(self, num_qubits, params):
"""Get number of qubits needed for state preparation"""
if isinstance(params, str):
num_qubits = len(params)
elif isinstance(params, int):
if num_qubits is None:
num_qubits = int(math.log2(params)) + 1
else:
num_qubits = math.log2(len(params))
# Check if param is a power of 2
if num_qubits == 0 or not num_qubits.is_integer():
raise QiskitError("Desired statevector length not a positive power of 2.")
num_qubits = int(num_qubits)
return num_qubits
def inverse(self):
"""Return inverted StatePreparation"""
label = (
None if self._label in ("State Preparation", "State Preparation Dg") else self._label
)
return StatePreparation(self._params_arg, inverse=not self._inverse, label=label)
def broadcast_arguments(self, qargs, cargs):
flat_qargs = [qarg for sublist in qargs for qarg in sublist]
if self.num_qubits != len(flat_qargs):
raise QiskitError(
"StatePreparation parameter vector has %d elements, therefore expects %s "
"qubits. However, %s were provided."
% (2**self.num_qubits, self.num_qubits, len(flat_qargs))
)
yield flat_qargs, []
def validate_parameter(self, parameter):
"""StatePreparation instruction parameter can be str, int, float, and complex."""
# StatePreparation instruction parameter can be str
if isinstance(parameter, str):
if parameter in ["0", "1", "+", "-", "l", "r"]:
return parameter
raise CircuitError(
"invalid param label {} for instruction {}. Label should be "
"0, 1, +, -, l, or r ".format(type(parameter), self.name)
)
# StatePreparation instruction parameter can be int, float, and complex.
if isinstance(parameter, (int, float, complex)):
return complex(parameter)
elif isinstance(parameter, np.number):
return complex(parameter.item())
else:
raise CircuitError(f"invalid param type {type(parameter)} for instruction {self.name}")
def _return_repeat(self, exponent: float) -> "Gate":
return Gate(name=f"{self.name}*{exponent}", num_qubits=self.num_qubits, params=[])
def _gates_to_uncompute(self):
"""Call to create a circuit with gates that take the desired vector to zero.
Returns:
QuantumCircuit: circuit to take self.params vector to :math:`|{00\\ldots0}\\rangle`
"""
q = QuantumRegister(self.num_qubits)
circuit = QuantumCircuit(q, name="disentangler")
# kick start the peeling loop, and disentangle one-by-one from LSB to MSB
remaining_param = self.params
for i in range(self.num_qubits):
# work out which rotations must be done to disentangle the LSB
# qubit (we peel away one qubit at a time)
(remaining_param, thetas, phis) = StatePreparation._rotations_to_disentangle(
remaining_param
)
# perform the required rotations to decouple the LSB qubit (so that
# it can be "factored" out, leaving a shorter amplitude vector to peel away)
add_last_cnot = True
if np.linalg.norm(phis) != 0 and np.linalg.norm(thetas) != 0:
add_last_cnot = False
if np.linalg.norm(phis) != 0:
rz_mult = self._multiplex(RZGate, phis, last_cnot=add_last_cnot)
circuit.append(rz_mult.to_instruction(), q[i : self.num_qubits])
if np.linalg.norm(thetas) != 0:
ry_mult = self._multiplex(RYGate, thetas, last_cnot=add_last_cnot)
circuit.append(ry_mult.to_instruction().reverse_ops(), q[i : self.num_qubits])
circuit.global_phase -= np.angle(sum(remaining_param))
return circuit
@staticmethod
def _rotations_to_disentangle(local_param):
"""
Static internal method to work out Ry and Rz rotation angles used
to disentangle the LSB qubit.
These rotations make up the block diagonal matrix U (i.e. multiplexor)
that disentangles the LSB.
[[Ry(theta_1).Rz(phi_1) 0 . . 0],
[0 Ry(theta_2).Rz(phi_2) . 0],
.
.
0 0 Ry(theta_2^n).Rz(phi_2^n)]]
"""
remaining_vector = []
thetas = []
phis = []
param_len = len(local_param)
for i in range(param_len // 2):
# Ry and Rz rotations to move bloch vector from 0 to "imaginary"
# qubit
# (imagine a qubit state signified by the amplitudes at index 2*i
# and 2*(i+1), corresponding to the select qubits of the
# multiplexor being in state |i>)
(remains, add_theta, add_phi) = StatePreparation._bloch_angles(
local_param[2 * i : 2 * (i + 1)]
)
remaining_vector.append(remains)
# rotations for all imaginary qubits of the full vector
# to move from where it is to zero, hence the negative sign
thetas.append(-add_theta)
phis.append(-add_phi)
return remaining_vector, thetas, phis
@staticmethod
def _bloch_angles(pair_of_complex):
"""
Static internal method to work out rotation to create the passed-in
qubit from the zero vector.
"""
[a_complex, b_complex] = pair_of_complex
# Force a and b to be complex, as otherwise numpy.angle might fail.
a_complex = complex(a_complex)
b_complex = complex(b_complex)
mag_a = abs(a_complex)
final_r = np.sqrt(mag_a**2 + np.absolute(b_complex) ** 2)
if final_r < _EPS:
theta = 0
phi = 0
final_r = 0
final_t = 0
else:
theta = 2 * np.arccos(mag_a / final_r)
a_arg = np.angle(a_complex)
b_arg = np.angle(b_complex)
final_t = a_arg + b_arg
phi = b_arg - a_arg
return final_r * np.exp(1.0j * final_t / 2), theta, phi
def _multiplex(self, target_gate, list_of_angles, last_cnot=True):
"""
Return a recursive implementation of a multiplexor circuit,
where each instruction itself has a decomposition based on
smaller multiplexors.
The LSB is the multiplexor "data" and the other bits are multiplexor "select".
Args:
target_gate (Gate): Ry or Rz gate to apply to target qubit, multiplexed
over all other "select" qubits
list_of_angles (list[float]): list of rotation angles to apply Ry and Rz
last_cnot (bool): add the last cnot if last_cnot = True
Returns:
DAGCircuit: the circuit implementing the multiplexor's action
"""
list_len = len(list_of_angles)
local_num_qubits = int(math.log2(list_len)) + 1
q = QuantumRegister(local_num_qubits)
circuit = QuantumCircuit(q, name="multiplex" + str(local_num_qubits))
lsb = q[0]
msb = q[local_num_qubits - 1]
# case of no multiplexing: base case for recursion
if local_num_qubits == 1:
circuit.append(target_gate(list_of_angles[0]), [q[0]])
return circuit
# calc angle weights, assuming recursion (that is the lower-level
# requested angles have been correctly implemented by recursion
angle_weight = np.kron([[0.5, 0.5], [0.5, -0.5]], np.identity(2 ** (local_num_qubits - 2)))
# calc the combo angles
list_of_angles = angle_weight.dot(np.array(list_of_angles)).tolist()
# recursive step on half the angles fulfilling the above assumption
multiplex_1 = self._multiplex(target_gate, list_of_angles[0 : (list_len // 2)], False)
circuit.append(multiplex_1.to_instruction(), q[0:-1])
# attach CNOT as follows, thereby flipping the LSB qubit
circuit.append(CXGate(), [msb, lsb])
# implement extra efficiency from the paper of cancelling adjacent
# CNOTs (by leaving out last CNOT and reversing (NOT inverting) the
# second lower-level multiplex)
multiplex_2 = self._multiplex(target_gate, list_of_angles[(list_len // 2) :], False)
if list_len > 1:
circuit.append(multiplex_2.to_instruction().reverse_ops(), q[0:-1])
else:
circuit.append(multiplex_2.to_instruction(), q[0:-1])
# attach a final CNOT
if last_cnot:
circuit.append(CXGate(), [msb, lsb])
return circuit
def prepare_state(self, state, qubits=None, label=None, normalize=False):
r"""Prepare qubits in a specific state.
This class implements a state preparing unitary. Unlike
:class:`qiskit.extensions.Initialize` it does not reset the qubits first.
Args:
state (str or list or int or Statevector):
* Statevector: Statevector to initialize to.
* str: labels of basis states of the Pauli eigenstates Z, X, Y. See
:meth:`.Statevector.from_label`. Notice the order of the labels is reversed with respect
to the qubit index to be applied to. Example label '01' initializes the qubit zero to
:math:`|1\rangle` and the qubit one to :math:`|0\rangle`.
* list: vector of complex amplitudes to initialize to.
* int: an integer that is used as a bitmap indicating which qubits to initialize
to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2
to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`.
qubits (QuantumRegister or Qubit or int):
* QuantumRegister: A list of qubits to be initialized [Default: None].
* Qubit: Single qubit to be initialized [Default: None].
* int: Index of qubit to be initialized [Default: None].
* list: Indexes of qubits to be initialized [Default: None].
label (str): An optional label for the gate
normalize (bool): Whether to normalize an input array to a unit vector.
Returns:
qiskit.circuit.Instruction: a handle to the instruction that was just initialized
Examples:
Prepare a qubit in the state :math:`(|0\rangle - |1\rangle) / \sqrt{2}`.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(1)
circuit.prepare_state([1/np.sqrt(2), -1/np.sqrt(2)], 0)
circuit.draw()
output:
.. parsed-literal::
┌─────────────────────────────────────┐
q_0: ┤ State Preparation(0.70711,-0.70711) ├
└─────────────────────────────────────┘
Prepare from a string two qubits in the state :math:`|10\rangle`.
The order of the labels is reversed with respect to qubit index.
More information about labels for basis states are in
:meth:`.Statevector.from_label`.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2)
circuit.prepare_state('01', circuit.qubits)
circuit.draw()
output:
.. parsed-literal::
┌─────────────────────────┐
q_0: ┤0 ├
│ State Preparation(0,1) │
q_1: ┤1 ├
└─────────────────────────┘
Initialize two qubits from an array of complex amplitudes
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2)
circuit.prepare_state([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits)
circuit.draw()
output:
.. parsed-literal::
┌───────────────────────────────────────────┐
q_0: ┤0 ├
│ State Preparation(0,0.70711,-0.70711j,0) │
q_1: ┤1 ├
└───────────────────────────────────────────┘
"""
if qubits is None:
qubits = self.qubits
elif isinstance(qubits, (int, np.integer, slice, Qubit)):
qubits = [qubits]
num_qubits = len(qubits) if isinstance(state, int) else None
return self.append(
StatePreparation(state, num_qubits, label=label, normalize=normalize), qubits
)
QuantumCircuit.prepare_state = prepare_state
|
https://github.com/tstopa/Qiskit_for_high_schools
|
tstopa
|
from qiskit import *
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_valencia')
import pprint
pprint.pprint(backend.configuration().coupling_map)
from qiskit.tools.visualization import plot_error_map
plot_error_map(backend)
|
https://github.com/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
import numpy as np
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Simon
from qiskit.aqua.components.oracles import TruthTableOracle
bitmaps = [
'01101001',
'10011001',
'01100110'
]
oracle = TruthTableOracle(bitmaps)
def compute_mask(input_bitmaps):
vals = list(zip(*input_bitmaps))[::-1]
def find_pair():
for i in range(len(vals)):
for j in range(i + 1, len(vals)):
if vals[i] == vals[j]:
return i, j
return 0, 0
k1, k2 = find_pair()
return np.binary_repr(k1 ^ k2, int(np.log2(len(input_bitmaps[0]))))
mask = compute_mask(bitmaps)
print(f'The groundtruth mask is {mask}.')
simon = Simon(oracle)
backend = BasicAer.get_backend('qasm_simulator')
result = simon.run(QuantumInstance(backend, shots=1024))
print('The mask computed using Simon is {}.'.format(result['result']))
assert(result['result'] == mask)
bitmaps = [
'00011110',
'01100110',
'10101010'
]
mask = compute_mask(bitmaps)
print(f'The groundtruth mask is {mask}.')
oracle = TruthTableOracle(bitmaps)
simon = Simon(oracle)
result = simon.run(QuantumInstance(backend, shots=1024))
print('The mask computed using Simon is {}.'.format(result['result']))
assert(result['result'] == mask)
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
import qiskit
from qiskit import *
print(qiskit.__version__)
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
from qiskit.providers.aer import QasmSimulator
# use Aer's qasm_simulator
simulator = QasmSimulator()
# create quantum circute acting on the q register
circuit = QuantumCircuit(2,2)
# add a H gate on qubit 0
circuit.h(0)
# add a cx (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0,1)
# map the quantum measurement to the classical bits
circuit.measure([0,1],[0,1])
# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)
# execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1024)
# grad results from the job
result = job.result()
# return counts
counts = result.get_counts(compiled_circuit)
print('total count for 00 and 11 are: ',counts)
# draw circuit
circuit.draw(output='mpl')
# plot histogram
plot_histogram(counts)
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.providers.aer import AerSimulator
backend = AerSimulator()
circuit = QuantumCircuit(2)
theta = Parameter('theta')
circuit.rx(234, 0)
circuit.draw(output='mpl')
backend = AerSimulator()
circuit = QuantumCircuit(2)
# theta = Parameter('theta')
circuit.rx(20, 0)
circuit.x(0)
circuit.h(1)
result = execute(circuit, backend=backend, shots=1024).result()
# counts=result.get_counts()
# print(counts)
circuit.draw(output='mpl')
|
https://github.com/qiskit-community/qiskit-alt
|
qiskit-community
|
import qiskit_alt
#geometry = [['H', [0., 0., 0.]], ['H', [0., 0., 0.7414]]]
geometry = [['O', [0., 0., 0.]],
['H', [0.757, 0.586, 0.]],
['H', [-0.757, 0.586, 0.]]]
#basis = 'sto3g'
#basis = '631g'
basis = 'dzvp2'
pauli_op = qiskit_alt.jordan_wigner(geometry, basis)
|
https://github.com/codigoscupom/QuantumAlgs
|
codigoscupom
|
import qiskit as q
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import math
qasm_sim = q.Aer.get_backend('qasm_simulator')
statevec_sim = q.Aer.get_backend("statevector_simulator")
c = q.QuantumCircuit(2,2)
c.ry(math.pi/4,0)
c.ry(math.pi/4,1)
orig_statevec = q.execute(c, backend=statevec_sim).result().get_statevector()
c.measure([0,1], [0,1]) # measuring qubit 3, which is impacted by those cnots:
orig_counts = q.execute(c, backend=qasm_sim, shots=1024).result().get_counts()
plot_bloch_multivector(orig_statevec)
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
import qiskit
qiskit.__qiskit_version__
import qiskit
qiskit.__qiskit_version__
# useful additional packages
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
'''# Load our saved IBMQ accounts
IBMQ.load_account()'''
n = 13 # the length of the first register for querying the oracle
# Choose a type of oracle at random. With probability half it is constant,
# and with the same probability it is balanced
oracleType, oracleValue = np.random.randint(2), np.random.randint(2)
if oracleType == 0:
print("The oracle returns a constant value ", oracleValue)
else:
print("The oracle returns a balanced function")
a = np.random.randint(1,2**n) # this is a hidden parameter for balanced oracle.
# Creating registers
# n qubits for querying the oracle and one qubit for storing the answer
qr = QuantumRegister(n+1) #all qubits are initialized to zero
# for recording the measurement on the first register
cr = ClassicalRegister(n)
circuitName = "DeutschJozsa"
djCircuit = QuantumCircuit(qr, cr)
# Create the superposition of all input queries in the first register by applying the Hadamard gate to each qubit.
for i in range(n):
djCircuit.h(qr[i])
# Flip the second register and apply the Hadamard gate.
djCircuit.x(qr[n])
djCircuit.h(qr[n])
# Apply barrier to mark the beginning of the oracle
djCircuit.barrier()
if oracleType == 0:#If the oracleType is "0", the oracle returns oracleValue for all input.
if oracleValue == 1:
djCircuit.x(qr[n])
else:
djCircuit.iden(qr[n])
else: # Otherwise, it returns the inner product of the input with a (non-zero bitstring)
for i in range(n):
if (a & (1 << i)):
djCircuit.cx(qr[i], qr[n])
# Apply barrier to mark the end of the oracle
djCircuit.barrier()
# Apply Hadamard gates after querying the oracle
for i in range(n):
djCircuit.h(qr[i])
# Measurement
djCircuit.barrier()
for i in range(n):
djCircuit.measure(qr[i], cr[i])
#draw the circuit
djCircuit.draw(output='mpl',scale=0.5)
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
job = execute(djCircuit, backend=backend, shots=shots)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
backend = IBMQ.get_backend('ibmq_16_melbourne')
djCompiled = transpile(djCircuit, backend=backend, optimization_level=1)
djCompiled.draw(output='mpl',scale=0.5)
job = execute(djCompiled, backend=backend, shots=1024)
job_monitor(job)
results = job.result()
answer = results.get_counts()
threshold = int(0.01 * shots) # the threshold of plotting significant measurements
filteredAnswer = {k: v for k,v in answer.items() if v >= threshold} # filter the answer for better view of plots
removedCounts = np.sum([ v for k,v in answer.items() if v < threshold ]) # number of counts removed
filteredAnswer['other_bitstrings'] = removedCounts # the removed counts are assigned to a new index
plot_histogram(filteredAnswer)
print(filteredAnswer)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import BasicAer, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
|
https://github.com/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# 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.
"""mpl circuit visualization style."""
import json
import os
from warnings import warn
from qiskit import user_config
class DefaultStyle:
"""Creates a Default Style dictionary
**Style Dict Details**
The style dict contains numerous options that define the style of the
output circuit visualization. The style dict is used by the `mpl` or
`latex` output. The options available in the style dict are defined below:
name (str): the name of the style. The name can be set to ``iqx``,
``iqx-dark``, ``textbook``, ``bw``, ``default``, or the name of a
user-created json file. This overrides the setting in the user config
file (usually ``~/.qiskit/settings.conf``).
textcolor (str): the color code to use for all text not inside a gate.
Defaults to ``#000000``
subtextcolor (str): the color code to use for subtext. Defaults to
``#000000``
linecolor (str): the color code to use for lines. Defaults to
``#000000``
creglinecolor (str): the color code to use for classical register
lines. Defaults to ``#778899``
gatetextcolor (str): the color code to use for gate text. Defaults to
``#000000``
gatefacecolor (str): the color code to use for a gate if no color
specified in the 'displaycolor' dict. Defaults to ``#BB8BFF``
barrierfacecolor (str): the color code to use for barriers. Defaults to
``#BDBDBD``
backgroundcolor (str): the color code to use for the background.
Defaults to ``#FFFFFF``
edgecolor (str): the color code to use for gate edges when using the
`bw` style. Defaults to ``#000000``.
fontsize (int): the font size to use for text. Defaults to 13.
subfontsize (int): the font size to use for subtext. Defaults to 8.
showindex (bool): if set to True, show the index numbers at the top.
Defaults to False.
figwidth (int): the maximum width (in inches) for the output figure.
If set to -1, the maximum displayable width will be used.
Defaults to -1.
dpi (int): the DPI to use for the output image. Defaults to 150.
margin (list): a list of margin values to adjust spacing around output
image. Takes a list of 4 ints: [x left, x right, y bottom, y top].
Defaults to [2.0, 0.1, 0.1, 0.3].
creglinestyle (str): The style of line to use for classical registers.
Choices are ``solid``, ``doublet``, or any valid matplotlib
`linestyle` kwarg value. Defaults to ``doublet``.
displaytext (dict): a dictionary of the text to use for certain element
types in the output visualization. These items allow the use of
LaTeX formatting for gate names. The 'displaytext' dict can contain
any number of elements. User created names and labels may be used as
keys, which allow these to have Latex formatting. The default
values are (`default.json`)::
{
'u1': 'U_1',
'u2': 'U_2',
'u3': 'U_3',
'sdg': 'S^\\dagger',
'sx': '\\sqrt{X}',
'sxdg': '\\sqrt{X}^\\dagger',
't': 'T',
'tdg': 'T^\\dagger',
'dcx': 'Dcx',
'iswap': 'Iswap',
'ms': 'MS',
'rx': 'R_X',
'ry': 'R_Y',
'rz': 'R_Z',
'rxx': 'R_{XX}',
'ryy': 'R_{YY}',
'rzx': 'R_{ZX}',
'rzz': 'ZZ',
'reset': '\\left|0\\right\\rangle',
'initialize': '|\\psi\\rangle'
}
displaycolor (dict): the color codes to use for each circuit element in
the form (gate_color, text_color). Colors can also be entered without
the text color, such as 'u1': '#FA74A6', in which case the text color
will always be `gatetextcolor`. The `displaycolor` dict can contain
any number of elements. User names and labels may be used as keys,
which allows for custom colors for user-created gates. The default
values are (`default.json`)::
{
'u1': ('#FA74A6', '#000000'),
'u2': ('#FA74A6', '#000000'),
'u3': ('#FA74A6', '#000000'),
'id': ('#05BAB6', '#000000'),
'u': ('#BB8BFF', '#000000'),
'p': ('#BB8BFF', '#000000'),
'x': ('#05BAB6', '#000000'),
'y': ('#05BAB6', '#000000'),
'z': ('#05BAB6', '#000000'),
'h': ('#6FA4FF', '#000000'),
'cx': ('#6FA4FF', '#000000'),
'ccx': ('#BB8BFF', '#000000'),
'mcx': ('#BB8BFF', '#000000'),
'mcx_gray': ('#BB8BFF', '#000000'),
'cy': ('#6FA4FF', '#000000'),
'cz': ('#6FA4FF', '#000000'),
'swap': ('#6FA4FF', '#000000'),
'cswap': ('#BB8BFF', '#000000'),
'ccswap': ('#BB8BFF', '#000000'),
'dcx': ('#6FA4FF', '#000000'),
'cdcx': ('#BB8BFF', '#000000'),
'ccdcx': ('#BB8BFF', '#000000'),
'iswap': ('#6FA4FF', '#000000'),
's': ('#6FA4FF', '#000000'),
'sdg': ('#6FA4FF', '#000000'),
't': ('#BB8BFF', '#000000'),
'tdg': ('#BB8BFF', '#000000'),
'sx': ('#6FA4FF', '#000000'),
'sxdg': ('#6FA4FF', '#000000')
'r': ('#BB8BFF', '#000000'),
'rx': ('#BB8BFF', '#000000'),
'ry': ('#BB8BFF', '#000000'),
'rz': ('#BB8BFF', '#000000'),
'rxx': ('#BB8BFF', '#000000'),
'ryy': ('#BB8BFF', '#000000'),
'rzx': ('#BB8BFF', '#000000'),
'reset': ('#000000', '#FFFFFF'),
'target': ('#FFFFFF', '#FFFFFF'),
'measure': ('#000000', '#FFFFFF'),
}
"""
def __init__(self):
colors = {
"### Default Colors": "Default Colors",
"basis": "#FA74A6", # Red
"clifford": "#6FA4FF", # Light Blue
"pauli": "#05BAB6", # Green
"def_other": "#BB8BFF", # Purple
"### IQX Colors": "IQX Colors",
"classical": "#002D9C", # Dark Blue
"phase": "#33B1FF", # Cyan
"hadamard": "#FA4D56", # Light Red
"non_unitary": "#A8A8A8", # Medium Gray
"iqx_other": "#9F1853", # Dark Red
"### B/W": "B/W",
"black": "#000000",
"white": "#FFFFFF",
"dark_gray": "#778899",
"light_gray": "#BDBDBD",
}
self.style = {
"name": "default",
"tc": colors["black"], # Non-gate Text Color
"gt": colors["black"], # Gate Text Color
"sc": colors["black"], # Gate Subtext Color
"lc": colors["black"], # Line Color
"cc": colors["dark_gray"], # creg Line Color
"gc": colors["def_other"], # Default Gate Color
"bc": colors["light_gray"], # Barrier Color
"bg": colors["white"], # Background Color
"ec": None, # Edge Color (B/W only)
"fs": 13, # Gate Font Size
"sfs": 8, # Subtext Font Size
"index": False,
"figwidth": -1,
"dpi": 150,
"margin": [2.0, 0.1, 0.1, 0.3],
"cline": "doublet",
"disptex": {
"u1": "U_1",
"u2": "U_2",
"u3": "U_3",
"id": "I",
"sdg": "S^\\dagger",
"sx": "\\sqrt{X}",
"sxdg": "\\sqrt{X}^\\dagger",
"tdg": "T^\\dagger",
"ms": "MS",
"rx": "R_X",
"ry": "R_Y",
"rz": "R_Z",
"rxx": "R_{XX}",
"ryy": "R_{YY}",
"rzx": "R_{ZX}",
"rzz": "ZZ",
"reset": "\\left|0\\right\\rangle",
"initialize": "$|\\psi\\rangle$",
},
"dispcol": {
"u1": (colors["basis"], colors["black"]),
"u2": (colors["basis"], colors["black"]),
"u3": (colors["basis"], colors["black"]),
"u": (colors["def_other"], colors["black"]),
"p": (colors["def_other"], colors["black"]),
"id": (colors["pauli"], colors["black"]),
"x": (colors["pauli"], colors["black"]),
"y": (colors["pauli"], colors["black"]),
"z": (colors["pauli"], colors["black"]),
"h": (colors["clifford"], colors["black"]),
"cx": (colors["clifford"], colors["black"]),
"ccx": (colors["def_other"], colors["black"]),
"mcx": (colors["def_other"], colors["black"]),
"mcx_gray": (colors["def_other"], colors["black"]),
"cy": (colors["clifford"], colors["black"]),
"cz": (colors["clifford"], colors["black"]),
"swap": (colors["clifford"], colors["black"]),
"cswap": (colors["def_other"], colors["black"]),
"ccswap": (colors["def_other"], colors["black"]),
"dcx": (colors["clifford"], colors["black"]),
"cdcx": (colors["def_other"], colors["black"]),
"ccdcx": (colors["def_other"], colors["black"]),
"iswap": (colors["clifford"], colors["black"]),
"s": (colors["clifford"], colors["black"]),
"sdg": (colors["clifford"], colors["black"]),
"t": (colors["def_other"], colors["black"]),
"tdg": (colors["def_other"], colors["black"]),
"sx": (colors["clifford"], colors["black"]),
"sxdg": (colors["clifford"], colors["black"]),
"r": (colors["def_other"], colors["black"]),
"rx": (colors["def_other"], colors["black"]),
"ry": (colors["def_other"], colors["black"]),
"rz": (colors["def_other"], colors["black"]),
"rxx": (colors["def_other"], colors["black"]),
"ryy": (colors["def_other"], colors["black"]),
"rzx": (colors["def_other"], colors["black"]),
"reset": (colors["black"], colors["white"]),
"target": (colors["white"], colors["white"]),
"measure": (colors["black"], colors["white"]),
},
}
def load_style(style):
"""Utility function to load style from json files and call set_style."""
current_style = DefaultStyle().style
style_name = "default"
def_font_ratio = current_style["fs"] / current_style["sfs"]
config = user_config.get_config()
if style is None:
if config:
style = config.get("circuit_mpl_style", "default")
else:
style = "default"
if style is False:
style_name = "bw"
elif isinstance(style, dict) and "name" in style:
style_name = style["name"]
elif isinstance(style, str):
style_name = style
elif not isinstance(style, (str, dict)):
warn(
f"style parameter '{style}' must be a str or a dictionary. Will use default style.",
UserWarning,
2,
)
if style_name.endswith(".json"):
style_name = style_name[:-5]
# Search for file in 'styles' dir, then config_path, and finally 'cwd'
style_path = []
if style_name != "default":
style_name = style_name + ".json"
spath = os.path.dirname(os.path.abspath(__file__))
style_path.append(os.path.join(spath, "styles", style_name))
if config:
config_path = config.get("circuit_mpl_style_path", "")
if config_path:
for path in config_path:
style_path.append(os.path.normpath(os.path.join(path, style_name)))
style_path.append(os.path.normpath(os.path.join("", style_name)))
for path in style_path:
exp_user = os.path.expanduser(path)
if os.path.isfile(exp_user):
try:
with open(exp_user) as infile:
json_style = json.load(infile)
set_style(current_style, json_style)
break
except json.JSONDecodeError as err:
warn(
f"Could not decode JSON in file '{path}': {str(err)}. "
"Will use default style.",
UserWarning,
2,
)
break
except (OSError, FileNotFoundError):
warn(
f"Error loading JSON file '{path}'. Will use default style.",
UserWarning,
2,
)
break
else:
warn(
f"Style JSON file '{style_name}' not found in any of these locations: "
f"{', '.join(style_path)}. "
"Will use default style.",
UserWarning,
2,
)
if isinstance(style, dict):
set_style(current_style, style)
return current_style, def_font_ratio
def set_style(current_style, new_style):
"""Utility function to take elements in new_style and
write them into current_style.
"""
valid_fields = {
"name",
"textcolor",
"gatetextcolor",
"subtextcolor",
"linecolor",
"creglinecolor",
"gatefacecolor",
"barrierfacecolor",
"backgroundcolor",
"edgecolor",
"fontsize",
"subfontsize",
"showindex",
"figwidth",
"dpi",
"margin",
"creglinestyle",
"displaytext",
"displaycolor",
}
current_style.update(new_style)
current_style["tc"] = current_style.get("textcolor", current_style["tc"])
current_style["gt"] = current_style.get("gatetextcolor", current_style["gt"])
current_style["sc"] = current_style.get("subtextcolor", current_style["sc"])
current_style["lc"] = current_style.get("linecolor", current_style["lc"])
current_style["cc"] = current_style.get("creglinecolor", current_style["cc"])
current_style["gc"] = current_style.get("gatefacecolor", current_style["gc"])
current_style["bc"] = current_style.get("barrierfacecolor", current_style["bc"])
current_style["bg"] = current_style.get("backgroundcolor", current_style["bg"])
current_style["ec"] = current_style.get("edgecolor", current_style["ec"])
current_style["fs"] = current_style.get("fontsize", current_style["fs"])
current_style["sfs"] = current_style.get("subfontsize", current_style["sfs"])
current_style["index"] = current_style.get("showindex", current_style["index"])
current_style["cline"] = current_style.get("creglinestyle", current_style["cline"])
current_style["disptex"] = {**current_style["disptex"], **new_style.get("displaytext", {})}
current_style["dispcol"] = {**current_style["dispcol"], **new_style.get("displaycolor", {})}
unsupported_keys = set(new_style) - valid_fields
if unsupported_keys:
warn(
f"style option/s ({', '.join(unsupported_keys)}) is/are not supported",
UserWarning,
2,
)
|
https://github.com/qiskit-community/qiskit-alt
|
qiskit-community
|
# Benchmark qiskit_alt constructing Fermionic operators from pyscf integrals.
import qiskit_alt
qiskit_alt.project.ensure_init()
import timeit
def make_setup_code(basis, geometry):
return f"""
import qiskit_alt
h2_geometry = [['H', [0., 0., 0.]], ['H', [0., 0., 0.7414]]]
h2o_geometry = [['O', [0., 0., 0.]],
['H', [0.757, 0.586, 0.]],
['H', [-0.757, 0.586, 0.]]]
from qiskit_alt.electronic_structure import fermionic_hamiltonian
fermionic_hamiltonian({geometry}, {basis})
#qiskit_alt.fermionic_hamiltonian({geometry}, {basis})
"""
def run_one_basis(basis, geometry, num_repetitions):
setup_code = make_setup_code(basis, geometry)
bench_code = f"fermionic_hamiltonian({geometry}, {basis})"
time = timeit.timeit(stmt=bench_code, setup=setup_code, number=num_repetitions)
t = 1000 * time / num_repetitions
print(f"geometry={geometry}, basis={basis} {t:0.2f}", "ms")
return t
def run_benchmarks():
alt_times = []
for basis, geometry, num_repetitions in (("'sto3g'", "h2_geometry", 10), ("'631g'", "h2_geometry", 10),
("'631++g'", "h2_geometry", 10),
("'sto3g'", "h2o_geometry", 10), ("'631g'", "h2o_geometry", 5)):
t = run_one_basis(basis, geometry, num_repetitions)
alt_times.append(t)
return alt_times
if __name__ == '__main__':
alt_times = run_benchmarks()
|
https://github.com/mballarin97/mps_qnn
|
mballarin97
|
# This code is part of qcircha.
#
# 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.
"""
Here we preprocess and produce the data for real work datasets, i.e.
the wine and breast cancer datasets
"""
import os
import numpy as np
from qcircha.circuit_selector import _select_circ
from qiskit import QuantumCircuit
import qmatchatea as qmt
from qmatchatea.qk_utils import qk_transpilation_params
import qtealeaves.observables as obs
from qtealeaves.emulator import MPS
from sklearn import preprocessing
from tqdm import tqdm
depth = 14
dataset_name = "breast"
if dataset_name == "wine":
dir_name = f"data/datasets/wine/"
input_file = "datasets/wine.data"
num_qubits = 13
else:
dir_name = f"data/datasets/breast_cancer/"
input_file = "datasets/breast-cancer.data"
num_qubits = 9
num_reps = 1
num_avg = 10
max_bond_dim = 128
if not os.path.isdir(dir_name):
os.makedirs(dir_name)
observables = obs.TNObservables()
observables += obs.TNObsBondEntropy()
observables += obs.TNState2File('mps_state.txt', 'F')
conv_params = qmt.QCConvergenceParameters(int(max_bond_dim), singval_mode="C")
backend = qmt.QCBackend()
trans_params = qk_transpilation_params(linearize=True)
feature_map = _select_circ(num_qubits, "zzfeaturemap")
ansatz = _select_circ(num_qubits, "twolocal")
# Load dataset and remove
dataset = np.loadtxt(input_file, delimiter=",", dtype=str)[:, 1:]
if dataset_name == "breast":
new_dataset = []
for features in dataset.T:
new_dataset.append(
preprocessing.LabelEncoder().fit_transform(features)
)
dataset = np.array(new_dataset).T
min_max_scaler = preprocessing.MinMaxScaler()
dataset = min_max_scaler.fit_transform(dataset)*np.pi
idx = 0
for data in tqdm((dataset)):
binded_fmap = feature_map.bind_parameters(data)
for _ in range(num_avg):
initial_state = "Vacuum"
entanglement_total = []
singvals_cut_total = []
states_total = []
for num_reps in range(depth):
#print(f"\n__Reps {num_reps}/{depth}")
random_params = np.pi * np.random.rand(len(ansatz.parameters))
binded_ansatz = ansatz.bind_parameters(random_params)
# Pick a PQC (modify the function)
qc = QuantumCircuit(num_qubits)
qc = qc.compose(binded_fmap)
qc = qc.compose(binded_ansatz)
io_info = qmt.QCIO(initial_state=initial_state)
results = qmt.run_simulation(qc, convergence_parameters=conv_params,
transpilation_parameters=trans_params, backend=backend,
observables=observables, io_info=io_info)
entanglement = np.array(list(results.entanglement.values()))
initial_state = results.mps
entanglement_total.append(entanglement)
states_total.append(results.singular_values_cut)
initial_state = MPS.from_tensor_list(initial_state)
np.save( os.path.join(dir_name, f"entanglement_{idx}.npy"), entanglement_total, allow_pickle=True)
#np.save( os.path.join(dir_name, f"states_{idx}.npy"), states_total, allow_pickle=True)
idx += 1
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# 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.
# pylint: disable=missing-docstring
import os
import configparser as cp
from uuid import uuid4
from unittest import mock
from qiskit import exceptions
from qiskit.test import QiskitTestCase
from qiskit import user_config
class TestUserConfig(QiskitTestCase):
def setUp(self):
super().setUp()
self.file_path = "test_%s.conf" % uuid4()
def test_empty_file_read(self):
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({}, config.settings)
def test_invalid_optimization_level(self):
test_config = """
[default]
transpile_optimization_level = 76
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
self.assertRaises(exceptions.QiskitUserConfigError, config.read_config_file)
def test_invalid_circuit_drawer(self):
test_config = """
[default]
circuit_drawer = MSPaint
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
self.assertRaises(exceptions.QiskitUserConfigError, config.read_config_file)
def test_circuit_drawer_valid(self):
test_config = """
[default]
circuit_drawer = latex
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({"circuit_drawer": "latex"}, config.settings)
def test_invalid_circuit_reverse_bits(self):
test_config = """
[default]
circuit_reverse_bits = Neither
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
self.assertRaises(exceptions.QiskitUserConfigError, config.read_config_file)
def test_circuit_reverse_bits_valid(self):
test_config = """
[default]
circuit_reverse_bits = false
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({"circuit_reverse_bits": False}, config.settings)
def test_optimization_level_valid(self):
test_config = """
[default]
transpile_optimization_level = 1
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({"transpile_optimization_level": 1}, config.settings)
def test_invalid_num_processes(self):
test_config = """
[default]
num_processes = -256
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
self.assertRaises(exceptions.QiskitUserConfigError, config.read_config_file)
def test_valid_num_processes(self):
test_config = """
[default]
num_processes = 31
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({"num_processes": 31}, config.settings)
def test_valid_parallel(self):
test_config = """
[default]
parallel = False
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual({"parallel_enabled": False}, config.settings)
def test_all_options_valid(self):
test_config = """
[default]
circuit_drawer = latex
circuit_mpl_style = default
circuit_mpl_style_path = ~:~/.qiskit
circuit_reverse_bits = false
transpile_optimization_level = 3
suppress_packaging_warnings = true
parallel = false
num_processes = 15
"""
self.addCleanup(os.remove, self.file_path)
with open(self.file_path, "w") as file:
file.write(test_config)
file.flush()
config = user_config.UserConfig(self.file_path)
config.read_config_file()
self.assertEqual(
{
"circuit_drawer": "latex",
"circuit_mpl_style": "default",
"circuit_mpl_style_path": ["~", "~/.qiskit"],
"circuit_reverse_bits": False,
"transpile_optimization_level": 3,
"num_processes": 15,
"parallel_enabled": False,
},
config.settings,
)
def test_set_config_all_options_valid(self):
self.addCleanup(os.remove, self.file_path)
user_config.set_config("circuit_drawer", "latex", file_path=self.file_path)
user_config.set_config("circuit_mpl_style", "default", file_path=self.file_path)
user_config.set_config("circuit_mpl_style_path", "~:~/.qiskit", file_path=self.file_path)
user_config.set_config("circuit_reverse_bits", "false", file_path=self.file_path)
user_config.set_config("transpile_optimization_level", "3", file_path=self.file_path)
user_config.set_config("parallel", "false", file_path=self.file_path)
user_config.set_config("num_processes", "15", file_path=self.file_path)
config_settings = None
with mock.patch.dict(os.environ, {"QISKIT_SETTINGS": self.file_path}, clear=True):
config_settings = user_config.get_config()
self.assertEqual(
{
"circuit_drawer": "latex",
"circuit_mpl_style": "default",
"circuit_mpl_style_path": ["~", "~/.qiskit"],
"circuit_reverse_bits": False,
"transpile_optimization_level": 3,
"num_processes": 15,
"parallel_enabled": False,
},
config_settings,
)
def test_set_config_multiple_sections(self):
self.addCleanup(os.remove, self.file_path)
user_config.set_config("circuit_drawer", "latex", file_path=self.file_path)
user_config.set_config("circuit_mpl_style", "default", file_path=self.file_path)
user_config.set_config("transpile_optimization_level", "3", file_path=self.file_path)
user_config.set_config("circuit_drawer", "latex", section="test", file_path=self.file_path)
user_config.set_config("parallel", "false", section="test", file_path=self.file_path)
user_config.set_config("num_processes", "15", section="test", file_path=self.file_path)
config = cp.ConfigParser()
config.read(self.file_path)
self.assertEqual(config.sections(), ["default", "test"])
self.assertEqual(
{
"circuit_drawer": "latex",
"circuit_mpl_style": "default",
"transpile_optimization_level": "3",
},
dict(config.items("default")),
)
|
https://github.com/Qiskit-Extensions/circuit-knitting-toolbox
|
Qiskit-Extensions
|
# This code is a Qiskit project.
# (C) Copyright IBM 2024.
# 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.
"""End to end tests for the cut finder workflow."""
from __future__ import annotations
import numpy as np
import unittest
from pytest import raises
from qiskit import QuantumCircuit
from qiskit.circuit.library import EfficientSU2
from circuit_knitting.cutting.cut_finding.cco_utils import qc_to_cco_circuit
from circuit_knitting.cutting.cut_finding.circuit_interface import (
SimpleGateList,
)
from circuit_knitting.cutting.cut_finding.optimization_settings import (
OptimizationSettings,
)
from circuit_knitting.cutting.automated_cut_finding import DeviceConstraints
from circuit_knitting.cutting.cut_finding.disjoint_subcircuits_state import (
get_actions_list,
SingleWireCutIdentifier,
WireCutLocation,
CutIdentifier,
CutLocation,
)
from circuit_knitting.cutting.cut_finding.lo_cuts_optimizer import (
LOCutsOptimizer,
)
from circuit_knitting.cutting.cut_finding.cut_optimization import CutOptimization
class TestCuttingFourQubitCircuit(unittest.TestCase):
def setUp(self):
qc = EfficientSU2(4, entanglement="linear", reps=2).decompose()
qc.assign_parameters([0.4] * len(qc.parameters), inplace=True)
self.circuit_internal = qc_to_cco_circuit(qc)
def test_four_qubit_cutting_workflow(self):
with self.subTest("No cuts needed"):
qubits_per_subcircuit = 4
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize(interface, settings, constraint_obj)
assert get_actions_list(output.actions) == [] # no cutting.
assert (
interface.export_subcircuits_as_string(name_mapping="default") == "AAAA"
)
with self.subTest("No cuts found when all flags set to False"):
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=False, wire_lo=False)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
with raises(ValueError) as e_info:
optimization_pass.optimize(interface, settings, constraint_obj)
assert (
e_info.value.args[0]
== "None state encountered: no cut state satisfying the specified constraints and settings could be found."
)
with self.subTest(
"No separating cuts possible if one qubit per qpu and only wire cuts allowed"
):
settings = OptimizationSettings(seed=12345, gate_lo=False, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
interface = SimpleGateList(self.circuit_internal)
qubits_per_subcircuit = 1
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
with raises(ValueError) as e_info:
optimization_pass.optimize(interface, settings, constraint_obj)
assert (
e_info.value.args[0]
== "None state encountered: no cut state satisfying the specified constraints and settings could be found."
)
with self.subTest("Gate cuts to get three qubits per subcircuit"):
# QPU with 3 qubits for a 4 qubit circuit enforces cutting.
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=17, gate_name="cx", qubits=[2, 3]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=25, gate_name="cx", qubits=[2, 3]
),
),
]
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 9
) # 2 LO cnot cuts.
assert (
optimization_pass.minimum_reached() is True
) # matches optimal solution.
assert (
interface.export_subcircuits_as_string(name_mapping="default") == "AAAB"
) # circuit separated into 2 subcircuits.
with self.subTest("Gate cuts to get two qubits per subcircuit"):
qubits_per_subcircuit = 2
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=9, gate_name="cx", qubits=[1, 2]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=20, gate_name="cx", qubits=[1, 2]
),
),
]
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 9
) # 2 LO cnot cuts.
assert optimization_pass.minimum_reached() is True # matches optimal solution.
assert (
interface.export_subcircuits_as_string(name_mapping="default") == "AABB"
) # circuit separated into 2 subcircuits.
assert (
optimization_pass.get_stats()["CutOptimization"].backjumps
<= settings.max_backjumps
)
with self.subTest("Cut both wires instance"):
qubits_per_subcircuit = 2
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=False, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=9, gate_name="cx", qubits=[1, 2], input=1
),
),
CutIdentifier(
cut_action="CutBothWires",
cut_location=CutLocation(
instruction_id=12, gate_name="cx", qubits=[0, 1]
),
),
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=17, gate_name="cx", qubits=[2, 3], input=1
),
),
CutIdentifier(
cut_action="CutBothWires",
cut_location=CutLocation(
instruction_id=20, gate_name="cx", qubits=[1, 2]
),
),
CutIdentifier(
cut_action="CutBothWires",
cut_location=CutLocation(
instruction_id=25, gate_name="cx", qubits=[2, 3]
),
),
]
best_result = optimization_pass.get_results()
assert output.upper_bound_gamma() == best_result.gamma_UB == 65536
assert (
interface.export_subcircuits_as_string(name_mapping="default")
== "ADABDEBCEFCF"
)
with self.subTest("Wire cuts to get to 3 qubits per subcircuit"):
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=False, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=17, gate_name="cx", qubits=[2, 3], input=1
),
),
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=20, gate_name="cx", qubits=[1, 2], input=1
),
),
]
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 16
) # 2 LO wire cuts.
assert (
interface.export_subcircuits_as_string(name_mapping="default") == "AABABB"
) # circuit separated into 2 subcircuits.
with self.subTest("Search engine not supported"):
# Check if unspported search engine is flagged
qubits_per_subcircuit = 4
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BeamSearch")
search_engine = settings.get_engine_selection("CutOptimization")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
with raises(ValueError) as e_info:
_ = optimization_pass.optimize()
assert (
e_info.value.args[0] == f"Search engine {search_engine} is not supported."
)
with self.subTest("Greedy search gate cut warm start test"):
# Even if the input cost bounds are too stringent, greedy_cut_optimization
# is able to return a solution.
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=False)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
# Impose a stringent cost upper bound, insist gamma <=2.
cut_opt = CutOptimization(interface, settings, constraint_obj)
cut_opt.update_upperbound_cost((2, 4))
state, cost = cut_opt.optimization_pass()
# 2 cnot cuts are still found
assert state is not None
assert cost[0] == 9
with self.subTest("Greedy search wire cut warm start test"):
# Even if the input cost bounds are too stringent, greedy_cut_optimization
# is able to return a solution.
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=False, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
# Impose a stringent cost upper bound, insist gamma <=2.
cut_opt = CutOptimization(interface, settings, constraint_obj)
cut_opt.update_upperbound_cost((2, 4))
state, cost = cut_opt.optimization_pass()
# 2 LO wire cuts are still found
assert state is not None
assert cost[0] == 16
class TestCuttingSevenQubitCircuit(unittest.TestCase):
def setUp(self):
qc = QuantumCircuit(7)
for i in range(7):
qc.rx(np.pi / 4, i)
qc.cx(0, 3)
qc.cx(1, 3)
qc.cx(2, 3)
qc.cx(3, 4)
qc.cx(3, 5)
qc.cx(3, 6)
self.circuit_internal = qc_to_cco_circuit(qc)
def test_seven_qubit_workflow(self):
with self.subTest("Two qubits per subcircuit"):
qubits_per_subcircuit = 2
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=7, gate_name="cx", qubits=[0, 3]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=8, gate_name="cx", qubits=[1, 3]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=9, gate_name="cx", qubits=[2, 3]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=11, gate_name="cx", qubits=[3, 5]
),
),
CutIdentifier(
cut_action="CutTwoQubitGate",
cut_location=CutLocation(
instruction_id=12, gate_name="cx", qubits=[3, 6]
),
),
]
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 243
) # 5 LO cnot cuts.
assert (
optimization_pass.minimum_reached() is True
) # matches optimal solution.
assert (
interface.export_subcircuits_as_string(name_mapping="default")
== "ABCDDEF"
) # circuit separated into 2 subcircuits.
with self.subTest("Single wire cut"):
qubits_per_subcircuit = 4
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=10, gate_name="cx", qubits=[3, 4], input=1
),
)
]
assert (
interface.export_subcircuits_as_string(name_mapping="default")
== "AAAABBBB"
) # extra wires because of wire cuts
# and no qubit reuse.
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 4
) # One LO wire cut.
assert (
optimization_pass.minimum_reached() is True
) # matches optimal solution
with self.subTest("Two single wire cuts"):
qubits_per_subcircuit = 3
interface = SimpleGateList(self.circuit_internal)
settings = OptimizationSettings(seed=12345, gate_lo=True, wire_lo=True)
settings.set_engine_selection("CutOptimization", "BestFirst")
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(interface, settings, constraint_obj)
output = optimization_pass.optimize()
cut_actions_list = output.cut_actions_sublist()
assert cut_actions_list == [
SingleWireCutIdentifier(
cut_action="CutRightWire",
wire_cut_location=WireCutLocation(
instruction_id=9, gate_name="cx", qubits=[2, 3], input=2
),
),
SingleWireCutIdentifier(
cut_action="CutLeftWire",
wire_cut_location=WireCutLocation(
instruction_id=11, gate_name="cx", qubits=[3, 5], input=1
),
),
]
assert (
interface.export_subcircuits_as_string(name_mapping="default")
== "AABABCBCC"
) # extra wires because of wire cuts
# and no qubit reuse. In the string above,
# {A: wire 0, A:wire 1, B:wire 2, A: wire 3,
# B: first cut on wire 3, C: second cut on wire 3,
# B: wire 4, C: wire 5, C: wire 6}.
best_result = optimization_pass.get_results()
assert (
output.upper_bound_gamma() == best_result.gamma_UB == 16
) # Two LO wire cuts.
assert optimization_pass.minimum_reached() is True # matches optimal solution
class TestCuttingMultiQubitGates(unittest.TestCase):
def setUp(self):
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
circuit_internal = qc_to_cco_circuit(qc)
self.interface = SimpleGateList(circuit_internal)
self.settings = OptimizationSettings(seed=12345)
self.settings.set_engine_selection("CutOptimization", "BestFirst")
def no_cutting_multiqubit_gates(self):
# The cutting of multiqubit gates is not supported at present.
qubits_per_subcircuit = 2
constraint_obj = DeviceConstraints(qubits_per_subcircuit)
optimization_pass = LOCutsOptimizer(
self.interface, self.settings, constraint_obj
)
with raises(ValueError) as e_info:
_ = optimization_pass.optimize()
assert e_info.value.args[0] == (
"The input circuit must contain only single and two-qubits gates. "
"Found 3-qubit gate: (ccx)."
)
|
https://github.com/rohitgit1/Quantum-Computing-Summer-School
|
rohitgit1
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from scipy.interpolate import griddata
%matplotlib inline
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, AncillaRegister, transpile
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import WeightedAdder, LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits per dimension to represent the uncertainty
num_uncertainty_qubits = 2
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# map to higher dimensional distribution
# for simplicity assuming dimensions are independent and identically distributed)
dimension = 2
num_qubits = [num_uncertainty_qubits] * dimension
low = low * np.ones(dimension)
high = high * np.ones(dimension)
mu = mu * np.ones(dimension)
cov = sigma**2 * np.eye(dimension)
# construct circuit
u = LogNormalDistribution(num_qubits=num_qubits, mu=mu, sigma=cov, bounds=list(zip(low, high)))
# plot PDF of uncertainty model
x = [v[0] for v in u.values]
y = [v[1] for v in u.values]
z = u.probabilities
# z = map(float, z)
# z = list(map(float, z))
resolution = np.array([2**n for n in num_qubits]) * 1j
grid_x, grid_y = np.mgrid[min(x) : max(x) : resolution[0], min(y) : max(y) : resolution[1]]
grid_z = griddata((x, y), z, (grid_x, grid_y))
plt.figure(figsize=(10, 8))
ax = plt.axes(projection="3d")
ax.plot_surface(grid_x, grid_y, grid_z, cmap=plt.cm.Spectral)
ax.set_xlabel("Spot Price $S_T^1$ (\$)", size=15)
ax.set_ylabel("Spot Price $S_T^2$ (\$)", size=15)
ax.set_zlabel("Probability (\%)", size=15)
plt.show()
# determine number of qubits required to represent total loss
weights = []
for n in num_qubits:
for i in range(n):
weights += [2**i]
# create aggregation circuit
agg = WeightedAdder(sum(num_qubits), weights)
n_s = agg.num_sum_qubits
n_aux = agg.num_qubits - n_s - agg.num_state_qubits # number of additional qubits
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 3.5
# map strike price from [low, high] to {0, ..., 2^n-1}
max_value = 2**n_s - 1
low_ = low[0]
high_ = high[0]
mapped_strike_price = (
(strike_price - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [0, mapped_strike_price]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = 2 * (2**num_uncertainty_qubits - 1) - mapped_strike_price
basket_objective = LinearAmplitudeFunction(
n_s,
slopes,
offsets,
domain=(0, max_value),
image=(f_min, f_max),
rescaling_factor=c_approx,
breakpoints=breakpoints,
)
# define overall multivariate problem
qr_state = QuantumRegister(u.num_qubits, "state") # to load the probability distribution
qr_obj = QuantumRegister(1, "obj") # to encode the function values
ar_sum = AncillaRegister(n_s, "sum") # number of qubits used to encode the sum
ar = AncillaRegister(max(n_aux, basket_objective.num_ancillas), "work") # additional qubits
objective_index = u.num_qubits
basket_option = QuantumCircuit(qr_state, qr_obj, ar_sum, ar)
basket_option.append(u, qr_state)
basket_option.append(agg, qr_state[:] + ar_sum[:] + ar[:n_aux])
basket_option.append(basket_objective, ar_sum[:] + qr_obj[:] + ar[: basket_objective.num_ancillas])
print(basket_option.draw())
print("objective qubit index", objective_index)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = np.linspace(sum(low), sum(high))
y = np.maximum(0, x - strike_price)
plt.plot(x, y, "r-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Sum of Spot Prices ($S_T^1 + S_T^2)$", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value
sum_values = np.sum(u.values, axis=1)
exact_value = np.dot(
u.probabilities[sum_values >= strike_price],
sum_values[sum_values >= strike_price] - strike_price,
)
print("exact expected value:\t%.4f" % exact_value)
num_state_qubits = basket_option.num_qubits - basket_option.num_ancillas
print("state qubits: ", num_state_qubits)
transpiled = transpile(basket_option, basis_gates=["u", "cx"])
print("circuit width:", transpiled.width())
print("circuit depth:", transpiled.depth())
basket_option_measure = basket_option.measure_all(inplace=False)
sampler = Sampler()
job = sampler.run(basket_option_measure)
# evaluate the result
value = 0
probabilities = job.result().quasi_dists[0].binary_probabilities()
for i, prob in probabilities.items():
if prob > 1e-4 and i[-num_state_qubits:][0] == "1":
value += prob
# map value to original range
mapped_value = (
basket_objective.post_processing(value) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
)
print("Exact Operator Value: %.4f" % value)
print("Mapped Operator value: %.4f" % mapped_value)
print("Exact Expected Payoff: %.4f" % exact_value)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=basket_option,
objective_qubits=[objective_index],
post_processing=basket_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = (
np.array(result.confidence_interval_processed)
/ (2**num_uncertainty_qubits - 1)
* (high_ - low_)
)
print("Exact value: \t%.4f" % exact_value)
print(
"Estimated value: \t%.4f"
% (result.estimation_processed / (2**num_uncertainty_qubits - 1) * (high_ - low_))
)
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/rubenandrebarreiro/ibm-qiskit-quantum-explorers-2023-2024
|
rubenandrebarreiro
|
# build your code here
password = "Experiment%"
# submit your answer using following code
# import the grader for the badge 3 of
# the IBM Qiskit's Quantum Explorers 2023-2024
from qc_grader.challenges.quantum_explorers23 import grade_badge3_ex1
# expected result type: string
grade_badge3_ex1(password)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
dc = pulse.DriveChannel
d0, d1, d2, d3, d4 = dc(0), dc(1), dc(2), dc(3), dc(4)
with pulse.build(name='pulse_programming_in') as pulse_prog:
pulse.play([1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], d0)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d1)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0], d2)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d3)
pulse.play([1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0], d4)
pulse_prog.draw()
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from random_lp.lp_random_gen import create_models
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/DENSE/" # 12.03.2021
Q_SEED = 10598 # as used in most issues
aqua_globals.random_seed = Q_SEED
shots = 4096
qps = create_models(DIR)
optimizer = COBYLA()
cplex = CplexOptimizer()
backend = BasicAer.get_backend('qasm_simulator')
max_qubits = backend.configuration().to_dict()['n_qubits']
quantum_instance = QuantumInstance(backend,
seed_simulator=Q_SEED,
seed_transpiler=Q_SEED,
shots=shots)
qaoa_mes = QAOA(quantum_instance=quantum_instance, optimizer=optimizer)
results = OrderedDict()
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
if qp.qubo.get_num_vars() > max_qubits:
break
qaoa = MinimumEigenOptimizer(qaoa_mes)
res = qaoa.solve(qp)
results[qp_name] = res
if res.status == OptimizationResultStatus.SUCCESS:
print("success")
cres = cplex.solve(qp)
if res.fval != cres.fval:
print("\n optimal value QAOA "+str(res.fval) + " , cplex:"+ str(cres.fval))
# see Class SubstituteVariables in https://qiskit.org/documentation/_modules/qiskit/optimization/problems/quadratic_program.html#QuadraticProgram
# for logger warning constraint A0_leb0 is infeasible due to substitution
# Afterwards a check for feasability of substituted solution is done (line 227 in meo result class) to set OptimizationResultStatus
res_7 = results["test_7"]
print(res_7)
qps["test_7"].is_feasible(res_7.x)
qps["test_8"].is_feasible(results["test_8"].x)
qps["test_8"].to_docplex().prettyprint()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import ParityMapper
from qiskit_nature.second_q.properties import ParticleNumber
from qiskit_nature.second_q.transformers import ActiveSpaceTransformer
bond_distance = 2.5 # in Angstrom
# specify driver
driver = PySCFDriver(
atom=f"Li 0 0 0; H 0 0 {bond_distance}",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
problem = driver.run()
# specify active space transformation
active_space_trafo = ActiveSpaceTransformer(
num_electrons=problem.num_particles, num_spatial_orbitals=3
)
# transform the electronic structure problem
problem = active_space_trafo.transform(problem)
# construct the parity mapper with 2-qubit reduction
qubit_mapper = ParityMapper(num_particles=problem.num_particles)
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms.ground_state_solvers import GroundStateEigensolver
np_solver = NumPyMinimumEigensolver()
np_groundstate_solver = GroundStateEigensolver(qubit_mapper, np_solver)
np_result = np_groundstate_solver.solve(problem)
target_energy = np_result.total_energies[0]
print(np_result)
from qiskit.circuit.library import EfficientSU2
ansatz = EfficientSU2(num_qubits=4, reps=1, entanglement="linear", insert_barriers=True)
ansatz.decompose().draw("mpl", style="iqx")
import numpy as np
from qiskit.utils import algorithm_globals
# fix random seeds for reproducibility
np.random.seed(5)
algorithm_globals.random_seed = 5
from qiskit.algorithms.optimizers import SPSA
optimizer = SPSA(maxiter=100)
initial_point = np.random.random(ansatz.num_parameters)
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.primitives import Estimator
estimator = Estimator()
local_vqe = VQE(
estimator,
ansatz,
optimizer,
initial_point=initial_point,
)
local_vqe_groundstate_solver = GroundStateEigensolver(qubit_mapper, local_vqe)
local_vqe_result = local_vqe_groundstate_solver.solve(problem)
print(local_vqe_result)
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(group="open") # replace by your runtime provider
backend = provider.get_backend("ibmq_qasm_simulator") # select a backend that supports the runtime
from qiskit_nature.runtime import VQEClient
runtime_vqe = VQEClient(
ansatz=ansatz,
optimizer=optimizer,
initial_point=initial_point,
provider=provider,
backend=backend,
shots=1024,
measurement_error_mitigation=True,
) # use a complete measurement fitter for error mitigation
runtime_vqe_groundstate_solver = GroundStateEigensolver(qubit_mapper, runtime_vqe)
runtime_vqe_result = runtime_vqe_groundstate_solver.solve(problem)
print(runtime_vqe_result)
runtime_result = runtime_vqe_result.raw_result
history = runtime_result.optimizer_history
loss = history["energy"]
import matplotlib.pyplot as plt
plt.rcParams["font.size"] = 14
# plot loss and reference value
plt.figure(figsize=(12, 6))
plt.plot(loss + runtime_vqe_result.nuclear_repulsion_energy, label="Runtime VQE")
plt.axhline(y=target_energy + 0.2, color="tab:red", ls=":", label="Target + 200mH")
plt.axhline(y=target_energy, color="tab:red", ls="--", label="Target")
plt.legend(loc="best")
plt.xlabel("Iteration")
plt.ylabel("Energy [H]")
plt.title("VQE energy");
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/rubenandrebarreiro/fct-nova-introduction-to-operations-research-labs
|
rubenandrebarreiro
|
# Import Scipy Python's Library and,
# its Optimisation Module and Linear Programming Sub-Module
from scipy.optimize import linprog
# Import the NumPy Python's Library, with the alias 'np'
import numpy as np
# Import the matplotlib Python's Library, with the alias 'plt'
import matplotlib.pyplot as plt
%matplotlib inline
# Construct Graphic Lines
# Steps for Implementation in Python:
# - 1) Set the Lines for the Bounds, as equalities:
# - The variable x is set indenpendindependently;
# - The variable y is set as one of yi's, in this case the y0;
# - 2) Set the Lines for the Constraints, as equalities:
# - All the equations always are solvable, in order to yi;
# - 3) Build the Graphic and Plot the Lines;
# - 4) Fill the Feasible Region:
# - Set the Maximum and Minimum of the Feasible Region,
# where, usually the inequations with '>=' are the maximums
# and the inequations with '<=' are the minimums;
# - Then, fill the Feasible Region;
# 1) Set the Lines for the Bounds, as equalities:
# a) x >= 0
x = np.linspace(0, 20, 2000)
# b) y >= 0
y0 = (x*0)
# 2) Set the Lines for the Constraints, as equalities:
# a) x + y <= 3 (=) y <= 3 - x
y1 = ( 3 - x )
# b) x + 4y >= 4 (=) 4y >= 4 - x (=) y >= (4 - x) / 4
y2 = ( 4 - x ) / 4
# c) -x + y <= 0 (=) y <= x
y3 = x
# 3) Build the Graphic and Plot the Lines:
plt.plot(x, y0, label=r'$ y \geq 0 $')
plt.plot(x, y1, label=r'$ x + y \leq 3 $')
plt.plot(x, y2, label=r'$ x + 4y \geq 4 $')
plt.plot(x, y3, label=r'$ -x + y \leq 0 $')
plt.xlim((0, 4.5))
plt.ylim((0, 4.5))
plt.xlabel(r'$x$')
plt.ylabel(r'$y$')
# 4) Fill the Feasible Region:
y4 = np.minimum(y1, y3)
y5 = np.maximum(y0, y2)
plt.fill_between(x, y4, y5, where=y4>y5, color='grey', alpha=0.5)
# Extras:
# - Add a Title to the Graphic Plot:
plt.title('Feasible Region for Exercise 1')
# - Add a Legend to the Graphic Plot:
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.0)
# - Adjust the size of the Graphic Plot:
plt.figure(figsize=(80,80))
# - Save the Graphic Plot, in PNG format:
#plt.savefig('exercise-1.png')
##### Extra: Building the Linear Programming Model
objective_function = [-1, -2]
# ─┬ ─┬
# │ └┤ Coefficient for y
# └────┤ Coefficient for x
constraints_inequalities = [ [ 1 , 1 ], # Constraint #1
[ 1 , 4 ], # Constraint #2
[ -1 , 1 ] ] # Constraint #3
constraints_function_values = [ 3, # Function Value for Constraint #1
4, # Function Value for Constraint #2
0 ] # Function Value for Constraint #3
variable_bounds = [ (0, float("inf")), # Bounds of x
(0, float("inf")) ] # Bounds of y
optimization_problem = linprog(c=objective_function,
A_ub=constraints_inequalities,
b_ub = constraints_function_values,
bounds=variable_bounds,
method="revised simplex")
optimization_problem
optimization_problem.fun
optimization_problem.success
optimization_problem.x
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
from dell_runtime import DellRuntimeProvider
from qiskit import QuantumCircuit
import logging
import requests
import time
import os
RUNTIME_PROGRAM = """
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# 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.
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish(result.to_dict(), final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
REMOTE_RUNTIME = os.getenv("SERVER_URL")
def main():
print("Starting...")
logging.basicConfig(level=logging.DEBUG)
provider = DellRuntimeProvider()
provider.remote(REMOTE_RUNTIME)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
print(f"PROGRAM ID: {program_id}")
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
# job.stream_results(print)
results = job.result(timeout=60)
print(results)
if __name__ == "__main__":
main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import ParityMapper
from qiskit_nature.second_q.properties import ParticleNumber
from qiskit_nature.second_q.transformers import ActiveSpaceTransformer
bond_distance = 2.5 # in Angstrom
# specify driver
driver = PySCFDriver(
atom=f"Li 0 0 0; H 0 0 {bond_distance}",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
problem = driver.run()
# specify active space transformation
active_space_trafo = ActiveSpaceTransformer(
num_electrons=problem.num_particles, num_spatial_orbitals=3
)
# transform the electronic structure problem
problem = active_space_trafo.transform(problem)
# construct the parity mapper with 2-qubit reduction
qubit_mapper = ParityMapper(num_particles=problem.num_particles)
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms.ground_state_solvers import GroundStateEigensolver
np_solver = NumPyMinimumEigensolver()
np_groundstate_solver = GroundStateEigensolver(qubit_mapper, np_solver)
np_result = np_groundstate_solver.solve(problem)
target_energy = np_result.total_energies[0]
print(np_result)
from qiskit.circuit.library import EfficientSU2
ansatz = EfficientSU2(num_qubits=4, reps=1, entanglement="linear", insert_barriers=True)
ansatz.decompose().draw("mpl", style="iqx")
import numpy as np
from qiskit.utils import algorithm_globals
# fix random seeds for reproducibility
np.random.seed(5)
algorithm_globals.random_seed = 5
from qiskit.algorithms.optimizers import SPSA
optimizer = SPSA(maxiter=100)
initial_point = np.random.random(ansatz.num_parameters)
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.primitives import Estimator
estimator = Estimator()
local_vqe = VQE(
estimator,
ansatz,
optimizer,
initial_point=initial_point,
)
local_vqe_groundstate_solver = GroundStateEigensolver(qubit_mapper, local_vqe)
local_vqe_result = local_vqe_groundstate_solver.solve(problem)
print(local_vqe_result)
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(group="open") # replace by your runtime provider
backend = provider.get_backend("ibmq_qasm_simulator") # select a backend that supports the runtime
from qiskit_nature.runtime import VQEClient
runtime_vqe = VQEClient(
ansatz=ansatz,
optimizer=optimizer,
initial_point=initial_point,
provider=provider,
backend=backend,
shots=1024,
measurement_error_mitigation=True,
) # use a complete measurement fitter for error mitigation
runtime_vqe_groundstate_solver = GroundStateEigensolver(qubit_mapper, runtime_vqe)
runtime_vqe_result = runtime_vqe_groundstate_solver.solve(problem)
print(runtime_vqe_result)
runtime_result = runtime_vqe_result.raw_result
history = runtime_result.optimizer_history
loss = history["energy"]
import matplotlib.pyplot as plt
plt.rcParams["font.size"] = 14
# plot loss and reference value
plt.figure(figsize=(12, 6))
plt.plot(loss + runtime_vqe_result.nuclear_repulsion_energy, label="Runtime VQE")
plt.axhline(y=target_energy + 0.2, color="tab:red", ls=":", label="Target + 200mH")
plt.axhline(y=target_energy, color="tab:red", ls="--", label="Target")
plt.legend(loc="best")
plt.xlabel("Iteration")
plt.ylabel("Energy [H]")
plt.title("VQE energy");
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/TuomasLe/Extended-basis-encoding-and-amplitude-encoding-algorithms-for-Qiskit
|
TuomasLe
|
from qiskit import IBMQ
IBMQ.load_account()
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.circuit.library.standard_gates import RYGate
from qiskit.circuit import Parameter
provider = IBMQ.load_account()
from qiskit import QuantumCircuit, IBMQ, execute, Aer, QuantumRegister, ClassicalRegister
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor,backend_overview
from qiskit.visualization import plot_histogram
import math
def parabola(l):
data_ = []
for i in range(l):
value = math.pow(l/2, 2) - math.pow(abs(i - l/2), 2)
print(value)
data_.append(value)
return data_
def sine(l):
data_ = []
for i in range(l):
value = 1 + math.sin(((i/(l/720)) / 180) * math.pi)
print(value)
data_.append(value)
return data_
def pi(l):
the_pi = "3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278865936153381827968230301952035301852968995773622599413891249721775283479131515574857242454150695950829533116861727855889075098381754637464939319255060400927701671139009848824012858361603563707660104710181942955596198946767"
data_ = []
for i in range(l):
value = int(the_pi[i])
data_.append(value)
return data_
def normalizeData(data_points):
divider = 0
sum = 0
print("Amplitudes: ")
for point in data_points:
divider += math.pow(point, 2)
divider = math.sqrt(divider)
normalized = []
for i in range(len(data_points)):
x = data_points[i] / divider
x2 = math.pow(data_points[i] / divider, 2)
print(round(x2, 3))
sum += x2
normalized.append(x)
return (normalized, divider)
def gen_angles(data):
if len(data) > 1:
new_length = int(len(data) / 2)
new_data = []
for k in range(new_length):
new_data.append(math.sqrt(math.pow(data[2*k], 2) + math.pow(data[2*k + 1], 2)))
#print("value")
#print(new_data)
inner_angles:List[float] = gen_angles(new_data)
angles = []
for k in range(len(new_data)):
if new_data[k] != 0:
inside = data[2*k + 1] / new_data[k]
print(round(inside, 4))
if (data[2*k] > 0):
angles.append(2 * math.asin(inside))
else:
angles.append(2 * math.pi - 2 * math.asin(inside))
else:
angles.append(0.0)
angles = inner_angles + angles
return angles
else:
return []
def getCtrlState(level, k):
ctrl_decimal = int(abs(k - (math.pow(2, level) - 1)))
ctrl_bin = str(bin(ctrl_decimal))
ctrl_str = ctrl_bin.split('b')[1].zfill(level)
ctrl_str = ''.join(reversed(ctrl_str)) ### Reverse because of Qiskit's most significant bit convention
return ctrl_str
### Main program
pi_result = True # change to true if using pi() function
data_length = 32 # this must be powers of two
data_points = pi(data_length) # 2^n long data vector, can also be changed manually or using the test functions
pair = normalizeData(data_points)
data = pair[0]
key = pair[1]
print("Key")
print(key)
print("")
print("Angles: ")
angles = gen_angles(data)
nqubits = int(math.log2(len(data_points)))
nclassical = nqubits
q = QuantumRegister(nqubits)
c = ClassicalRegister(nclassical)
circ = QuantumCircuit(q, c)
a = Parameter('a')
CCRY = RYGate(a).control(2, ctrl_state = '10') # example how to create multi-qubit controlled ry gate
print("Levels:")
for k in range(len(angles)):
j = 0
if (k > 0):
j = int(math.log2(k + 1)) # level in the binary tree
print(j)
if (j == 0):
circ.ry(angles[k], nqubits - 1 - j)
if (k == 1):
circ.cry(angles[k], nqubits - 1, nqubits - 1 - j, ctrl_state = 0)
elif(k == 2):
circ.cry(angles[k], nqubits - 1, nqubits - 1 - j, ctrl_state = 1)
elif(k > 2):
ctrl = getCtrlState(j, k)
CCRY = RYGate(angles[k]).control(j, ctrl_state = ctrl)
qubits = []
for i in range(j + 1):
qubits.append(nqubits - 1 - i)
circ.append(CCRY, qubits)
circ.barrier()
circ.measure(q, c)
circ.draw(output='mpl')
provider = IBMQ.get_provider()
provider.backends()
local_sim_backend = Aer.get_backend('qasm_simulator')
sim_backend = provider.get_backend('ibmq_qasm_simulator')
real_backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", real_backend)
print(real_backend)
job1 = execute(circ,local_sim_backend)
job2 = execute(circ,sim_backend)
job3 = execute(circ,real_backend)
job_monitor(job3)
counts1 = job1.result().get_counts()
counts2 = job2.result().get_counts()
counts3 = job3.result().get_counts()
test_job = job2 # the job which results get printed
test_counts = counts2 # the counts for the same job as above
shots = test_job.result().to_dict()["results"][0]["shots"]
time_taken = test_job.result().time_taken
print("Time taken: ", time_taken)
measured_results = []
binaries = sorted(test_counts.keys())
if (pi_result):
for dict_key in binaries:
binary_state = dict_key
print(binary_state, end = ' | ')
measured_result = math.sqrt(test_counts[''.join(binary_state)] / shots) * key
measured_results.append(measured_result)
print("%3.3f" % measured_result, end = ' \n')
str_result = ""
for k in range(len(measured_results)):
if (k == 0):
str_result = str_result + str(round(measured_results[k]))
str_result = str_result + "."
else:
str_result = str_result + str(round(measured_results[k]))
print(str_result)
legend = ['Local simulator', 'Remote simulator', 'Real processor']
circ.draw()
plot_histogram([counts1, counts2, counts3], legend=legend, bar_labels = True)
the_pi = "3.141592653589793238462643383279502884197169399"
|
https://github.com/jayeshparashar/Bloch-sphere-
|
jayeshparashar
|
from qiskit import *
import numpy as np
import math
from qiskit.visualization import plot_bloch_multivector, plot_state_qsphere, plot_histogram
# Define a function which will return a gate equivalent to (control-Z)^n, this gate is used in a below circuit to change
# the phase of control qubits by various powers of 2.
def CU_Z(power) :
circ = QuantumCircuit(2)
circ.cz(0,1)
Unitary = circ.to_gate()
ret_unitary = Unitary.power(power)
return ret_unitary
# Define a function which will return a gate equivalent to (control-RZ(pi))^n, it is used in below circuit to change
# the phase of control qubits by powers of 2, such that the control qubits carries the value of global phase introduced
# by a single RZ(pi) in fourier (phase) basis.
def CU_RZ(power) :
circ = QuantumCircuit(2)
circ.crz(np.pi, 0,1)
Unitary = circ.to_gate()
ret_unitary = Unitary.power(power)
return ret_unitary
# define a function that will convert the information from phase basis to computational basis
def inv_qft(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1) # you don't need this step if you apply control Ops on qubits in reversed order
for j in range(n):
for m in range(j):
circuit.cp(-math.pi/float(2**(j-m)), m, j)
circuit.h(j)
# Run a circuit to calculate global phase introduced by a Rz(pi) gate
nqubits = 3
qc = QuantumCircuit(nqubits + 1, nqubits)
qc.h(range(nqubits)) # set control qubits to phase basis
qc.x(nqubits) # comment this line to choose |0> eigen vector, it will not change the results
qc.append(CU_RZ(1), [0, nqubits]) # Kickback a phase introduced by Rz(pi) times 2^0 to 0th control qubit
qc.append(CU_RZ(2), [1, nqubits]) # Kickback the phase introduced by Rz(pi) times 2^1 to 1st control qubit
qc.append(CU_RZ(4), [2, nqubits]) # Kickback the phase introduced by Rz(pi) times 2^2 to 2nd control qubit
qc.draw()
# print qubits on Bloch sphere to witness the global phase introduced by a Rz(pi) rotation
bkend = Aer.get_backend('statevector_simulator')
job = execute(qc, bkend)
sv1 = job.result().get_statevector(qc)
#print(sv1)
plot_bloch_multivector(sv1)
# apply inverse qft to read convert infomration coded in phase basis to computational basis
inv_qft(qc, nqubits)
qc.measure(range(nqubits), range(nqubits))
qc.draw()
# Run circuit with qasm simulator or real quantum computer on cloud to obtain the value of global phase using IQFT
# We only have to measure first three qubits from LSB as the state on MSB qubit will remain unchanged
bkend = Aer.get_backend('qasm_simulator')
job = execute(qc, bkend, shots=100)
cnt1 = job.result().get_counts(qc)
print(cnt1)
max_val = max(cnt1, key=cnt1.get)
max_val_dec = int(max_val, 2)
print('Global Phase introduced by Rz(pi) gate is = ', (2*np.pi)/(2**nqubits) * max_val_dec, ' radians and ', (360/(2**nqubits) * max_val_dec), ' Degrees.')
plot_histogram(cnt1)
#### Lets run same routine with Z gate that rotate the state vector on bloch sphere by pi radians around Z axis
# Run below circuit to calculate the global phase introduced by Z gate
nqubits = 3
qc_z = QuantumCircuit(nqubits + 1, nqubits)
qc_z.h(range(nqubits))
qc_z.x(nqubits)
qc_z.append(CU_Z(1), [0, nqubits]) #Kickback the phase introduced by a Z gate times 2^0 to 0th control qubit
qc_z.append(CU_Z(2), [1, nqubits]) #Kickback a phase introduced by a Z gate times 2^1 to 0th control qubit
qc_z.append(CU_Z(4), [2, nqubits]) #Kickback a phase introduced by a Z gate times 2^2 to 0th control qubit
qc_z.draw()
# print qubits on Bloch Sphere to get the global phase introduced by a Z gate
bkend = Aer.get_backend('statevector_simulator')
job = execute(qc_z, bkend)
sv2 = job.result().get_statevector(qc_z)
#print(sv2)
plot_bloch_multivector(sv2)
# apply inverse qft to read convert information coded in phase basis to computational basis
inv_qft(qc_z, nqubits)
qc_z.measure(range(nqubits), range(nqubits))
qc_z.draw()
# Run circuit with qasm simulator or real quantum computer on cloud to extract and print the value of global phase
# using IQFT introduced by a Z gate, We only have to measure the first three qubits from LSB as the state on MSB qubit
# will remain unchanged
bkend = Aer.get_backend('qasm_simulator')
job = execute(qc_z, bkend, shots=100)
cnt2 = job.result().get_counts(qc_z)
print(cnt2)
max_val = max(cnt2, key=cnt2.get)
max_val_dec = int(max_val, 2)
print('Global Phase introduced by a Z gate is = ', (2*np.pi)/(2**nqubits) * max_val_dec, ' radians and ', (360/(2**nqubits) * max_val_dec), ' Degrees.')
plot_histogram(cnt2)
# end of program
|
https://github.com/kosakhro/QAOA-for-exact-cover
|
kosakhro
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
IBMQ.load_account()
matplotlib inline
my_provider = IBMQ.get_provider()
my_provider.backends()
simulator = my_provider.get_backend('ibmq_5_yorktown')
# Making the quantum circuit
def circuitI(gamma, beta, J, h1, h2):
qc = QuantumCircuit(2, 2)
qc.h([0, 1])
qc.h(1)
qc.cz(0,1)
qc.rx(2*gamma*J, 1)
qc.cz(0,1)
qc.h(1)
qc.i(0)
qc.rz(2*gamma*h1, 0)
qc.rz(2*gamma*h2, 1)
qc.rx(2*beta, 0)
qc.rx(2*beta, 1)
qc.measure([0,1], [0,1])
return qc
# Initializing the variables for C.
J = 0
h1 = -0.5
h2 = -0.5
#Setting the dimesions of the pasephase. The amount of simulated points = n**2
n = 61
p = np.pi/(n-1)
res = np.zeros([n, n, 4])
# Running a simulation for each point
for i in range(n):
qc_list = []
gamma = i*p
for j in range(n):
beta = j*p
qc = circuitI(gamma, beta, J, h1, h2)
qc_list.append(qc)
transpiled_circs = transpile(qc_list, backend=simulator)
job = execute(transpiled_circs, backend = simulator, shots=1000 )
for circ_index in range(len(transpiled_circs)):
counts = job.result().get_counts(qc_list[circ_index])
res[i][circ_index][:] = np.array([int(counts.get('00', 0)), int(counts.get('01', 0)), int(counts.get('10', 0)),
int(counts.get('11', 0))])
print(res)
#Draw the current circuit
qc.draw(output='mpl')
transpiled_circs[0].draw(output='mpl')
# Making a heatmap plot
sns.heatmap(res[:, :, 3])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
dc = pulse.DriveChannel
d0, d1, d2, d3, d4 = dc(0), dc(1), dc(2), dc(3), dc(4)
with pulse.build(name='pulse_programming_in') as pulse_prog:
pulse.play([1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], d0)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d1)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0], d2)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d3)
pulse.play([1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0], d4)
pulse_prog.draw()
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# You can reverse the order of the qubits.
from qiskit.quantum_info import DensityMatrix
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.t(1)
qc.s(0)
qc.cx(0,1)
matrix = DensityMatrix(qc)
plot_bloch_multivector(matrix, title='My Bloch Spheres', reverse_bits=True)
|
https://github.com/mcoggins96/Quantum-Computing-UK-Repository
|
mcoggins96
|
print('\nShor Code')
print('--------------')
from qiskit import QuantumRegister
from qiskit import ClassicalRegister
from qiskit import QuantumCircuit, execute,IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.enable_account(‘ENTER API KEY HERE')
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(1,'q')
c = ClassicalRegister(1,'c')
circuit = QuantumCircuit(q,c)
circuit.h(q[0])
####error here############
circuit.x(q[0])#Bit flip error
circuit.z(q[0])#Phase flip error
############################
circuit.h(q[0])
circuit.barrier(q)
circuit.measure(q[0],c[0])
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\n Uncorrected bit flip and phase error")
print("--------------------------------------")
print(counts)
#####Shor code starts here ########
q = QuantumRegister(9,'q')
c = ClassicalRegister(1,'c')
circuit = QuantumCircuit(q,c)
circuit.cx(q[0],q[3])
circuit.cx(q[0],q[6])
circuit.h(q[0])
circuit.h(q[3])
circuit.h(q[6])
circuit.cx(q[0],q[1])
circuit.cx(q[3],q[4])
circuit.cx(q[6],q[7])
circuit.cx(q[0],q[2])
circuit.cx(q[3],q[5])
circuit.cx(q[6],q[8])
circuit.barrier(q)
####error here############
circuit.x(q[0])#Bit flip error
circuit.z(q[0])#Phase flip error
############################
circuit.barrier(q)
circuit.cx(q[0],q[1])
circuit.cx(q[3],q[4])
circuit.cx(q[6],q[7])
circuit.cx(q[0],q[2])
circuit.cx(q[3],q[5])
circuit.cx(q[6],q[8])
circuit.ccx(q[1],q[2],q[0])
circuit.ccx(q[4],q[5],q[3])
circuit.ccx(q[8],q[7],q[6])
circuit.h(q[0])
circuit.h(q[3])
circuit.h(q[6])
circuit.cx(q[0],q[3])
circuit.cx(q[0],q[6])
circuit.ccx(q[6],q[3],q[0])
circuit.barrier(q)
circuit.measure(q[0],c[0])
circuit.draw(output='mpl',filename='shorcode.png') #Draws an image of the circuit
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\nShor code with bit flip and phase error")
print("----------------------------------------")
print(counts)
input()
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend=simulator).result()
statevector = result.get_statevector()
print(statevector)
%matplotlib inline
circuit.draw(output='mpl')
# bloch sphere
plot_bloch_multivector(statevector)
# measurement
circuit.measure([0],[0])
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=backend, shots=1024).result()
counts = result.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('unitary_simulator')
result = execute(circuit, backend=simulator).result()
unitary = result.get_unitary()
print(unitary)
%matplotlib inline
circuit.draw(output='mpl')
# bloch sphere
plot_bloch_multivector(unitary)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw, IQXDebugging
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc = transpile(qc, FakeBoeblingen(), layout_method='trivial')
sched = schedule(qc, FakeBoeblingen())
draw(sched, style=IQXDebugging(), backend=FakeBoeblingen())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver()
problem = driver.run()
print(problem)
from qiskit_nature.second_q.problems import ElectronicBasis
driver.run_pyscf()
problem = driver.to_problem(basis=ElectronicBasis.MO, include_dipole=True)
print(problem.basis)
ao_problem = driver.to_problem(basis=ElectronicBasis.AO)
print(ao_problem.basis)
from qiskit_nature.second_q.formats.qcschema_translator import qcschema_to_problem
qcschema = driver.to_qcschema()
ao_problem = qcschema_to_problem(qcschema, basis=ElectronicBasis.AO)
from qiskit_nature.second_q.formats.qcschema_translator import get_ao_to_mo_from_qcschema
basis_transformer = get_ao_to_mo_from_qcschema(qcschema)
mo_problem = basis_transformer.transform(ao_problem)
print(mo_problem.basis)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/bibscore/qiskit_kindergarten
|
bibscore
|
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.tools.monitor import job_monitor
import matplotlib as mpl
import numpy as np
# import basic plot tools
from qiskit.visualization import plot_histogram
# length of the n-bit string
n = 4
constant_oracle = QuantumCircuit(n+1)
constant_oracle.clear()
output = np.random.randint(2) # random no. 0/1 as output
if output == 1:
constant_oracle.x(n)
balance_oracle = QuantumCircuit(n+1)
balance_oracle.clear()
b_str = "1000"
# implementing x-gates
for i in range(len(b_str)):
if b_str[i] == '1':
balance_oracle.x(i)
balance_oracle.barrier()
# implementing cnot gates
for qubit in range(n):
balance_oracle.cx(qubit, n)
balance_oracle.barrier()
balance_oracle.draw()
# implemneting x-gates
for i in range (len(b_str)):
if b_str[i] == '1':
balance_oracle.x(i)
balance_oracle.barrier()
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit = dj_circuit.compose(constant_oracle)
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
dj_circuit.draw('mpl')
aer_sim = Aer.get_backend('aer_simulator') #Local Simulator
shots = 1024 #No. of times the circuit is running
qobj = assemble(dj_circuit, shots = shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# 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.
"""Test the EnlargeWithAncilla pass"""
import unittest
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.transpiler import Layout
from qiskit.transpiler.passes import EnlargeWithAncilla
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
class TestEnlargeWithAncilla(QiskitTestCase):
"""Tests the EnlargeWithAncilla pass."""
def setUp(self):
super().setUp()
self.qr3 = QuantumRegister(3, "qr")
circuit = QuantumCircuit(self.qr3)
circuit.h(self.qr3)
self.dag = circuit_to_dag(circuit)
def test_no_extension(self):
"""There are no virtual qubits to extend."""
layout = Layout({self.qr3[0]: 0, self.qr3[1]: 1, self.qr3[2]: 2})
pass_ = EnlargeWithAncilla()
pass_.property_set["layout"] = layout
after = pass_.run(self.dag)
qregs = list(after.qregs.values())
self.assertEqual(1, len(qregs))
self.assertEqual(self.qr3, qregs[0])
def test_with_extension(self):
"""There are 2 virtual qubit to extend."""
ancilla = QuantumRegister(2, "ancilla")
layout = Layout(
{0: self.qr3[0], 1: ancilla[0], 2: self.qr3[1], 3: ancilla[1], 4: self.qr3[2]}
)
layout.add_register(ancilla)
pass_ = EnlargeWithAncilla()
pass_.property_set["layout"] = layout
after = pass_.run(self.dag)
qregs = list(after.qregs.values())
self.assertEqual(2, len(qregs))
self.assertEqual(self.qr3, qregs[0])
self.assertEqual(ancilla, qregs[1])
if __name__ == "__main__":
unittest.main()
|
https://github.com/epelaaez/QuantumLibrary
|
epelaaez
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
from qiskit.extensions import Initialize
from qiskit.ignis.verification import marginal_counts
from qiskit.quantum_info import random_statevector
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
## SETUP
# Protocol uses 3 qubits and 2 classical bits in 2 different registers
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical bits
crx = ClassicalRegister(1, name="crx") # in 2 different registers
teleportation_circuit = QuantumCircuit(qr, crz, crx)
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a,b)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, psi, a):
qc.cx(psi, a)
qc.h(psi)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
"""Measures qubits a & b and 'sends' the results to Bob"""
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
measure_and_send(teleportation_circuit, 0 ,1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1) # Apply gates if the registers
qc.z(qubit).c_if(crz, 1) # are in the state '1'
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
## STEP 3
measure_and_send(teleportation_circuit, 0, 1)
## STEP 4
teleportation_circuit.barrier() # Use barrier to separate steps
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
# Create random 1-qubit state
psi = random_statevector(2)
# Display it nicely
display(array_to_latex(psi, prefix="|\\psi\\rangle ="))
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
## STEP 0
# First, let's initialize Alice's q0
qc.append(init_gate, [0])
qc.barrier()
## STEP 1
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
## STEP 2
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
## STEP 3
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
## STEP 4
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
# Display the circuit
qc.draw()
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw('mpl')
|
https://github.com/sanori/quantum-docker
|
sanori
|
import cirq
cirq.__version__
import cirq_google
print(cirq_google.Sycamore23)
from cirq.contrib.svg import SVGCircuit
# Create a circuit to generate a Bell State:
# sqrt(2) * ( |00> + |11> )
bell_circuit = cirq.Circuit()
q0, q1 = cirq.LineQubit.range(2)
bell_circuit.append(cirq.H(q0))
bell_circuit.append(cirq.CNOT(q0,q1))
SVGCircuit(bell_circuit)
# Initialize Simulator
s=cirq.Simulator()
# Simulate the circuit
results=s.simulate(bell_circuit)
print(results)
# For sampling, we need to add a measurement at the end
bell_circuit.append(cirq.measure(q0, q1, key='result'))
# Sample the circuit
samples=s.run(bell_circuit, repetitions=1000)
# Print a histogram of results
print(samples.histogram(key='result'))
SVGCircuit(bell_circuit)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2020.
#
# 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.
"""Test the functional Pauli rotations."""
import unittest
from collections import defaultdict
import numpy as np
from ddt import ddt, data, unpack
from qiskit.test.base import QiskitTestCase
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import (
LinearPauliRotations,
PolynomialPauliRotations,
PiecewiseLinearPauliRotations,
)
@ddt
class TestFunctionalPauliRotations(QiskitTestCase):
"""Test the functional Pauli rotations."""
def assertFunctionIsCorrect(self, function_circuit, reference):
"""Assert that ``function_circuit`` implements the reference function ``reference``."""
num_state_qubits = function_circuit.num_qubits - function_circuit.num_ancillas - 1
num_ancilla_qubits = function_circuit.num_ancillas
circuit = QuantumCircuit(num_state_qubits + 1 + num_ancilla_qubits)
circuit.h(list(range(num_state_qubits)))
circuit.append(function_circuit.to_instruction(), list(range(circuit.num_qubits)))
backend = BasicAer.get_backend("statevector_simulator")
statevector = execute(circuit, backend).result().get_statevector()
probabilities = defaultdict(float)
for i, statevector_amplitude in enumerate(statevector):
i = bin(i)[2:].zfill(circuit.num_qubits)[num_ancilla_qubits:]
probabilities[i] += np.real(np.abs(statevector_amplitude) ** 2)
unrolled_probabilities = []
unrolled_expectations = []
for i, probability in probabilities.items():
x, last_qubit = int(i[1:], 2), i[0]
if last_qubit == "0":
expected_amplitude = np.cos(reference(x)) / np.sqrt(2**num_state_qubits)
else:
expected_amplitude = np.sin(reference(x)) / np.sqrt(2**num_state_qubits)
unrolled_probabilities += [probability]
unrolled_expectations += [np.real(np.abs(expected_amplitude) ** 2)]
np.testing.assert_almost_equal(unrolled_probabilities, unrolled_expectations)
@data(
([1, 0.1], 3),
([0, 0.4, 2], 2),
([1, 0.5, 0.2, -0.2, 0.4, 2.5], 5),
)
@unpack
def test_polynomial_function(self, coeffs, num_state_qubits):
"""Test the polynomial rotation."""
def poly(x):
res = sum(coeff * x**i for i, coeff in enumerate(coeffs))
return res
polynome = PolynomialPauliRotations(num_state_qubits, [2 * coeff for coeff in coeffs])
self.assertFunctionIsCorrect(polynome, poly)
def test_polynomial_rotations_mutability(self):
"""Test the mutability of the linear rotations circuit."""
polynomial_rotations = PolynomialPauliRotations()
with self.subTest(msg="missing number of state qubits"):
with self.assertRaises(AttributeError): # no state qubits set
print(polynomial_rotations.draw())
with self.subTest(msg="default setup, just setting number of state qubits"):
polynomial_rotations.num_state_qubits = 2
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: x / 2)
with self.subTest(msg="setting non-default values"):
polynomial_rotations.coeffs = [0, 1.2 * 2, 0.4 * 2]
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: 1.2 * x + 0.4 * x**2)
with self.subTest(msg="changing of all values"):
polynomial_rotations.num_state_qubits = 4
polynomial_rotations.coeffs = [1 * 2, 0, 0, -0.5 * 2]
self.assertFunctionIsCorrect(polynomial_rotations, lambda x: 1 - 0.5 * x**3)
@data(
(2, 0.1, 0),
(4, -2, 2),
(1, 0, 0),
)
@unpack
def test_linear_function(self, num_state_qubits, slope, offset):
"""Test the linear rotation arithmetic circuit."""
def linear(x):
return offset + slope * x
linear_rotation = LinearPauliRotations(num_state_qubits, slope * 2, offset * 2)
self.assertFunctionIsCorrect(linear_rotation, linear)
def test_linear_rotations_mutability(self):
"""Test the mutability of the linear rotations circuit."""
linear_rotation = LinearPauliRotations()
with self.subTest(msg="missing number of state qubits"):
with self.assertRaises(AttributeError): # no state qubits set
print(linear_rotation.draw())
with self.subTest(msg="default setup, just setting number of state qubits"):
linear_rotation.num_state_qubits = 2
self.assertFunctionIsCorrect(linear_rotation, lambda x: x / 2)
with self.subTest(msg="setting non-default values"):
linear_rotation.slope = -2.3 * 2
linear_rotation.offset = 1 * 2
self.assertFunctionIsCorrect(linear_rotation, lambda x: 1 - 2.3 * x)
with self.subTest(msg="changing all values"):
linear_rotation.num_state_qubits = 4
linear_rotation.slope = 0.2 * 2
linear_rotation.offset = 0.1 * 2
self.assertFunctionIsCorrect(linear_rotation, lambda x: 0.1 + 0.2 * x)
@data(
(1, [0], [1], [0]),
(2, [0, 2], [-0.5, 1], [2, 1]),
(3, [0, 2, 5], [1, 0, -1], [0, 2, 2]),
(2, [1, 2], [1, -1], [2, 1]),
(3, [0, 1], [1, 0], [0, 1]),
)
@unpack
def test_piecewise_linear_function(self, num_state_qubits, breakpoints, slopes, offsets):
"""Test the piecewise linear rotations."""
def pw_linear(x):
for i, point in enumerate(reversed(breakpoints)):
if x >= point:
return offsets[-(i + 1)] + slopes[-(i + 1)] * (x - point)
return 0
pw_linear_rotations = PiecewiseLinearPauliRotations(
num_state_qubits,
breakpoints,
[2 * slope for slope in slopes],
[2 * offset for offset in offsets],
)
self.assertFunctionIsCorrect(pw_linear_rotations, pw_linear)
def test_piecewise_linear_rotations_mutability(self):
"""Test the mutability of the linear rotations circuit."""
pw_linear_rotations = PiecewiseLinearPauliRotations()
with self.subTest(msg="missing number of state qubits"):
with self.assertRaises(AttributeError): # no state qubits set
print(pw_linear_rotations.draw())
with self.subTest(msg="default setup, just setting number of state qubits"):
pw_linear_rotations.num_state_qubits = 2
self.assertFunctionIsCorrect(pw_linear_rotations, lambda x: x / 2)
with self.subTest(msg="setting non-default values"):
pw_linear_rotations.breakpoints = [0, 2]
pw_linear_rotations.slopes = [-1 * 2, 1 * 2]
pw_linear_rotations.offsets = [0, -1.2 * 2]
self.assertFunctionIsCorrect(
pw_linear_rotations, lambda x: -1.2 + (x - 2) if x >= 2 else -x
)
with self.subTest(msg="changing all values"):
pw_linear_rotations.num_state_qubits = 4
pw_linear_rotations.breakpoints = [1, 3, 6]
pw_linear_rotations.slopes = [-1 * 2, 1 * 2, -0.2 * 2]
pw_linear_rotations.offsets = [0, -1.2 * 2, 2 * 2]
def pw_linear(x):
if x >= 6:
return 2 - 0.2 * (x - 6)
if x >= 3:
return -1.2 + (x - 3)
if x >= 1:
return -(x - 1)
return 0
self.assertFunctionIsCorrect(pw_linear_rotations, pw_linear)
if __name__ == "__main__":
unittest.main()
|
https://github.com/epelaaez/QuantumLibrary
|
epelaaez
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from grader import *
language(False)
phi_plus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(phi_plus, backend).result().get_statevector()
array_to_latex(result)
phi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
phi_minus.draw('mpl')
# This cell will tell you if what you did gives the correct result.
# Just take it as an indication, the tests do not take into consideration every possible option
# If you think that your answer is (in)correct and the grader says different, just ask me please
# Don't try to tamper with the code, please :)
ex1_grader(phi_minus)
psi_plus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
psi_plus.draw('mpl')
ex2_grader(psi_plus)
psi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
psi_minus.draw('mpl')
ex3_grader(psi_minus)
GHZ = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
GHZ.draw('mpl')
ex4_grader(GHZ)
Even = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
Even.draw('mpl')
ex5_grader(Even)
Odd = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
Odd.draw('mpl')
ex6_grader(Odd)
def measure_z_axis(qc, qubit, cbit): #Measurements have to be saved in classical bits
qc.measure(qubit, cbit)
def measure_x_axis(qc, qubit, cbit):
##### ==================================
# Write your solution in here.
##### ==================================
ex7_grader(measure_x_axis)
def expectation_value_single_qubit(qc, nshots=8092):
# Run the given circuit that is already measuring the selected basis
backend_shots = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend_shots, shots=nshots).result().get_counts() #Counts is a dictionary that contains the number of zeros and the number of ones measured
# This is just to make things easier in your solution
if '1' not in counts.keys():
counts['1'] = 0
if '0' not in counts.keys():
counts['0'] = 0
# Get the number of times that 0 and 1 were measured
n_zeros = counts['0']
n_ones = counts['1']
# Compute the probabilities
p_0 = n_zeros/nshots
p_1 = n_ones/nshots #OR 1-p_0
expectation_value = 1*p_0+(-1)*p_1
return expectation_value
# Measure <Z> over a state that you like
qc_z = QuantumCircuit(1,1)
measure_z_axis(qc_z, 0, 0)
print('<Z>=', expectation_value_single_qubit(qc_z))
qc_z.draw('mpl')
# Measure <X> over a state that you like
qc_x = QuantumCircuit(1,1)
measure_x_axis(qc_x, 0, 0)
print('<X>=', expectation_value_single_qubit(qc_x))
qc_x.draw('mpl')
##### ==================================
# Write your solution in here.
# Create bell state circuit
# For each of the operators that we want to measure (ZZ, ZX, XZ and XX) create a new circuit (maybe using qc.copy())
# that measures along that axis.
chsh_circuits = []
##### ==================================
chsh_circuits[0].draw('mpl')
chsh_circuits[1].draw('mpl')
chsh_circuits[2].draw('mpl')
chsh_circuits[3].draw('mpl')
# I couldn't come up with tests that would not give the answer away if you looked at the code so you are on your own here!
# We can run all the circuits at the same time and then post process the data
nshots = 8092 # The more shots, the less error
backend_shots = Aer.get_backend('qasm_simulator')
counts_list = execute(chsh_circuits, backend_shots, shots=nshots).result().get_counts()
counts_list
##### ==================================
# Write your solution in here.
# For each of the circuits, take the counts that you got from that circuit, compute the probability
# of each state and combine them together being very careful of which sign goes with which term
# You might want to take some inspiration from the function expectation_value_single_qubit
# If you are completely lost and don't know how to solve this, just ask
##### ==================================
# If you don't know if your answer is correct you can compute the results by hand
# (it's probably easier than doing this) and check if everything is working
##### ==================================
# Write your solution in here.
exp_AB =
exp_Ab =
exp_aB =
exp_ab =
CHSH =
##### ==================================
print('Your result is <CHSH>=', CHSH)
print('The correct result is <CHSH>=', 2*np.sqrt(2))
##### ==================================
# Write your solution in here.
Can_entanglement_be_teleported = #Write True or False :D
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
Where_did_the_bell_pair_go = 'Write where you think they went'
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
##### ==================================
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from sklearn.datasets import load_iris
iris_data = load_iris()
print(iris_data.DESCR)
features = iris_data.data
labels = iris_data.target
from sklearn.preprocessing import MinMaxScaler
features = MinMaxScaler().fit_transform(features)
import pandas as pd
import seaborn as sns
df = pd.DataFrame(iris_data.data, columns=iris_data.feature_names)
df["class"] = pd.Series(iris_data.target)
sns.pairplot(df, hue="class", palette="tab10")
from sklearn.model_selection import train_test_split
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 123
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=0.8, random_state=algorithm_globals.random_seed
)
from sklearn.svm import SVC
svc = SVC()
_ = svc.fit(train_features, train_labels) # suppress printing the return value
train_score_c4 = svc.score(train_features, train_labels)
test_score_c4 = svc.score(test_features, test_labels)
print(f"Classical SVC on the training dataset: {train_score_c4:.2f}")
print(f"Classical SVC on the test dataset: {test_score_c4:.2f}")
from qiskit.circuit.library import ZZFeatureMap
num_features = features.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
feature_map.decompose().draw(output="mpl", fold=20)
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
ansatz.decompose().draw(output="mpl", fold=20)
from qiskit.algorithms.optimizers import COBYLA
optimizer = COBYLA(maxiter=100)
from qiskit.primitives import Sampler
sampler = Sampler()
from matplotlib import pyplot as plt
from IPython.display import clear_output
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
import time
from qiskit_machine_learning.algorithms.classifiers import VQC
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(train_features, train_labels)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q4 = vqc.score(train_features, train_labels)
test_score_q4 = vqc.score(test_features, test_labels)
print(f"Quantum VQC on the training dataset: {train_score_q4:.2f}")
print(f"Quantum VQC on the test dataset: {test_score_q4:.2f}")
from sklearn.decomposition import PCA
features = PCA(n_components=2).fit_transform(features)
plt.rcParams["figure.figsize"] = (6, 6)
sns.scatterplot(x=features[:, 0], y=features[:, 1], hue=labels, palette="tab10")
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=0.8, random_state=algorithm_globals.random_seed
)
svc.fit(train_features, train_labels)
train_score_c2 = svc.score(train_features, train_labels)
test_score_c2 = svc.score(test_features, test_labels)
print(f"Classical SVC on the training dataset: {train_score_c2:.2f}")
print(f"Classical SVC on the test dataset: {test_score_c2:.2f}")
num_features = features.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
optimizer = COBYLA(maxiter=40)
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
# make the objective function plot look nicer.
plt.rcParams["figure.figsize"] = (12, 6)
start = time.time()
vqc.fit(train_features, train_labels)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q2_ra = vqc.score(train_features, train_labels)
test_score_q2_ra = vqc.score(test_features, test_labels)
print(f"Quantum VQC on the training dataset using RealAmplitudes: {train_score_q2_ra:.2f}")
print(f"Quantum VQC on the test dataset using RealAmplitudes: {test_score_q2_ra:.2f}")
from qiskit.circuit.library import EfficientSU2
ansatz = EfficientSU2(num_qubits=num_features, reps=3)
optimizer = COBYLA(maxiter=40)
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(train_features, train_labels)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q2_eff = vqc.score(train_features, train_labels)
test_score_q2_eff = vqc.score(test_features, test_labels)
print(f"Quantum VQC on the training dataset using EfficientSU2: {train_score_q2_eff:.2f}")
print(f"Quantum VQC on the test dataset using EfficientSU2: {test_score_q2_eff:.2f}")
print(f"Model | Test Score | Train Score")
print(f"SVC, 4 features | {train_score_c4:10.2f} | {test_score_c4:10.2f}")
print(f"VQC, 4 features, RealAmplitudes | {train_score_q4:10.2f} | {test_score_q4:10.2f}")
print(f"----------------------------------------------------------")
print(f"SVC, 2 features | {train_score_c2:10.2f} | {test_score_c2:10.2f}")
print(f"VQC, 2 features, RealAmplitudes | {train_score_q2_ra:10.2f} | {test_score_q2_ra:10.2f}")
print(f"VQC, 2 features, EfficientSU2 | {train_score_q2_eff:10.2f} | {test_score_q2_eff:10.2f}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc = transpile(qc, FakeBoeblingen(), layout_method='trivial')
sched = schedule(qc, FakeBoeblingen())
draw(sched, backend=FakeBoeblingen())
|
https://github.com/qiskit-community/qopt-best-practices
|
qiskit-community
|
from demo_src.graph import generate_demo_graph, draw_graph
demo_graph = generate_demo_graph()
draw_graph(demo_graph)
from demo_src.map import map_graph_to_qubo
qubo = map_graph_to_qubo(demo_graph)
print(qubo.prettyprint())
from demo_src.map import map_qubo_to_ising
cost_hamiltonian, offset = map_qubo_to_ising(qubo)
print("Offset:", offset)
print("Cost Function Hamiltonian:", cost_hamiltonian)
from demo_src.map import map_ising_to_circuit
circuit = map_ising_to_circuit(cost_hamiltonian, num_layers=1)
circuit.draw('mpl')
circuit.parameters
# IBM Quantum devices are named after cities
# For the purpose of the first part of this demo, we will
# use a simulated device from the "fake_provider"
from qiskit_ibm_runtime.fake_provider import FakeVigoV2
backend = FakeVigoV2()
from demo_src.transpile import optimize_circuit
opt_circuit = optimize_circuit(circuit, backend)
opt_circuit.draw('mpl', fold=False)
optimal_gamma = 5.11350346
optimal_beta = 5.52673212
candidate_circuit = opt_circuit.assign_parameters([optimal_gamma, optimal_beta])
candidate_circuit.draw('mpl', fold=False)
# For the purpose of the first part of this demo, we will
# use a simulated device from the "fake_provider"
from qiskit_ibm_runtime.fake_provider import FakeVigoV2
from qiskit.primitives import BackendSampler
backend = FakeVigoV2()
sampler = BackendSampler(backend=backend)
final_distribution = sampler.run(candidate_circuit, shots=int(1e4)).result().quasi_dists[0]
print(final_distribution)
from demo_src.post import sample_most_likely
best_result = sample_most_likely(final_distribution, len(demo_graph))
print("Result bitstring:", best_result)
from demo_src.post import plot_distribution
plot_distribution(final_distribution)
from demo_src.post import plot_result
plot_result(demo_graph, best_result)
with open("data/125node_example.lp", "r") as file:
problem = file.read()
print(problem)
with open("data/125node_example_ising.txt") as input_file:
for _ in range(10):
print(str(next(input_file)).replace("\n", ""))
team = 1 # Fill in your team here, either 1 or 2
from qiskit import qpy # QPY is the circuit serializer in Qiskit.
# Load the circuits
if team == 1:
backend_type = "eagle"
elif team == 2:
backend_type = "heron"
else:
raise ValueError("team should be 1 or 2.")
# Depth zero-circuit
with open(f"data/125node_{backend_type}_depth_zero.qpy", "rb") as fd:
depth_zero_circuit = qpy.load(fd)[0]
# Depth one-circuit
with open(f"data/125node_{backend_type}_depth_one.qpy", "rb") as fd:
depth_one_circuit = qpy.load(fd)[0]
depth_one_circuit.draw('mpl', fold=False)
from qiskit_ibm_runtime import QiskitRuntimeService
# QiskitRuntimeService.save_account(channel="ibm_quantum", token="<MY_IBM_QUANTUM_TOKEN>", overwrite=True, set_as_default=True)
if team == 1:
# Eagle = Osaka
service = QiskitRuntimeService(channel='ibm_quantum')
backend = service.get_backend('ibm_osaka')
elif team == 2:
# Heron = Torino
service = QiskitRuntimeService(channel='ibm_quantum')
backend = service.get_backend('ibm_torino')
from qiskit_ibm_runtime import Sampler, Options
# Since we have already done the transpilation we can skip it.
options = Options()
options.transpilation.skip_transpilation = True
sampler = Sampler(backend=backend, options=options)
depth_one_circuit.parameters
depth_one_bound_circuit = depth_one_circuit.assign_parameters([0.3927, 0.3927], inplace=False)
#sampler_job = sampler.run([depth_one_bound_circuit, depth_zero_circuit])
#sampler_job.job_id()
#sampler_job.status()
from demo_src.run import save_result
# save_result(sampler_job.result(), backend_type, path="sampler_data")
from demo_src.post import load_data, samples_to_objective_values, load_qp, plot_cdf
import matplotlib.pyplot as plt
qp, max_cut, min_cut = load_qp()
depth_one_heron, depth_zero_heron, depth_one_eagle, depth_zero_eagle = load_data(qp)
if team == 1:
depth_zero = depth_zero_eagle
depth_one = depth_one_eagle
elif team ==2:
depth_zero = depth_zero_heron
depth_one = depth_one_heron
fig, ax = plt.subplots(1, 1)
plot_cdf(depth_zero, depth_one, max_cut, min_cut, ax, "Approximation ratio:")
fig, ax = plt.subplots(1, 2, figsize=(15, 6))
plot_cdf(depth_zero_eagle, depth_one_eagle, max_cut, min_cut, ax[0], "Approximation ratio Eagle:")
plot_cdf(depth_zero_heron, depth_one_heron, max_cut, min_cut, ax[1], "Approximation ratio Heron:")
|
https://github.com/KathrinKoenig/QuantumTopologicalDataAnalysis
|
KathrinKoenig
|
import numpy as np
import qtda_module as qtda
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from scipy.spatial import distance_matrix
from qiskit import ClassicalRegister, Aer, execute
def generate_circles():
phi_values = np.linspace(0, 2*np.pi, 10)
small_circle = [[np.cos(phi), np.sin(phi)] for phi in phi_values]
phi_values = np.linspace(0, 2*np.pi, 12)
large_circle = [[3 + 2*np.cos(phi), 2*np.sin(phi)] for phi in phi_values]
return np.array(small_circle + large_circle)
point_data = generate_circles()
plt.scatter(point_data[:,0], point_data[:,1])
# alternatively a distance matrix (here generated from the point data for exemplification)
# can be used
dist_mat = distance_matrix(point_data, point_data)
filtration = qtda.DataFiltration(
data=point_data,
# distance_matrix=dist_mat,
max_dimension=4,
max_edge_length=10
)
filtration.plot_persistence_diagram()
n_vertices = 4 # number of qubits to represent the simplicial complex
num_eval_qubits = 5 # number of numerical evaluation qubits for the QPE algorithm
S0 = [(0,0,0,1),(0,0,1,0), (0,1,0,0),(1,0,0,0)] # 0-simplex: points in the graph
S1 = [(0,0,1,1),(0,1,1,0),(1,1,0,0),(1,0,0,1),(1,0,1,0)] # 1-simplex: connection lines between points
S2 = [(1,0,1,1)] # 2-simplex: filled triangle
S3 = []
state_dict = {0: S0, 1: S1, 2: S2, 3: S3}
k = 1 # order of the combinatorial Laplacian
qc = qtda.QTDAalgorithm(num_eval_qubits, k, state_dict)
qc.draw('mpl')
qc.add_register(ClassicalRegister(num_eval_qubits)) #add classical register to measure evaluation qubits
for q in qc.eval_qubits:
qc.measure(q,q)
shots = 1000
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=shots)
counts = job.result().get_counts(qc)
dim = len(state_dict[1]) # dimension of 1-simplex space
prob = counts.get("0"*num_eval_qubits)/shots # probability of eigenvalue 0
print('The number of 1-holes is', dim * prob)
plot_histogram(counts)
shots = 1000
num_eval_qubits = 10
data = qtda.Q_top_spectra(state_dict, num_eval_qubits, shots)
spectra = data.get_spectra()
for top_order in spectra.keys():
print()
print('Topological order: ', top_order)
print('Number of holes: ', spectra[top_order][0.0])
print('Dimension of the k-simplex subspace: ', len(data.state_dict[top_order]))
print('Eigenvalues of the combinatorial laplacian with dimension of corresponding eigenspaces: ')
print(spectra[top_order])
display(plot_histogram(data.get_counts()[top_order]))
n_vertices = 4
S0 = [(0,0,0,1),(0,0,1,0), (0,1,0,0),(1,0,0,0)]
S1 = [(0,0,1,1),(0,1,1,0),(1,1,0,0),(1,0,0,1),(1,0,1,0)]
S2 = []
S3 = []
state_dict = {0: S0, 1: S1, 2: S2, 3: S3}
shots = 1000
num_eval_qubits = 10
data = qtda.Q_top_spectra(state_dict, num_eval_qubits, shots)
spectra = data.get_spectra()
for top_order in spectra.keys():
print()
print('Topological order: ', top_order)
print('Number of holes: ', spectra[top_order][0.0])
print('Dimension of the k-simplex subspace: ', len(data.state_dict[top_order]))
print('Eigenvalues of the combinatorial laplacian with dimension of corresponding eigenspaces: ')
print(spectra[top_order])
display(plot_histogram(data.get_counts()[top_order]))
import qiskit
qiskit.__qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.problems import BaseProblem
dummy_hamiltonian = None
base_problem = BaseProblem(dummy_hamiltonian)
print(base_problem.properties)
from qiskit_nature.second_q.properties import AngularMomentum
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Adding AngularMomentum to problem.properties...")
base_problem.properties.add(AngularMomentum(2))
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Discarding AngularMomentum from problem.properties...")
base_problem.properties.discard(AngularMomentum)
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
from qiskit_nature.second_q.drivers import PySCFDriver
es_problem = PySCFDriver().run()
print(es_problem.properties.particle_number)
print(es_problem.properties.angular_momentum)
print(es_problem.properties.magnetization)
print(es_problem.properties.electronic_dipole_moment)
print(es_problem.properties.electronic_density)
from qiskit_nature.second_q.properties import ElectronicDensity
density = ElectronicDensity.from_orbital_occupation(
es_problem.orbital_occupations,
es_problem.orbital_occupations_b,
)
es_problem.properties.electronic_density = density
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/intrinsicvardhan/QuantumComputingAlgos
|
intrinsicvardhan
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import *
from ibm_quantum_widgets import *
# qiskit-ibmq-provider has been deprecated.
# Please see the Migration Guides in https://ibm.biz/provider_migration_guide for more detail.
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options
# Loading your IBM Quantum account(s)
service = QiskitRuntimeService(channel="ibm_quantum")
# Invoke a primitive. For more details see https://docs.quantum.ibm.com/run/primitives
# result = Sampler().run(circuits).result()
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1,0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set(msg).issubset({"0","1"}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1,0)
qc.h(1)
return qc
# Charlie creates the entangled pair between Alice and Bob
qc = create_bell_pair()
# We'll add a barrier for visual separation
qc.barrier()
message = '11'
qc = encode_message(qc, 1, message)
qc.barrier()
# Alice then sends her qubit to Bob.
# After receiving qubit 0, Bob applies the recovery protocol:
qc = decode_message(qc)
# Finally, Bob measures his qubits to read Alice's message
qc.measure_all()
# Draw our output
qc.draw()
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qreg_q = QuantumRegister(3, 'q')
creg_c0 = ClassicalRegister(1, 'c0')
creg_c1 = ClassicalRegister(1, 'c1')
creg_c2 = ClassicalRegister(1, 'c2')
circuit = QuantumCircuit(qreg_q, creg_c0, creg_c1, creg_c2)
#quantum teleportation example
circuit.u(0.3, 0.2, 0.1, qreg_q[0])
#creating the first qubit change the values of theta, phi and lambda to create a different qubit
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.barrier(qreg_q)
circuit.cx(qreg_q[0], qreg_q[1])
circuit.h(qreg_q[0])
circuit.measure(qreg_q[0], creg_c0[0])
circuit.measure(qreg_q[1], creg_c1[0])
circuit.z(qreg_q[2]).c_if(creg_c0, 1)
circuit.x(qreg_q[2]).c_if(creg_c1, 1)
circuit.measure(qreg_q[2], creg_c2[0])
circuit.draw()
from qiskit_aer import Aer, AerSimulator
from qiskit.compiler import assemble
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.cx(0,1)
qc.h(0)
qc.h(1)
display(qc.draw())
qc.save_unitary()
usim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
qc.cx(1,0)
display(qc.draw())
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
qc.cp(pi/4, 0, 1)
display(qc.draw())
# See Results:
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Controlled-T} = \n")
|
https://github.com/HuangJunye/Qiskit-for-GameDev
|
HuangJunye
|
string qasmStr = ""
qasmStr
print(qasmStr)
|
https://github.com/mspronesti/qlearnkit
|
mspronesti
|
import logging
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
logger = logging.getLogger(__name__)
def _map_function(x):
r"""
We map data feature values to :math:`\theta` and :math:`\phi` values using
the following eqaution:
.. math:: \phi = (x + 1) \frac{\pi}{2}
where :math:`\phi` is the phase and :math:`\theta` the angle
"""
return (x + 1) * np.pi / 2
def _map_features(input_point,
centroids,
n_centroids: int):
r"""
Map the input point and the centroids to :math:`\theta` and :math:`\phi` values
via the :func:`_map_function` method.
Args:
input_point:
Input point to map.
centroids:
Array of points to map.
n_centroids:
Number of centroids.
Returns:
Tuple containing input point and centroids mapped.
"""
phi_centroids_list = []
theta_centroids_list = []
phi_input = _map_function(input_point[0])
theta_input = _map_function(input_point[1])
for i in range(0, n_centroids):
phi_centroids_list.append(_map_function(centroids[i][0]))
theta_centroids_list.append(_map_function(centroids[i][1]))
return phi_input, theta_input, phi_centroids_list, theta_centroids_list
def construct_circuit(input_point: np.ndarray,
centroids: np.ndarray,
k: int) -> QuantumCircuit:
"""
Apply a Hadamard to the ancillary qubit and our mapped data points.
Encode data points using U3 gate.
Perform controlled swap to entangle the state with the ancillary qubit
Apply another Hadamard gate to the ancillary qubit.
.. parsed-literal::
┌───┐ ┌───┐
|0anc>: ┤ H ├────────────■──────┤ H ├────────M
└───┘ | └───┘
┌───┐ ┌────┐ |
|0>: ───┤ H ├───┤ U3 ├───X──────────
└───┘ └────┘ |
┌───┐ ┌────┐ |
|0>: ───┤ H ├───┤ U3 ├───X──────────
└───┘ └────┘
Args:
input_point:
Input point from which calculate the distance.
centroids:
Array of points representing the centroids to calculate
the distance to
k:
Number of centroids
Returns:
The quantum circuit created
"""
phi_input, theta_input, phi_centroids_list, theta_centroids_list = \
_map_features(input_point, centroids, k)
# We need 3 quantum registers, of size k one for a data point (input),
# one for each centroid and one for each ancillary
qreg_input = QuantumRegister(k, name='qreg_input')
qreg_centroid = QuantumRegister(k, name='qreg_centroid')
qreg_psi = QuantumRegister(k, name='qreg_psi')
# Create a k bit ClassicalRegister to hold the result
# of the measurements
creg = ClassicalRegister(k, 'creg')
# Create the quantum circuit containing our registers
qc = QuantumCircuit(qreg_input, qreg_centroid, qreg_psi, creg, name='qc')
for i in range(0, k):
# Apply Hadamard
qc.h(qreg_psi[i])
qc.h(qreg_input[i])
qc.h(qreg_centroid[i])
# Encode new point and centroid
qc.u(theta_input, phi_input, 0, qreg_input[i])
qc.u(theta_centroids_list[i], phi_centroids_list[i], 0, qreg_centroid[i])
# Perform controlled swap
qc.cswap(qreg_psi[i], qreg_input[i], qreg_centroid[i])
# Apply second Hadamard to ancillary
qc.h(qreg_psi[i])
# Measure ancillary
qc.measure(qreg_psi[i], creg[i])
return qc
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import BasicAer, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 0)
qc.x(0).c_if(cr, 0)
qc.measure(0, 0)
qc.draw('mpl')
|
https://github.com/hritiksauw199/Qiskit-textbook-solutions
|
hritiksauw199
|
import numpy as np
from numpy import pi
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
def qft_rotations(circuit, n):
if n == 0: # Exit function if circuit is empty
return circuit
n -= 1 # Indexes start from 0
circuit.h(n) # Apply the H-gate to the most significant qubit
for qubit in range(n):
# For each less significant qubit, we need to do a
# smaller-angled controlled rotation:
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
# Putting the qubit in the state |4>
nqubits = 3
number = 4
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
qc.p(number*pi/4,0)
qc.p(number*pi/2,1)
qc.p(number*pi,2)
qc.draw()
qc_init = qc.copy()
qc_init.save_statevector()
sim = Aer.get_backend("aer_simulator")
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qc = inverse_qft(qc, nqubits)
qc.measure_all()
qc.draw()
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to nqubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
shots = 1024
transpiled_qc = transpile(qc, backend, optimization_level=3)
job = backend.run(transpiled_qc, shots=shots)
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
# Putting the qubit in the state |4>
nqubits = 3
number = 3
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
qc.p(number*pi/4,0)
qc.p(number*pi/2,1)
qc.p(number*pi,2)
qc.draw()
qc_init = qc.copy()
qc_init.save_statevector()
sim = Aer.get_backend("aer_simulator")
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qc = inverse_qft(qc, nqubits)
qc.measure_all()
qc.draw()
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to nqubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
shots = 1024
transpiled_qc = transpile(qc, backend, optimization_level=3)
job = backend.run(transpiled_qc, shots=shots)
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# 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.
# pylint: disable=missing-function-docstring
"""Tests basic functionality of the sequence function"""
import unittest
from qiskit import QuantumCircuit, pulse
from qiskit.compiler import sequence, transpile, schedule
from qiskit.pulse.transforms import pad
from qiskit.providers.fake_provider import FakeParis
from qiskit.test import QiskitTestCase
class TestSequence(QiskitTestCase):
"""Test sequence function."""
def setUp(self):
super().setUp()
self.backend = FakeParis()
def test_sequence_empty(self):
self.assertEqual(sequence([], self.backend), [])
def test_transpile_and_sequence_agree_with_schedule(self):
qc = QuantumCircuit(2, name="bell")
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(actual, pad(expected))
def test_transpile_and_sequence_agree_with_schedule_for_circuit_with_delay(self):
qc = QuantumCircuit(1, 1, name="t2")
qc.h(0)
qc.delay(500, 0, unit="ns")
qc.h(0)
qc.measure(0, 0)
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(
actual.exclude(instruction_types=[pulse.Delay]),
expected.exclude(instruction_types=[pulse.Delay]),
)
@unittest.skip("not yet determined if delays on ancilla should be removed or not")
def test_transpile_and_sequence_agree_with_schedule_for_circuits_without_measures(self):
qc = QuantumCircuit(2, name="bell_without_measurement")
qc.h(0)
qc.cx(0, 1)
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(actual, pad(expected))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
Trot_gate = trotter_gate(dt)
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# backend = provider.get_backend("ibmq_jakarta")
jobs = []
st_qcs_list = []
shots = 1 << 13
# Number of trotter steps
trotter_steps = 120 ### CAN BE >= 4
for num_steps in range(1, trotter_steps + 1, 10):
print("trotter step: ", num_steps)
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(num_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/num_steps})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
st_qcs_list.append(st_qcs)
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
print()
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3)
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
results = []
for job in jobs:
results.append( job.result() )
mit_results = []
for job in jobs:
mit_results.append( meas_fitter.filter.apply(job.result()) )
len(results), len(mit_results)
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
raw_fids = []
for result in results:
fid = state_tomo(result, st_qcs)
raw_fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
plt.clf()
plt.title("fidelity with QREM")
plt.plot(range(1, trotter_steps + 1, 10), raw_fids)
plt.plot(range(1, trotter_steps + 1, 10), fids)
plt.xlabel("number of trotter steps")
plt.ylabel("fidelity")
for i, fid in enumerate(raw_fids):
print(i+1, fid)
for i, fid in enumerate(fids):
print(i+1, fid)
st_qcs_list[-1][-1].draw("mpl")
st_qcs_list[-2][-1].draw("mpl")
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import *
qc = QuantumCircuit(2)
qc.h(i)
qc.crz (PI/4, 0, 1)
|
https://github.com/soultanis/Quantum-SAT-Solver
|
soultanis
|
# Import the Qiskit SDK.
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, Aer
from qiskit.tools.visualization import plot_histogram, circuit_drawer, plot_state
# Define the number of n-qbits.
n = 6
# Create a Quantum Register with n-qbits.
q = QuantumRegister(n)
# Create a Classical Register with n-bits.
c = ClassicalRegister(n)
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
# Init with |1>
qc.x(q[0])
qc.x(q[1])
# Add H-gate to get superposition.
qc.h(q[0])
qc.h(q[1])
# Apply the oracle 11.
qc.cx(q[0],q[1],q[2])
qc.x(q[0])
qc.x(q[1])
qc.cx(q[0],q[1],q[3])
qc.x(q[0])
qc.x(q[1])
qc.x(q[0])
qc.cx(q[0],q[4])
qc.x(q[0])
qc.x(q[2])
qc.x(q[3])
qc.x(q[4])
qc.x(q[5])
qc.cx(q[2],q[3],q[4],q[5])
qc.x(q[2])
qc.x(q[3])
qc.x(q[4])
qc.x(q[5])
qc.z(q[5])
qc.x(q[2])
qc.x(q[3])
qc.x(q[4])
qc.x(q[5])
qc.cx(q[2],q[3],q[4],q[5])
qc.x(q[2])
qc.x(q[3])
qc.x(q[4])
qc.x(q[5])
qc.x(q[0])
qc.cx(q[0],q[4])
qc.x(q[0])
qc.x(q[0])
qc.x(q[1])
qc.cx(q[0],q[1],q[3])
qc.x(q[0])
qc.x(q[1])
qc.cx(q[0],q[1],q[2])
# Apply the grover-algorithm 11
# Measure qubit to bit. .
qc.measure(q, c)
# Get Aer backend.
backend_sim = Aer.get_backend('qasm_simulator')
# Compile and run the Quantum circuit on a simulator backend.
sim_result1 = execute(qc, backend_sim, shots=1000).result()
counts1 = sim_result1.get_counts(qc)
# Show the results as text and plot.
print("Simulation: ", sim_result1)
print("Output: ", counts1)
plot_histogram(counts1)
circuit_drawer(qc)
|
https://github.com/Juan-Varela11/BNL_2020_Summer_Internship
|
Juan-Varela11
|
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.aqua.components.initial_states import Zero
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.aqua.operators import Z2Symmetries
from qiskit.aqua.components.variational_forms import RY, RYRZ, swaprz
from qiskit import BasicAer
from qiskit.aqua.components.optimizers import COBYLA, L_BFGS_B, SLSQP
import numpy as np
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms.adaptive import VQE
from qiskit.aqua.algorithms.classical import ExactEigensolver
import pylab
import matplotlib.pyplot as plt
pauli_dict = {
'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
{"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "ZI"},
{"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "IZ"},
{"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
{"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
]
}
qubit_op = WeightedPauliOperator.from_dict(pauli_dict)
num_qubits = qubit_op.num_qubits
print('Number of qubits: {}'.format(num_qubits))
# using driver to get fermionic Hamiltonian
# PySCF example
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6', unit=UnitsType.ANGSTROM,
charge=0, spin=0, basis='sto3g')
molecule = driver.run()
# please be aware that the idx here with respective to original idx
freeze_list = [0]
remove_list = [-3, -2] # negative number denotes the reverse order
map_type = 'parity'
h1 = molecule.one_body_integrals
h2 = molecule.two_body_integrals
nuclear_repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
print("HF energy: {}".format(molecule.hf_energy - molecule.nuclear_repulsion_energy))
print("# of electrons: {}".format(num_particles))
print("# of spin orbitals: {}".format(num_spin_orbitals))
# prepare full idx of freeze_list and remove_list
# convert all negative idx to positive
remove_list = [x % molecule.num_orbitals for x in remove_list]
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
# update the idx in remove_list of the idx after frozen, since the idx of orbitals are changed after freezing
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [x + molecule.num_orbitals - len(freeze_list) for x in remove_list]
freeze_list += [x + molecule.num_orbitals for x in freeze_list]
# prepare fermionic hamiltonian with orbital freezing and eliminating, and then map to qubit hamiltonian
# and if PARITY mapping is selected, reduction qubits
energy_shift = 0.0
qubit_reduction = True if map_type == 'parity' else False
ferOp = FermionicOperator(h1=h1, h2=h2)
if len(freeze_list) > 0:
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
if len(remove_list) > 0:
ferOp = ferOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubit_op = ferOp.mapping(map_type=map_type)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, num_particles) if qubit_reduction else qubitOp
qubit_op.chop(10**-10)
# print(qubit_op.print_operators())
print(qubit_op)
print(qubit_op.num_qubits)
num_qubits = qubit_op.num_qubits
init_state_UCCSD = HartreeFock(qubit_op.num_qubits, num_spin_orbitals, num_particles, map_type,
qubit_reduction)
init_state_Zero = Zero(num_qubits)
UCCSD_var_form = UCCSD(num_qubits,depth=1, num_orbitals=num_spin_orbitals,num_particles=num_particles, initial_state=init_state_UCCSD)
## Some code that extract the variational form. Ideally it will draw it out as well.
init_state = Zero(num_qubits)
var_form = RY(num_qubits, initial_state=init_state_Zero)
backend = BasicAer.get_backend('statevector_simulator')
optimizers = [COBYLA, SLSQP]
converge_cnts = np.empty([len(optimizers)], dtype=object)
converge_vals = np.empty([len(optimizers)], dtype=object)
param_vals = np.empty([len(optimizers)], dtype=object)
num_qubits = qubit_op.num_qubits
for i in range(len(optimizers)):
aqua_globals.random_seed = 250
optimizer = optimizers[i]()
print('\rOptimizer: {} '.format(type(optimizer).__name__), end='')
counts = []
values = []
params = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
params.append(parameters)
algo = VQE(qubit_op, UCCSD_var_form, optimizer, callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend=backend)
algo_result = algo.run(quantum_instance)
converge_cnts[i] = np.asarray(counts)
converge_vals[i] = np.asarray(values)
param_vals[i] = np.asarray(params)
print('\rOptimization complete ');
ee = ExactEigensolver(qubit_op)
result = ee.run()
ref = result['energy']
print('Reference value: {}'.format(ref))
plt.figure(figsize=(10,5))
for i in range(len(optimizers)):
plt.plot(converge_cnts[i], abs(ref - converge_vals[i]), label=optimizers[i].__name__)
plt.xlabel('Eval count')
plt.ylabel('Energy difference from solution reference value')
plt.title('Energy convergence for various optimizers')
plt.yscale('log')
plt.legend(loc='upper right')
optimizers = [COBYLA, SLSQP]
converge_cnts = np.empty([len(optimizers)], dtype=object)
converge_vals = np.empty([len(optimizers)], dtype=object)
param_vals = np.empty([len(optimizers)], dtype=object)
num_qubits = qubit_op.num_qubits
for i in range(len(optimizers)):
aqua_globals.random_seed = 250
optimizer = optimizers[i]()
print('\rOptimizer: {} '.format(type(optimizer).__name__), end='')
counts = []
values = []
params = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
params.append(parameters)
algo = VQE(qubit_op, var_form, optimizer, callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend=backend)
algo_result = algo.run(quantum_instance)
converge_cnts[i] = np.asarray(counts)
converge_vals[i] = np.asarray(values)
param_vals[i] = np.asarray(params)
print('\rOptimization complete ');
test = 0
interesting_pt = param_vals[1][test]
circuit = algo.construct_circuit(interesting_pt)
circuit[0].draw()
ee = ExactEigensolver(qubit_op)
result = ee.run()
ref = result['energy']
print('Reference value: {}'.format(ref))
plt.figure(figsize=(10,5))
for i in range(len(optimizers)):
plt.plot(converge_cnts[i], abs(ref - converge_vals[i]), label=optimizers[i].__name__)
plt.xlabel('Eval count')
plt.ylabel('Energy difference from solution reference value')
plt.title('Energy convergence for various optimizers')
plt.yscale('log')
plt.legend(loc='upper right')
|
https://github.com/JoelHBierman/SSVQE
|
JoelHBierman
|
# 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.
import numpy as np
import textwrap
from typing import Union
from functools import partial
from qiskit import QuantumCircuit
from qiskit.opflow import OperatorBase, ListOp, PrimitiveOp, PauliOp
from qiskit.opflow import I, Z
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import Optimizer
from qiskit.utils import QuantumInstance
from qiskit.providers import BaseBackend
from volta.observables import sample_hamiltonian
class SSVQE(object):
"""Subspace-search variational quantum eigensolver for excited states
algorithm class.
Based on https://arxiv.org/abs/1810.09434
"""
def __init__(
self,
hamiltonian: Union[OperatorBase, ListOp, PrimitiveOp, PauliOp],
ansatz: QuantumCircuit,
backend: Union[BaseBackend, QuantumInstance],
optimizer: Optimizer,
n_excited: int,
debug: bool = False,
) -> None:
"""Initialize the class.
Args:
hamiltonian (Union[OperatorBase, ListOp, PrimitiveOp, PauliOp]): Hamiltonian
constructed using qiskit's aqua operators.
ansatz (QuantumCircuit): Anstaz that you want to run VQD.
optimizer (qiskit.aqua.components.optimizers.Optimizer): Classical Optimizers
from aqua components.
backend (Union[BaseBackend, QuantumInstance]): Backend for running the algorithm.
"""
# Input parameters
self.hamiltonian = hamiltonian
self.n_qubits = hamiltonian.num_qubits
self.optimizer = optimizer
self.backend = backend
# Helper Parameters
self.ansatz = ansatz
self.n_parameters = self._get_num_parameters
self._debug = debug
self._ansatz_1_params = None
self._first_optimization = False
self._n_excited = n_excited
# Running inate functions
self._inate_optimizer_run()
def _create_blank_circuit(self) -> list:
return [QuantumCircuit(self.n_qubits) for _ in range(self._n_excited)]
def _copy_unitary(self, list_states: list) -> list:
out_states = []
for state in list_states:
out_states.append(state.copy())
return out_states
def _apply_initialization(self, list_states: list) -> None:
for ind, state in enumerate(list_states):
b = bin(ind)[2:]
if len(b) != self.n_qubits:
b = "0" * (self.n_qubits - len(b)) + b
spl = textwrap.wrap(b, 1)
for qubit, val in enumerate(spl):
if val == "1":
state.x(qubit)
@property
def _get_num_parameters(self) -> int:
"""Get the number of parameters in a given ansatz.
Returns:
int: Number of parameters of the given ansatz.
"""
return len(self.ansatz.parameters)
def _apply_varform_params(self, ansatz, params: list):
"""Get an hardware-efficient ansatz for n_qubits
given parameters.
"""
# Define variational Form
var_form = ansatz
# Get Parameters from the variational form
var_form_params = sorted(var_form.parameters, key=lambda p: p.name)
# Check if the number of parameters is compatible
assert len(var_form_params) == len(
params
), "The number of parameters don't match"
# Create a dictionary with the parameters and values
param_dict = dict(zip(var_form_params, params))
# Assing those values for the ansatz
wave_function = var_form.assign_parameters(param_dict)
return wave_function
def _apply_ansatz(self, list_states: list, name: str = None) -> None:
for states in list_states:
if name:
self.ansatz.name = name
states.append(self.ansatz, range(self.n_qubits))
def _construct_states(self):
circuit = self._create_blank_circuit()
self._apply_initialization(circuit)
self._apply_ansatz(circuit)
return circuit
def _cost_function_1(self, params: list) -> float:
"""Evaluate the first cost function of SSVQE.
Args:
params (list): Parameter values for the ansatz.
Returns:
float: Cost function value.
"""
# Construct states
states = self._construct_states()
cost = 0
w = np.arange(len(states), 0, -1)
for i, state in enumerate(states):
qc = self._apply_varform_params(state, params)
# Hamiltonian
hamiltonian_eval = sample_hamiltonian(
hamiltonian=self.hamiltonian, ansatz=qc, backend=self.backend
)
cost += w[i] * hamiltonian_eval
return cost
def _inate_optimizer_run(self):
# Random initialization
params = np.random.rand(self.n_parameters)
optimal_params, energy, n_iters = self.optimizer.optimize(
num_vars=self.n_parameters,
objective_function=self._cost_function_1,
initial_point=params,
)
self._ansatz_1_params = optimal_params
self._first_optimization = True
def _cost_excited_state(self, ind: int, params: list):
cost = 0
# Construct states
states = self._construct_states()
# Define Ansatz
qc = self._apply_varform_params(states[ind], params)
# Hamiltonian
hamiltonian_eval = sample_hamiltonian(
hamiltonian=self.hamiltonian, ansatz=qc, backend=self.backend
)
cost += hamiltonian_eval
return cost, qc
def run(self, index: int) -> (float, QuantumCircuit):
"""Run SSVQE for a given index.
Args:
index(int): Index of the given excited state.
Returns:
Energy: Energy of such excited state.
State: State for such energy.
"""
energy, state = self._cost_excited_state(index, self._ansatz_1_params)
return energy, state
if __name__ == "__main__":
import qiskit
from qiskit import BasicAer
optimizer = qiskit.algorithms.optimizers.COBYLA(maxiter=100)
backend = QuantumInstance(
backend=BasicAer.get_backend("qasm_simulator"), shots=10000
)
hamiltonian = 1 / 2 * (Z ^ I) + 1 / 2 * (Z ^ Z)
ansatz = TwoLocal(hamiltonian.num_qubits, ["ry", "rz"], "cx", reps=1)
algo = SSVQE(hamiltonian, ansatz, backend, optimizer)
energy, state = algo.run(1)
print(energy)
print(state)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main")
program_id = "qaoa"
qaoa_program = provider.runtime.program(program_id)
print(f"Program name: {qaoa_program.name}, Program id: {qaoa_program.program_id}")
print(qaoa_program.parameters())
import numpy as np
from qiskit.tools import job_monitor
from qiskit.opflow import PauliSumOp, Z, I
from qiskit.algorithms.optimizers import SPSA
# Define the cost operator to run.
op = (
(Z ^ Z ^ I ^ I ^ I)
- (I ^ I ^ Z ^ Z ^ I)
+ (I ^ I ^ Z ^ I ^ Z)
- (Z ^ I ^ Z ^ I ^ I)
- (I ^ Z ^ Z ^ I ^ I)
+ (I ^ Z ^ I ^ Z ^ I)
+ (I ^ I ^ I ^ Z ^ Z)
)
# SPSA helps deal with noisy environments.
optimizer = SPSA(maxiter=100)
# We will run a depth two QAOA.
reps = 2
# The initial point for the optimization, chosen at random.
initial_point = np.random.random(2 * reps)
# The backend that will run the programm.
options = {"backend_name": "ibmq_qasm_simulator"}
# The inputs of the program as described above.
runtime_inputs = {
"operator": op,
"reps": reps,
"optimizer": optimizer,
"initial_point": initial_point,
"shots": 2**13,
# Set to True when running on real backends to reduce circuit
# depth by leveraging swap strategies. If False the
# given optimization_level (default is 1) will be used.
"use_swap_strategies": False,
# Set to True when optimizing sparse problems.
"use_initial_mapping": False,
# Set to true when using echoed-cross-resonance hardware.
"use_pulse_efficient": False,
}
job = provider.runtime.run(
program_id=program_id,
options=options,
inputs=runtime_inputs,
)
job_monitor(job)
print(f"Job id: {job.job_id()}")
print(f"Job status: {job.status()}")
result = job.result()
from collections import defaultdict
def op_adj_mat(op: PauliSumOp) -> np.array:
"""Extract the adjacency matrix from the op."""
adj_mat = np.zeros((op.num_qubits, op.num_qubits))
for pauli, coeff in op.primitive.to_list():
idx = tuple([i for i, c in enumerate(pauli[::-1]) if c == "Z"]) # index of Z
adj_mat[idx[0], idx[1]], adj_mat[idx[1], idx[0]] = np.real(coeff), np.real(coeff)
return adj_mat
def get_cost(bit_str: str, adj_mat: np.array) -> float:
"""Return the cut value of the bit string."""
n, x = len(bit_str), [int(bit) for bit in bit_str[::-1]]
cost = 0
for i in range(n):
for j in range(n):
cost += adj_mat[i, j] * x[i] * (1 - x[j])
return cost
def get_cut_distribution(result) -> dict:
"""Extract the cut distribution from the result.
Returns:
A dict of cut value: probability.
"""
adj_mat = op_adj_mat(PauliSumOp.from_list(result["inputs"]["operator"]))
state_results = []
for bit_str, amp in result["eigenstate"].items():
state_results.append((bit_str, get_cost(bit_str, adj_mat), amp**2 * 100))
vals = defaultdict(int)
for res in state_results:
vals[res[1]] += res[2]
return dict(vals)
import matplotlib.pyplot as plt
cut_vals = get_cut_distribution(result)
fig, axs = plt.subplots(1, 2, figsize=(14, 5))
axs[0].plot(result["optimizer_history"]["energy"])
axs[1].bar(list(cut_vals.keys()), list(cut_vals.values()))
axs[0].set_xlabel("Energy evaluation number")
axs[0].set_ylabel("Energy")
axs[1].set_xlabel("Cut value")
axs[1].set_ylabel("Probability")
from qiskit_optimization.runtime import QAOAClient
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization import QuadraticProgram
qubo = QuadraticProgram()
qubo.binary_var("x")
qubo.binary_var("y")
qubo.binary_var("z")
qubo.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qubo.prettyprint())
qaoa_mes = QAOAClient(
provider=provider, backend=provider.get_backend("ibmq_qasm_simulator"), reps=2, alpha=0.75
)
qaoa = MinimumEigenOptimizer(qaoa_mes)
result = qaoa.solve(qubo)
print(result.prettyprint())
from qiskit.transpiler import PassManager
from qiskit.circuit.library.standard_gates.equivalence_library import (
StandardEquivalenceLibrary as std_eqlib,
)
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
UnrollCustomDefinitions,
BasisTranslator,
Optimize1qGatesDecomposition,
)
from qiskit.transpiler.passes.calibration.builders import RZXCalibrationBuilderNoEcho
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import (
EchoRZXWeylDecomposition,
)
from qiskit.test.mock import FakeBelem
backend = FakeBelem()
inst_map = backend.defaults().instruction_schedule_map
channel_map = backend.configuration().qubit_channel_mapping
rzx_basis = ["rzx", "rz", "x", "sx"]
pulse_efficient = PassManager(
[
# Consolidate consecutive two-qubit operations.
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=["rz", "sx", "x", "rxx"]),
# Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
EchoRZXWeylDecomposition(backend.defaults().instruction_schedule_map),
# Attach scaled CR pulse schedules to the RZX gates.
RZXCalibrationBuilderNoEcho(
instruction_schedule_map=inst_map, qubit_channel_mapping=channel_map
),
# Simplify single-qubit gates.
UnrollCustomDefinitions(std_eqlib, rzx_basis),
BasisTranslator(std_eqlib, rzx_basis),
Optimize1qGatesDecomposition(rzx_basis),
]
)
from qiskit import QuantumCircuit
circ = QuantumCircuit(3)
circ.h([0, 1, 2])
circ.rzx(0.5, 0, 1)
circ.swap(0, 1)
circ.cx(2, 1)
circ.rz(0.4, 1)
circ.cx(2, 1)
circ.rx(1.23, 2)
circ.cx(2, 1)
circ.draw("mpl")
pulse_efficient.run(circ).draw("mpl", fold=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit.quantum_info import Operator
from qiskit.circuit.library.standard_gates import XGate
class ThreeQubitCode:
def __init__(self):
# Initialize Registers
self.code = QuantumRegister(3, name="code")
self.syndrm = QuantumRegister(2, name="syndrome")
# Build Circuit Components
self.encoder_ckt = self.build_encoder()
self.syndrome_ckt = self.build_syndrome()
self.correction_ckt = self.build_correction()
# Build Noisy Channel
self.noise_ckt = QuantumCircuit(self.code, self.syndrm)
self.noise_ckt.unitary(Operator(np.eye(2)), [self.code[0]], label='noise')
self.noise_ckt.unitary(Operator(np.eye(2)), [self.code[1]], label='noise')
self.noise_ckt.unitary(Operator(np.eye(2)), [self.code[2]], label='noise')
# Compose Full Circuit
circ = QuantumCircuit(self.code, self.syndrm)
circ.barrier()
self.circuit = self.encoder_ckt + circ + self.noise_ckt + circ + self.syndrome_ckt + circ + self.correction_ckt
def build_encoder(self):
# Build Encoder Circuit
circ = QuantumCircuit(self.code, self.syndrm, name="Encoder Circuit")
circ.cx(self.code[0], self.code[1])
circ.cx(self.code[0], self.code[2])
return circ
def build_syndrome(self):
# Build Syndrome Circuit
circ = QuantumCircuit(self.code, self.syndrm, name="Syndrome Circuit")
circ.h(self.syndrm)
circ.barrier()
circ.cz(self.syndrm[1], self.code[2])
circ.cz(self.syndrm[1], self.code[1])
circ.cz(self.syndrm[0], self.code[1])
circ.cz(self.syndrm[0], self.code[0])
circ.barrier()
circ.h(self.syndrm)
return circ
def build_correction(self):
# Build Correction Circuit
circ = QuantumCircuit(self.code, self.syndrm)
circ.append(XGate().control(2, ctrl_state=2), [self.syndrm[0], self.syndrm[1], self.code[2]])
circ.append(XGate().control(2, ctrl_state=3), [self.syndrm[0], self.syndrm[1], self.code[1]])
circ.append(XGate().control(2, ctrl_state=1), [self.syndrm[0], self.syndrm[1], self.code[0]])
return circ
def visualize(self):
# Draw Circuits
self.encoder_ckt.draw('mpl', reverse_bits=True).suptitle('Encoder Circuit', fontsize=16)
self.syndrome_ckt.draw('mpl', reverse_bits=True).suptitle('Syndrome Circuit', fontsize=16)
self.correction_ckt.draw('mpl', reverse_bits=True).suptitle('Error Correction', fontsize=16)
self.circuit.draw('mpl', reverse_bits=True).suptitle('Three Qubit Error Correction', fontsize=16)
plt.show()
|
https://github.com/if-quantum/pairwise-tomography
|
if-quantum
|
from qiskit import execute, Aer
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.providers import JobStatus
from qiskit.tools.qi.qi import partial_trace
from qiskit.quantum_info import state_fidelity
from qiskit.compiler import transpile
from qiskit.quantum_info.random.utils import random_state
import time
from pairwise_tomography.pairwise_state_tomography_circuits import pairwise_state_tomography_circuits
from pairwise_tomography.pairwise_fitter import PairwiseStateTomographyFitter
from pairwise_tomography.utils import concurrence
backend = Aer.get_backend('qasm_simulator')
nq = 5
q = QuantumRegister(nq)
qc = QuantumCircuit(q)
qc.ry(3., q[0])
qc.cx(q[0], q[1])
qc.x(q[1])
qc.ry(2.1, q[2])
qc.cx(q[2], q[3])
qc.h(q[4])
qc.cx(q[4], q[1])
qc.cx(q[1], q[4])
qc.cx(q[4], q[3])
qc.cx(q[3], q[4])
qc.draw(output='mpl')
pw_tomo_circs = pairwise_state_tomography_circuits(qc, q)
print(len(pw_tomo_circs))
pw_tomo_circs[10].draw(output='mpl')
job = execute(pw_tomo_circs, Aer.get_backend('qasm_simulator'), shots=8192)
fitter = PairwiseStateTomographyFitter(job.result(), pw_tomo_circs, q)
fit_result = fitter.fit()
print(fit_result[(0,1)])
pairwise_entanglement = {key: concurrence(value) for key, value in fit_result.items()}
print(pairwise_entanglement)
from pairwise_tomography.visualization import draw_entanglement_graph
draw_entanglement_graph(pairwise_entanglement)
|
https://github.com/vindem/quantumMD
|
vindem
|
from qiskit import IBMQ, Aer
from CSWAPCircuit import CSWAPCircuit
import random
from scipy.spatial import distance
from sklearn.metrics import mean_squared_error
random.seed(42)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-research-2', group='vienna-uni-tech-1', project='main')
backend_sim = provider.backend.ibmq_qasm_simulator
def generate_random_vector(n_points):
vec = []
for i in range(n_points):
vec.append([random.uniform(0, 1) for j in range(3)])
return vec
backend = Aer.get_backend('qasm_simulator')
for num_qubits in range(0,5):
quantum_distances = []
classic_distances = []
for i in range(10):
A = generate_random_vector(2**num_qubits)
B = generate_random_vector(2**num_qubits)
cswap_circuit = CSWAPCircuit(1, 1, 3, 1, backend_sim, 8192)
quantum_ED = cswap_circuit.execute_swap_test(A, B)
classic_ED = [distance.euclidean(A[i], B[i]) for i in range(len(A))]
quantum_distances.append(quantum_ED)
classic_distances.append(classic_ED)
mse = mean_squared_error(quantum_distances, classic_distances)
print(mse)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# External imports
from pylab import cm
from sklearn import metrics
import numpy as np
import matplotlib.pyplot as plt
# Qiskit imports
from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
from qiskit.visualization import circuit_drawer
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import ZZFeatureMap
from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel
from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer
from qiskit_machine_learning.algorithms import QSVC
from qiskit_machine_learning.datasets import ad_hoc_data
class QKTCallback:
"""Callback wrapper class."""
def __init__(self) -> None:
self._data = [[] for i in range(5)]
def callback(self, x0, x1=None, x2=None, x3=None, x4=None):
"""
Args:
x0: number of function evaluations
x1: the parameters
x2: the function value
x3: the stepsize
x4: whether the step was accepted
"""
self._data[0].append(x0)
self._data[1].append(x1)
self._data[2].append(x2)
self._data[3].append(x3)
self._data[4].append(x4)
def get_callback_data(self):
return self._data
def clear_callback_data(self):
self._data = [[] for i in range(5)]
adhoc_dimension = 2
X_train, y_train, X_test, y_test, adhoc_total = ad_hoc_data(
training_size=20,
test_size=5,
n=adhoc_dimension,
gap=0.3,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
plt.scatter(
X_train[np.where(y_train[:] == 0), 0],
X_train[np.where(y_train[:] == 0), 1],
marker="s",
facecolors="w",
edgecolors="b",
label="A train",
)
plt.scatter(
X_train[np.where(y_train[:] == 1), 0],
X_train[np.where(y_train[:] == 1), 1],
marker="o",
facecolors="w",
edgecolors="r",
label="B train",
)
plt.scatter(
X_test[np.where(y_test[:] == 0), 0],
X_test[np.where(y_test[:] == 0), 1],
marker="s",
facecolors="b",
edgecolors="w",
label="A test",
)
plt.scatter(
X_test[np.where(y_test[:] == 1), 0],
X_test[np.where(y_test[:] == 1), 1],
marker="o",
facecolors="r",
edgecolors="w",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset for classification")
plt.show()
# Create a rotational layer to train. We will rotate each qubit the same amount.
training_params = ParameterVector("θ", 1)
fm0 = QuantumCircuit(2)
fm0.ry(training_params[0], 0)
fm0.ry(training_params[0], 1)
# Use ZZFeatureMap to represent input data
fm1 = ZZFeatureMap(2)
# Create the feature map, composed of our two circuits
fm = fm0.compose(fm1)
print(circuit_drawer(fm))
print(f"Trainable parameters: {training_params}")
# Instantiate quantum kernel
quant_kernel = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)
# Set up the optimizer
cb_qkt = QKTCallback()
spsa_opt = SPSA(maxiter=10, callback=cb_qkt.callback, learning_rate=0.05, perturbation=0.05)
# Instantiate a quantum kernel trainer.
qkt = QuantumKernelTrainer(
quantum_kernel=quant_kernel, loss="svc_loss", optimizer=spsa_opt, initial_point=[np.pi / 2]
)
# Train the kernel using QKT directly
qka_results = qkt.fit(X_train, y_train)
optimized_kernel = qka_results.quantum_kernel
print(qka_results)
# Use QSVC for classification
qsvc = QSVC(quantum_kernel=optimized_kernel)
# Fit the QSVC
qsvc.fit(X_train, y_train)
# Predict the labels
labels_test = qsvc.predict(X_test)
# Evalaute the test accuracy
accuracy_test = metrics.balanced_accuracy_score(y_true=y_test, y_pred=labels_test)
print(f"accuracy test: {accuracy_test}")
plot_data = cb_qkt.get_callback_data() # callback data
K = optimized_kernel.evaluate(X_train) # kernel matrix evaluated on the training samples
plt.rcParams["font.size"] = 20
fig, ax = plt.subplots(1, 2, figsize=(14, 5))
ax[0].plot([i + 1 for i in range(len(plot_data[0]))], np.array(plot_data[2]), c="k", marker="o")
ax[0].set_xlabel("Iterations")
ax[0].set_ylabel("Loss")
ax[1].imshow(K, cmap=cm.get_cmap("bwr", 20))
fig.tight_layout()
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/anirban-m/qiskit-superstaq
|
anirban-m
|
import json
from typing import Any, Dict
import pytest
import qiskit
import requests
import qiskit_superstaq as qss
class MockConfiguration:
backend_name = "superstaq_backend"
backend_version = qss.API_VERSION
class MockProvider(qss.superstaq_provider.SuperstaQProvider):
def __init__(self) -> None:
self.access_token = "very.tech"
class MockDevice(qss.superstaq_backend.SuperstaQBackend):
def __init__(self) -> None:
self._provider = MockProvider()
self.diff = ""
_configuration = MockConfiguration()
url = "super.tech"
class MockJob(qss.superstaq_job.SuperstaQJob):
def __init__(self) -> None:
self._backend = MockDevice()
self._job_id = "123abc"
self.qobj = None
class MockJobs(qss.superstaq_job.SuperstaQJob):
def __init__(self) -> None:
self._backend = MockDevice()
self._job_id = "123abc,456def"
self.qobj = None
class MockResponse:
def __init__(self, status_str: str) -> None:
self.content = json.dumps({"status": status_str, "samples": None, "shots": 100})
def json(self) -> Dict:
return json.loads(self.content)
def test_wait_for_results(monkeypatch: Any) -> None:
job = MockJob()
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Done"))
assert job._wait_for_results() == [{"status": "Done", "samples": None, "shots": 100}]
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Error"))
with pytest.raises(qiskit.providers.JobError, match="API returned error"):
job._wait_for_results()
jobs = MockJobs()
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Done"))
assert jobs._wait_for_results() == [
{"status": "Done", "samples": None, "shots": 100},
{"status": "Done", "samples": None, "shots": 100},
]
def test_result(monkeypatch: Any) -> None:
job = MockJob()
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Done"))
expected_results = [{"success": True, "shots": 100, "data": {"counts": None}}]
expected = qiskit.result.Result.from_dict(
{
"results": expected_results,
"qobj_id": -1,
"backend_name": "superstaq_backend",
"backend_version": qss.API_VERSION,
"success": True,
"job_id": "123abc",
}
)
ans = job.result()
assert ans.backend_name == expected.backend_name
assert ans.job_id == expected.job_id
def test_status(monkeypatch: Any) -> None:
job = MockJob()
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Queued"))
assert job.status() == qiskit.providers.JobStatus.QUEUED
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Running"))
assert job.status() == qiskit.providers.JobStatus.RUNNING
monkeypatch.setattr(requests, "get", lambda *_, **__: MockResponse("Done"))
assert job.status() == qiskit.providers.JobStatus.DONE
def test_submit() -> None:
job = qss.superstaq_job.SuperstaQJob(backend=MockDevice(), job_id="12345")
with pytest.raises(NotImplementedError, match="Submit through SuperstaQBackend"):
job.submit()
def test_eq() -> None:
job = qss.superstaq_job.SuperstaQJob(backend=MockDevice(), job_id="12345")
assert job != "super.tech"
job2 = qss.superstaq_job.SuperstaQJob(backend=MockDevice(), job_id="123456")
assert job != job2
job3 = qss.superstaq_job.SuperstaQJob(backend=MockDevice(), job_id="12345")
assert job == job3
|
https://github.com/gustavomirapalheta/Quantum-Computing-with-Qiskit
|
gustavomirapalheta
|
!pip install qutip -q
!pip install qiskit -q
!pip install qiskit[visualization] -q
!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src -q
import numpy as np
np.set_printoptions(precision=3, suppress=True)
import qutip as qt
from matplotlib import pyplot as plt
%matplotlib inline
import pandas as pd
import sklearn as sk
import qiskit as qk
!pip install qutip -q
!pip install qiskit -q
!pip install qiskit[visualization] -q
!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src -q
import numpy as np
np.set_printoptions(precision=3, suppress=True)
import qutip as qt
from matplotlib import pyplot as plt
%matplotlib inline
import pandas as pd
import sklearn as sk
import qiskit as qk
# Remember that qiskit has to be already installed in the Python environment.
# Otherwise the import command will fail
import qiskit as qk
# A circuit composed of just one qubit
qc = qk.QuantumCircuit(1)
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qk
# A qubit initialized in |0> and a measurement
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.measure_all()
qc.draw('mpl')
import qiskit as qk
# A list of possible measurements. The results of measurements are obtained
# by executing an object called backend
a = [print(i) for i in qk.Aer.backends()]
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
# Let's choose the statevector simulator from the Aer backend
backend = qk.Aer.get_backend('statevector_simulator')
# And execute the circuit qc in the simulator backend
# getting as final result the counts from 1.000 measures
# of the qubit state
result = qk.execute(qc, backend, shots=1000).result().get_counts()
result
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.measure(0,0)
qc.draw('mpl')
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import numpy as np
v0 = np.array([[1],[0]]);v0
v1 = np.array([[0],[1]]); v1
X = np.array([[0,1],[1,0]]); X
X.dot(v0)
X.dot(v1)
import qiskit as qk
qr = qk.QuantumRegister(1,"q0")
cr = qk.ClassicalRegister(1,"c0")
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.measure(qr[0], cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import numpy as np
# Notice that we are creating the v0 matrix using the transpose operation
v0 = np.array([[1,0]]).T; v0
# Here it is created again de X matrix
X = np.array([[0,1],[1,0]]); X
# Multiplying v0 by the X matrix twice you get again v0
X.dot(X).dot(v0)
# Multiplying the X matrix by itself you get the Identity matrix
X.dot(X)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.x(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
# The result of 1000 measures of the qubit above gives the |0> state as result
# in all measures
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,2**-0.5],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
v0 = np.array([[1,0]]).T; v0
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H.dot(v0)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.h(qr[0])
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.h(0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
# First let's start with the qubit in the state |psi> = (|0> - |1>)/sqrt(2)
psi = np.array([[1,-1]]).T/(2**0.5); psi
H = np.array([[1,1],[1,-1]])/2**0.5; H
# Now let's pass the qubit Psi through an Hadamard gate.
# The result is a qubit in the state |1>
H.dot(psi)
# Let's start with a qubit in the state |1>, pass it through a
# a hadamard gate twice and check the result
v0 = np.array([[0,1]]).T; v0
H.dot(H).dot(v0)
# This means that if we multiply the H gate by itself the result
# will be an Identity matrix. Let's check it.
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T; psi1
psi2 = np.array([[1,0]]).T; psi2
# In numpy the tensor product is calculated with the function kron
np.kron(psi1,psi2)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T;psi1
psi2 = np.array([[1,0]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[0,1]]).T;psi1
psi2 = np.array([[0,1]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v00 = np.array([[1,0,0,0]]).T;v00
# C.v00 = v00
C.dot(v00)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
# Please notice that Qiskit's qubits presentation order is reversed.
# Therefore 10 in the histogram's x axis should be read as 01 (from
# inside out or right to left).
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v01 = np.array([[0,1,0,0]]).T;v01
# C.v01 = v01
C.dot(v01)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v10 = np.array([[0,0,1,0]]).T; v10
# C.v10 = v11
C.dot(v10)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
# Again remember to read qiskit qubits state presentation order
# from right to left. Therefore 01 in the x axis is in fact 10
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v11 = np.array([[0,0,0,1]]).T; v11
# C.v11 = v10
C.dot(v11)
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
va = np.array([[1,0]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
vout = C.dot(vaHvb); vout
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
va = np.array([[0,1]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
vout = C.dot(vaHvb); vout
# Get the IBM API key in: https://quantum-computing.ibm.com
# chave = 'My key is already saved in this environment'
# qk.IBMQ.save_account(chave)
# Load the account in the active session
qk.IBMQ.load_account()
# The default provider is é hub='ibm-q', group='open, project='main'
# The code below is executed as an example
provider_1 = qk.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
# In the public provider we will use a cloud simulator.
backend_1 = provider_1.get_backend('ibmq_qasm_simulator')
# The provider listed below has unlimited jobs
provider_2 = qk.IBMQ.get_provider(hub='ibm-q-education', group='fgv-1', project='ml-business-app')
# For this provider we will use the ibmq_jakarta machine
backend_2 = provider_2.get_backend('ibmq_jakarta')
# With n Qubits we can generate a random number from 0 to 2^n - 1
n = 3
qr = qk.QuantumRegister(n,'q')
cr = qk.ClassicalRegister(n,'c')
qc = qk.QuantumCircuit(qr, cr)
# Applying a Hadamard to each of the three qubits
for i in range(n):
qc.h(q[i])
# Measuring the three qubits
qc.measure(q,c)
# Visualizing the circuit
qc.draw('mpl')
# qk.execute envia para o backend. Conferindo no iqmq explorer aparece o job
new_job = qk.execute(circ, backend_2, shots=1)
# this result is stored on the local machine. However, it will only be available
# after the job has been executed. It returns a python dictionary.
new_job.result().get_counts()
int(list(new_job.result().get_counts().keys())[0],2)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1], [0,1])
display(circuit.draw('mpl'))
from qiskit.providers.aer import AerSimulator
print(AerSimulator().run(circuit, shots=1000).result().get_counts())
print(AerSimulator().run(circuit, shots=1000).result().get_counts())
from qiskit import QuantumCircuit
circuito = QuantumCircuit(3,3)
for i in range(3):
circuito.h(i)
circuito.measure(i,i)
display(circuito.draw('mpl'))
from qiskit.providers.aer import AerSimulator
AerSimulator().run(circuito, shots = 1000).result().get_counts()
from qiskit import QuantumCircuit
qc = QuantumCircuit(4,4)
qc.x([0,1])
qc.cx([0,1],[2,2])
qc.ccx(0,1,3)
qc.measure([0,1,2,3],[0,1,2,3])
display(qc.draw(output='mpl'))
from qiskit.providers.aer import AerSimulator
AerSimulator().run(qc, shots = 10000).result().get_counts()
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
print("Circuit 1 - Registers Only")
display(qc.draw('mpl'))
qc.x(qr)
print("Circuit 1 - Quantum Register with a Gate X ")
display(qc.draw('mpl'))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'))
result1 = job.result().get_statevector()
print("Quantum Register Vector State")
from qiskit.tools.visualization import plot_bloch_multivector
display(plot_bloch_multivector(result1))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('unitary_simulator'))
print("Transformation Matrix (up to this stage)")
print(job.result().get_unitary())
qc.measure(qr, cr)
print()
print("Circuit 1 - Registers, Gate X and Quantum Register Measure")
display(qc.draw('mpl'))
print("Quantum Register Thousand Measures")
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'),
shots = 1000)
print(job.result().get_counts())
print()
print("Result's Histogram")
from qiskit.tools.visualization import plot_histogram
plot_histogram(data = job.result().get_counts(), figsize=(4,3))
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
display(qc.draw('mpl'))
sv = Statevector.from_label('000')
state_data = lambda qc,sv: np.round(np.asarray(sv.evolve(qc).data),4)
state_bloch = lambda qc,sv: plot_bloch_multivector(sv.evolve(qc).data, reverse_bits=True)
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.x(0)
qc.barrier()
display(qc.draw('mpl'))
print(state_data(qc,sv))
display(state_bloch(qc,sv))
qc.h(1)
display(qc.draw('mpl'))
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.cnot(1,2)
display(qc.draw("mpl"))
state_data(qc,sv)
state_bloch(qc,sv)
qc.cnot(0,1)
display(qc.draw('mpl'))
state_data(qc,sv)
qc.h(0)
qc.barrier()
display(qc.draw('mpl'))
state_data(qc,sv)
qc.measure(0,0)
qc.measure(1,1)
qc.barrier()
qc.cnot(1,2)
qc.cz(0,2)
qc.measure(2,2)
display(qc.draw('mpl'))
simulador = qk.Aer.get_backend('statevector_simulator')
resultado = qk.execute(qc, simulador, shots=10000).result()
qk.visualization.plot_histogram(resultado.get_counts())
import numpy as np
V = np.array([[3+2j],[4-2j]])
modV = np.real(V.T.conjugate().dot(V)[0,0])**0.5
Vn = V/modV; Vn
v0 = np.array([[1,0]]).T
v1 = np.array([[0,1]]).T
Vn[0,0]*v0 + Vn[1,0]*v1
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([Vn[0,0],Vn[1,0]],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
Vn[0,0].conjugate()*Vn[0,0]
Vn[1,0].conjugate()*Vn[1,0]
import numpy as np
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT.dot(CNOT)
import numpy as np
H = np.array([[1,1],[1,-1]])/2**0.5
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.cnot(qr[0],qr[1])
qc.h(0)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
X = np.array([[0,1],
[1,0]])
X
X.conj().T.dot(X)
Y = np.array([[0,-1j],
[1j,0]])
Y
Y.conj().T.dot(Y)
Z = np.array([[1,0],
[0,-1]])
Z
Z.conj().T.dot(Z)
H = (X+Z)/np.sqrt(2); H
H.dot(Z).dot(H)
H.dot(X).dot(H)
-H.dot(Y).dot(H)
import numpy as np
S = np.array([[1,0],
[0,1j]])
S
S.conj().T.dot(S)
T = np.array([[1,0],
[0,np.exp(1j*np.pi/4)]])
T
T.conj().T.dot(T)
S = np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]]); S
S.dot(v00)
S.dot(v01)
S.dot(v10)
S.dot(v11)
C = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]]);C
C_ = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]]);C_
C.dot(C_).dot(C)
v = v0 + v1; v
n = np.array([[0,0],[0,1]]); n
n.dot(v)
n_ = np.array([[1,0],[0,0]]);n_
I2 = np.identity(2); I2
I2 - n
n_.dot(v)
n.dot(n)
n_.dot(n_)
n.dot(n_)
n_.dot(n)
n+n_
n.dot(X)
X.dot(n_)
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
# ni nj operam em bits distintos. Como cada operador n atua em um vetor de
# 2 dimensões, ni nj é um operador de 4 dimensões. Sendo assim, fica implícito
# pelos subscritos que ni nj é um produto tensorial.
np.kron(n,n)
# O mesmo vale para n'i n'j
np.kron(n_,n_)
# Para ni n'j
np.kron(n,n_)
# E para n'i nj
np.kron(n_,n)
# Xi Xj são dois operadores 2x2 de inversão, cada um atuando em um bit
# distinto. Sendo assim, fazemos o produto tensorial entre ambos
# para obter XiXj
np.kron(X,X)
# No caso da expressão XiXj(ninj' + ni'nj) temos entre parênteses duas
# matrizes 4x4 (ninj'+ni'nj) e fora dos parênteses uma matriz 4x4 (XiXj)
# Sendo assim fazemos neste caso o produto matricial normal para
# calcular esta expressão.
np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
# E por último somamos com o resultado inicial de ninj + ni'nj'
# Como pode-se ver, esta expressão gera o operador de SWAP
np.kron(n,n) + np.kron(n_,n_) + np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
# É importante observar que ninj forma um operador que projeta um vetor de
# 4 dimensões (00, 01, 10, 11) em sua componente 11
np.kron(n,n)
# De maneira similar ni'nj' projeta um vetor de 4 dimensões em sua componente 00
np.kron(n_,n_)
# ni'nj projeta em 01
np.kron(n_,n)
# Assim como ninj' projeta em 10
np.kron(n,n_)
# E por último vemos que ni'nj' + ni'nj + ninj' + ninj = I
nn = np.kron(n,n)
nn_ = np.kron(n,n_)
n_n = np.kron(n_,n)
n_n_ = np.kron(n_,n_)
nn + nn_ + n_n + n_n_
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
# (n x n).(n_ x n_)
np.kron(n,n).dot(np.kron(n_,n_))
# Faz sentido que (ni x nj).(ni_ x nj_) seja o vetor nulo pois:
# ni_ x nj_ é um operador que recebe um vetor de 4 dimensões e
# produz como resultado apenas sua componente |00>. Por sua
# vez ni x nj é um operador que recebe um vetor de 4 dimensões
# e produz como resultado apenas sua componente |11>. Esta
# componente foi zerada pelo primeiro operador, logo o resultado
# será nulo. Isto vai acontecer sempre que a componente não
# zerada do primeiro operador for diferente da do segundo em
# outras palavras sempre que ij do primeiro for diferente de ij
# do segundo.
np.kron(n,n).dot(np.kron(n_,n_))
# Outra forma de entender é transformar (n x n).(n_ x n_) em
# (n.n_) x (n.n_). Como n é ortogonal a n_, a projeção de n
# em n_ dará zero também.
np.kron(n.dot(n_),n.dot(n_))
nn.dot(n_n_)
# (n_ x n).(n x n_)
np.kron(n_,n).dot(np.kron(n,n_))
n_n.dot(nn_)
# (n x n_).(n_ x n)
np.kron(n, n_).dot(np.kron(n_,n))
nn_.dot(n_n)
# (n_ x n_).(n x n)
np.kron(n_, n_).dot(np.kron(n, n))
n_n_.dot(nn)
NOT = np.array([[0,1],[1,0]]); NOT
NOT.dot(D0)
NOT.dot(D1)
AND = np.array([[1,1,1,0],[0,0,0,1]]); AND
AND.dot(np.kron(D0,D0))
AND.dot(np.kron(D0,D1))
AND.dot(np.kron(D1,D0))
AND.dot(np.kron(D1,D1))
OR = np.array([[1,0,0,0],[0,1,1,1]]); OR
OR.dot(np.kron(D0,D0))
OR.dot(np.kron(D0,D1))
OR.dot(np.kron(D1,D0))
OR.dot(np.kron(D1,D1))
NAND = np.array([[0,0,0,1],[1,1,1,0]]); NAND
NOT.dot(AND)
NOR = np.array([[0,1,1,1],[1,0,0,0]]);NOR
NOT.dot(OR)
np.kron(NOT,AND)
OR.dot(np.kron(NOT,AND))
NOT.dot(AND).dot(np.kron(NOT,NOT))
OR
NOT.dot(OR).dot(np.kron(NOT,NOT))
AND
import numpy as np
k = np.kron
XOR = np.array([[1,0,0,1],
[0,1,1,0]])
AND = np.array(([1,1,1,0],
[0,0,0,1]))
k(XOR,AND)
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
k(XOR,AND).dot(criaCompat(2,2))
import numpy as np
k = np.kron
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
NOT = np.array([[0,1],
[1,0]])
AND3 = np.array([[1,1,1,1,1,1,1,0],
[0,0,0,0,0,0,0,1]])
OR4 = np.array([[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]])
I2 = np.array([[1,0],
[0,1]])
t1z = k(NOT,k(NOT,I2))
t2z = k(NOT,k(I2,NOT))
t3z = k(I2,k(NOT,NOT))
t4z = k(I2,k(I2,I2))
ORz = k(AND3,k(AND3,k(AND3,AND3)))
ORz = OR4.dot(ORz).dot(k(t1z,k(t2z,k(t3z,t4z))))
t1c = k(NOT,k(I2,I2))
t2c = k(I2,k(NOT,I2))
t3c = k(I2,k(I2,NOT))
t4c = k(I2,k(I2,I2))
ORc = k(AND3,k(AND3,k(AND3,AND3)))
ORc = OR4.dot(ORc).dot(k(t1c,k(t2c,k(t3c,t4c))))
compat = criaCompat(3,8)
k(ORz,ORc).dot(compat)
import numpy as np
TOFFOLI = np.array([[1,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,0,0,1,0]])
TOFFOLI.dot(TOFFOLI)
Z1 = np.array([[0,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
Z1
Z1I4 = np.array([[0,0,0,0],
[1,0,0,0],
[0,0,0,0],
[0,1,0,0],
[0,0,0,0],
[0,0,1,0],
[0,0,0,0],
[0,0,0,1]])
TOFFOLI.dot(ZpY).dot(TOFFOLI).dot(Z1I4)
ZpY = np.zeros([8,8])
ZpY[0,0] = 1; ZpY[1,2] = 1; ZpY[2,1] = 1; ZpY[3,3] = 1
ZpY[4,4] = 1; ZpY[5,6] = 1; ZpY[6,5] = 1; ZpY[7,7] = 1
ZpY
Zfim = np.array([[1,0,1,0,1,0,1,0],
[0,1,0,1,0,1,0,1]])
Zfim.dot(TOFFOLI).dot(ZpY).dot(TOFFOLI).dot(Z1I4)
import numpy as np
fred = np.identity(8)
fred[5,5] = 0; fred[5,6] = 1
fred[6,5] = 1; fred[6,6] = 0
fred
fred.dot(fred)
import numpy as np
Fy0 = np.zeros([8,4])
Fy0[0,0] = 1; Fy0[1,1] = 1; Fy0[4,2] = 1; Fy0[5,3] = 1
Fy0
xYz = np.array([[1,1,0,0,1,1,0,0],
[0,0,1,1,0,0,1,1]])
xYz.dot(fred).dot(Fy0)
import numpy as np
q0 = np.array([[1,0]]).T; q0
q1 = np.array([[0,1]]).T; q1
q01 = np.kron(q0,q1); q01
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H2 = np.kron(H,H); H2
H2.dot(q01)
I4 = np.eye(4); I4
I4.dot(H2).dot(q01)
I2 = np.eye(2); I2
HI2 = np.kron(H,I2); HI2
HI2.dot(I4).dot(H2).dot(q01)
X = np.array([[0,1],[1,0]]); X
I2 = np.eye(2); I2
I2X = np.kron(I2,X); I2X
HI2.dot(I2X).dot(H2).dot(q01)
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT
HI2.dot(CNOT).dot(H2).dot(q01)
X = np.array([[0,1],[1,0]]); X
I2 = np.eye(2); I2
XI2 = np.kron(X,I2); XI2
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT
CNOT.dot(XI2)
HI2.dot(CNOT).dot(XI2).dot(H2).dot(q01)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.x(1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.cx(0,1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.x(0)
qc.cx(0,1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.barrier()
qc.cnot(1,2)
qc.barrier()
qc.draw('mpl')
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(1,2)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
qc.draw('mpl')
def histograma(qc):
import qiskit as qk
from qiskit.visualization import plot_histogram
simulador = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulador,shots=10000).result().get_counts()
grafico = plot_histogram(results)
return(grafico)
histograma(qc)
import numpy as np
x1 = np.array([[1,0]]).T
x0 = np.array([[1,0]]).T
y = np.array([[0,1]]).T
psi0 = np.kron(y,np.kron(x1,x0)); psi0.T
import numpy as np
H = np.array([[1, 1],
[1,-1]])/np.sqrt(2)
H3 = np.kron(H,np.kron(H,H)); np.round(H3,3)
psi0 = np.array([[0,0,0,0,1,0,0,0]]).T
psi1 = H3.dot(psi0); psi1.T
CNOTsm = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]])
I2 = np.array([[1,0],
[0,1]])
CNOTsm_I2 = np.kron(CNOTsm,I2)
psi0 = np.array([[0,0,0,0,1,0,0,0]]).T
CNOTsm_I2.dot(H3).dot(psi0).T
psi = np.array([[1,1,-1,-1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(0,2)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
import numpy as np
v0 = np.array([[0,0,0,0,1,0,0,0]]).T; v0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
H3.dot(v0).T
CNOTs_I_m = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0]])
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
CNOTs_I_m.dot(H3).dot(v0).T
psi = np.array([[+1,-1,+1,-1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(0,1)
qc.cnot(1,2)
qc.cnot(0,1)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
H3.dot(v0).T
CNOT_CNOT = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
CNOT_CNOT.dot(H3).dot(v0).T
psi = np.array([[+1,-1,-1,+1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import numpy as np
CNOTsm = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]])
I = np.array([[1,0],
[0,1]])
ISM = np.kron(I,CNOTsm)
SMI = np.kron(CNOTsm,I)
H = np.array([[1, 1],
[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H2,H)
IH2 = np.kron(I,H2)
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
IH2.dot(ISM).dot(SMI).dot(ISM).dot(H3).dot(v0).round(3)
CNOT_CNOT = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
ISM.dot(SMI).dot(ISM)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
psi = np.array([[1,1,1,1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.x(2)
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
psi = np.array([[1,1,1,1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.ccx(0,1,2)
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry)
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.draw('mpl')
def histograma(qc):
simulador = qk.Aer.get_backend('statevector_simulator')
resultado = qk.execute(qc,simulador,shots=10000).result()
contagens = resultado.get_counts()
grafico = qk.visualization.plot_histogram(contagens)
return(grafico)
def simon(initial_y, initial_x):
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
crx = qk.ClassicalRegister(4,'c')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry,crx)
qc.initialize(initial_x,qrx)
qc.initialize(initial_y,qry)
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.measure([0,1,2,3],[0,1,2,3])
display(qc.draw('mpl'))
grafico = histograma(qc)
return(grafico)
simon([1,0,0,0],[1,0,0,0])
simon([1,0,0,0],[0,0,0,1])
simon([1,0,0,0],[0,1,0,0])
simon([1,0,0,0],[0,0,1,0])
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
crx = qk.ClassicalRegister(2,'c')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry,crx)
qc.initialize([1,0,0,0],qrx)
qc.initialize([1,0,0,0],qry)
qc.h([0,1])
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x1x0 = np.kron(x1,x0)
y0 = np.array([[1,0]]).T
y1 = np.array([[1,0]]).T
y1y0 = np.kron(y1,y0)
psi0 = np.kron(y1y0,x1x0)
psi0.T
H = np.array([[1,1],[1,-1]],dtype='int')
H2 = np.kron(H,H)
I2 = np.eye(4)
I2H2 = np.kron(I2,H2)
psi1 = I2H2.dot(psi0)/(np.sqrt(2)*np.sqrt(2))
I2H2.dot(psi0).T
Tf1_2 = np.eye(16)
Tf1_2 = Tf1_2[:,[0,5,2,7,4,1,6,3,8,9,10,11,12,13,14,15]]
psi2 = Tf1_2.dot(psi1); psi2.T*2
Tf2_3 = np.eye(16)
Tf2_3 = Tf2_3[:,[0,1,2,3,4,13,6,15,8,9,10,11,12,5,14,7]]
psi3 = Tf2_3.dot(psi2); psi3.T*2
Tf3_4 = np.eye(16)
Tf3_4 = Tf3_4[:,[0,1,6,3,4,5,2,7,8,9,10,15,12,13,14,11]]
psi4 = Tf3_4.dot(psi3); psi4.T*2
Tf4_5 = np.eye(16)
Tf4_5 = Tf4_5[:,[0,1,2,11,4,5,14,7,8,9,10,3,12,13,6,15]]
psi5 = Tf4_5.dot(psi4); psi5.T*2
I2 = np.eye(4)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
I2H2 = np.kron(I2,H2)
psi6 = I2H2.dot(psi5)
print(psi6.T*2)
import numpy as np
I2 = np.eye(4, dtype='int');
H2 = np.array([[1, 1, 1, 1],
[1,-1, 1,-1],
[1, 1,-1,-1],
[1,-1,-1, 1]])/2;
I2H2 = np.kron(I2,H2);
print(I2H2*2)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x2 = np.array([[1,0]]).T
x2x1x0 = np.kron(x2,np.kron(x1,x0))
x2x1x0.T
y0 = np.array([[1,0]]).T
y1 = np.array([[1,0]]).T
y2 = np.array([[1,0]]).T
y2y1y0 = np.kron(y2,np.kron(y1,y0))
y2y1y0.T
psi0 = np.kron(y2y1y0,x2x1x0)
psi0.T
I3 = np.eye(2**3)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H,H2)
I3H3 = np.kron(I3,H3)
psi1 = I3H3.dot(psi0)
psi1.T.round(2)
n = 2*3 # 2 números de 3 digitos cada
Uf = np.eye(2**n) # 2^6 = 64 posições
Uf = Uf[:,[ 0, 9,18,27,12, 5,30,23,
8, 1,10,11, 4,13,14,15,
16,17, 2,19,20,21,22, 7,
24,25,26, 3,28,29, 6,31,
32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,
48,49,50,51,52,53,54,55,
56,57,58,59,60,61,62,63]]
psi5 = Uf.dot(psi1)
psi5.T.round(2)
psi6 = I3H3.dot(psi5)
psi6.T
np.where(psi6 > 0)[0]
[format(i,'#08b')[2:] for i in np.where(psi6 > 0)[0]]
import numpy as np
CCNOT = np.eye(8)
CCNOT = CCNOT[:,[0,1,2,7,4,5,6,3]]
CCNOT.dot(CCNOT)
import qiskit as qk
def qNAND(y0,x0):
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
z = qk.QuantumRegister(1,"z")
u = qk.QuantumRegister(1,"u")
c = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(x,y,z,u,c)
# Put qubits u and z in state |0>
qc.initialize([1,0],z)
qc.initialize([1,0],u)
qc.initialize(y0,y)
qc.initialize(x0,x)
# Perform computation
qc.barrier()
qc.ccx(x,y,z)
qc.x(z)
# Copy CLASSICALY state of z to u
qc.cx(z,u)
qc.barrier()
# Reverse computation
qc.x(z)
qc.ccx(x,y,z)
qc.barrier()
# Measure results
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(u,c[2])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
print("0 NAND 0 = 1")
qNAND([1,0],[1,0])
print("0 NAND 1 = 1")
qNAND([1,0],[0,1])
print("1 NAND 0 = 1")
qNAND([0,1],[1,0])
print("1 NAND 1 = 0")
qNAND([0,1],[0,1])
import qiskit as qk
def qOR(y0,x0):
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
z = qk.QuantumRegister(1,"z")
u = qk.QuantumRegister(1,"u")
c = qk.ClassicalRegister(3,'c')
# Initialize qubits
qc = qk.QuantumCircuit(x,y,z,u,c)
qc.initialize(x0,x)
qc.initialize(y0,y)
qc.initialize([1,0],z)
qc.initialize([1,0],u)
# Compute function
qc.barrier()
qc.x(x)
qc.x(y)
qc.ccx(x,y,z)
qc.x(z)
qc.cx(z,u)
qc.barrier()
# Reverse computation
qc.x(z)
qc.ccx(x,y,z)
qc.x(y)
qc.x(x)
qc.barrier()
# Measure results
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(u,c[2])
display(qc.draw('mpl'))
# Simulate circuit
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
qOR([1,0],[1,0])
qOR([1,0],[0,1])
qOR([0,1],[1,0])
qOR([0,1],[0,1])
import qiskit as qk
def qNXOR(y0,x0,calc=True,show=False):
##################################################
# Create registers #
##################################################
# Base registers
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
# Auxiliary register (for x and y)
z = qk.QuantumRegister(1,"z")
# Auxiliary register (to store x AND y)
a1 = qk.QuantumRegister(1,"a1")
# Auxiliary register (to store NOT(x) AND NOT(y))
a2 = qk.QuantumRegister(1,"a2")
# Auxiliary register (for a1 and a2)
b1 = qk.QuantumRegister(1,"b1")
# Auxiliary register (to store a1 OR a2)
b2 = qk.QuantumRegister(1,"b2")
# Classical Registers to store x,y and final measurement
c = qk.ClassicalRegister(3,"c")
##################################################
# Create Circuit #
##################################################
qc = qk.QuantumCircuit(x,y,z,a1,a2,b1,b2,c)
##################################################
# Initialize registers #
##################################################
qc.initialize(x0,x)
qc.initialize(y0,y)
qc.initialize([1,0],z)
qc.initialize([1,0],a1)
qc.initialize([1,0],a2)
qc.initialize([1,0],b1)
qc.initialize([1,0],b2)
###################################################
# Calculate x AND y. Copy result to a1. Reverse z #
###################################################
qc.barrier()
qc.ccx(x,y,z)
qc.cx(z,a1)
qc.ccx(x,y,z)
qc.barrier()
#########################################################
# Calc. NOT(x) AND NOT(y). Copy result to a2. Reverse z #
#########################################################
qc.barrier()
qc.x(x)
qc.x(y)
qc.ccx(x,y,z)
qc.cx(z,a2)
qc.ccx(x,y,z)
qc.x(y)
qc.x(x)
qc.barrier()
#################################################
# Calc. a1 OR a2. Copy result to b2. Reverse b1 #
#################################################
qc.barrier()
qc.x(a1)
qc.x(a2)
qc.ccx(a1,a2,b1)
qc.x(b1)
qc.cx(b1,b2)
qc.x(b1)
qc.ccx(a1,a2,b1)
qc.barrier()
#################################################
# Measure b2 #
#################################################
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(b2,c[2])
#################################################
# Draw circuit #
#################################################
if show:
display(qc.draw("mpl"))
#################################################
# Run circuit. Collect results #
#################################################
if calc:
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
else:
return()
qNXOR([1,0],[1,0],False,True)
qNXOR([1,0],[1,0])
qNXOR([1,0],[0,1])
qNXOR([0,1],[1,0])
qNXOR([0,1],[0,1])
x0 = np.array([1,1])/np.sqrt(2)
y0 = np.array([1,1])/np.sqrt(2)
qNXOR(y0,x0)
import qiskit as qk
from qiskit.quantum_info.operators import Operator
qr = qk.QuantumRegister(6,"q")
cr = qk.ClassicalRegister(6,"c")
qc = qk.QuantumCircuit(qr,cr)
for i in range(6):
qc.initialize([1,0],i)
for i in range(3):
qc.h(i)
oracle = np.eye(2**6)
oracle[:,[ 0, 0]] = oracle[:,[ 0, 0]]
oracle[:,[ 1, 9]] = oracle[:,[ 9, 1]]
oracle[:,[ 2, 18]] = oracle[:,[ 18, 2]]
oracle[:,[ 3, 27]] = oracle[:,[ 27, 3]]
oracle[:,[ 4, 12]] = oracle[:,[ 12, 4]]
oracle[:,[ 5, 5]] = oracle[:,[ 5, 5]]
oracle[:,[ 6, 30]] = oracle[:,[ 30, 6]]
oracle[:,[ 7, 23]] = oracle[:,[ 23, 7]]
oracle = Operator(oracle)
qc.append(oracle,qr)
for i in range(3):
qc.h(i)
qc.barrier()
for i in range(3):
qc.measure(i,i)
display(qc.draw("mpl"))
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
psi0 = np.kron(x1,x0)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
psi1 = H2.dot(psi0)
psi1.T
# Initialize a qubit y in state |1>
y = np.array([[0,1]]).T
# Pass it through a Hadamard gate and obtain state psi2a
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
psi2a = H.dot(y)
psi2a.T
psi2 = np.kron(psi2a,psi1)
psi2.T
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle
psi3 = oracle.dot(psi2)
psi3.T
v0 = np.array([[10,20,-30,40,50]]).T
mu = np.mean(v0)
v0.T, mu
D = v0 - mu
D.T
v1 = 2*np.mean(v0)-v0
v1.T
import numpy as np
A = np.ones(5**2).reshape(5,5)
A = A/5
I = np.eye(5)
R = 2*A-I
R
R.dot(R)
n = 4
I = np.eye(n)
A = np.ones(n**2).reshape(n,n)/n
R = 2*A-I
R
I2 = np.eye(2)
I2R = np.kron(I2,R)
I2R
psi4 = I2R.dot(psi3)
psi4.T
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(3,'q')
c = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.initialize([0,1],2)
qc.h(2)
qc.barrier()
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle = Operator(oracle)
qc.append(oracle,q)
# n = 2 (two digits number to look for)
A = np.ones(4*4).reshape(4,4)/4
I4 = np.eye(4)
R = 2*A - I4
I2 = np.eye(2)
boost = np.kron(I2,R)
boost = Operator(boost)
qc.append(boost,q)
qc.barrier()
qc.measure(q[:2],c[:2])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x2 = np.array([[1,0]]).T
x2x1x0 = np.kron(x2,np.kron(x1,x0))
x2x1x0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H,H2)
x = H3.dot(x2x1x0)
x.T
y0 = np.array([[0,1]]).T
y0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
y = H.dot(y0)
y.T
psi0 = np.kron(y,x)
psi0.T
oracle = np.eye(16)
oracle[:,[5,13]] = oracle[:,[13,5]]
psi1 = oracle.dot(psi0)
psi1.T
# n = 8
A = np.ones(8*8).reshape(8,8)/8
I8 = np.eye(8)
R = 2*A-I8
R
I2 = np.eye(2)
I2R = np.kron(I2,R)
psi2 = I2R.dot(psi1)
psi2.T
0.625**2 + 0.625**2
psi3 = I2R.dot(oracle).dot(psi2)
psi3.T
0.687**2 + 0.687**2
I2R.dot(oracle).dot(psi3).T
T = I2R.dot(oracle)
psi = psi1
prob = []
for i in range(25):
prob.append(psi[5,0]**2 + psi[13,0]**2)
psi = T.dot(psi)
from matplotlib import pyplot as plt
plt.plot(list(range(25)), prob);
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(4,'q')
c = qk.ClassicalRegister(4,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.initialize([0,1],3)
qc.h(3)
qc.barrier()
# Create oracle matrix
oracle = np.eye(16)
oracle[:,[5,13]] = oracle[:,[13,5]]
# Create rotation about the mean matrix
# n = 3 (three digits number to look for)
A = np.ones(8*8).reshape(8,8)/8
I8 = np.eye(8)
R = 2*A - I8
# Identity matrix to leave fourth qubit undisturbed
I2 = np.eye(2)
# Create second transformation matrix
boost = np.kron(I2,R)
# Combine oracle with second transformation matrix in
# an unique operator
T = boost.dot(oracle)
T = Operator(T)
# Apply operator twice (2 phase inversions and
# rotations about the mean)
qc.append(T,q)
qc.append(T,q)
qc.barrier()
qc.measure(q[:3],c[:3])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(5,'q')
c = qk.ClassicalRegister(5,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
qc.initialize([1,0],3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.initialize([0,1],4)
qc.h(4)
qc.barrier()
# Create oracle matrix
oracle = np.eye(32)
oracle[:,[13,29]] = oracle[:,[29,13]]
# Create rotation about the mean matrix
# n = 4 (four digits number to look for)
A = np.ones(16*16).reshape(16,16)/16
I16 = np.eye(16)
R = 2*A - I16
# Identity matrix to leave fifth qubit undisturbed
I2 = np.eye(2)
# Create second transformation matrix
boost = np.kron(I2,R)
# Combine oracle with second transformation matrix in
# an unique operator
T = boost.dot(oracle)
# n = 4. Therefore it will be necessary 4 T operations
# to get maximum probability.
Tn = T.dot(T).dot(T)
Tn = Operator(Tn)
# Apply operator Tn once (n phase inversions and
# rotations about the mean)
qc.append(Tn,q)
qc.barrier()
qc.measure(q[:4],c[:4])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
import pandas as pd
N = 35; a = 6
GCD = pd.DataFrame({'N':[N], 'a':[a], 'N-a':[N-a]})
while GCD.iloc[-1,2] != 0:
temp = GCD.iloc[-1].values
temp = np.sort(temp); temp[-1] = temp[-2] - temp[-3]
temp = pd.DataFrame(data = temp.reshape(-1,3), columns = ['N','a','N-a'])
GCD = GCD.append(temp, ignore_index=True)
GCD
import numpy as np
import pandas as pd
N = 15; a = 9
GCD = pd.DataFrame({'N':[N], 'a':[a], 'N-a':[N-a]})
while GCD.iloc[-1,2] != 0:
temp = GCD.iloc[-1].values
temp = np.sort(temp); temp[-1] = temp[-2] - temp[-3]
temp = pd.DataFrame(data = temp.reshape(-1,3), columns = ['N','a','N-a'])
GCD = GCD.append(temp, ignore_index=True)
GCD
import numpy as np
np.gcd(6,35), np.gcd(9,15)
import numpy as np
np.gcd(215,35), np.gcd(217,35)
20 % 7
import numpy as np
f = lambda x,a,N: a**x % N
[f(x,2,15) for x in range(10)]
import numpy as np
(13*35)%11, ((2%11)*(24%11))%11
import numpy as np
def f(x,a,N):
a0 = 1
for i in range(x):
a0 = ((a%N)*(a0))%N
return(a0)
[f(x,2,371) for x in range(8)]
[f(x,2,371) for x in range(154,159)]
[f(x,24,371) for x in range(77,81)]
import numpy as np
def fr(a,N):
ax = ((a%N)*(1))%N
x = 1
while ax != 1:
ax = ((a%N)*(ax))%N
x = x+1
return(x)
fr(2,371), fr(6,371), fr(24,371)
import numpy as np
def fr(a,N):
a0 = 1
a0 = ((a%N)*a0)%N
x = 2
find = False
while find==False:
a0 = ((a%N)*(a0))%N
if a0 == 1:
find = True
x = x+1
return(x-1)
N = 35
a = 2
fr(a,N)
2**(12/2)-1, 2**(12/2)+1
np.gcd(63,35), np.gcd(65,35)
import numpy as np
# Function to calculate the period of f(x) = a^x MOD N
def fr(a,N):
a1 = ((a%N)*(1))%N
x = 1
while a1 != 1:
a1 = ((a%N)*a1)%N
x = x+1
return(x)
# Function to factor N based on a
def factor(N, a=2):
r = fr(a,N)
g1 = a**(int(r/2)) - 1
g2 = a**(int(r/2)) + 1
f1 = np.gcd(g1,N)
f2 = np.gcd(g2,N)
return(f1,f2, f1*f2)
factor(247)
factor(1045)
import numpy as np
N = 15 # number to be factored
n = 4 # number of bits necessary to represent N
m = 8 # number of bits necessary to represent N^2
x = np.zeros(2**m).reshape(-1,1)
x[0,0] = 1
x.shape # since x is a 2^8 = 256 positions vector it will not be showed here
y = np.zeros(2**n).reshape(-1,1)
y[0,0] = 1; y.T # y is a 2^4 = 16 positions vector shown below
psi0 = np.kron(y,x)
psi0.shape # psi0 is a 256 x 16 = 4.096 positions vector
In = np.eye(2**n); In.shape
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
Hm = H.copy()
for i in range(1,m):
Hm = np.kron(Hm,H)
Hm.shape
psi1 = np.kron(In,Hm).dot(psi0); psi1.shape
|
https://github.com/cjsproject/qiskit_learning
|
cjsproject
|
import numpy as np
from matplotlib.image import imread
import matplotlib.pyplot as plt
import torch
from torchvision import transforms
from torchvision.datasets import MNIST
# the data is not normalized, and needs to be converted to a np array...
digits = MNIST('data', train=True, download=False)
# converting to np array and normalizing by val/max(arr)
digits = digits.data.numpy()
digits = digits/np.max(digits)
#displaying image
display = plt.imshow(digits[0])
display.set_cmap('gray')
print(digits[0].shape)
# grab 4x4 squares of the image
im1 = digits[0]
stride = 1
mat_sq = np.zeros([28,28,4,4])
for i in range(0, len(im1)-4, stride):
for j in range(0, len(im1[i])-4, stride):
cube = im1[i:i+4, j:j+4]
mat_sq[i, j] = cube
# creates a 2d collection of matrices, where each [i, j] index contains a 4x4 matrix
print(mat_sq[14, 14])
display = plt.imshow(mat_sq[14, 14])
display.set_cmap('gray')
# find SVD of each submatrix, make unitary and assign to uni
uni = np.zeros([28,28,4,4])
for i in range(len(mat_sq)):
for j in range(len(mat_sq[i])):
U, S, VT = np.linalg.svd(mat_sq[i, j])
uni[i, j] = np.dot(U, VT)
#print(f"U =\n{U}\n S =\n{S}\n VT=\n{VT}\n")
test = uni[14,14]
# comparing unitary, they aren't the same :(
print(f"U*VT:\n{uni[14, 14]}\nOriginal:\n{mat_sq[14, 14]}")
# try graham schmidt, they're just about the same!
# seems to have detected an edge.
Q, R = np.linalg.qr(mat_sq[14, 14])
print(f"Q:\n{Q}\nOriginal:\n{mat_sq[14, 14]}\nIs Q Unitary:\n{np.matmul(Q, Q.transpose(0, 1)).round()}")
display = plt.imshow(Q)
display.set_cmap('gray')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.random import random_circuit
circuit = random_circuit(2, 2, seed=0, measure=True).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit.primitives import Sampler
sampler = Sampler()
job = sampler.run(circuit)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> {result}")
print(f" > Quasi-distribution: {result.quasi_dists[0]}")
circuit = random_circuit(2, 2, seed=1, measure=True).decompose(reps=1)
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f">>> Quasi-distribution: {result.quasi_dists[0]}")
circuits = (
random_circuit(2, 2, seed=0, measure=True).decompose(reps=1),
random_circuit(2, 2, seed=1, measure=True).decompose(reps=1),
)
job = sampler.run(circuits)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f">>> Quasi-distribution: {result.quasi_dists}")
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
circuit.measure_all()
parameter_values = [0, 1, 2, 3, 4, 5]
job = sampler.run(circuit, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f">>> Parameter values: {parameter_values}")
print(f">>> Quasi-distribution: {result.quasi_dists[0]}")
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
circuit = random_circuit(2, 2, seed=0, measure=True).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit_ibm_runtime import Sampler
sampler = Sampler(session=backend)
job = sampler.run(circuit)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> {result}")
print(f" > Quasi-distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Options
options = Options(optimization_level=3, environment={"log_level": "INFO"})
from qiskit_ibm_runtime import Options
options = Options()
options.resilience_level = 1
options.execution.shots = 2048
sampler = Sampler(session=backend, options=options)
result = sampler.run(circuit).result()
print(f">>> Metadata: {result.metadata[0]}")
sampler = Sampler(session=backend, options=options)
result = sampler.run(circuit, shots=1024).result()
print(f">>> Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Options
# optimization_level=3 adds dynamical decoupling
# resilience_level=1 adds readout error mitigation
options = Options(optimization_level=3, resilience_level=1)
sampler = Sampler(session=backend, options=options)
result = sampler.run(circuit).result()
print(f">>> Quasi-distribution: {result.quasi_dists[0]}")
print(f">>> Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Session, Estimator
with Session(backend=backend, max_time="1h"):
sampler = Sampler()
result = sampler.run(circuit).result()
print(f">>> Quasi-distribution from the first run: {result.quasi_dists[0]}")
result = sampler.run(circuit).result()
print(f">>> Quasi-distribution from the second run: {result.quasi_dists[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
estimator_circuit = random_circuit(2, 2, seed=0).decompose(reps=1)
display(estimator_circuit.draw("mpl"))
observable = SparsePauliOp("XZ")
print(f">>> Observable: {observable.paulis}")
from qiskit_ibm_runtime import Session, Sampler, Estimator
with Session(backend=backend):
sampler = Sampler()
estimator = Estimator()
result = sampler.run(circuit).result()
print(f">>> Quasi Distribution from the sampler job: {result.quasi_dists[0]}")
result = estimator.run(estimator_circuit, observable).result()
print(f">>> Expectation value from the estimator job: {result.values[0]}")
from qiskit_ibm_runtime import Session, Sampler, Estimator
with Session(backend=backend):
sampler = Sampler()
estimator = Estimator()
sampler_job = sampler.run(circuit)
estimator_job = estimator.run(estimator_circuit, observable)
print(f">>> Quasi Distribution from the sampler job: {sampler_job.result().quasi_dists[0]}")
print(f">>> Expectation value from the estimator job: {estimator_job.result().values[0]}")
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Estimator, Options
# 1. Initialize account
service = QiskitRuntimeService(channel="ibm_quantum")
# 2. Specify options, such as enabling error mitigation
options = Options(resilience_level=1)
# 3. Select a backend.
backend = service.backend("ibmq_qasm_simulator")
# 4. Create a session
with Session(backend=backend):
# 5. Create primitive instances
sampler = Sampler(options=options)
estimator = Estimator(options=options)
# 6. Submit jobs
sampler_job = sampler.run(circuit)
estimator_job = estimator.run(estimator_circuit, observable)
# 7. Get results
print(f">>> Quasi Distribution from the sampler job: {sampler_job.result().quasi_dists[0]}")
print(f">>> Expectation value from the estimator job: {estimator_job.result().values[0]}")
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/ronitd2002/IBM-Quantum-challenge-2024
|
ronitd2002
|
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=2, reps=1, entanglement='linear')
ansatz.draw('mpl', style='iqx')
from qiskit.opflow import Z, I
hamiltonian = Z ^ Z
from qiskit.opflow import StateFn
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
import numpy as np
point = np.random.random(ansatz.num_parameters)
index = 2
from qiskit import Aer
from qiskit.utils import QuantumInstance
backend = Aer.get_backend('qasm_simulator')
q_instance = QuantumInstance(backend, shots = 8192, seed_simulator = 2718, seed_transpiler = 2718)
from qiskit.circuit import QuantumCircuit
from qiskit.opflow import Z, X
H = X ^ X
U = QuantumCircuit(2)
U.h(0)
U.cx(0, 1)
# YOUR CODE HERE
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
matmult_result =expectation.eval()
from qc_grader import grade_lab4_ex1
# Note that the grading function is expecting a complex number
grade_lab4_ex1(matmult_result)
from qiskit.opflow import CircuitSampler, PauliExpectation
sampler = CircuitSampler(q_instance)
# YOUR CODE HERE
sampler = CircuitSampler(q_instance) # q_instance is the QuantumInstance from the beginning of the notebook
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
in_pauli_basis = PauliExpectation().convert(expectation)
shots_result = sampler.convert(in_pauli_basis).eval()
from qc_grader import grade_lab4_ex2
# Note that the grading function is expecting a complex number
grade_lab4_ex2(shots_result)
from qiskit.opflow import PauliExpectation, CircuitSampler
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
in_pauli_basis = PauliExpectation().convert(expectation)
sampler = CircuitSampler(q_instance)
def evaluate_expectation(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(in_pauli_basis, params=value_dict).eval()
return np.real(result)
eps = 0.2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / (2 * eps)
print(finite_difference)
from qiskit.opflow import Gradient
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('fin_diff', analytic=False, epsilon=eps)
grad = shifter.convert(expectation, params=ansatz.parameters[index])
print(grad)
value_dict = dict(zip(ansatz.parameters, point))
sampler.convert(grad, value_dict).eval().real
eps = np.pi / 2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / 2
print(finite_difference)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient() # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('lin_comb') # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
# initial_point = np.random.random(ansatz.num_parameters)
initial_point = np.array([0.43253681, 0.09507794, 0.42805949, 0.34210341])
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
sampler = CircuitSampler(q_instance)
def evaluate_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(gradient_in_pauli_basis, params=value_dict).eval() # add parameters in here!
return np.real(result)
# Note: The GradientDescent class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import GradientDescent
from qc_grader.gradient_descent import GradientDescent
gd_loss = []
def gd_callback(nfevs, x, fx, stepsize):
gd_loss.append(fx)
gd = GradientDescent(maxiter=300, learning_rate=0.01, callback=gd_callback)
x_opt, fx_opt, nfevs = gd.optimize(initial_point.size, # number of parameters
evaluate_expectation, # function to minimize
gradient_function=evaluate_gradient, # function to evaluate the gradient
initial_point=initial_point) # initial point
import matplotlib
import matplotlib.pyplot as plt
matplotlib.rcParams['font.size'] = 14
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, label='vanilla gradient descent')
plt.axhline(-1, ls='--', c='tab:red', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend();
from qiskit.opflow import NaturalGradient
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
natural_gradient = NaturalGradient(regularization='ridge').convert(expectation)
natural_gradient_in_pauli_basis = PauliExpectation().convert(natural_gradient)
sampler = CircuitSampler(q_instance, caching="all")
def evaluate_natural_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(natural_gradient, params=value_dict).eval()
return np.real(result)
print('Vanilla gradient:', evaluate_gradient(initial_point))
print('Natural gradient:', evaluate_natural_gradient(initial_point))
qng_loss = []
def qng_callback(nfevs, x, fx, stepsize):
qng_loss.append(fx)
qng = GradientDescent(maxiter=300, learning_rate=0.01, callback=qng_callback)
x_opt, fx_opt, nfevs = qng.optimize(initial_point.size,
evaluate_expectation,
gradient_function=evaluate_natural_gradient,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
from qc_grader.spsa import SPSA
spsa_loss = []
def spsa_callback(nfev, x, fx, stepsize, accepted):
spsa_loss.append(fx)
spsa = SPSA(maxiter=300, learning_rate=0.01, perturbation=0.01, callback=spsa_callback)
x_opt, fx_opt, nfevs = spsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
# Note: The QNSPSA class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import QNSPSA
from qc_grader.qnspsa import QNSPSA
qnspsa_loss = []
def qnspsa_callback(nfev, x, fx, stepsize, accepted):
qnspsa_loss.append(fx)
fidelity = QNSPSA.get_fidelity(ansatz, q_instance, expectation=PauliExpectation())
qnspsa = QNSPSA(fidelity, maxiter=300, learning_rate=0.01, perturbation=0.01, callback=qnspsa_callback)
x_opt, fx_opt, nfevs = qnspsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
autospsa_loss = []
def autospsa_callback(nfev, x, fx, stepsize, accepted):
autospsa_loss.append(fx)
autospsa = SPSA(maxiter=300, learning_rate=None, perturbation=None, callback=autospsa_callback)
x_opt, fx_opt, nfevs = autospsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.plot(autospsa_loss, 'tab:red', label='Powerlaw SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
H_tfi = -(Z^Z^I)-(I^Z^Z)-(X^I^I)-(I^X^I)-(I^I^X)
from qc_grader import grade_lab4_ex3
# Note that the grading function is expecting a Hamiltonian
grade_lab4_ex3(H_tfi)
from qiskit.circuit.library import EfficientSU2
efficient_su2 = EfficientSU2(3, entanglement="linear", reps=2)
tfi_sampler = CircuitSampler(q_instance)
def evaluate_tfi(parameters):
exp = StateFn(H_tfi, is_measurement=True).compose(StateFn(efficient_su2))
value_dict = dict(zip(efficient_su2.parameters, parameters))
result = tfi_sampler.convert(PauliExpectation().convert(exp), params=value_dict).eval()
return np.real(result)
# target energy
tfi_target = -3.4939592074349326
# initial point for reproducibility
tfi_init = np.array([0.95667807, 0.06192812, 0.47615196, 0.83809827, 0.89022282,
0.27140831, 0.9540853 , 0.41374024, 0.92595507, 0.76150126,
0.8701938 , 0.05096063, 0.25476016, 0.71807858, 0.85661325,
0.48311132, 0.43623886, 0.6371297 ])
tfi_result = SPSA(maxiter=300, learning_rate=None, perturbation=None)
tfi_result = tfi_result.optimize(tfi_init.size, evaluate_tfi, initial_point=tfi_init)
tfi_minimum = tfi_result[1]
print("Error:", np.abs(tfi_result[1] - tfi_target))
from qc_grader import grade_lab4_ex4
# Note that the grading function is expecting a floating point number
grade_lab4_ex4(tfi_minimum)
from qiskit_machine_learning.datasets import ad_hoc_data
training_features, training_labels, test_features, test_labels = ad_hoc_data(
training_size=20, test_size=10, n=2, one_hot=False, gap=0.5
)
# the training labels are in {0, 1} but we'll use {-1, 1} as class labels!
training_labels = 2 * training_labels - 1
test_labels = 2 * test_labels - 1
def plot_sampled_data():
from matplotlib.patches import Patch
from matplotlib.lines import Line2D
import matplotlib.pyplot as plt
plt.figure(figsize=(12,6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label in zip(test_features, test_labels):
marker = 's'
plt.scatter(feature[0], feature[1], marker=marker, s=100, facecolor='none', edgecolor='k')
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='none', mec='k', label='test features', ms=10)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.6))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_sampled_data()
from qiskit.circuit.library import ZZFeatureMap
dim = 2
feature_map = ZZFeatureMap(dim, reps=1) # let's keep it simple!
feature_map.draw('mpl', style='iqx')
ansatz = RealAmplitudes(num_qubits=dim, entanglement='linear', reps=1) # also simple here!
ansatz.draw('mpl', style='iqx')
circuit = feature_map.compose(ansatz)
circuit.draw('mpl', style='iqx')
hamiltonian = Z ^ Z # global Z operators
gd_qnn_loss = []
def gd_qnn_callback(*args):
gd_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=gd_qnn_callback)
from qiskit_machine_learning.neural_networks import OpflowQNN
qnn_expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
exp_val=PauliExpectation(),
gradient=Gradient(), # <-- Parameter-Shift gradients
quantum_instance=q_instance)
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
#initial_point = np.array([0.2, 0.1, 0.3, 0.4])
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)
classifier.fit(training_features, training_labels);
predicted = classifier.predict(test_features)
def plot_predicted():
from matplotlib.lines import Line2D
plt.figure(figsize=(12, 6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label, pred in zip(test_features, test_labels, predicted):
marker = 's'
color = 'tab:green' if pred == -1 else 'tab:blue'
if label != pred: # mark wrongly classified
plt.scatter(feature[0], feature[1], marker='o', s=500, linewidths=2.5,
facecolor='none', edgecolor='tab:red')
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='tab:green', label='predict A', ms=10),
Line2D([0], [0], marker='s', c='w', mfc='tab:blue', label='predict B', ms=10),
Line2D([0], [0], marker='o', c='w', mfc='none', mec='tab:red', label='wrongly classified', mew=2, ms=15)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.7))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_predicted()
qng_qnn_loss = []
def qng_qnn_callback(*args):
qng_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=qng_qnn_callback)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
gradient=NaturalGradient(regularization='ridge'), # <-- using Natural Gradients!
quantum_instance=q_instance)
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)#, initial_point=initial_point)
classifier.fit(training_features, training_labels);
def plot_losses():
plt.figure(figsize=(12, 6))
plt.plot(gd_qnn_loss, 'tab:blue', marker='o', label='vanilla gradients')
plt.plot(qng_qnn_loss, 'tab:green', marker='o', label='natural gradients')
plt.xlabel('iterations')
plt.ylabel('loss')
plt.legend(loc='best')
plot_losses()
from qiskit.opflow import I
def sample_gradients(num_qubits, reps, local=False):
"""Sample the gradient of our model for ``num_qubits`` qubits and ``reps`` repetitions.
We sample 100 times for random parameters and compute the gradient of the first RY rotation gate.
"""
index = num_qubits - 1
# you can also exchange this for a local operator and observe the same!
if local:
operator = Z ^ Z ^ (I ^ (num_qubits - 2))
else:
operator = Z ^ num_qubits
# real amplitudes ansatz
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
# construct Gradient we want to evaluate for different values
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = Gradient().convert(expectation, params=ansatz.parameters[index])
# evaluate for 100 different, random parameter values
num_points = 100
grads = []
for _ in range(num_points):
# points are uniformly chosen from [0, pi]
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
gradients = [sample_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='measured variance')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
from qiskit.opflow import NaturalGradient
def sample_natural_gradients(num_qubits, reps):
index = num_qubits - 1
operator = Z ^ num_qubits
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = # TODO: ``grad`` should be the natural gradient for the parameter at index ``index``.
# Hint: Check the ``sample_gradients`` function, this one is almost the same.
grad = NaturalGradient().convert(expectation, params=ansatz.parameters[index])
num_points = 100
grads = []
for _ in range(num_points):
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
natural_gradients = [sample_natural_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(natural_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='vanilla gradients')
plt.semilogy(num_qubits, np.var(natural_gradients, axis=1), 's-', label='natural gradients')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {float(fit[0]):.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_global_gradients = [sample_gradients(n, 1) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_global_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
linear_depth_local_gradients = [sample_gradients(n, n, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(linear_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_local_gradients = [sample_gradients(n, 1, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_local_gradients, axis=1), 'o-', label='local cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = 6
operator = Z ^ Z ^ (I ^ (num_qubits - 4))
def minimize(circuit, optimizer):
initial_point = np.random.random(circuit.num_parameters)
exp = StateFn(operator, is_measurement=True) @ StateFn(circuit)
grad = Gradient().convert(exp)
# pauli basis
exp = PauliExpectation().convert(exp)
grad = PauliExpectation().convert(grad)
sampler = CircuitSampler(q_instance, caching="all")
def loss(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(exp, values_dict).eval())
def gradient(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(grad, values_dict).eval())
return optimizer.optimize(circuit.num_parameters, loss, gradient, initial_point=initial_point)
circuit = RealAmplitudes(4, reps=1, entanglement='linear')
circuit.draw('mpl', style='iqx')
circuit.reps = 5
circuit.draw('mpl', style='iqx')
def layerwise_training(ansatz, max_num_layers, optimizer):
optimal_parameters = []
fopt = None
for reps in range(1, max_num_layers):
ansatz.reps = reps
# bind already optimized parameters
values_dict = dict(zip(ansatz.parameters, optimal_parameters))
partially_bound = ansatz.bind_parameters(values_dict)
xopt, fopt, _ = minimize(partially_bound, optimizer)
print('Circuit depth:', ansatz.depth(), 'best value:', fopt)
optimal_parameters += list(xopt)
return fopt, optimal_parameters
ansatz = RealAmplitudes(4, entanglement='linear')
optimizer = GradientDescent(maxiter=50)
np.random.seed(12)
fopt, optimal_parameters = layerwise_training(ansatz, 4, optimizer)
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
"""
Quantum Fourier Transform Benchmark Program - QSim
"""
import math
import sys
import time
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import QFT
sys.path[1:1] = [ "_common", "_common/qsim" ]
sys.path[1:1] = [ "../../_common", "../../_common/qsim" ]
import execute as ex
import metrics as metrics
from execute import BenchmarkResult
# Benchmark Name
benchmark_name = "Quantum Fourier Transform"
np.random.seed(0)
verbose = False
# saved circuits for display
num_gates = 0
depth = 0
QC_ = None
QFT_ = None
QFTI_ = None
############### Circuit Definition
def QuantumFourierTransform (num_qubits, secret_int, method=1):
global num_gates, depth
# Size of input is one less than available qubits
input_size = num_qubits
num_gates = 0
depth = 0
# allocate qubits
qr = QuantumRegister(num_qubits); cr = ClassicalRegister(num_qubits);
qc = QuantumCircuit(qr, cr, name=f"qft({method})-{num_qubits}-{secret_int}")
if method==1:
# Perform X on each qubit that matches a bit in the secret string
s = ('{0:0'+str(input_size)+'b}').format(secret_int)
for i_qubit in range(input_size):
if s[input_size-1-i_qubit]=='1':
qc.x(qr[i_qubit])
num_gates += 1
depth += 1
qc.barrier()
# perform QFT on the input
qc.append(qft_gate(input_size).to_instruction(), qr)
# End with Hadamard on all qubits (to measure the z rotations)
''' don't do this unless NOT doing the inverse afterwards
for i_qubit in range(input_size):
qc.h(qr[i_qubit])
qc.barrier()
'''
qc.barrier()
# some compilers recognize the QFT and IQFT in series and collapse them to identity;
# perform a set of rotations to add one to the secret_int to avoid this collapse
for i_q in range(0, num_qubits):
divisor = 2 ** (i_q)
qc.rz( 1 * math.pi / divisor , qr[i_q])
num_gates+=1
qc.barrier()
# to revert back to initial state, apply inverse QFT
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
qc.barrier()
elif method == 2:
for i_q in range(0, num_qubits):
qc.h(qr[i_q])
num_gates += 1
for i_q in range(0, num_qubits):
divisor = 2 ** (i_q)
qc.rz(secret_int * math.pi / divisor, qr[i_q])
num_gates += 1
depth += 1
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
# This method is a work in progress
elif method==3:
for i_q in range(0, secret_int):
qc.h(qr[i_q])
num_gates+=1
for i_q in range(secret_int, num_qubits):
qc.x(qr[i_q])
num_gates+=1
depth += 1
qc.append(inv_qft_gate(input_size).to_instruction(), qr)
else:
exit("Invalid QFT method")
# measure all qubits
qc.measure(qr, cr) # to get the partial_probability
# qc.measure(qr, cr, basis='Ensemble', add_param='Z') # to get the ensemble_probability
# However, Qiskit's measure method might not directly support the 'Ensemble' basis with 'Z' parameter.
# The basis parameter is typically used for different bases such as 'X', 'Y', or 'Z', but 'Ensemble' might not be directly supported.
num_gates += num_qubits
depth += 1
# save smaller circuit example for display
global QC_
if QC_ == None or num_qubits <= 5:
if num_qubits < 9: QC_ = qc
# return a handle on the circuit
return qc
############### QFT Circuit
def qft_gate(input_size):
global QFT_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in range(0, input_size):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in range(0, num_crzs):
divisor = 2 ** (num_crzs - j)
qc.crz( math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
# followed by an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
qc.barrier()
if QFT_ == None or input_size <= 8:
if input_size < 9: QFT_ = qc
return qc
############### Inverse QFT Circuit
def inv_qft_gate(input_size):
global QFTI_, num_gates, depth
qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft")
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in reversed(range(0, input_size)):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# precede with an H gate (applied to all qubits)
qc.h(qr[hidx])
num_gates += 1
depth += 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in reversed(range(0, num_crzs)):
divisor = 2 ** (num_crzs - j)
qc.crz( -math.pi / divisor , qr[hidx], qr[input_size - j - 1])
num_gates += 1
depth += 1
qc.barrier()
if QFTI_ == None or input_size <= 8:
if input_size < 9: QFTI_= qc
return qc
# Define expected distribution calculated from applying the iqft to the prepared secret_int state
def expected_dist(num_qubits, secret_int, counts):
dist = {}
s = num_qubits - secret_int
for key in counts.keys():
if key[(num_qubits-secret_int):] == ''.zfill(secret_int):
dist[key] = 1/(2**s)
return dist
############### Result Data Analysis
# Analyze and print measured results
def analyze_and_print_result (qc, result, num_qubits, secret_int, num_shots, method):
# obtain probs from the result object
if result.backend_name == 'dm_simulator':
benchmark_result = BenchmarkResult(result, num_shots)
probs = benchmark_result.get_probs(num_shots) # get results as measured probability
else:
probs = result.get_counts(qc) # get results as measured counts
# For method 1, expected result is always the secret_int
if method==1:
# add one to the secret_int to compensate for the extra rotations done between QFT and IQFT
secret_int_plus_one = (secret_int + 1) % (2 ** num_qubits)
# print("secret_int_plus_one =====", secret_int_plus_one)
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int_plus_one, f"0{num_qubits}b") # format is in big-endian since it was for counts
# print(f"keys ===== {key}")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
# For method 2, expected result is always the secret_int
elif method==2:
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int, f"0{num_qubits}b")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
# For method 3, correct_dist is a distribution with more than one value
elif method==3:
# correct_dist is from the expected dist
correct_dist = expected_dist(num_qubits, secret_int, probs)
# print(f"\ncorrect_dist ===== {correct_dist}")
# print(f"\nsecret_int ====== {secret_int} ")
# use our polarization fidelity rescaling
fidelity = metrics.polarization_fidelity(probs, correct_dist)
if verbose: print(f"For secret int {secret_int} measured: {probs} fidelity: {fidelity}")
print(f"Fidelity :::::::: {fidelity}")
return probs, fidelity
################ Benchmark Loop
# Execute program with default parameters (try for both with and without noise by changing in execute.py)
def run (min_qubits = 2, max_qubits = 8, max_circuits = 3, skip_qubits=1, num_shots = 100, # increasing max_circuits to ensure a better exploration of the possibilities.
method=1, backend_id='dm_simulator', provider_backend=None,
#hub="ibm-q", group="open", project="main",
exec_options=None, context=None):
print(f"{benchmark_name} ({method}) Benchmark Program - QSim")
# validate parameters (smallest circuit is 2 qubits)
max_qubits = max(3, max_qubits)
min_qubits = min(max(2, min_qubits), max_qubits)
skip_qubits = max(1, skip_qubits)
#print(f"min, max qubits = {min_qubits} {max_qubits}")
# create context identifier
if context is None: context = f"{benchmark_name} ({method}) Benchmark"
##########
# Initialize metrics module
metrics.init_metrics()
# Define custom result handler
def execution_handler (qc, result, input_size, s_int, num_shots):
# determine fidelity of result set
num_qubits = int(input_size)
counts, fidelity = analyze_and_print_result(qc, result, num_qubits, int(s_int), num_shots, method)
metrics.store_metric(input_size, s_int, 'fidelity', fidelity)
# Initialize execution module using the execution result handler above and specified backend_id
ex.init_execution(execution_handler)
ex.set_execution_target(backend_id, provider_backend=provider_backend,
# hub=hub, group=group, project=project,
exec_options=exec_options, context=context)
##########
# Execute Benchmark Program N times for multiple circuit sizes
# Accumulate metrics asynchronously as circuits complete
for input_size in range(min_qubits, max_qubits + 1, skip_qubits):
# reset random seed
np.random.seed(0) # when you need reproducibility, for example, when debugging or testing algorithms where you want the same sequence of random numbers for consistency.
num_qubits = input_size
# determine number of circuits to execute for this group
# and determine range of secret strings to loop over
if method == 1 or method == 2:
num_circuits = min(2**(input_size), max_circuits)
if 2**(input_size) <= max_circuits:
s_range = list(range(num_circuits))
# print("if ============ if")
else:
s_range = np.random.choice(range(2**(input_size)), num_circuits, False)
# print("else ============== else")
print(f"s_range === {s_range}")
elif method == 3:
num_circuits = min(input_size, max_circuits)
if input_size <= max_circuits:
s_range = list(range(num_circuits))
else:
s_range = np.random.choice(range(input_size), num_circuits, False)
else:
sys.exit("Invalid QFT method")
print(f"************\nExecuting [{num_circuits}] circuits with num_qubits = {num_qubits}")
# loop over limited # of secret strings for this
for s_int in s_range:
# create the circuit for given qubit size and secret string, store time metric
ts = time.time()
qc = QuantumFourierTransform(num_qubits, s_int, method=method).reverse_bits() #check qiskit-aakash/releasenotes/notes/0.17/qft-little-endian-d232c93e044f0063.yaml
metrics.store_metric(input_size, s_int, 'create_time', time.time()-ts)
# collapse the sub-circuits used in this benchmark (for qiskit)
qc2 = qc.decompose()
# submit circuit for execution on target (simulator, cloud simulator, or hardware)
ex.submit_circuit(qc2, input_size, s_int, num_shots)
print(qc)
print(f"... number of gates, depth = {num_gates}, {depth}")
# Wait for some active circuits to complete; report metrics when groups complete
ex.throttle_execution(metrics.finalize_group)
# Wait for all active circuits to complete; report metrics when groups complete
ex.finalize_execution(metrics.finalize_group)
##########
# print a sample circuit created (if not too large)
print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
if method==1:
print("\nQFT Circuit ="); print(QFT_)
print("\nInverse QFT Circuit ="); print(QFTI_)
# Plot metrics for all circuit sizes
metrics.plot_metrics(f"Benchmark Results - {benchmark_name} ({method}) - QSim")
# if main, execute method 1
if __name__ == '__main__': run()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_bogota')
from qiskit.tools.visualization import plot_histogram
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
def qc_df():
qc = QuantumCircuit(1, name = 'DF')
qc.s(0); qc.h(0); qc.s(0)
return qc
qc_df_ = qc_df(); qc_df_.draw(output = 'mpl')
def qc_bomb():
qc = QuantumCircuit(2, name = 'bomba')
qc.cx(0,1)
return qc
qc_bomb_ = qc_bomb(); qc_bomb_.draw(output = 'mpl')
def qc_espelho():
qc = QuantumCircuit(1, name = 'espelho')
qc.z(0); qc.y(0)
return qc
qc_espelho_ = qc_espelho(); qc_espelho_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_df_ = qc_df(); qc.append(qc_df_, [0])
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc_bomb_ = qc_bomb(); qc.append(qc_bomb_, [0,1])
qc.append(qc_df_, [0]); qc.barrier()
qc.measure([0,1],[0,1])
qc.draw(output = 'mpl')
job = qiskit.execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
job = qiskit.execute(qc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
plot_histogram(job.result().get_counts(qc))
T, R = symbols('T R'); Udfg = Matrix([[T,1j*R],[1j*R,T]]); Udfgd = Matrix([[T,-1j*R],[-1j*R,T]])
Udfg*Udfgd, Udfgd*Udfg # ok, é unitária
def qc_dfg(th):
qc = QuantumCircuit(1, name = 'DFG')
qc.rx(-2*th, 0)
return qc
qc_dfg_ = qc_dfg(math.pi); qc_dfg_.draw(output = 'mpl')
def qc_imzg(th, ph):
qc = QuantumCircuit(1, name = 'IMZG')
qc_dfg_ = qc_dfg(th); qc.append(qc_dfg_, [0])
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc.p(ph, 0)
qc_dfg_ = qc_dfg(th); qc.append(qc_dfg_, [0])
return qc
qc_imzg_ = qc_imzg(math.pi, math.pi/2); qc_imzg_.draw(output = 'mpl')
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
th = math.pi/8
print('T = ', math.cos(th), ', R = ', math.sin(th))
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d);
for j in range(0, d):
PD0teo[j] = 2*math.sin(th)**2*math.cos(th)**2*(1+math.cos(ph[j])) # theoretical
qc = QuantumCircuit(1)
qc_imzg_ = qc_imzg(th, ph[j]); qc.append(qc_imzg_, [0])
qstc = state_tomography_circuits(qc, [0]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
#plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.show()
def V(pd):
return (np.max(pd)-np.min(pd))/(np.max(pd)+np.min(pd))
def Vt(pd):
return np.max(pd)*(np.max(pd)-np.min(pd))/(np.max(pd)+np.min(pd))
def pd_ph(th):
phmax = 2*math.pi; dph = phmax/100; ph = np.arange(0, phmax+dph, dph)
return 2*math.sin(th)**2*math.cos(th)**2*(1+np.cos(ph))
dth = 0.05; th = np.arange(dth, math.pi/2, dth); d = th.shape[0]
Vis = np.zeros(d); VisT= np.zeros(d); Vteo = np.zeros(d)
for j in range(0, d):
Vteo[j] = 4*math.cos(th[j])**2*math.sin(th[j])**2
pd = pd_ph(th[j]); Vis[j] = V(pd); VisT[j] = Vt(pd)
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(th, Vis, label = r'$V$'); plt.plot(th, VisT, label = r'$\tilde{V}$')
plt.plot(th, Vteo, '*', label = r'$V_{teo}$')
plt.xlabel(r'$\theta$'); plt.legend(); plt.show()
float(cos(pi/12)**2)
float((cos(pi/12)**2)**6), float((cos(pi/24)**2)**12), float((cos(pi/48)**2)**24), float((cos(pi/96)**2)**48)
Udf = (1/sqrt(2))*Matrix([[1,1j],[1j,1]]); Ue = Matrix([[0,1j],[1j,0]]); Udf*Ue*Udf
T = cos(math.pi/12); T
th = +pi-pi/6; float((sin(th/2)**2)**6)
T = cos(th); R = sin(th); print('T = ', float(T), ', R = ', float(R)) # ??????????????
N = 6; th = math.pi-math.pi/N; qc = QuantumCircuit(2, N)
for j in range(0, N-1):
qc.rx(th, 0)
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc.cx(0, 1); qc.measure(1, j); qc.reset(1)
qc.barrier()
qc.rx(th, 0) # o último DFG é colocado só na última volta
qc.measure(0, N-1)
#qc.draw(output = 'mpl')
qc.decompose().draw(output = 'mpl')
matplotlib.rcParams.update({'font.size':12})
#plt.figure(figsize = (6,4), dpi = 100)
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
import numpy as np
for j in range(0,20):
print(np.random.randint(11))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.