Noise transformation with new channel interface

.gitignore

@@ -13,6 +13,7 @@ out/*
 *.so
 *.pyc
 *_skbuild*
+*_cmake_test_compile*
 *.whl
 *.egg*
 build/*

CHANGELOG.rst

@@ -22,6 +22,8 @@ Added
 -----
 - Improve efficiency of parallelization with max_memory_mb a new parameter of backend_opts (#61)
 - Add optimized mcx, mcy, mcz, mcu1, mcu2, mcu3, gates to QubitVector (#124)
+- Add optimized controlled-swap gate to QubitVector
+- Add gate-fusion optimization for QasmContoroller, which is enabled by setting fusion_enable=true (#136)
 
 Changed
 -------

qiskit/providers/aer/VERSION.txt

@@ -1 +1 @@
-0.1.1
+0.2.0

qiskit/providers/aer/backends/aerbackend.py

@@ -144,12 +144,17 @@ def _format_results(self, job_id, output, time_taken):
 
     def _validate_controller_output(self, output):
         """Validate output from the controller wrapper."""
+        if not isinstance(output, dict):
+            logger.error("%s: simulation failed.", self.name())
+            if output:
+                logger.error('Output: %s', output)
+            raise AerError("simulation terminated without returning valid output.")
         # Check results
         # TODO: Once https://github.com/Qiskit/qiskit-terra/issues/1023
         #       is merged this should be updated to deal with errors using
         #       the Result object methods
         if not output.get("success", False):
-            logger.error("AerBackend: simulation failed")
+            logger.error("%s: simulation failed", self.name())
             # Check for error message in the failed circuit
             for res in output.get('results'):
                 if not res.get('success', False):

qiskit/providers/aer/backends/wrappers/CMakeLists.txt

@@ -10,28 +10,41 @@ find_package(PythonLibs REQUIRED)
 # shared library.
 string(REPLACE " -static " "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
+# Set some general flags
+if(APPLE)
+    message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be
+                    solved at runtime by the loader")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        set(AER_LINKER_FLAGS "-undefined dynamic_lookup")
+    else()
+        # -flat_namespace linker flag is needed otherwise dynamic symbol resolution doesn't work as expected with GCC.
+        # Symbols with the same name exist in different .so, so the loader just takes the first one it finds,
+        # which is usually the one from the first .so loaded.
+        # See: Two-Leve namespace symbol resolution
+        set(AER_LINKER_FLAGS "-undefined dynamic_lookup -flat_namespace")
+    endif()
+    unset(PYTHON_LIBRARIES)
+endif()
+
+
 # QASM Controller
 
 add_cython_target(qasm_controller_wrapper qasm_controller_wrapper.pyx CXX)
 add_library(qasm_controller_wrapper MODULE ${qasm_controller_wrapper})
 set_target_properties(qasm_controller_wrapper PROPERTIES
-	LINKER_LANGUAGE CXX
+    LINKER_LANGUAGE CXX
     CXX_STANDARD 14)
+if(APPLE)
+    set_target_properties(qasm_controller_wrapper PROPERTIES
+        LINK_FLAGS ${AER_LINKER_FLAGS})
+endif()
 # We only need to pass the linter once, as the codebase is the same for
 # all controllers
 add_linter(qasm_controller_wrapper)
 target_include_directories(qasm_controller_wrapper
     PRIVATE ${AER_SIMULATOR_CPP_SRC_DIR}
     PRIVATE ${AER_SIMULATOR_CPP_EXTERNAL_LIBS}
     PRIVATE ${PYTHON_INCLUDE_DIRS})
-
-if(APPLE)
-    message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be
-        solved at runtime by the loader")
-    set_target_properties(qasm_controller_wrapper PROPERTIES LINK_FLAGS "-undefined dynamic_lookup -flat_namespace")
-    unset(PYTHON_LIBRARIES)
-endif()
-
 target_link_libraries(qasm_controller_wrapper
     ${AER_LIBRARIES}
     ${PYTHON_LIBRARIES})
@@ -51,22 +64,14 @@ add_library(statevector_controller_wrapper MODULE ${statevector_controller_wrapp
 set_target_properties(statevector_controller_wrapper PROPERTIES
 	LINKER_LANGUAGE CXX
     CXX_STANDARD 14)
+if(APPLE)
+    set_target_properties(statevector_controller_wrapper PROPERTIES
+        LINK_FLAGS ${AER_LINKER_FLAGS})
+endif()
 target_include_directories(statevector_controller_wrapper
     PRIVATE ${AER_SIMULATOR_CPP_SRC_DIR}
     PRIVATE ${AER_SIMULATOR_CPP_EXTERNAL_LIBS}
     PRIVATE ${PYTHON_INCLUDE_DIRS})
-
-if(APPLE)
-    message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be
-        solved at runtime by the loader")
-    # -flat_namespace linker flag is needed otherwise dynamic symbol resolution doesn't work as expected.
-    # Symbols with the same name exist in different .so, so the loader just takes the first one it finds,
-    # which is usually the one from the first .so loaded.
-    # See: Two-Leve namespace symbol resolution
-    set_target_properties(statevector_controller_wrapper PROPERTIES LINK_FLAGS "-undefined dynamic_lookup -flat_namespace")
-    unset(PYTHON_LIBRARIES)
-endif()
-
 target_link_libraries(statevector_controller_wrapper
     ${AER_LIBRARIES}
     ${PYTHON_LIBRARIES})
@@ -86,18 +91,14 @@ add_library(unitary_controller_wrapper MODULE ${unitary_controller_wrapper})
 set_target_properties(unitary_controller_wrapper PROPERTIES
 	LINKER_LANGUAGE CXX
     CXX_STANDARD 14)
+if(APPLE)
+    set_target_properties(unitary_controller_wrapper PROPERTIES
+        LINK_FLAGS ${AER_LINKER_FLAGS})
+endif()
 target_include_directories(unitary_controller_wrapper
     PRIVATE ${AER_SIMULATOR_CPP_SRC_DIR}
     PRIVATE ${AER_SIMULATOR_CPP_EXTERNAL_LIBS}
     PRIVATE ${PYTHON_INCLUDE_DIRS})
-
-if(APPLE)
-    message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be
-        solved at runtime by the loader")
-    set_target_properties(unitary_controller_wrapper PROPERTIES LINK_FLAGS "-undefined dynamic_lookup -flat_namespace")
-    unset(PYTHON_LIBRARIES)
-endif()
-
 target_link_libraries(unitary_controller_wrapper
     ${AER_LIBRARIES}
     ${PYTHON_LIBRARIES})

qiskit/providers/aer/noise/__init__.py

@@ -62,8 +62,17 @@
    Amplitude damping error
    Phase damping error
    Combined phase and amplitude damping error
+
+Noise Utilities
+--------------
+The `noise.utils` module contains utilities for noise models and errors including:
+    'approximate_quantum_error' for approximating a general quantum error via
+    a provided set of errors (e.g. approximating amplitude damping via reset errors)
+    'approximate_noise_model' for approximating all the errors in a nose model using
+    the same provided set of errors
 """
 
 from .noise_model import NoiseModel
 from . import errors
 from . import device
+from . import utils

qiskit/providers/aer/noise/errors/errorutils.py

@@ -10,7 +10,9 @@
 
 import numpy as np
 
+from qiskit.quantum_info.operators.operator import Operator
 from qiskit.quantum_info.operators.channel.kraus import Kraus
+from qiskit.quantum_info.operators.channel.superop import SuperOp
 from qiskit.quantum_info.operators.predicates import is_identity_matrix
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix
 from qiskit.quantum_info.operators.predicates import matrix_equal
@@ -45,13 +47,30 @@ def standard_gate_instruction(instruction, ignore_phase=True):
     Returns:
         list: a list of qobj instructions equivalent to in input instruction.
     """
-    if instruction.get("name", None) not in ["mat", "unitary"]:
-        return [instruction]
 
+    name = instruction.get("name", None)
+    if name not in ["mat", "unitary", "kraus"]:
+        return [instruction]
     qubits = instruction["qubits"]
-    mat_dagger = np.conj(instruction["params"])
+    params = instruction["params"]
+
+    # Check for single-qubit reset Kraus
+    if name == "kraus":
+        if len(qubits) == 1:
+            superop = SuperOp(Kraus(params))
+            # Check if reset to |0>
+            reset0 = reset_superop(1)
+            if superop == reset0:
+                return [{"name": "reset", "qubits": qubits}]
+            # Check if reset to |1>
+            reset1 = reset0.compose(Operator(standard_gate_unitary('x')))
+            if superop == reset1:
+                return [{"name": "reset", "qubits": qubits}, {"name": "x", "qubits": qubits}]
+        # otherwise just return the kraus instruction
+        return [instruction]
 
     # Check single qubit gates
+    mat_dagger = np.conj(params[0])
     if len(qubits) == 1:
         # Check clifford gates
         for j in range(24):
@@ -87,7 +106,8 @@ def standard_gate_instruction(instruction, ignore_phase=True):
         for pauli0 in paulis:
             for pauli1 in paulis:
                 pmat = np.kron(
-                    standard_gate_unitary(pauli1), standard_gate_unitary(pauli0))
+                    standard_gate_unitary(pauli1),
+                    standard_gate_unitary(pauli0))
                 if matrix_equal(mat_dagger, pmat, ignore_phase=ignore_phase):
                     if pauli0 is "id":
                         return [{"name": pauli1, "qubits": [qubits[1]]}]
@@ -304,6 +324,114 @@ def standard_gate_unitary(name):
     return None
 
 
+def reset_superop(num_qubits):
+    """Return a N-qubit reset SuperOp."""
+    reset = SuperOp(
+        np.array([[1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]))
+    if num_qubits == 1:
+        return reset
+    reset_n = reset
+    for _ in range(num_qubits - 1):
+        reset_n.tensor(reset)
+    return reset_n
+
+
+def standard_instruction_operator(instr):
+    """Return the Operator for a standard gate instruction."""
+    # Convert to dict (for QobjInstruction types)
+    if hasattr(instr, 'as_dict'):
+        instr = instr.as_dict()
+    # Get name and parameters
+    name = instr.get('name', "")
+    params = instr.get('params', [])
+    # Check if standard unitary gate name
+    mat = standard_gate_unitary(name)
+    if isinstance(mat, np.ndarray):
+        return Operator(mat)
+
+    # Check if standard parameterized waltz gates
+    if name == 'u1':
+        lam = params[0]
+        mat = np.diag([1, np.exp(1j * lam)])
+        return Operator(mat)
+    if name == 'u2':
+        phi = params[0]
+        lam = params[1]
+        mat = np.array([[1, -np.exp(1j * lam)],
+                        [np.exp(1j * phi),
+                         np.exp(1j * (phi + lam))]]) / np.sqrt(2)
+        return Operator(mat)
+    if name == 'u3':
+        theta = params[0]
+        phi = params[1]
+        lam = params[2]
+        mat = np.array(
+            [[np.cos(theta / 2), -np.exp(1j * lam) * np.sin(theta / 2)],
+             [np.exp(1j * phi) * np.sin(theta / 2), np.exp(1j * (phi + lam)) * np.cos(theta / 2)]])
+        return Operator(mat)
+
+    # Check if unitary instruction
+    if name == 'unitary':
+        return Operator(params[0])
+
+    # Otherwise return None if we cannot convert instruction
+    return None
+
+
+def standard_instruction_channel(instr):
+    """Return the SuperOp channel for a standard instruction."""
+    # Check if standard operator
+    oper = standard_instruction_operator(instr)
+    if oper is not None:
+        return SuperOp(oper)
+
+    # Convert to dict (for QobjInstruction types)
+    if hasattr(instr, 'as_dict'):
+        instr = instr.as_dict()
+    # Get name and parameters
+    name = instr.get('name', "")
+
+    # Check if reset instruction
+    if name == 'reset':
+        # params should be the number of qubits being reset
+        num_qubits = len(instr['qubits'])
+        return reset_superop(num_qubits)
+    # Check if Kraus instruction
+    if name == 'kraus':
+        params = instr['params']
+        return SuperOp(Kraus(params))
+    return None
+
+
+def circuit2superop(circuit, min_qubits=1):
+    """Return the SuperOp for a standard instruction."""
+    # Get number of qubits
+    max_qubits = 1
+    for instr in circuit:
+        qubits = []
+        if hasattr(instr, 'qubits'):
+            qubits = instr.qubits
+        elif isinstance(instr, dict):
+            qubits = instr.get('qubits', [])
+        max_qubits = max(max_qubits, 1 + max(qubits))
+
+    num_qubits = max(max_qubits, min_qubits)
+
+    # Initialize N-qubit identity superoperator
+    superop = SuperOp(np.eye(4**num_qubits))
+    # compose each circuit element with the superoperator
+    for instr in circuit:
+        instr_op = standard_instruction_channel(instr)
+        if instr_op is None:
+            raise NoiseError('Cannot convert instruction {} to SuperOp'.format(instr))
+        if hasattr(instr, 'qubits'):
+            qubits = instr.qubits
+        else:
+            qubits = instr['qubits']
+        superop = superop.compose(instr_op, qubits=qubits)
+    return superop
+
+
 def make_unitary_instruction(mat, qubits, standard_gates=True):
     """Return a qobj instruction for a unitary matrix gate.
 
@@ -323,7 +451,7 @@ def make_unitary_instruction(mat, qubits, standard_gates=True):
         raise NoiseError("Input matrix is not unitary.")
     elif isinstance(qubits, int):
         qubits = [qubits]
-    instruction = {"name": "unitary", "qubits": qubits, "params": mat}
+    instruction = {"name": "unitary", "qubits": qubits, "params": [mat]}
     if standard_gates:
         return standard_gate_instruction(instruction)
     else: