Cache block fix

.github/CODEOWNERS

@@ -8,15 +8,13 @@
 
 # Generic rule for the repository. This pattern is actually the one that will
 # apply unless specialized by a later rule
-* @chriseclectic @vvilpas @atilag
+* @chriseclectic @vvilpas
 
 # Individual folders on root directory
-/qiskit         @chriseclectic @atilag @vvilpas
-/cmake          @atilag @vvilpas
-/doc            @chriseclectic @atilag @vvilpas
-/examples       @chriseclectic @atilag @vvilpas
-/contrib        @chriseclectic @atilag @vvilpas
-/test           @chriseclectic @atilag @vvilpas
-/src            @chriseclectic @atilag @vvilpas
-
-# AER specific folders
+/qiskit         @chriseclectic @vvilpas @mtreinish
+/test           @chriseclectic @vvilpas @mtreinish
+/doc            @chriseclectic @vvilpas @mtreinish
+/releasenotes   @chriseclectic @vvilpas @mtreinish
+/cmake          @vvilpas
+/contrib        @chriseclectic @vvilpas @hhorii
+/src            @chriseclectic @vvilpas @hhorii

README.md

@@ -20,7 +20,7 @@ To install from source, follow the instructions in the [contribution guidelines]
 
 ## Installing GPU support
 
