qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/pulse/utils.py

@@ -0,0 +1,149 @@
+# 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.
+
+"""Module for common pulse programming utilities."""
+from typing import List, Dict, Union, Sequence
+import warnings
+
+import numpy as np
+
+from qiskit.circuit import ParameterVector, Parameter
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.pulse.exceptions import UnassignedDurationError, QiskitError, PulseError
+
+
+def format_meas_map(meas_map: List[List[int]]) -> Dict[int, List[int]]:
+    """
+    Return a mapping from qubit label to measurement group given the nested list meas_map returned
+    by a backend configuration. (Qubits can not always be measured independently.) Sorts the
+    measurement group for consistency.
+
+    Args:
+        meas_map: Groups of qubits that get measured together, for example: [[0, 1], [2, 3, 4]]
+    Returns:
+        Measure map in map format
+    """
+    qubit_mapping = {}
+    for sublist in meas_map:
+        sublist.sort()
+        for q in sublist:
+            qubit_mapping[q] = sublist
+    return qubit_mapping
+
+
+def format_parameter_value(
+    operand: ParameterExpression,
+    decimal: int = 10,
+) -> Union[ParameterExpression, complex]:
+    """Convert ParameterExpression into the most suitable data type.
+
+    Args:
+        operand: Operand value in arbitrary data type including ParameterExpression.
+        decimal: Number of digit to round returned value.
+
+    Returns:
+        Value casted to non-parameter data type, when possible.
+    """
+    if isinstance(operand, ParameterExpression):
+        try:
+            operand = operand.numeric()
+        except TypeError:
+            # Unassigned expression
+            return operand
+
+    # Return integer before calling the numpy round function.
+    # The input value is multiplied by 10**decimals, rounds to an integer
+    # and divided by 10**decimals. For a large enough integer,
+    # this operation may introduce a rounding error in the float operations
+    # and accidentally returns a float number.
+    if isinstance(operand, int):
+        return operand
+
+    # Remove truncation error and convert the result into Python builtin type.
+    # Value could originally contain a rounding error, e.g. 1.00000000001
+    # which may occur during the parameter expression evaluation.
+    evaluated = np.round(operand, decimals=decimal).item()
+
+    if isinstance(evaluated, complex):
+        if np.isclose(evaluated.imag, 0.0):
+            evaluated = evaluated.real
+        else:
+            warnings.warn(
+                "Assignment of complex values to ParameterExpression in Qiskit Pulse objects is "
+                "now pending deprecation. This will align the Pulse module with other modules "
+                "where such assignment wasn't possible to begin with. The typical use case for complex "
+                "parameters in the module was the SymbolicPulse library. As of Qiskit-Terra "
+                "0.23.0 all library pulses were converted from complex amplitude representation"
+                " to real representation using two floats (amp,angle), as used in the "
+                "ScalableSymbolicPulse class. This eliminated the need for complex parameters. "
+                "Any use of complex parameters (and particularly custom-built pulses) should be "
+                "converted in a similar fashion to avoid the use of complex parameters.",
+                PendingDeprecationWarning,
+            )
+            return evaluated
+    # Type cast integer-like float into Python builtin integer, after rounding.
+    if evaluated.is_integer():
+        return int(evaluated)
+    return evaluated
+
+
+def instruction_duration_validation(duration: int):
+    """Validate instruction duration.
+
+    Args:
+        duration: Instruction duration value to validate.
+
+    Raises:
+        UnassignedDurationError: When duration is unassigned.
+        QiskitError: When invalid duration is assigned.
+    """
+    if isinstance(duration, ParameterExpression):
+        raise UnassignedDurationError(
+            f"Instruction duration {repr(duration)} is not assigned. "
+            "Please bind all durations to an integer value before playing in the Schedule, "
+            "or use ScheduleBlock to align instructions with unassigned duration."
+        )
+
+    if not isinstance(duration, (int, np.integer)) or duration < 0:
+        raise QiskitError(
+            f"Instruction duration must be a non-negative integer, got {duration} instead."
+        )
+
+
+def _validate_parameter_vector(parameter: ParameterVector, value):
+    """Validate parameter vector and its value."""
+    if not isinstance(value, Sequence):
+        raise PulseError(
+            f"Parameter vector '{parameter.name}' has length {len(parameter)},"
+            f" but was assigned to {value}."
+        )
+    if len(parameter) != len(value):
+        raise PulseError(
+            f"Parameter vector '{parameter.name}' has length {len(parameter)},"
+            f" but was assigned to {len(value)} values."
+        )
+
+
+def _validate_single_parameter(parameter: Parameter, value):
+    """Validate single parameter and its value."""
+    if not isinstance(value, (int, float, complex, ParameterExpression)):
+        raise PulseError(f"Parameter '{parameter.name}' is not assignable to {value}.")
+
+
+def _validate_parameter_value(parameter, value):
+    """Validate parameter and its value."""
+    if isinstance(parameter, ParameterVector):
+        _validate_parameter_vector(parameter, value)
+        return True
+    else:
+        _validate_single_parameter(parameter, value)
+        return False

