def check_installed() -> None: """Checks that PySCF is actually installed. Raises: MissingOptionalLibraryError: If PySCF is not installed. """ try: spec = importlib.util.find_spec("pyscf") if spec is not None: return except Exception as ex: # pylint: disable=broad-except logger.debug("PySCF check error %s", str(ex)) raise MissingOptionalLibraryError( libname="PySCF", name="PySCFDriver", pip_install="pip install 'qiskit-nature[pyscf]'", msg="See https://pyscf.org/install.html", ) from ex raise MissingOptionalLibraryError( libname="PySCF", name="PySCFDriver", pip_install="pip install 'qiskit-nature[pyscf]'", msg="See https://pyscf.org/install.html", )
def __init__( self, maxiter: int = 1000, maxfail: int = 10, maxmp: int = None, verbose: bool = False, ) -> None: """ Args: maxiter: Maximum number of function evaluations. maxmp: Maximum number of model points requested for the local fit. Default = 2 * number of parameters + 6 set to this value when None. maxfail: Maximum number of failures to improve the solution. Stops the algorithm after maxfail is reached. verbose: Provide verbose (debugging) output. Raises: MissingOptionalLibraryError: scikit-quant or SQSnobFit not installed """ if not _HAS_SKQUANT: raise MissingOptionalLibraryError( libname="scikit-quant", name="SNOBFIT", pip_install="pip install scikit-quant") if not _HAS_SKSNOBFIT: raise MissingOptionalLibraryError( libname="SQSnobFit", name="SNOBFIT", pip_install="pip install SQSnobFit") super().__init__() self._maxiter = maxiter self._maxfail = maxfail self._maxmp = maxmp self._verbose = verbose
def to_networkx(self): """Returns a copy of the DAGDependency in networkx format.""" # For backwards compatibility, return networkx structure from terra 0.12 # where DAGNodes instances are used as indexes on the networkx graph. warnings.warn( "The to_networkx() method is deprecated and will be removed in a future release.", DeprecationWarning, stacklevel=2, ) try: import networkx as nx except ImportError as ex: raise MissingOptionalLibraryError( libname="Networkx", name="DAG dependency", pip_install="pip install networkx", ) from ex dag_networkx = nx.MultiDiGraph() for node in self.get_nodes(): dag_networkx.add_node(node) for node in self.topological_nodes(): for source_id, dest_id, edge in self.get_in_edges(node.node_id): dag_networkx.add_edge(self.get_node(source_id), self.get_node(dest_id), **edge) return dag_networkx
def __init__(self, expression: str, name: str = None) -> None: """ Args: expression (str): The logical expression string. name (str): Optional. Instruction gate name. Otherwise part of the expression is going to be used. Raises: MissingOptionalLibraryError: If tweedledum is not installed. Tweedledum is required. """ if not HAS_TWEEDLEDUM: raise MissingOptionalLibraryError( libname="tweedledum", name="BooleanExpression compiler", pip_install="pip install tweedledum", ) from tweedledum import BoolFunction self._tweedledum_bool_expression = BoolFunction.from_expression( expression) short_expr_for_name = (expression[:10] + "...") if len(expression) > 13 else expression num_qubits = (self._tweedledum_bool_expression.num_outputs() + self._tweedledum_bool_expression.num_inputs()) super().__init__(name or short_expr_for_name, num_qubits=num_qubits, params=[])
def _check_gurobipy_is_installed(name: str): if not _HAS_GUROBI: raise MissingOptionalLibraryError( libname="GUROBI", name=name, pip_install="pip install qiskit-optimization[gurobi]", )
def solve_cpx_problem(self, time_limit: float = 60, threads: int = None) -> str: """Solve the BIP problem using CPLEX. Args: time_limit: Time limit (seconds) given to CPLEX. threads: Number of threads to be allowed for CPLEX to use. Returns: Status string that CPLEX returned after solving the BIP problem. Raises: MissingOptionalLibraryError: If CPLEX is not installed """ if not HAS_CPLEX: raise MissingOptionalLibraryError( libname="CPLEX", name="CplexOptimizer", pip_install="pip install cplex", ) self.problem.set_time_limit(time_limit) if threads is not None: self.problem.context.cplex_parameters.threads = threads self.problem.context.cplex_parameters.randomseed = 777 self.solution = self.problem.solve() status = self.problem.solve_details.status logger.info("BIP solution status: %s", status) return status
def generate_latex_label(label): """Convert a label to a valid latex string.""" if not HAS_PYLATEX: raise MissingOptionalLibraryError( libname="pylatexenc", name="the latex and latex_source circuit drawers", pip_install="pip install pylatexenc", ) regex = re.compile(r"(?<!\\)\$(.*)(?<!\\)\$") match = regex.search(label) if not match: label = label.replace(r"\$", "$") final_str = utf8tolatex(label, non_ascii_only=True) else: mathmode_string = match.group(1).replace(r"\$", "$") before_match = label[: match.start()] before_match = before_match.replace(r"\$", "$") after_match = label[match.end() :] after_match = after_match.replace(r"\$", "$") final_str = ( utf8tolatex(before_match, non_ascii_only=True) + mathmode_string + utf8tolatex(after_match, non_ascii_only=True) ) return final_str.replace(" ", "\\,") # Put in proper spaces
def from_dimacs_file(cls, filename: str): """Create a BooleanExpression from the string in the DIMACS format. Args: filename: A file in DIMACS format. Returns: BooleanExpression: A gate for the input string Raises: MissingOptionalLibraryError: If tweedledum is not installed. Tweedledum is required. FileNotFoundError: If filename is not found. """ if not HAS_TWEEDLEDUM: raise MissingOptionalLibraryError( libname='tweedledum', name='BooleanExpression compiler', pip_install='pip install tweedledum') from tweedledum import BoolFunction expr_obj = cls.__new__(cls) if not isfile(filename): raise FileNotFoundError('The file %s does not exists.' % filename) expr_obj._tweedledum_bool_expression = BoolFunction.from_dimacs_file(filename) num_qubits = (expr_obj._tweedledum_bool_expression.num_inputs() + expr_obj._tweedledum_bool_expression.num_outputs()) super(BooleanExpression, expr_obj).__init__( # pylint: disable=no-value-for-parameter name=basename(filename), num_qubits=num_qubits, params=[]) return expr_obj
def _mpl(graph: PyGraph, self_loop: bool, **kwargs): """ Auxiliary function for drawing the lattice using matplotlib. Args: graph : graph to be drawn. self_loop : Draw self-loops, which are edges connecting a node to itself. **kwargs : Kwargs for drawing the lattice. Raises: MissingOptionalLibraryError: Requires matplotlib. """ if not HAS_MATPLOTLIB: raise MissingOptionalLibraryError( libname="Matplotlib", name="_mpl", pip_install="pip install matplotlib" ) from matplotlib import pyplot as plt if not self_loop: self_loops = [(i, i) for i in range(graph.num_nodes()) if graph.has_edge(i, i)] graph.remove_edges_from(self_loops) mpl_draw( graph=graph, **kwargs, ) plt.draw()
def __init__(self, num_cuts: int, sort_cuts: bool = True, unique_cuts: bool = True, seed: int = 0): """ Args: num_cuts: Number of cuts to generate. sort_cuts: True if sort cuts by their values. unique_cuts: The solve method returns only unique cuts, thus there may be less cuts than ``num_cuts``. seed: A seed value for the random number generator. Raises: MissingOptionalLibraryError: CVXPY is not installed. """ if not _HAS_CVXPY: raise MissingOptionalLibraryError( libname="CVXPY", name="GoemansWilliamsonOptimizer", pip_install="pip install 'qiskit-optimization[cvxpy]'") super().__init__() self._num_cuts = num_cuts self._sort_cuts = sort_cuts self._unique_cuts = unique_cuts np.random.seed(seed)
def __init__( self, tickers: Optional[Union[str, List[str]]] = None, start: datetime.datetime = datetime.datetime(2016, 1, 1), end: datetime.datetime = datetime.datetime(2016, 1, 30), ) -> None: """ Initializer Args: tickers: tickers start: start time end: end time Raises: MissingOptionalLibraryError: YFinance not installed """ super().__init__() if not _HAS_YFINANCE: raise MissingOptionalLibraryError( libname="YFinance", name="YahooDataProvider", pip_install="pip install yfinance", ) self._tickers = None # type: Optional[Union[str, List[str]]] tickers = tickers if tickers is not None else [] if isinstance(tickers, list): self._tickers = tickers else: self._tickers = tickers.replace("\n", ";").split(";") self._n = len(self._tickers) self._tickers = tickers self._start = start.strftime("%Y-%m-%d") self._end = end.strftime("%Y-%m-%d") self._data = []
def __init__(self, tickers: Optional[Union[str, List[str]]] = None, start: datetime.datetime = datetime.datetime(2016, 1, 1), end: datetime.datetime = datetime.datetime(2016, 1, 30), seed: Optional[int] = None) -> None: """ Initializer Args: tickers: tickers start: first data point end: last data point precedes this date seed: shall a seed be used? Raises: MissingOptionalLibraryError: Pandas not installed """ super().__init__() if not _HAS_PANDAS: raise MissingOptionalLibraryError(libname='Pandas', name='RandomDataProvider', pip_install='pip install pandas') tickers = tickers if tickers is not None else ["TICKER1", "TICKER2"] if isinstance(tickers, list): self._tickers = tickers else: self._tickers = tickers.replace('\n', ';').split(";") self._n = len(self._tickers) self._start = start self._end = end self._seed = seed
def __init__( self, token: Optional[str] = None, tickers: Optional[Union[str, List[str]]] = None, start: datetime.datetime = datetime.datetime(2016, 1, 1), end: datetime.datetime = datetime.datetime(2016, 1, 30) ) -> None: """ Initializer Args: token: quandl access token, which is not needed, strictly speaking tickers: tickers start: start time end: end time Raises: MissingOptionalLibraryError: Quandl not installed """ super().__init__() if not _HAS_QUANDL: raise MissingOptionalLibraryError(libname='Quandl', name='WikipediaDataProvider', pip_install='pip install quandl') self._tickers = None # type: Optional[Union[str, List[str]]] tickers = tickers if tickers is not None else [] if isinstance(tickers, list): self._tickers = tickers else: self._tickers = tickers.replace('\n', ';').split(";") self._n = len(self._tickers) self._token = token self._tickers = tickers self._start = start.strftime('%Y-%m-%d') self._end = end.strftime('%Y-%m-%d') self._data = []
def draw( self, result: Optional[Union[OptimizationResult, np.ndarray]] = None, pos: Optional[Dict[int, np.ndarray]] = None, ) -> None: """Draw a graph with the result. When the result is None, draw an original graph without colors. Args: result: The calculated result for the problem pos: The positions of nodes Raises: MissingOptionalLibraryError: if matplotlib is not installed. """ if not _HAS_MATPLOTLIB: raise MissingOptionalLibraryError( libname="matplotlib", name="GraphOptimizationApplication", pip_install="pip install 'qiskit-optimization[matplotlib]'", ) if result is None: nx.draw(self._graph, pos=pos, with_labels=True) else: self._draw_result(result, pos)
def visit_FunctionDef(self, node): """The function definition should have type hints""" if HAS_TWEEDLEDUM: from tweedledum.classical import LogicNetwork # pylint: disable=no-name-in-module else: raise MissingOptionalLibraryError( libname='tweedledum', name='classical function compiler', pip_install='pip install tweedledum') if node.returns is None: raise ClassicalFunctionParseError("return type is needed") scope = { 'return': (node.returns.id, None), node.returns.id: ('type', None) } # Extend scope with the decorator's names scope.update({ decorator.id: ('decorator', None) for decorator in node.decorator_list }) self.scopes.append(scope) self._network = LogicNetwork() self.extend_scope(node.args) return super().generic_visit(node)
def get_unique_backends(): """Gets the unique backends that are available. Returns: list: Unique available backends. Raises: QiskitError: No backends available. MissingOptionalLibraryError: If qiskit-ibmq-provider is not installed """ try: from qiskit.providers.ibmq import IBMQ except ImportError as ex: raise MissingOptionalLibraryError( libname="qiskit-ibmq-provider", name="get_unique_backends", pip_install="pip install qiskit-ibmq-provider", ) from ex backends = [] for provider in IBMQ.providers(): for backend in provider.backends(): backends.append(backend) unique_hardware_backends = [] unique_names = [] for back in backends: if back.name() not in unique_names and not back.configuration().simulator: unique_hardware_backends.append(back) unique_names.append(back.name()) if not unique_hardware_backends: raise QiskitError("No backends available.") return unique_hardware_backends
def _ridge(a: np.ndarray, c: np.ndarray, lambda_: float = 1., lambda1: float = 1e-4, lambda4: float = 1e-1, tol_search: float = 1e-8, fit_intercept: bool = True, normalize: bool = False, copy_a: bool = True, max_iter: int = 1000, tol: float = 0.0001, solver: str = 'auto', random_state: Optional[int] = None) -> Tuple[float, np.ndarray]: """ Ridge Regression with automatic search for a good regularization term lambda x_lambda = arg min{||Ax-C||^2 + lambda*||x||_2^2} (3) `Scikit Learn Ridge Regression <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html>` Args: a: see (1) and (2) c: see (1) and (2) lambda_ : regularization parameter used if auto_search = False lambda1: left starting point for L-curve corner search lambda4: right starting point for L-curve corner search tol_search: termination threshold for regularization parameter search fit_intercept: if True calculate intercept normalize: deprecated if fit_intercept=False, if True normalize A for regression copy_a: if True A is copied, else overwritten max_iter: max. number of iterations if solver is CG tol: precision of the regression solution solver: solver {‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’, ‘saga’} random_state: seed for the pseudo random number generator used when data is shuffled Returns: regularization coefficient, solution to the regularization inverse problem Raises: MissingOptionalLibraryError: scikit-learn not installed """ try: from sklearn.linear_model import Ridge except ImportError as ex: raise MissingOptionalLibraryError( libname='scikit-learn', name='_ridge', pip_install='pip install scikit-learn') from ex reg = Ridge(alpha=lambda_, fit_intercept=fit_intercept, normalize=normalize, copy_X=copy_a, max_iter=max_iter, tol=tol, solver=solver, random_state=random_state) def reg_method(a, c, alpha): reg.set_params(alpha=alpha) reg.fit(a, c) return reg.coef_ lambda_mc, x_mc = NaturalGradient._reg_term_search(a, c, reg_method, lambda1=lambda1, lambda4=lambda4, tol=tol_search) return lambda_mc, np.transpose(x_mc)
def __init__(self, source, name=None): """Creates a ``ClassicalFunction`` from Python source code in ``source``. The code should be a single function with types. Args: source (str): Python code with type hints. name (str): Optional. Default: "*classicalfunction*". ClassicalFunction name. Raises: MissingOptionalLibraryError: If tweedledum is not installed. QiskitError: If source is not a string. """ if not isinstance(source, str): raise QiskitError( 'ClassicalFunction needs a source code as a string.') if not HAS_TWEEDLEDUM: raise MissingOptionalLibraryError( libname='tweedledum', name='classical function compiler', pip_install='pip install tweedledum') self._ast = ast.parse(source) self._network = None self._scopes = None self._args = None self._truth_table = None super().__init__(name or '*classicalfunction*', num_qubits=sum([qreg.size for qreg in self.qregs]), params=[])
def __init__(self, n_features: int = 1, n_out: int = 1) -> None: """ Args: n_features: Dimension of input data vector. n_out: Dimension of the discriminator's output vector. Raises: MissingOptionalLibraryError: Pytorch not installed """ super().__init__() if not _HAS_TORCH: raise MissingOptionalLibraryError( libname='Pytorch', name='PyTorchDiscriminator', pip_install="pip install 'qiskit-meachine-learning[torch]'") self._n_features = n_features self._n_out = n_out # discriminator_net: torch.nn.Module or None, Discriminator network. # pylint: disable=import-outside-toplevel from ._pytorch_discriminator_net import DiscriminatorNet self._discriminator = DiscriminatorNet(self._n_features, self._n_out) # optimizer: torch.optim.Optimizer or None, Optimizer initialized w.r.t # discriminator network parameters. self._optimizer = optim.Adam(self._discriminator.parameters(), lr=1e-5, amsgrad=True) self._ret = {} # type: Dict[str, Any]
def __init__(self, max_evals: int = 1000) -> None: # pylint: disable=unused-argument """ Args: max_evals: Maximum allowed number of function evaluations. Raises: MissingOptionalLibraryError: NLopt library not installed. """ if not _HAS_NLOPT: raise MissingOptionalLibraryError( libname='nlopt', name='NLoptOptimizer', msg='See https://qiskit.org/documentation/apidoc/' 'qiskit.aqua.components.optimizers.nlopts.html' ' for installation information') super().__init__() for k, v in list(locals().items()): if k in self._OPTIONS: self._options[k] = v self._optimizer_names = { NLoptOptimizerType.GN_CRS2_LM: nlopt.GN_CRS2_LM, NLoptOptimizerType.GN_DIRECT_L_RAND: nlopt.GN_DIRECT_L_RAND, NLoptOptimizerType.GN_DIRECT_L: nlopt.GN_DIRECT_L, NLoptOptimizerType.GN_ESCH: nlopt.GN_ESCH, NLoptOptimizerType.GN_ISRES: nlopt.GN_ISRES, }
def qasm_widget(circuit: QuantumCircuit) -> wid.VBox: """Generate a QASM widget with header for a quantum circuit. Args: circuit: Input quantum circuit. Returns: Output widget. Raises: MissingOptionalLibraryError: If pygments is not installed """ if not HAS_PYGMENTS: raise MissingOptionalLibraryError( libname="pygments>2.4", name="qasm_widget", pip_install="pip install pygments", ) qasm_code = circuit.qasm() code = pygments.highlight(qasm_code, OpenQASMLexer(), HtmlFormatter()) html_style = HtmlFormatter( style=QasmHTMLStyle).get_style_defs(".highlight") code_style = (""" <style> .highlight { font-family: monospace; font-size: 14px; line-height: 1.7em; } .highlight .err { color: #000000; background-color: #FFFFFF } %s </style> """ % html_style) out = wid.HTML( code_style + code, layout=wid.Layout(max_height="500px", height="auto", overflow="scroll scroll"), ) out_label = wid.HTML( f"<p style='{head_style}'>OpenQASM</p>", layout=wid.Layout(margin="0px 0px 10px 0px"), ) qasm = wid.VBox( children=[out_label, out], layout=wid.Layout(height="auto", max_height="500px", width="60%", margin="0px 0px 0px 20px"), ) qasm._code_length = len(qasm_code.split("\n")) return qasm
def plot_bloch_multivector(state, title="", figsize=None, *, rho=None, reverse_bits=False): """Plot the Bloch sphere. Plot a sphere, axes, the Bloch vector, and its projections onto each axis. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Has no effect, here for compatibility only. reverse_bits (bool): If True, plots qubits following Qiskit's convention [Default:False]. Returns: matplotlib.Figure: A matplotlib figure instance. Raises: MissingOptionalLibraryError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. Example: .. jupyter-execute:: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_bloch_multivector %matplotlib inline qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = Statevector.from_instruction(qc) plot_bloch_multivector(state, title="New Bloch Multivector", reverse_bits=False) """ if not HAS_MATPLOTLIB: raise MissingOptionalLibraryError( libname="Matplotlib", name="plot_bloch_multivector", pip_install="pip install matplotlib", ) from matplotlib import get_backend from matplotlib import pyplot as plt # Data bloch_data = ( _bloch_multivector_data(state)[::-1] if reverse_bits else _bloch_multivector_data(state) ) num = len(bloch_data) width, height = plt.figaspect(1 / num) fig = plt.figure(figsize=(width, height)) for i in range(num): pos = num - 1 - i if reverse_bits else i ax = fig.add_subplot(1, num, i + 1, projection="3d") plot_bloch_vector(bloch_data[i], "qubit " + str(pos), ax=ax, figsize=figsize) fig.suptitle(title, fontsize=16) if get_backend() in ["module://ipykernel.pylab.backend_inline", "nbAgg"]: plt.close(fig) return fig
def plot_bloch_vector(bloch, title="", ax=None, figsize=None, coord_type="cartesian"): """Plot the Bloch sphere. Plot a sphere, axes, the Bloch vector, and its projections onto each axis. Args: bloch (list[double]): array of three elements where [<x>, <y>, <z>] (Cartesian) or [<r>, <theta>, <phi>] (spherical in radians) <theta> is inclination angle from +z direction <phi> is azimuth from +x direction title (str): a string that represents the plot title ax (matplotlib.axes.Axes): An Axes to use for rendering the bloch sphere figsize (tuple): Figure size in inches. Has no effect is passing ``ax``. coord_type (str): a string that specifies coordinate type for bloch (Cartesian or spherical), default is Cartesian Returns: Figure: A matplotlib figure instance if ``ax = None``. Raises: MissingOptionalLibraryError: Requires matplotlib. Example: .. jupyter-execute:: from qiskit.visualization import plot_bloch_vector %matplotlib inline plot_bloch_vector([0,1,0], title="New Bloch Sphere") """ if not HAS_MATPLOTLIB: raise MissingOptionalLibraryError( libname="Matplotlib", name="plot_bloch_vector", pip_install="pip install matplotlib", ) from qiskit.visualization.bloch import Bloch from matplotlib import get_backend from matplotlib import pyplot as plt if figsize is None: figsize = (5, 5) B = Bloch(axes=ax) if coord_type == "spherical": r, theta, phi = bloch[0], bloch[1], bloch[2] bloch[0] = r * np.sin(theta) * np.cos(phi) bloch[1] = r * np.sin(theta) * np.sin(phi) bloch[2] = r * np.cos(theta) B.add_vectors(bloch) B.render(title=title) if ax is None: fig = B.fig fig.set_size_inches(figsize[0], figsize[1]) if get_backend() in ["module://ipykernel.pylab.backend_inline", "nbAgg"]: plt.close(fig) return fig return None
def __init__( self, coupling_map, qubit_subset=None, objective="depth", backend_prop=None, time_limit=30, threads=None, max_swaps_inbetween_layers=None, ): """BIPMapping initializer. Args: coupling_map (CouplingMap): Directed graph represented a coupling map. qubit_subset (list[int]): Sublist of physical qubits to be used in the mapping. If None, all qubits in the coupling_map will be considered. objective (str): Type of objective function to be minimized: * ``'gate_error'``: Approximate gate error of the circuit, which is given as the sum of negative logarithm of 2q-gate fidelities in the circuit. It takes into account only the 2q-gate (CNOT) errors reported in ``backend_prop`` and ignores the other errors in such as 1q-gates, SPAMs and idle times. * ``'depth'``: [Default] Depth (number of 2q-gate layers) of the circuit. * ``'balanced'``: Weighted sum of ``'gate_error'`` and ``'depth'`` backend_prop (BackendProperties): Backend properties object containing 2q-gate gate errors, which are required in computing certain types of objective function such as ``'gate_error'`` or ``'balanced'``. time_limit (float): Time limit for solving BIP in seconds threads (int): Number of threads to be allowed for CPLEX to solve BIP max_swaps_inbetween_layers (int): Number of swaps allowed in between layers. If None, automatically set. Large value could decrease the probability to build infeasible BIP problem but also could reduce the chance of finding a feasible solution within the ``time_limit``. Raises: MissingOptionalLibraryError: if cplex or docplex are not installed. TranspilerError: if invalid options are specified. """ if not HAS_DOCPLEX or not HAS_CPLEX: raise MissingOptionalLibraryError( libname="bip-mapper", name="BIP-based mapping pass", pip_install="pip install 'qiskit-terra[bip-mapper]'", msg="This may not be possible for all Python versions and OSes", ) if backend_prop is None and objective in ("gate_error", "balanced"): raise TranspilerError(f"'backend_prop' is required for '{objective}' objective") super().__init__() self.coupling_map = coupling_map self.qubit_subset = qubit_subset if self.coupling_map is not None and self.qubit_subset is None: self.qubit_subset = list(range(self.coupling_map.size())) self.objective = objective self.backend_prop = backend_prop self.time_limit = time_limit self.threads = threads self.max_swaps_inbetween_layers = max_swaps_inbetween_layers
def check_installed() -> None: """ Checks if PSI4 is installed and available Raises: MissingOptionalLibraryError: if not installed. """ if PSI4_APP is None: raise MissingOptionalLibraryError(libname="PSI4", name="PSI4Driver")
def latex(self): """Return the corresponding math mode latex string.""" try: from pylatexenc.latexencode import utf8tolatex except ImportError as ex: raise MissingOptionalLibraryError("pylatexenc", "latex-from-qasm exporter", "pip install pylatexenc") from ex return utf8tolatex(self.sym())
def _replace_pauli_sums(cls, operator): try: from qiskit.providers.aer.library import SaveExpectationValue except ImportError as ex: raise MissingOptionalLibraryError( libname="qiskit-aer", name="AerPauliExpectation", pip_install="pip install qiskit-aer", ) from ex # The 'expval_measurement' label on the save instruction is special - the # CircuitSampler will look for it to know that the circuit is a Expectation # measurement, and not simply a # circuit to replace with a DictStateFn if operator.__class__ == ListOp: return operator.traverse(cls._replace_pauli_sums) if isinstance(operator, PauliSumOp): save_instruction = SaveExpectationValue(operator.primitive, "expval_measurement") return CircuitStateFn(save_instruction, coeff=operator.coeff, is_measurement=True, from_operator=True) # Change to Pauli representation if necessary if {"Pauli"} != operator.primitive_strings(): logger.warning( "Measured Observable is not composed of only Paulis, converting to " "Pauli representation, which can be expensive.") # Setting massive=False because this conversion is implicit. User can perform this # action on the Observable with massive=True explicitly if they so choose. operator = operator.to_pauli_op(massive=False) if isinstance(operator, SummedOp): sparse_pauli = reduce(add, (meas.coeff * SparsePauliOp(meas.primitive) for meas in operator.oplist)) save_instruction = SaveExpectationValue(sparse_pauli, "expval_measurement") return CircuitStateFn(save_instruction, coeff=operator.coeff, is_measurement=True, from_operator=True) if isinstance(operator, PauliOp): sparse_pauli = operator.coeff * SparsePauliOp(operator.primitive) save_instruction = SaveExpectationValue(sparse_pauli, "expval_measurement") return CircuitStateFn(save_instruction, is_measurement=True, from_operator=True) raise TypeError( f"Conversion of OperatorStateFn of {operator.__class__.__name__} is not defined." )
def __init__(self): if not HAS_TWEEDLEDUM: raise MissingOptionalLibraryError( libname='tweedledum', name='classical function compiler', pip_install='pip install tweedledum') self.scopes = [] self.args = [] self._network = None self.name = None super().__init__()
def __getattr__(self, attr): if not self.aer: try: from qiskit.providers import aer self.aer = aer.Aer except ImportError as ex: raise MissingOptionalLibraryError( "qiskit-aer", "Aer provider", "pip install qiskit-aer" ) from ex return getattr(self.aer, attr)
def __getattr__(self, attr): if not self.ibmq: try: from qiskit.providers import ibmq self.ibmq = ibmq.IBMQ except ImportError as ex: raise MissingOptionalLibraryError( "qiskit-ibmq-provider", "IBMQ provider", "pip install qiskit-ibmq-provider" ) from ex return getattr(self.ibmq, attr)