-In order to install and run the GPU supported simulators, you need CUDA® 10.1 or newer previously installed.
+In order to install and run the GPU supported simulators on Linux, you need CUDA® 10.1 or newer previously installed.
 CUDA® itself would require a set of specific GPU drivers. Please follow CUDA® installation procedure in the NVIDIA® [web](https://www.nvidia.com/drivers).
 
 If you want to install our GPU supported simulators, you have to install this other package:
@@ -33,6 +33,11 @@ This will overwrite your current `qiskit-aer` package installation giving you
 the same functionality found in the canonical `qiskit-aer` package, plus the
 ability to run the GPU supported simulators: statevector, density matrix, and unitary.
 
+**Note**: This package is only available on x86_64 Linux. For other platforms
+that have CUDA support you will have to build from source. You can refer to
+the [contributing guide](https://github.com/Qiskit/qiskit-aer/blob/master/CONTRIBUTING.md#building-with-gpu-support)
+for instructions on doing this.
+
 ## Simulating your first quantum program with Qiskit Aer
 Now that you have Qiskit Aer installed, you can start simulating quantum circuits with noise. Here is a basic example:
 

qiskit/providers/aer/backends/qasm_simulator.py

@@ -524,8 +524,8 @@ def _method_configuration(method=None):
             config.custom_instructions = sorted(['roerror', 'snapshot', 'save_statevector',
                                                  'save_expval', 'save_expval_var'])
             config.basis_gates = sorted([
-                'cx', 'cz', 'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'sx', 'swap',
-                'u0', 'u1', 'p', 'ccx', 'ccz', 'delay'
+                'cx', 'cz', 'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'sx',
+                'swap', 'u0', 't', 'tdg', 'u1', 'p', 'ccx', 'ccz', 'delay'
             ] + config.custom_instructions)
 
         return config

qiskit/providers/aer/noise/noise_model.py

@@ -15,7 +15,6 @@
 
 import json
 import logging
-from warnings import warn
 
 from qiskit.circuit import Instruction
 from qiskit.providers import BaseBackend, Backend
@@ -154,7 +153,6 @@ def __init__(self, basis_gates=None):
         # dict(str: ReadoutError)
         # where the dict keys are the gate qubits.
         self._local_readout_errors = {}
-        self._x90_gates = []
 
     @property
     def basis_gates(self):
@@ -361,9 +359,6 @@ def __str__(self):
         if self._noise_qubits:
             output += "\n  Qubits with noise: {}".format(
                 list(self._noise_qubits))
-        if self._x90_gates:
-            output += "\n  X-90 based single qubit gates: {}".format(
-                list(self._x90_gates))
         if default_error_ops != []:
             output += "\n  All-qubits errors: {}".format(default_error_ops)
         if local_error_ops != []:
@@ -426,28 +421,6 @@ def add_basis_gates(self, instructions, warnings=True):
                     "Warning: Adding a gate \"%s\" to basis_gates which is "
                     "not in QasmSimulator basis_gates.", name)
 
-    def set_x90_single_qubit_gates(self, instructions):
-        """
-        Declares X90 based gates for noise model.
-
-        Args:
-            instructions (list[str] or
-                          list[Instruction]): the instructions error applies to.
-
-        Raises:
-            NoiseError: if the input instructions are not valid.
-        """
-        warn('This function is deprecated and will be removed in a future release. '
-             'To use an X90 based noise model use the Sqrt(X) "sx" gate and one of '
-             ' the single-qubit phase gates "u1", "rx", "p" in the noise model and '
-             ' basis gates to decompose into this gateset for noise simulations.',
-             DeprecationWarning)
-        for name, label in self._instruction_names_labels(instructions):
-            # Add X-90 based gate to noisy gates
-            self._noise_instructions.add(label)
-            self._basis_gates.add(name)
-        self._x90_gates = instructions
-
     def add_all_qubit_quantum_error(self, error, instructions, warnings=True):
         """
         Add a quantum error to the noise model that applies to all qubits.
@@ -806,7 +779,7 @@ def to_dict(self, serializable=False):
             error_dict["gate_qubits"] = [self._str2qubits(qubits_str)]
             error_list.append(error_dict)
 
-        ret = {"errors": error_list, "x90_gates": self._x90_gates}
+        ret = {"errors": error_list}
         if serializable:
             ret = json.loads(json.dumps(ret, cls=AerJSONEncoder))
 
@@ -829,9 +802,6 @@ def from_dict(noise_dict):
         # Return noise model
         noise_model = NoiseModel()
 
-        # Set X90 gates
-        noise_model.set_x90_single_qubit_gates(noise_dict.get('x90_gates', []))
-
         # Get error terms
         errors = noise_dict.get('errors', [])
 

qiskit/providers/aer/utils/noise_transformation.py

@@ -214,10 +214,7 @@ def approximate_noise_model(model, *,
         error_dict["gate_qubits"] = [model._str2qubits(qubits_str)]
         error_list.append(error_dict)
 
-    approx_noise_model = NoiseModel.from_dict({
-        "errors": error_list,
-        "x90_gates": model._x90_gates
-    })
+    approx_noise_model = NoiseModel.from_dict({"errors": error_list})
     # Update basis gates
     approx_noise_model._basis_gates = model._basis_gates
     return approx_noise_model

releasenotes/notes/remove-deprecated-ba6eb1060207af99.yaml

@@ -0,0 +1,6 @@
+---
+upgrade:
+  - |
+    Removed x90 gate decomposition from noise models that was deprecated
+    in qiskit-aer 0.7. This decomposition is now done by using regular
+    noise model basis gates and the qiskit transpiler.

src/framework/creg.hpp

@@ -138,20 +138,6 @@ bool ClassicalRegister::check_conditional(const Operations::Op &op) const {
   // Check if op is conditional
   if (op.conditional)
     return (creg_register_[creg_register_.size() - op.conditional_reg - 1] == '1');
-
-  // DEPRECATED: old style conditional
-  if (op.old_conditional) {
-    std::string current;
-    auto mask = Utils::padleft(Utils::hex2bin(op.old_conditional_mask, false),
-                               '0', creg_memory_.size());
-    for (size_t pos=0; pos < mask.size(); pos++) {
-      if (mask[pos] == '1')
-        current.push_back(creg_memory_[pos]);
-    }
-    auto val = Utils::padleft(Utils::hex2bin(op.old_conditional_val, false),
-                              '0', current.size());
-    return (val == current);
-  }
 
   // Op is not conditional
   return true;

src/framework/operations.hpp

@@ -166,11 +166,6 @@ struct Op {
   uint_t conditional_reg;   // (opt) the (single) register location to look up for conditional
   RegComparison bfunc;      // (opt) boolean function relation
 
-  // DEPRECATED: Old style conditionals (remove in 0.3)
-  bool old_conditional = false;     // is gate old style conditional gate
-  std::string old_conditional_mask; // hex string for conditional mask
-  std::string old_conditional_val;  // hex string for conditional value
-
   // Measurement
   reg_t memory;             // (opt) register operation it acts on (measure)
   reg_t registers;          // (opt) register locations it acts on (measure, conditional)
@@ -586,16 +581,8 @@ void add_conditional(const Allowed allowed, Op& op, const json_t &js) {
       throw std::invalid_argument("Invalid instruction: \"" + op.name + "\" cannot be conditional.");
     }
     // If instruction is allowed to be conditional add parameters
-    if (js["conditional"].is_number()) {
-      // New style conditional
-      op.conditional_reg = js["conditional"];
-      op.conditional = true;
-    } else {
-      // DEPRECATED: old style conditional (remove in 0.3)
-      JSON::get_value(op.old_conditional_mask, "mask", js["conditional"]);
-      JSON::get_value(op.old_conditional_val, "val", js["conditional"]);
-      op.old_conditional = true;
-    }
+    op.conditional_reg = js["conditional"];
+    op.conditional = true;
   }
 }
 
@@ -788,7 +775,6 @@ Op json_to_op_roerror(const json_t &js) {
   op.name = "roerror";
   JSON::get_value(op.memory, "memory", js);
   JSON::get_value(op.registers, "register", js);
-  JSON::get_value(op.probs, "probabilities", js); // DEPRECATED: Remove in 0.4
   JSON::get_value(op.probs, "params", js);
   // Conditional
   add_conditional(Allowed::No, op, js);

src/noise/noise_model.hpp

@@ -120,11 +120,6 @@ class NoiseModel {
   void add_readout_error(const ReadoutError &error,
                          const std::vector<reg_t> &op_qubits = {});
 
-  // Set which single qubit gates should use the X90 waltz error model
-  inline void set_x90_gates(const stringset_t &x90_gates) {
-    x90_gates_ = x90_gates;
-  }
-
   //-----------------------------------------------------------------------
   // Utils
   //-----------------------------------------------------------------------
@@ -173,15 +168,6 @@ class NoiseModel {
   NoiseOps sample_noise_helper(const Operations::Op &op,
                                RngEngine &rng) const;
 
-  // Sample a noisy implementation of a two-X90 pulse u3 gate
-  NoiseOps sample_noise_x90_u3(uint_t qubit, complex_t theta,
-                               complex_t phi, complex_t lamba,
-                               RngEngine &rng) const;
-
-  // Sample a noisy implementation of a single-X90 pulse u2 gate
-  NoiseOps sample_noise_x90_u2(uint_t qubit, complex_t phi, complex_t lambda,
-                               RngEngine &rng) const;
-
   // Add a local quantum error to the noise model for specific qubits
   void add_local_quantum_error(const QuantumError &error,
                                const stringset_t &op_labels,
@@ -233,9 +219,6 @@ class NoiseModel {
   // If conversion isn't possible this returns an empty matrix
   cmatrix_t op2unitary(const Operations::Op &op) const;
 
-  // Table of single-qubit gates to use a Waltz X90 based error model
-  stringset_t x90_gates_;
-
   // Lookup table for gate strings to enum
   enum class WaltzGate {id, x, y, z, h, s, sdg, t, tdg, u0, u1, u2, u3};
   const static stringmap_t<WaltzGate> waltz_gate_table_;
@@ -285,47 +268,8 @@ NoiseModel::param_gate_table_ = {
 NoiseModel::NoiseOps NoiseModel::sample_noise(const Operations::Op &op,
                                               RngEngine &rng) const {
   // Noise operations
-  NoiseOps noise_ops;
-  // Look to see if gate is a waltz gate for this error model
-  // NOTE this is deprecated and waltz gate noise sampling should be removed
-  auto it = x90_gates_.find(op.name);
-  if (it == x90_gates_.end()) {
-    // Non-X90 based gate, run according to base model
-    noise_ops = sample_noise_helper(op, rng);
-  } else {
-    // Decompose ops in terms of their waltz implementation
-    auto gate = waltz_gate_table_.find(op.name);
-    if (gate != waltz_gate_table_.end()) {
-      switch (gate->second) {
-        case WaltzGate::u3:
-          noise_ops = sample_noise_x90_u3(op.qubits[0],
-                                          op.params[0], op.params[1], op.params[2],
-                                          rng);
-          break;
-        case WaltzGate::u2:
-          noise_ops = sample_noise_x90_u2(op.qubits[0],
-                                          op.params[0], op.params[1],
-                                           rng);
-          break;
-        case WaltzGate::x:
-          noise_ops =  sample_noise_x90_u3(op.qubits[0], M_PI, 0., M_PI, rng);
-          break;
-        case WaltzGate::y:
-          noise_ops = sample_noise_x90_u3(op.qubits[0],  M_PI, 0.5 * M_PI, 0.5 * M_PI, rng);
-          break;
-        case WaltzGate::h:
-          noise_ops = sample_noise_x90_u2(op.qubits[0], 0., M_PI, rng);
-          break;
-        default:
-          // The rest of the Waltz operations are noise free (u1 only)
-          noise_ops = {op};
-          break;
-      }
-    } else {
-      // something went wrong if we end up here
-      throw std::invalid_argument("Invalid waltz gate.");
-    }
-  }
+  NoiseOps noise_ops = sample_noise_helper(op, rng);
+
   // If original op is conditional, make all the noise operations also conditional
   if (op.conditional) {
     for (auto& noise_op : noise_ops) {
@@ -772,107 +716,6 @@ NoiseModel::waltz_gate_table_ = {
 };
 
 
-NoiseModel::NoiseOps NoiseModel::sample_noise_x90_u3(uint_t qubit,
-                                                     complex_t theta,
-                                                     complex_t phi,
-                                                     complex_t lambda,
-                                                     RngEngine &rng) const {
-  // sample noise for single X90
-  const auto x90 = Operations::make_unitary({qubit}, Linalg::Matrix::X90, "x90");
-  switch (method_) {
-    case Method::superop: {
-      // The first element of the sample should be the superoperator to combine
-      auto sample = sample_noise_helper(x90, rng);
-      // The first element of the sample should be the superoperator to combine
-      if (sample[0].type != Operations::OpType::superop) {
-        throw std::runtime_error("Sampling superoperator noise failed.");
-      }
-      cmatrix_t& current = sample[0].mats[0];
-      // Combine with middle u1 gate with two noisy x90 superops
-      auto mat = Linalg::Matrix::u1(theta + M_PI);
-      auto super = Utils::tensor_product(AER::Utils::conjugate(mat), mat);
-      current = current * super * current;
-
-      // Prepend with first u1 matrix with superop
-      mat = Linalg::Matrix::u1(lambda);
-      super = Utils::tensor_product(AER::Utils::conjugate(mat),
-                                          mat);
-      current = current * super;
-      // Append third u1 matrix with superop
-      mat = Linalg::Matrix::u1(phi + M_PI);
-      super = Utils::tensor_product(AER::Utils::conjugate(mat), mat);
-      current = super * current;
-      return sample;
-    }
-    default: {
-      NoiseOps ret;
-      if (std::abs(lambda) > u1_threshold_
-          && std::abs(lambda - 2 * M_PI) > u1_threshold_
-          && std::abs(lambda + 2 * M_PI) > u1_threshold_) {
-        ret.push_back(Operations::make_u1(qubit, lambda)); // add 1st U1
-      }
-      auto sample = sample_noise_helper(x90, rng); // sample noise for 1st X90
-      ret.insert(ret.end(), sample.begin(), sample.end()); // add 1st noisy X90
-      if (std::abs(theta + M_PI) > u1_threshold_
-          && std::abs(theta - M_PI) > u1_threshold_) {
-        ret.push_back(Operations::make_u1(qubit, theta + M_PI)); // add 2nd U1
-      }
-      sample = sample_noise_helper(x90, rng); // sample noise for 2nd X90
-      ret.insert(ret.end(), sample.begin(), sample.end()); // add 2nd noisy X90
-      if (std::abs(phi + M_PI) > u1_threshold_
-          && std::abs(phi - M_PI) > u1_threshold_) {
-        ret.push_back(Operations::make_u1(qubit, phi + M_PI)); // add 3rd U1
-      }
-      return ret;
-    }
-  }
-}
-
-
-NoiseModel::NoiseOps NoiseModel::sample_noise_x90_u2(uint_t qubit,
-                                                     complex_t phi,
-                                                     complex_t lambda,
-                                                     RngEngine &rng) const {
-  // sample noise for single X90
-  const auto x90 = Operations::make_unitary({qubit}, Linalg::Matrix::X90, "x90");
-  auto sample = sample_noise_helper(x90, rng); 
-  switch (method_) {
-    case Method::superop: {
-      // The first element of the sample should be the superoperator to combine
-      if (sample[0].type != Operations::OpType::superop) {
-        throw std::runtime_error("Sampling superoperator noise failed.");
-      }
-      cmatrix_t &current = sample[0].mats[0];
-      // Combine first u1 matrix with superop
-      auto mat = Linalg::Matrix::u1(lambda - 0.5 * M_PI);
-      auto super = Utils::tensor_product(AER::Utils::conjugate(mat),
-                                               mat);
-      current = current * super;
-      // Combine second u1 matrix with superop
-      mat = Linalg::Matrix::u1(phi + 0.5 * M_PI);
-      super = Utils::tensor_product(AER::Utils::conjugate(mat), mat);
-      current = super * current;
-      return sample;
-    }
-    default: {
-      NoiseOps ret;
-      // Standard method doesn't combine any ops
-      if (std::abs(lambda - 0.5 * M_PI) > u1_threshold_) {
-        // add 1st u1
-        ret.push_back(Operations::make_u1(qubit, lambda - 0.5 * M_PI));
-      }
-      // add 1st noisy x90
-      ret.insert(ret.end(), sample.begin(), sample.end()); 
-      if (std::abs(phi + 0.5 * M_PI) > u1_threshold_) {
-        // add 2nd u1
-        ret.push_back(Operations::make_u1(qubit, phi + 0.5 * M_PI));
-      }
-      return ret;
-    }
-  }
-}
-
-
 cmatrix_t NoiseModel::op2superop(const Operations::Op &op) const {
   switch (op.type) {
     case Operations::OpType::superop:
@@ -1114,8 +957,7 @@ void NoiseModel::remap_qubits(const std::unordered_map<uint_t, uint_t> &mapping)
   Schemas:
   {
     "error_model": {
-      "errors": [error js],
-      "x90_gates": which gates should be implemented as waltz gates and use the "x90" term
+      "errors": [error js]
     }
   }
 
@@ -1151,11 +993,6 @@ void NoiseModel::load_from_json(const json_t &js) {
     throw std::invalid_argument("Invalid noise_params JSON: not an object.");
   }
 
-  // See if any single qubit gates have a waltz error model applied to them
-  if (JSON::check_key("x90_gates", js)) {
-    set_x90_gates(js["x90_gates"]);
-  }
-
   if (JSON::check_key("errors", js)) {
     if (!js["errors"].is_array()) {
       throw std::invalid_argument("Invalid noise_params JSON: \"error\" field is not a list");

src/simulators/extended_stabilizer/extended_stabilizer_state.hpp

@@ -353,7 +353,7 @@ bool State::check_measurement_opt(const std::vector<Operations::Op> &ops) const
 {
   for (const auto &op: ops)
   {
-    if (op.conditional || op.old_conditional)
+    if (op.conditional)
     {
       return false;
     }

test/terra/backends/qasm_simulator/qasm_save_expval.py

@@ -46,9 +46,9 @@ def test_save_expval_stabilizer_pauli(self, pauli):
 
         # Stabilizer test circuit
         state_circ = qi.random_clifford(2, seed=SEED).to_circuit()
-        oper = qi.Pauli(pauli)
+        oper = qi.Operator(qi.Pauli(pauli))
         state = qi.Statevector(state_circ)
-        target = state.expectation_value(oper).real.round(10)
+        target = state.expectation_value(oper).real
 
         # Snapshot circuit
         opts = self.BACKEND_OPTS.copy()
@@ -78,7 +78,7 @@ def test_save_expval_var_stabilizer_pauli(self, pauli):
 
         # Stabilizer test circuit
         state_circ = qi.random_clifford(2, seed=SEED).to_circuit()
-        oper = qi.Pauli(pauli)
+        oper = qi.Operator(qi.Pauli(pauli))
         state = qi.Statevector(state_circ)
         expval = state.expectation_value(oper).real
         variance = state.expectation_value(oper ** 2).real - expval ** 2
@@ -178,9 +178,9 @@ def test_save_expval_nonstabilizer_pauli(self, pauli):
 
         # Stabilizer test circuit
         state_circ = QuantumVolume(2, 1, seed=SEED)
-        oper = qi.Pauli(pauli)
+        oper = qi.Operator(qi.Pauli(pauli))
         state = qi.Statevector(state_circ)
-        target = state.expectation_value(oper).real.round(10)
+        target = state.expectation_value(oper).real
 
         # Snapshot circuit
         opts = self.BACKEND_OPTS.copy()
@@ -209,7 +209,7 @@ def test_save_expval_var_nonstabilizer_pauli(self, pauli):
 
         # Stabilizer test circuit
         state_circ = QuantumVolume(2, 1, seed=SEED)
-        oper = qi.Pauli(pauli)
+        oper = qi.Operator(qi.Pauli(pauli))
         state = qi.Statevector(state_circ)
         expval = state.expectation_value(oper).real
         variance = state.expectation_value(oper ** 2).real - expval ** 2
@@ -244,7 +244,7 @@ def test_save_expval_nonstabilizer_hermitian(self, qubits):
         state_circ = QuantumVolume(3, 1, seed=SEED)
         oper = qi.random_hermitian(4, traceless=True, seed=SEED)
         state = qi.Statevector(state_circ)
-        target = state.expectation_value(oper, qubits).real.round(10)
+        target = state.expectation_value(oper, qubits).real
 
         # Snapshot circuit
         opts = self.BACKEND_OPTS.copy()
@@ -305,15 +305,15 @@ def test_save_expval_cptp_pauli(self, pauli):
         opts = self.BACKEND_OPTS.copy()
         if opts.get('method') in SUPPORTED_METHODS:
 
-            oper = qi.Pauli(pauli)
+            oper = qi.Operator(qi.Pauli(pauli))
 
             # CPTP channel test circuit
             channel = qi.random_quantum_channel(4, seed=SEED)
             state_circ = QuantumCircuit(2)
             state_circ.append(channel, range(2))
 
             state = qi.DensityMatrix(state_circ)
-            target = state.expectation_value(oper).real.round(10)
+            target = state.expectation_value(oper).real
 
             # Snapshot circuit
             circ = transpile(state_circ, self.SIMULATOR)
@@ -337,7 +337,7 @@ def test_save_expval_var_cptp_pauli(self, pauli):
         opts = self.BACKEND_OPTS.copy()
         if opts.get('method') in SUPPORTED_METHODS:
 
-            oper = qi.Pauli(pauli)
+            oper = qi.Operator(qi.Operator(qi.Pauli(pauli)))
 
             # CPTP channel test circuit
             channel = qi.random_quantum_channel(4, seed=SEED)