qiskit/qasm/libs/dummy/stdgates.inc

@@ -0,0 +1,75 @@
+// OpenQASM 3 standard gate library
+
+// phase gate
+gate p(lambda) a {}
+
+// Pauli gate: bit-flip or NOT gate
+gate x a {}
+// Pauli gate: bit and phase flip
+gate y a {}
+// Pauli gate: phase flip
+gate z a {}
+
+// Clifford gate: Hadamard
+gate h a {}
+// Clifford gate: sqrt(Z) or S gate
+gate s a {}
+// Clifford gate: inverse of sqrt(Z)
+gate sdg a {}
+
+// sqrt(S) or T gate
+gate t a {}
+// inverse of sqrt(S)
+gate tdg a {}
+
+// sqrt(NOT) gate
+gate sx a {}
+
+// Rotation around X-axis
+gate rx(theta) a {}
+// rotation around Y-axis
+gate ry(theta) a {}
+// rotation around Z axis
+gate rz(lambda) a {}
+
+// controlled-NOT
+gate cx c, t {}
+// controlled-Y
+gate cy a, b {}
+// controlled-Z
+gate cz a, b {}
+// controlled-phase
+gate cp(lambda) a, b {}
+// controlled-rx
+gate crx(theta) a, b {}
+// controlled-ry
+gate cry(theta) a, b {}
+// controlled-rz
+gate crz(theta) a, b {}
+// controlled-H
+gate ch a, b {}
+
+// swap
+gate swap a, b {}
+
+// Toffoli
+gate ccx a, b, c {}
+// controlled-swap
+gate cswap a, b, c {}
+
+// four parameter controlled-U gate with relative phase
+gate cu(theta, phi, lambda, gamma) c, t {}
+
+// Gates for OpenQASM 2 backwards compatibility
+// CNOT
+gate CX c, t {}
+// phase gate
+gate phase(lambda) q {}
+// controlled-phase
+gate cphase(lambda) a, b {}
+// identity or idle gate
+gate id a {}
+// IBM Quantum experience gates
+gate u1(lambda) q {}
+gate u2(phi, lambda) q {}
+gate u3(theta, phi, lambda) q {}

qiskit/qasm/libs/qelib1.inc

