Merge branch 'feature/symbolic'

Author: jvdwetering

pyzx/graph/base.py

@@ -90,6 +90,7 @@ def __init__(self) -> None:
         # merge_vdata(v0,v1) is an optional, custom function for merging
         # vdata of v1 into v0 during spider fusion etc.
         self.merge_vdata: Optional[Callable[[VT,VT], None]] = None
+        self.variable_types: Dict[str,bool] = dict() # mapping of variable names to their type (bool or continuous)
 
     def __str__(self) -> str:
         return "Graph({} vertices, {} edges)".format(

pyzx/graph/diff.py

@@ -18,10 +18,10 @@
 from typing import Any, Callable, Generic, Optional, List, Dict, Tuple
 import copy
 
-from ..utils import VertexType, EdgeType, FractionLike, FloatInt
+from ..utils import VertexType, EdgeType, FractionLike, FloatInt, phase_to_s
 from .base import BaseGraph, VT, ET
 from .graph_s import GraphS
-from .jsonparser import ComplexDecoder, ComplexEncoder, _phase_to_quanto_value, _quanto_value_to_phase
+from .jsonparser import ComplexDecoder, ComplexEncoder, string_to_phase
 
 class GraphDiff(Generic[VT, ET]):
 	removed_verts: List[VT]
@@ -33,6 +33,7 @@ class GraphDiff(Generic[VT, ET]):
 	changed_phases: Dict[VT, FractionLike]
 	changed_pos: Dict[VT, Tuple[FloatInt,FloatInt]]
 	changed_vdata: Dict[VT, Any]
+	variable_types: Dict[str,bool]
 
 	def __init__(self, g1: BaseGraph[VT,ET], g2: BaseGraph[VT,ET]) -> None:
 		self.calculate_diff(g1,g2)
@@ -43,6 +44,8 @@ def calculate_diff(self, g1: BaseGraph[VT,ET], g2: BaseGraph[VT,ET]) -> None:
 		self.changed_phases = {}
 		self.changed_pos = {}
 		self.changed_vdata = {}
+		self.variable_types = g1.variable_types.copy()
+		self.variable_types.update(g2.variable_types)
 
 		old_verts = g1.vertex_set()
 		new_verts = g2.vertex_set()
@@ -132,7 +135,7 @@ def to_json(self) -> str:
 		changed_edge_types_str_dict = {}
 		for key, value in self.changed_edge_types.items():
 			changed_edge_types_str_dict[f"{key[0]},{key[1]}"] = value # type: ignore
-		changed_phases_str = {k: _phase_to_quanto_value(v) for k, v in self.changed_phases.items()}
+		changed_phases_str = {k: phase_to_s(v) for k, v in self.changed_phases.items()}
 		return json.dumps({
 			"removed_verts": self.removed_verts,
 			"new_verts": self.new_verts,
@@ -143,6 +146,7 @@ def to_json(self) -> str:
 			"changed_phases": changed_phases_str,
 			"changed_pos": self.changed_pos,
 			"changed_vdata": self.changed_vdata,
+			"variable_types": self.variable_types
 		},  cls=ComplexEncoder)
 
 	@staticmethod
@@ -155,7 +159,7 @@ def from_json(json_str: str) -> "GraphDiff":
 		gd.new_edges = list(map(tuple, d["new_edges"])) # type: ignore
 		gd.changed_vertex_types = map_dict_keys(d["changed_vertex_types"], int)
 		gd.changed_edge_types = map_dict_keys(d["changed_edge_types"], lambda x: tuple(map(int, x.split(","))))
-		gd.changed_phases = {int(k): _quanto_value_to_phase(v) for k, v in d["changed_phases"].items()}
+		gd.changed_phases = {int(k): string_to_phase(v,gd) for k, v in d["changed_phases"].items()}
 		gd.changed_pos = map_dict_keys(d["changed_pos"], int)
 		gd.changed_vdata = map_dict_keys(d["changed_vdata"], int)
 		return gd

pyzx/graph/jsonparser.py

@@ -15,36 +15,60 @@
 # limitations under the License.
 
 import json
+import re
 from fractions import Fraction
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Callable, Union, TYPE_CHECKING
 
-from ..utils import FractionLike, EdgeType, VertexType
+from ..utils import FractionLike, EdgeType, VertexType, phase_to_s
 from .graph import Graph
 from .scalar import Scalar
 from .base import BaseGraph, VT, ET
 from ..simplify import id_simp
-
-def _quanto_value_to_phase(s: str) -> Fraction:
-    if not s: return Fraction(0)
-    if r'\pi' in s:
+from ..symbolic import parse, Poly, new_var
+if TYPE_CHECKING:
+    from .diff import GraphDiff
+
+
+#def _phase_to_quanto_value(p: FractionLike) -> str:
+#    if not p: return ""
+#    try:
+#        p = Fraction(p)
+#        if p.numerator == -1: v = "-"
+#        elif p.numerator == 1: v = ""
+#        else: v = str(p.numerator)
+#        d = "/"+str(p.denominator) if p.denominator!=1 else ""
+#        return r"{}\pi{}".format(v,d)
+#    except TypeError:
+
+
+def string_to_phase(string: str, g: Union[BaseGraph,'GraphDiff']) -> Union[Fraction, Poly]:
+    if not string:
+        return Fraction(0)
+    try:
+        s = string.lower().replace(' ', '')
+        s = re.sub(r'\\?(pi|\u04c0)', '', s)
+        if s == '': return Fraction(1)
+        if s == '-': return Fraction(-1)
+        if '.' in s or 'e' in s:
+            return Fraction(float(s))
+        elif '/' in s:
+            a, b = s.split("/", 2)
+            if not a:
+                return Fraction(1, int(b))
+            if a == '-':
+                a = '-1'
+            return Fraction(int(a), int(b))
+        else:
+            return Fraction(int(s))
+    except ValueError:
+        def _new_var(name: str) -> Poly:
+            if name not in g.variable_types:
+                g.variable_types[name] = False
+            return new_var(name, g.variable_types)
         try:
-            r = s.replace(r'\pi','').strip()
-            if r.startswith('-'): r = "-1"+r[1:]
-            if r.startswith('/'): r = "1"+r
-            return Fraction(str(r)) if r else Fraction(1)
-        except ValueError:
-            raise ValueError("Invalid phase '{}'".format(s))
-    return Fraction(s)
-
-def _phase_to_quanto_value(p: FractionLike) -> str:
-    if not p: return ""
-    p = Fraction(p)
-    if p.numerator == -1: v = "-"
-    elif p.numerator == 1: v = ""
-    else: v = str(p.numerator)
-    d = "/"+str(p.denominator) if p.denominator!=1 else ""
-    return r"{}\pi{}".format(v,d)
-
+            return parse(string, _new_var)
+        except Exception as e:
+            raise ValueError(e)
 
 def json_to_graph(js: str, backend:Optional[str]=None) -> BaseGraph:
     """Converts the json representation of a .qgraph Quantomatic graph into
@@ -76,7 +100,7 @@ def json_to_graph(js: str, backend:Optional[str]=None) -> BaseGraph:
             elif d['type'] == 'Z_box': g.set_type(v,VertexType.Z_BOX)
             else: raise TypeError("unsupported type '{}'".format(d['type']))
             if 'value' in d:
-                g.set_phase(v,_quanto_value_to_phase(d['value']))
+                g.set_phase(v,string_to_phase(d['value'],g))
             else:
                 g.set_phase(v,Fraction(0,1))
             if d.get('ground', False):
@@ -89,7 +113,7 @@ def json_to_graph(js: str, backend:Optional[str]=None) -> BaseGraph:
                 continue
             elif key == 'label':
                 if type(value) != complex:
-                    value = _quanto_value_to_phase(value)
+                    value = string_to_phase(value,g)
             g.set_vdata(v, key, value)
 
     inputs = {}
@@ -207,10 +231,10 @@ def graph_to_json(g: BaseGraph[VT,ET], include_scalar: bool=True) -> str:
                 node_vs[name]["data"]["type"] = "Z_box"
                 zbox_label = g.vdata(v, 'label', 1)
                 if type(zbox_label) == Fraction:
-                    zbox_label = _phase_to_quanto_value(zbox_label)
+                    zbox_label = phase_to_s(zbox_label)
                 node_vs[name]["annotation"]["label"] = zbox_label
             else: raise Exception("Unkown vertex type "+ str(t))
-            phase = _phase_to_quanto_value(g.phase(v))
+            phase = phase_to_s(g.phase(v))
             if phase: node_vs[name]["data"]["value"] = phase
             if g.is_ground(v):
                 node_vs[name]["data"]["ground"] = True

pyzx/graph/scalar.py

@@ -24,6 +24,7 @@
 import json
 
 from ..utils import FloatInt, FractionLike
+from ..symbolic import Poly
 
 __all__ = ['Scalar']
 
@@ -53,7 +54,7 @@ class Scalar(object):
     """Represents a global scalar for a Graph instance."""
     def __init__(self) -> None:
         self.power2: int = 0 # Stores power of square root of two
-        self.phase: Fraction = Fraction(0) # Stores complex phase of the number
+        self.phase: FractionLike = Fraction(0) # Stores complex phase of the number
         self.phasenodes: List[FractionLike] = [] # Stores list of legless spiders, by their phases.
         self.floatfactor: complex = 1.0
         self.is_unknown: bool = False # Whether this represents an unknown scalar value
@@ -114,7 +115,10 @@ def to_latex(self) -> str:
         if self.power2 != 0:
             s += r"\sqrt{{2}}^{{{:d}}}".format(self.power2)
         if self.phase not in (0,1):
-            s += r"\exp(i~\frac{{{:d}\pi}}{{{:d}}})".format(self.phase.numerator,self.phase.denominator)
+            if isinstance(self.phase, Poly):
+                s += fr"\exp(i~{str(self.phase)})".format(str(self.phase))
+            else:
+                s += r"\exp(i~\frac{{{:d}\pi}}{{{:d}}})".format(self.phase.numerator,self.phase.denominator)
         s += "$"
         if s == "$$": return ""
         return s
@@ -127,6 +131,8 @@ def to_unicode(self) -> str:
         f = self.floatfactor
         for node in self.phasenodes:
             f *= 1+cexp(node)
+        if isinstance(self.phase, Poly):
+            raise NotImplementedError("Unicode representation of Poly not implemented")
         phase = Fraction(self.phase)
         if self.phase >= 1:
             f *= -1
@@ -218,6 +224,9 @@ def add_spider_pair(self, p1: FractionLike,p2: FractionLike) -> None:
             self.add_power(1)
             self.add_phase(p2)
             return
+        if isinstance(p1, Poly) or isinstance(p2, Poly):
+            self.set_unknown()
+            return
         if p2.denominator == 2:
             p1, p2 = p2, p1
         if p1 == Fraction(1,2):

pyzx/io.py

@@ -22,6 +22,7 @@
 from .graph import Graph, EdgeType, VertexType
 from .graph.base import BaseGraph, VT, ET
 from .simplify import id_simp
+from .symbolic import Poly
 
 __all__ = ['json_to_graph', 'graph_to_json', 'to_graphml']
 
@@ -39,6 +40,8 @@ def _quanto_value_to_phase(s: str) -> Fraction:
 
 def _phase_to_quanto_value(p: FractionLike) -> str:
     if not p: return ""
+    if isinstance(p, Poly):
+        raise ValueError("Symbolic phases not supported")
     p = Fraction(p)
     if p.numerator == -1: v = "-"
     elif p.numerator == 1: v = ""

pyzx/mbqc.py

@@ -1,5 +1,6 @@
 from . import Graph
 from .graph.base import BaseGraph
+from .symbolic import Poly
 from .utils import VertexType, EdgeType, FractionLike
 
 from fractions import Fraction
@@ -35,6 +36,8 @@ def measure(g:BaseGraph, pos:Tuple[int,int], t:VertexType.Type=VertexType.Z, pha
     q = 2*pos[0]-0.8
     r = 2*pos[1]+0.8
     found = False
+    if isinstance(phase, Poly):
+        raise ValueError("Symbolic phases not supported")
     if not isinstance(phase, Fraction): phase = Fraction(phase)
     outputs = list(g.outputs())
     for v in g.vertices():

pyzx/quimb.py

@@ -31,6 +31,7 @@
 from .utils import EdgeType, VertexType
 from .graph.base import BaseGraph
 from .simplify import to_gh
+from .symbolic import Poly
 
 
 def to_quimb_tensor(g: BaseGraph) -> "qtn.TensorNetwork": # type:ignore
@@ -56,7 +57,10 @@ def to_quimb_tensor(g: BaseGraph) -> "qtn.TensorNetwork": # type:ignore
     # Here we have phase tensors corresponding to Z-spiders with only one output and no input.
     for v in g.vertices():
         if g.type(v) == VertexType.Z and g.phase(v) != 0:
-            tensors.append(qtn.Tensor(data = [1, np.exp(1j * np.pi * g.phase(v))],
+            phase = g.phase(v)
+            if isinstance(phase, Poly):
+                raise NotImplementedError("Quimb does not support symbolic phases")
+            tensors.append(qtn.Tensor(data = [1, np.exp(1j * np.pi * phase)],
                                       inds = (f'{v}',),
                                       tags = ("V",)))
 
@@ -74,8 +78,13 @@ def to_quimb_tensor(g: BaseGraph) -> "qtn.TensorNetwork": # type:ignore
     # In particular, it doesn't check g.scalar.phasenodes
     # TODO: This will give the wrong tensor when g.scalar.is_zero == True.
     # Grab the float factor and exponent from the scalar
-    scalar_float = np.exp(1j * np.pi * g.scalar.phase) * g.scalar.floatfactor
+    phase = g.scalar.phase
+    if isinstance(phase, Poly):
+        raise NotImplementedError("Quimb does not support symbolic phases")
+    scalar_float = np.exp(1j * np.pi * phase) * g.scalar.floatfactor
     for node in g.scalar.phasenodes:    # Each node is a Fraction
+        if isinstance(node, Poly):
+            raise NotImplementedError("Quimb does not support symbolic phases")
         scalar_float *= 1 + np.exp(1j * np.pi * node)
     scalar_exp = math.log10(math.sqrt(2)) * g.scalar.power2
 

pyzx/rules.py

@@ -57,6 +57,7 @@
 
 from .utils import VertexType, EdgeType, get_w_partner, get_z_box_label, set_z_box_label, toggle_edge, vertex_is_w, vertex_is_zx, FloatInt, FractionLike, get_w_io, vertex_is_z_like
 from .graph.base import BaseGraph, VT, ET
+from .symbolic import Poly
 
 RewriteOutputType = Tuple[Dict[ET,List[int]], List[VT], List[ET], bool]
 MatchObject = TypeVar('MatchObject')
@@ -273,9 +274,10 @@ def match_z_to_z_box_parallel(
     if matchf is not None: candidates = set([v for v in g.vertices() if matchf(v)])
     else: candidates = g.vertex_set()
     types = g.types()
+    phases = g.phases()
     m = []
     for v in candidates:
-        if types[v] == VertexType.Z:
+        if types[v] == VertexType.Z and not isinstance(phases[v],Poly):
             if num == 0: break
             m.append(v)
             num -= 1
@@ -285,7 +287,9 @@ def z_to_z_box(g: BaseGraph[VT,ET], matches: List[VT]) -> RewriteOutputType[ET,V
     """Converts a Z vertex to a Z-box."""
     for v in matches:
         g.set_type(v, VertexType.Z_BOX)
-        label = np.round(np.e**(1j * np.pi * g.phase(v)), 8)
+        phase = g.phase(v)
+        assert not isinstance(phase, Poly)
+        label = np.round(np.e**(1j * np.pi * phase), 8)
         set_z_box_label(g, v, label)
         g.set_phase(v, 0)
     return ({}, [], [], True)
@@ -729,6 +733,7 @@ def lcomp(g: BaseGraph[VT,ET], matches: List[MatchLcompType[VT]]) -> RewriteOutp
     for m in matches:
         a = g.phase(m[0])
         rem.append(m[0])
+        assert isinstance(a,Fraction)  # For mypy
         if a.numerator == 1: g.scalar.add_phase(Fraction(1,4))
         else: g.scalar.add_phase(Fraction(7,4))
         n = len(m[1])
@@ -824,10 +829,7 @@ def match_phase_gadgets(g: BaseGraph[VT,ET],vertexf:Optional[Callable[[VT],bool]
     # First we find all the phase-gadgets, and the list of vertices they act on
     for v in candidates:
         non_clifford = phases[v] != 0 and getattr(phases[v], 'denominator', 1) > 2
-        try: # symbol check
-            float(phases[v])
-        except:
-            non_clifford = True
+        if isinstance(phases[v], Poly): non_clifford = True
         if non_clifford and len(list(g.neighbors(v)))==1:
             n = list(g.neighbors(v))[0]
             if phases[n] not in (0,1): continue # Not a real phase gadget (happens for scalar diagrams)

pyzx/simulate.py

@@ -24,7 +24,6 @@
 sq2 = math.sqrt(2)
 omega = (1+1j)/sq2
 from fractions import Fraction
-import itertools
 from typing import List, Optional, Dict, Tuple, Any
 
 import numpy as np
@@ -34,6 +33,7 @@
 from .circuit import Circuit
 from .graph import Graph
 from .graph.base import BaseGraph,VT,ET
+from .symbolic import Poly
 
 MAGIC_GLOBAL = -(7+5*sq2)/(2+2j)
 MAGIC_B60 = -16 + 12*sq2
@@ -241,13 +241,22 @@ def calculate_path_sum(g: BaseGraph[VT,ET]) -> complex:
                     if t == v: continue
                     if t not in variable_dict:
                         variable_dict[t] = len(variables)
-                        variables.append(int(float(phases[t]*4)))
+                        phase_t = phases[t]
+                        if isinstance(phase_t, Poly):
+                            raise NotImplementedError("Symbolic phases not supported")
+                        variables.append(int(float(phase_t*4)))
                     targets.add(variable_dict[t])
                 prefactor += len(targets)-1
-                xors[frozenset(targets)] = int(float(phases[v]*4))
+                phase_v = phases[v]
+                if isinstance(phase_v, Poly):
+                    raise NotImplementedError("Symbolic phases not supported")
+                xors[frozenset(targets)] = int(float(phase_v*4))
                 continue
         variable_dict[v] = len(variables)
-        variables.append(int(float(phases[v]*4)))
+        phase_v = phases[v]
+        if isinstance(phase_v, Poly):
+            raise NotImplementedError("Symbolic phases not supported")
+        variables.append(int(float(phase_v*4)))
     verts = sorted(list(variable_dict.keys()), key=lambda x: variable_dict[x])
     n = len(verts)
     for i in range(n):