Source code for lambeq.ansatz.base

# Copyright 2021-2022 Cambridge Quantum Computing Ltd.
# 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.

An ansatz is used to convert a DisCoCat diagram into a quantum circuit.

from __future__ import annotations

__all__ = ['BaseAnsatz', 'Symbol']

from abc import ABC, abstractmethod
from import Mapping
from typing import Any, Literal

from discopy import monoidal, rigid
import sympy

[docs]class Symbol(sympy.Symbol): """A sympy symbol augmented with extra information. Attributes ---------- size : int The size of the tensor that this symbol represents. """ size: int def __new__(cls, name: str, size: int = 1, **assumptions: bool) -> Symbol: """Initialise a symbol. Parameters ---------- size : int, default: 1 The size of the tensor that this symbol represents. """ cls._sanitize(assumptions, cls) obj: Symbol = sympy.Symbol.__xnew__(cls, name, **assumptions) obj.size = size return obj def __getnewargs_ex__(self) -> tuple[tuple[str, int], dict[str, bool]]: return (, self.size), self.assumptions0
[docs] @sympy.cacheit def sort_key(self, order: Literal[None] = None) -> tuple[Any, ...]: return (self.class_key(), (2, (, self.size)), sympy.S.One.sort_key(), sympy.S.One)
def _hashable_content(self) -> tuple[Any, ...]: return (*super()._hashable_content(), self.size)
[docs]class BaseAnsatz(ABC): """Base class for ansatz."""
[docs] @abstractmethod def __init__(self, ob_map: Mapping[rigid.Ty, monoidal.Ty]) -> None: """Instantiate an ansatz. Parameters ---------- ob_map : dict A mapping from `discopy.rigid.Ty` to a type in the target category. In the category of quantum circuits, this type is the number of qubits; in the category of vector spaces, this type is a vector space. """
[docs] @abstractmethod def __call__(self, diagram: rigid.Diagram) -> monoidal.Diagram: """Convert a DisCoPy diagram into a DisCoPy circuit or tensor."""
@staticmethod def _summarise_box(box: rigid.Box) -> str: """Summarise the given DisCoPy box.""" dom = str(box.dom).replace(' @ ', '@') if box.dom else '' cod = str(box.cod).replace(' @ ', '@') if box.cod else '' return f'{}_{dom}_{cod}'