@@ -0,0 +1,266 @@
+// Quantum Experience (QE) Standard Header
+// file: qelib1.inc
+
+// --- QE Hardware primitives ---
+
+// 3-parameter 2-pulse single qubit gate
+gate u3(theta,phi,lambda) q { U(theta,phi,lambda) q; }
+// 2-parameter 1-pulse single qubit gate
+gate u2(phi,lambda) q { U(pi/2,phi,lambda) q; }
+// 1-parameter 0-pulse single qubit gate
+gate u1(lambda) q { U(0,0,lambda) q; }
+// controlled-NOT
+gate cx c,t { CX c,t; }
+// idle gate (identity)
+gate id a { U(0,0,0) a; }
+// idle gate (identity) with length gamma*sqglen
+gate u0(gamma) q { U(0,0,0) q; }
+
+// --- QE Standard Gates ---
+
+// generic single qubit gate
+gate u(theta,phi,lambda) q { U(theta,phi,lambda) q; }
+// phase gate
+gate p(lambda) q { U(0,0,lambda) q; }
+// Pauli gate: bit-flip
+gate x a { u3(pi,0,pi) a; }
+// Pauli gate: bit and phase flip
+gate y a { u3(pi,pi/2,pi/2) a; }
+// Pauli gate: phase flip
+gate z a { u1(pi) a; }
+// Clifford gate: Hadamard
+gate h a { u2(0,pi) a; }
+// Clifford gate: sqrt(Z) phase gate
+gate s a { u1(pi/2) a; }
+// Clifford gate: conjugate of sqrt(Z)
+gate sdg a { u1(-pi/2) a; }
+// C3 gate: sqrt(S) phase gate
+gate t a { u1(pi/4) a; }
+// C3 gate: conjugate of sqrt(S)
+gate tdg a { u1(-pi/4) a; }
+
+// --- Standard rotations ---
+// Rotation around X-axis
+gate rx(theta) a { u3(theta, -pi/2,pi/2) a; }
+// rotation around Y-axis
+gate ry(theta) a { u3(theta,0,0) a; }
+// rotation around Z axis
+gate rz(phi) a { u1(phi) a; }
+
+// --- QE Standard User-Defined Gates  ---
+
+// sqrt(X)
+gate sx a { sdg a; h a; sdg a; }
+// inverse sqrt(X)
+gate sxdg a { s a; h a; s a; }
+// controlled-Phase
+gate cz a,b { h b; cx a,b; h b; }
+// controlled-Y
+gate cy a,b { sdg b; cx a,b; s b; }
+// swap
+gate swap a,b { cx a,b; cx b,a; cx a,b; }
+// controlled-H
+gate ch a,b {
+h b; sdg b;
+cx a,b;
+h b; t b;
+cx a,b;
+t b; h b; s b; x b; s a;
+}
+// C3 gate: Toffoli
+gate ccx a,b,c
+{
+  h c;
+  cx b,c; tdg c;
+  cx a,c; t c;
+  cx b,c; tdg c;
+  cx a,c; t b; t c; h c;
+  cx a,b; t a; tdg b;
+  cx a,b;
+}
+// cswap (Fredkin)
+gate cswap a,b,c
+{
+  cx c,b;
+  ccx a,b,c;
+  cx c,b;
+}
+// controlled rx rotation
+gate crx(lambda) a,b
+{
+  u1(pi/2) b;
+  cx a,b;
+  u3(-lambda/2,0,0) b;
+  cx a,b;
+  u3(lambda/2,-pi/2,0) b;
+}
+// controlled ry rotation
+gate cry(lambda) a,b
+{
+  ry(lambda/2) b;
+  cx a,b;
+  ry(-lambda/2) b;
+  cx a,b;
+}
+// controlled rz rotation
+gate crz(lambda) a,b
+{
+  rz(lambda/2) b;
+  cx a,b;
+  rz(-lambda/2) b;
+  cx a,b;
+}
+// controlled phase rotation
+gate cu1(lambda) a,b
+{
+  u1(lambda/2) a;
+  cx a,b;
+  u1(-lambda/2) b;
+  cx a,b;
+  u1(lambda/2) b;
+}
+gate cp(lambda) a,b
+{
+  p(lambda/2) a;
+  cx a,b;
+  p(-lambda/2) b;
+  cx a,b;
+  p(lambda/2) b;
+}
+// controlled-U
+gate cu3(theta,phi,lambda) c, t
+{
+  // implements controlled-U(theta,phi,lambda) with  target t and control c
+  u1((lambda+phi)/2) c;
+  u1((lambda-phi)/2) t;
+  cx c,t;
+  u3(-theta/2,0,-(phi+lambda)/2) t;
+  cx c,t;
+  u3(theta/2,phi,0) t;
+}
+// controlled-sqrt(X)
+gate csx a,b { h b; cu1(pi/2) a,b; h b; }
+// controlled-U gate
+gate cu(theta,phi,lambda,gamma) c, t
+{ p(gamma) c;
+  p((lambda+phi)/2) c;
+  p((lambda-phi)/2) t;
+  cx c,t;
+  u(-theta/2,0,-(phi+lambda)/2) t;
+  cx c,t;
+  u(theta/2,phi,0) t;
+}
+// two-qubit XX rotation
+gate rxx(theta) a,b
+{
+  u3(pi/2, theta, 0) a;
+  h b;
+  cx a,b;
+  u1(-theta) b;
+  cx a,b;
+  h b;
+  u2(-pi, pi-theta) a;
+}
+// two-qubit ZZ rotation
+gate rzz(theta) a,b
+{
+  cx a,b;
+  u1(theta) b;
+  cx a,b;
+}
+// relative-phase CCX
+gate rccx a,b,c
+{
+  u2(0,pi) c;
+  u1(pi/4) c;
+  cx b, c;
+  u1(-pi/4) c;
+  cx a, c;
+  u1(pi/4) c;
+  cx b, c;
+  u1(-pi/4) c;
+  u2(0,pi) c;
+}
+// relative-phase 3-controlled X gate
+gate rc3x a,b,c,d
+{
+  u2(0,pi) d;
+  u1(pi/4) d;
+  cx c,d;
+  u1(-pi/4) d;
+  u2(0,pi) d;
+  cx a,d;
+  u1(pi/4) d;
+  cx b,d;
+  u1(-pi/4) d;
+  cx a,d;
+  u1(pi/4) d;
+  cx b,d;
+  u1(-pi/4) d;
+  u2(0,pi) d;
+  u1(pi/4) d;
+  cx c,d;
+  u1(-pi/4) d;
+  u2(0,pi) d;
+}
+// 3-controlled X gate
+gate c3x a,b,c,d
+{
+    h d;
+    p(pi/8) a;
+    p(pi/8) b;
+    p(pi/8) c;
+    p(pi/8) d;
+    cx a, b;
+    p(-pi/8) b;
+    cx a, b;
+    cx b, c;
+    p(-pi/8) c;
+    cx a, c;
+    p(pi/8) c;
+    cx b, c;
+    p(-pi/8) c;
+    cx a, c;
+    cx c, d;
+    p(-pi/8) d;
+    cx b, d;
+    p(pi/8) d;
+    cx c, d;
+    p(-pi/8) d;
+    cx a, d;
+    p(pi/8) d;
+    cx c, d;
+    p(-pi/8) d;
+    cx b, d;
+    p(pi/8) d;
+    cx c, d;
+    p(-pi/8) d;
+    cx a, d;
+    h d;
+}
+// 3-controlled sqrt(X) gate, this equals the C3X gate where the CU1 rotations are -pi/8 not -pi/4
+gate c3sqrtx a,b,c,d
+{
+    h d; cu1(pi/8) a,d; h d;
+    cx a,b;
+    h d; cu1(-pi/8) b,d; h d;
+    cx a,b;
+    h d; cu1(pi/8) b,d; h d;
+    cx b,c;
+    h d; cu1(-pi/8) c,d; h d;
+    cx a,c;
+    h d; cu1(pi/8) c,d; h d;
+    cx b,c;
+    h d; cu1(-pi/8) c,d; h d;
+    cx a,c;
+    h d; cu1(pi/8) c,d; h d;
+}
+// 4-controlled X gate
+gate c4x a,b,c,d,e
+{
+    h e; cu1(pi/2) d,e; h e;
+    c3x a,b,c,d;
+    h e; cu1(-pi/2) d,e; h e;
+    c3x a,b,c,d;
+    c3sqrtx a,b,c,e;
+}

qiskit/qasm/libs/stdgates.inc

@@ -0,0 +1,82 @@
+// OpenQASM 3.0 standard gate library
+//
+// Vendored from the OpenQASM 3.0 project at commit 4ca1d793833b24a1 of
+// https://github.com/openqasm/openqasm.
+//
+// Used under the terms of its Apache-2.0 license.
+// Copyright 2017-2024 OpenQASM Contributors.
+
+
+// phase gate
+gate p(λ) a { ctrl @ gphase(λ) a; }
+
+// Pauli gate: bit-flip or NOT gate
+gate x a { U(π, 0, π) a; gphase(-π/2);}
+// Pauli gate: bit and phase flip
+gate y a { U(π, π/2, π/2) a; gphase(-π/2);}
+ // Pauli gate: phase flip
+gate z a { p(π) a; }
+
+// Clifford gate: Hadamard
+gate h a { U(π/2, 0, π) a; gphase(-π/4);}
+// Clifford gate: sqrt(Z) or S gate
+gate s a { pow(0.5) @ z a; }
+// Clifford gate: inverse of sqrt(Z)
+gate sdg a { inv @ pow(0.5) @ z a; }
+
+// sqrt(S) or T gate
+gate t a { pow(0.5) @ s a; }
+// inverse of sqrt(S)
+gate tdg a { inv @ pow(0.5) @ s a; }
+
+// sqrt(NOT) gate
+gate sx a { pow(0.5) @ x a; }
+
+// Rotation around X-axis
+gate rx(θ) a { U(θ, -π/2, π/2) a; gphase(-θ/2);}
+// rotation around Y-axis
+gate ry(θ) a { U(θ, 0, 0) a; gphase(-θ/2);}
+// rotation around Z axis
+gate rz(λ) a { gphase(-λ/2); U(0, 0, λ) a; }
+
+// controlled-NOT
+gate cx a, b { ctrl @ x a, b; }
+// controlled-Y
+gate cy a, b { ctrl @ y a, b; }
+// controlled-Z
+gate cz a, b { ctrl @ z a, b; }
+// controlled-phase
+gate cp(λ) a, b { ctrl @ p(λ) a, b; }
+// controlled-rx
+gate crx(θ) a, b { ctrl @ rx(θ) a, b; }
+// controlled-ry
+gate cry(θ) a, b { ctrl @ ry(θ) a, b; }
+// controlled-rz
+gate crz(θ) a, b { ctrl @ rz(θ) a, b; }
+// controlled-H
+gate ch a, b { ctrl @ h a, b; }
+
+// swap
+gate swap a, b { cx a, b; cx b, a; cx a, b; }
+
+// Toffoli
+gate ccx a, b, c { ctrl @ ctrl @ x a, b, c; }
+// controlled-swap
+gate cswap a, b, c { ctrl @ swap a, b, c; }
+
+// four parameter controlled-U gate with relative phase γ
+gate cu(θ, φ, λ, γ) a, b { p(γ-θ/2) a; ctrl @ U(θ, φ, λ) a, b; }
+
+// Gates for OpenQASM 2 backwards compatibility
+// CNOT
+gate CX a, b { ctrl @ U(π, 0, π) a, b; }
+// phase gate
+gate phase(λ) q { U(0, 0, λ) q; }
+// controlled-phase
+gate cphase(λ) a, b { ctrl @ phase(λ) a, b; }
+// identity or idle gate
+gate id a { U(0, 0, 0) a; }
+// IBM Quantum experience gates
+gate u1(λ) q { U(0, 0, λ) q; }
+gate u2(φ, λ) q { gphase(-(φ+λ+π/2)/2); U(π/2, φ, λ) q; }
+gate u3(θ, φ, λ) q { gphase(-(φ+λ+θ)/2); U(θ, φ, λ) q; }