erl-CaTL 1.0.0__tar.gz

erl_catl-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Explainable Robotics Lab (ERL)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

erl_catl-1.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: erl-CaTL
+Version: 1.0.0
+Summary: Capability Temporal Logic Tool
+Author-email: Crockett Hensley <crh325@lehigh.edu>, Cristian-Ioan Vasile <crv519@lehigh.edu>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/erl-lehigh/catl
+Project-URL: Repository, https://github.com/erl-lehigh/catl
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytelo>=1.0.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: shapely>=2.0
+Requires-Dist: pyyaml>=5.4
+Requires-Dist: matplotlib>=3.7
+Dynamic: license-file
+
+# Capability Temporal Logic (CaTL)
+
+Setup
+-----
+
+```bash
+git clone git@github.com:wasserfeder/catl.git
+mkdir -p catl/lib
+cd catl/lib
+wget 'https://www.antlr.org/download/antlr-4.8-complete.jar'
+pip install antlr4-python2-runtime==4.8
+sudo apt-get install default-jre
+```
+
+For permanent settings use:
+
+```bash
+cd <clone-dir>
+echo "export CLASSPATH=\".:$PWD/lib/antlr-4.8-complete.jar:$CLASSPATH\"" >> ~/.bashrc
+echo "alias antlr4=\"java -jar $PWD/lib/antlr-4.8-complete.jar -visitor\"" >> ~/.bashrc
+echo "alias grun=\"java org.antlr.v4.gui.TestRig\"" >> ~/.bashrc
+```
+
+Otherwise
+
+```bash
+cd <clone-dir>
+export CLASSPATH=".:$PWD/lib/antlr-4.8-complete.jar:$CLASSPATH"
+alias antlr4="java -jar $PWD/lib/antlr-4.8-complete.jar -visitor"'
+alias grun="java org.antlr.v4.gui.TestRig"
+```
+
+where `<clone-dir>` is the directory where you cloned the `catl` repository.
+
+Install *Gurobi* with *gurobipy* for python2, and optionally for python3.
+
+
+Run
+---
+
+```bash
+cd <clone-dir>/catl
+antlr4 -Dlanguage=Python2 catl.g4
+```
+
+**NOTE:** At the moment the implementation only supports python2. However, you
+can generate lexers, parsers, listeners, and visitors for other target languages,
+such as Java (default), C++, Python3, C#, Go, JavaScript, and Swift.
+See http://www.antlr.org/download.html for more details.

erl_catl-1.0.0/README.md

@@ -0,0 +1,49 @@
+# Capability Temporal Logic (CaTL)
+
+Setup
+-----
+
+```bash
+git clone git@github.com:wasserfeder/catl.git
+mkdir -p catl/lib
+cd catl/lib
+wget 'https://www.antlr.org/download/antlr-4.8-complete.jar'
+pip install antlr4-python2-runtime==4.8
+sudo apt-get install default-jre
+```
+
+For permanent settings use:
+
+```bash
+cd <clone-dir>
+echo "export CLASSPATH=\".:$PWD/lib/antlr-4.8-complete.jar:$CLASSPATH\"" >> ~/.bashrc
+echo "alias antlr4=\"java -jar $PWD/lib/antlr-4.8-complete.jar -visitor\"" >> ~/.bashrc
+echo "alias grun=\"java org.antlr.v4.gui.TestRig\"" >> ~/.bashrc
+```
+
+Otherwise
+
+```bash
+cd <clone-dir>
+export CLASSPATH=".:$PWD/lib/antlr-4.8-complete.jar:$CLASSPATH"
+alias antlr4="java -jar $PWD/lib/antlr-4.8-complete.jar -visitor"'
+alias grun="java org.antlr.v4.gui.TestRig"
+```
+
+where `<clone-dir>` is the directory where you cloned the `catl` repository.
+
+Install *Gurobi* with *gurobipy* for python2, and optionally for python3.
+
+
+Run
+---
+
+```bash
+cd <clone-dir>/catl
+antlr4 -Dlanguage=Python2 catl.g4
+```
+
+**NOTE:** At the moment the implementation only supports python2. However, you
+can generate lexers, parsers, listeners, and visitors for other target languages,
+such as Java (default), C++, Python3, C#, Go, JavaScript, and Swift.
+See http://www.antlr.org/download.html for more details.

erl_catl-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "erl-CaTL"                    # This becomes the pip name
+version = "1.0.0"
+description = "Capability Temporal Logic Tool"
+readme = "README.md"
+license = {text = "BSD-3-Clause"}
+authors = [{name = "Crockett Hensley", email = "crh325@lehigh.edu"}, {name = "Cristian-Ioan Vasile", email = "crv519@lehigh.edu"}]
+requires-python = ">=3.10"
+dependencies = [
+    "pytelo>=1.0.0",
+    "networkx>=3.0",
+    "shapely>=2.0",
+    "pyyaml>=5.4",
+    "matplotlib>=3.7"
+]
+
+
+[project.urls]
+"Homepage" = "https://github.com/erl-lehigh/catl"
+"Repository" = "https://github.com/erl-lehigh/catl"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

erl_catl-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

erl_catl-1.0.0/src/catl/__init__.py

@@ -0,0 +1,10 @@
+'''
+ Copyright (C) 2018-2020 Cristian Ioan Vasile <cvasile@lehigh.edu>
+ Explainable Robotics Lab (ERL), Autonomous and Intelligent Robotics (AIR) Lab,
+ Lehigh University
+ Hybrid and Networked Systems (HyNeSs) Group, BU Robotics Lab, Boston University
+ See license.txt file for license information.
+'''
+from .catl import Operation, CATLFormula, CapabilityRequest
+from .catl2stl import catl2stl
+

erl_catl-1.0.0/src/catl/catl.py

@@ -0,0 +1,316 @@
+'''
+ Copyright (C) 2018-2020 Cristian Ioan Vasile <cvasile@lehigh.edu>
+ Explainable Robotics Lab (ERL), Autonomous and Intelligent Robotics (AIR) Lab,
+ Lehigh University
+ Hybrid and Networked Systems (HyNeSs) Group, BU Robotics Lab, Boston University
+ See license.txt file for license information.
+'''
+
+import itertools as it
+from collections import namedtuple
+
+from antlr4 import InputStream, CommonTokenStream, TerminalNode
+
+from .catlLexer import catlLexer
+from .catlParser import catlParser
+from .catlVisitor import catlVisitor
+
+
+class Operation(object):
+    '''CATL operations'''
+    NOP, NOT, OR, AND, IMPLIES, UNTIL, EVENT, ALWAYS, PRED, LIMIT, BOOL = \
+        range(11)
+    opnames = [None, '!', '||', '&&', '=>', 'U', 'F', 'G', 'T', 'L', 'bool']
+    opcodes = {'!': NOT, '&&': AND, '||' : OR, '=>': IMPLIES,
+               'U': UNTIL, 'F': EVENT, 'G': ALWAYS, 'T': PRED, 'L': LIMIT}
+
+    @classmethod
+    def getCode(cls, text):
+        ''' Gets the code corresponding to the string representation.'''
+        return cls.opcodes.get(text, cls.NOP)
+
+    @classmethod
+    def getString(cls, op):
+        '''Gets custom string representation for each operation.'''
+        return cls.opnames[op]
+
+CapabilityRequest = namedtuple('CapabilityRequest', ['capability', 'count'])
+ResourceRequest = namedtuple('ResourceRequest', ['resource', 'quantity'])
+
+class CATLFormula(object):
+    '''Abstract Syntax Tree representation of an CATL formula'''
+
+    def __init__(self, operation, **kwargs):
+        '''Constructor'''
+        self.op = operation
+
+        if self.op == Operation.BOOL:
+            self.value = kwargs['value']
+        elif self.op == Operation.PRED:
+            self.duration = kwargs['duration']
+            self.proposition = kwargs['proposition']
+            self.capability_requests = kwargs['capabilities']
+            self.resource_requests = kwargs['resources']
+        elif self.op == Operation.LIMIT:
+            self.proposition = kwargs['proposition']
+            self.capability_requests = kwargs['capabilities']
+            self.resource_requests = kwargs['resources']
+        elif self.op in (Operation.AND, Operation.OR):
+            self.children = kwargs['children']
+        elif self.op == Operation.IMPLIES:
+            self.left = kwargs['left']
+            self.right = kwargs['right']
+        elif self.op == Operation.NOT:
+            self.child = kwargs['child']
+        elif self.op in(Operation.ALWAYS, Operation.EVENT):
+            self.low = kwargs['low']
+            self.high = kwargs['high']
+            self.child = kwargs['child']
+        elif self.op == Operation.UNTIL:
+            self.low = kwargs['low']
+            self.high = kwargs['high']
+            self.left = kwargs['left']
+            self.right = kwargs['right']
+
+        self.__string = None
+        self.__hash = None
+
+    def robustness(self, s, t):
+        '''Computes the robustness of the CATL formula.'''
+        raise NotImplementedError
+
+    def bound(self):
+        '''Computes the bound of the CATL formula.'''
+        if self.op == Operation.BOOL:
+            return 0
+        elif self.op == Operation.PRED:
+            return self.duration
+        elif self.op == Operation.LIMIT:
+            return 0
+        elif self.op in (Operation.AND, Operation.OR):
+            return max([ch.bound() for ch in self.children])
+        elif self.op == Operation.IMPLIES:
+            return max(self.left.bound(), self.right.bound())
+        elif self.op == Operation.NOT:
+            return self.child.bound()
+        elif self.op == Operation.UNTIL:
+            return self.high + max(self.left.bound(), self.right.bound())
+        elif self.op in (Operation.ALWAYS, Operation.EVENT):
+            return self.high + self.child.bound()
+
+    def propositions(self):
+        '''Computes the set of propositions involved in the CATL formula.'''
+        if self.op in (Operation.PRED, Operation.LIMIT):
+            return {self.proposition}
+        elif self.op in (Operation.AND, Operation.OR):
+            return set.union(*[child.propositions() for child in self.children])
+        elif self.op in (Operation.IMPLIES, Operation.UNTIL):
+            return self.left.propositions() | self.right.propositions()
+        elif self.op in (Operation.NOT, Operation.ALWAYS, Operation.EVENT):
+            return self.child.propositions()
+
+    def capabilities(self):
+        '''Computes the set of capabilities involved in the CATL formula.'''
+        if self.op in (Operation.PRED, Operation.LIMIT):
+            return {cr.capability for cr in self.capability_requests}
+        elif self.op in (Operation.AND, Operation.OR):
+            return set.union(*[child.capabilities() for child in self.children])
+        elif self.op in (Operation.IMPLIES, Operation.UNTIL):
+            return self.left.capabilities() | self.right.capabilities()
+        elif self.op in (Operation.NOT, Operation.ALWAYS, Operation.EVENT):
+            return self.child.capabilities()
+
+    def resources(self):
+        '''Computes the set of resources involved in the CATL formula.'''
+        if self.op in (Operation.PRED, Operation.LIMIT):
+            return {cr.resource for cr in self.resource_requests}
+        elif self.op in (Operation.AND, Operation.OR):
+            return set.union(*[child.resources() for child in self.children])
+        elif self.op in (Operation.IMPLIES, Operation.UNTIL):
+            return self.left.resources() | self.right.resources()
+        elif self.op in (Operation.NOT, Operation.ALWAYS, Operation.EVENT):
+            return self.child.resources()
+
+    def identifier(self):
+        '''Computes an integer identifier for the formula based on the object's
+        hash value.
+        '''
+        h = hash(self)
+        if h < 0:
+            h = hex(ord('-'))[2:] + hex(-h)[1:]
+        else:
+            h = hex(ord('+'))[2:] + hex(h)[1:]
+        return h
+
+    def __hash__(self):
+        if self.__hash is None:
+            self.__hash = hash(str(self))
+        return self.__hash
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        if self.__string is not None:
+            return self.__string
+
+        opname = Operation.getString(self.op)
+        if self.op == Operation.BOOL:
+            s = str(self.value)
+        elif self.op == Operation.PRED:
+            s = '({p} {d} {caps} {res})'.format(p=self.proposition,
+                                                d=self.duration,
+                                                caps=self.capability_requests,
+                                                res=self.resource_requests)
+        elif self.op == Operation.LIMIT:
+            s = '(! {p} {caps} {res})'.format(p=self.proposition,
+                                                caps=self.capability_requests,
+                                                res=self.resource_requests)
+        elif self.op == Operation.IMPLIES:
+            s = '({left} {op} {right})'.format(left=self.left, op=opname,
+                                               right=self.right)
+        elif self.op in (Operation.AND, Operation.OR):
+            children = [str(child) for child in self.children]
+            s = '(' + ' {op} '.format(op=opname).join(children) + ')'
+        elif self.op == Operation.NOT:
+            s = '{op} {child}'.format(op=opname, child=self.child)
+        elif self.op == Operation.UNTIL:
+            s = '({left} {op}[{low}, {high}] {right})'.format(op=opname,
+                 left=self.left, right=self.right, low=self.low, high=self.high)
+        elif self.op in (Operation.ALWAYS, Operation.EVENT):
+            s = '({op}[{low}, {high}] {child})'.format(op=opname,
+                                 low=self.low, high=self.high, child=self.child)
+        else:
+            raise ValueError('Unknown operation {}!'.format(self.op))
+        self.__string = s
+        return self.__string
+
+    @classmethod
+    def from_formula(cls, formula):
+        '''Creates a CATLFormula object from a formula string.
+
+        Parameters
+        ----------
+        formula (str) CATL formula
+
+        Returns
+        -------
+        (CATLFormula) an AST of the CATL formula
+        '''
+        lexer = catlLexer(InputStream(formula))
+        tokens = CommonTokenStream(lexer)
+        parser = catlParser(tokens)
+        t = parser.catlProperty()
+        return CATLAbstractSyntaxTreeExtractor().visit(t)
+
+
+class CATLAbstractSyntaxTreeExtractor(catlVisitor):
+    '''Parse Tree visitor that constructs the AST of an CATL formula'''
+
+    def visitFormula(self, ctx):
+        op = Operation.getCode(ctx.op.text)
+        ret = None
+        low = -1
+        high = -1
+        if op in (Operation.AND, Operation.OR):
+            left = self.visit(ctx.left)
+            right = self.visit(ctx.right)
+            assert op != right.op
+            if left.op == op:
+                children = left.children
+            else:
+                children = [left]
+            children.append(right)
+            ret = CATLFormula(op, children=children)
+        elif op == Operation.IMPLIES:
+            ret = CATLFormula(op, left=self.visit(ctx.left),
+                             right=self.visit(ctx.right))
+        elif op == Operation.NOT:
+            ret = CATLFormula(op, child=self.visit(ctx.child))
+        elif op == Operation.UNTIL:
+            low = float(ctx.low.text)
+            high = float(ctx.high.text)
+            ret = CATLFormula(op, left=self.visit(ctx.left),
+                             right=self.visit(ctx.right), low=low, high=high)
+        elif op in (Operation.ALWAYS, Operation.EVENT):
+            low = float(ctx.low.text)
+            high = float(ctx.high.text)
+            ret = CATLFormula(op, child=self.visit(ctx.child),
+                             low=low, high=high)
+        else:
+            print('Error: unknown operation!')
+        return ret
+
+    def visitCatlPredicate(self, ctx):
+        return self.visit(ctx.predicate())
+
+    def visitPredicate(self, ctx):
+        if Operation.getCode(ctx.op.text) == Operation.PRED:
+            if ctx.resources():
+                resources = self.visit(ctx.resources())
+            else:
+                resources = set()
+            return CATLFormula(Operation.PRED, duration=int(ctx.duration.text),
+                               proposition=ctx.proposition.text,
+                               capabilities=self.visit(ctx.capabilities()),
+                               resources=resources)
+        return CATLFormula(Operation.BOOL, value=bool(ctx.op.text))
+
+    def visitCatlLimit(self, ctx):
+        return self.visit(ctx.limit())
+
+    def visitLimit(self, ctx):
+        if Operation.getCode(ctx.op.text) == Operation.LIMIT:
+            if ctx.capabilities():
+                capabilities = self.visit(ctx.capabilities())
+            else:
+                capabilities = set()
+            if ctx.resources():
+                resources = self.visit(ctx.resources())
+            else:
+                resources = set()
+            if not capabilities and not resources:
+                raise Exception('Limit operator must constrain either agents'
+                                ' or resources!')
+            return CATLFormula(Operation.LIMIT,
+                               proposition=ctx.proposition.text,
+                               capabilities=capabilities,
+                               resources=resources)
+        return CATLFormula(Operation.BOOL, value=bool(ctx.op.text))
+
+    def visitCapabilities(self, ctx):
+        return {self.visit(ch) for ch in ctx.children
+                                            if not isinstance(ch, TerminalNode)}
+
+    def visitCapabilityRequest(self, ctx):
+        return CapabilityRequest(capability=ctx.cap.text,
+                                 count=int(ctx.count.text))
+
+    def visitResources(self, ctx):
+        return {self.visit(ch) for ch in ctx.children
+                                            if not isinstance(ch, TerminalNode)}
+
+    def visitResourceRequest(self, ctx):
+        return ResourceRequest(resource=ctx.res.text,
+                               quantity=float(ctx.quantity.text))
+
+    def visitParprop(self, ctx):
+        return self.visit(ctx.child)
+
+
+if __name__ == '__main__':
+    ast = CATLFormula.from_formula(
+            'F[0, 2] T(4, test, {(a, 2), (b, 3)})'
+            '&& G[1, 7] T(2, test, {(a, 1), (c, 4)}, {(h1, 2.3), (h2, 5)})'
+            '&& F[3, 5] T(3, test2, {(b, 1), (d, 2)})'
+            '&& F[3, 5] L(test2, {(b, 1), (d, 2)})'
+            '&& F[3, 5] L(test2, {}, {(h1, 2.3), (h2, 5)})'
+            '&& F[3, 5] L(test2, {(b, 1), (d, 2)}, {(h1, 2.3), (h2, 5)})')
+    print('AST:', str(ast))
+    print('Propositions:', ast.propositions())
+    print('Capabilities:', ast.capabilities())
+    print('Resources:', ast.resources())
+    print('Bound:', ast.bound())

erl_catl-1.0.0/src/catl/catl2stl.py

@@ -0,0 +1,110 @@
+'''
+ Copyright (C) 2018-2020 Cristian Ioan Vasile <cvasile@lehigh.edu>
+ Explainable Robotics Lab (ERL), Autonomous and Intelligent Robotics (AIR) Lab,
+ Lehigh University
+ Hybrid and Networked Systems (HyNeSs) Group, BU Robotics Lab, Boston University
+ See license.txt file for license information.
+'''
+
+from antlr4 import InputStream, CommonTokenStream
+
+from .catl import Operation as CATLOperation
+from .catl import CATLFormula
+from .catl import CATLAbstractSyntaxTreeExtractor
+
+from .catlLexer import catlLexer
+from .catlParser import catlParser
+
+from pytelo.stl import Operation as STLOperation
+from pytelo.stl import RelOperation as STLRelOperation
+from pytelo.stl import STLFormula
+
+
+def catl2stl(catl_ast):
+    '''Translates a CATL abstract syntax tree to an STL one.
+    The set of variables in the STL formula is the Cartesian product between the
+    set of atomic propositions and the set of capabilities in the CATL formula.
+    The variable labels are in the form "z_{proposition}_{capability}".
+    The STL predicates capture the minimum number ``n''of agents with capability
+    ``c'' needed at regions labeled with proposition ``p'', i.e.,
+    ``z_{\pi,c} \geq n''. Thus, a CATL task is translated to STL as follows
+
+    .. math ::
+
+        T(d, \pi, \{(c_1, n_1), \ldots,(c_m, n_m)\}) \equiv
+        \box_{[0, d]} \bigcup_{i=1}^{m} (z_{\pi, c_i} \geq n_i)
+    '''
+    if catl_ast.op == CATLOperation.BOOL:
+        return STLFormula(STLOperation.BOOL, value=catl_ast.value)
+    elif catl_ast.op == CATLOperation.PRED:
+        var = catl_ast.proposition + '_{cap}'
+        conjunction_terms = \
+            [STLFormula(STLOperation.PRED, relation=STLRelOperation.GE,
+                        variable=var.format(cap=cap), threshold=th)
+                               for cap, th in catl_ast.capability_requests]
+        child = STLFormula(STLOperation.AND, children=conjunction_terms)
+
+        return STLFormula(STLOperation.ALWAYS, low=0, high=catl_ast.duration,
+                          child=child)
+    elif catl_ast.op == CATLOperation.LIMIT:
+        var = catl_ast.proposition + '_{cap}'
+        conjunction_terms = \
+            [STLFormula(STLOperation.PRED, relation=STLRelOperation.LE,
+                        variable=var.format(cap=cap), threshold=th)
+                               for cap, th in catl_ast.capability_requests]
+        return STLFormula(STLOperation.AND, children=conjunction_terms)
+    elif catl_ast.op in (CATLOperation.AND, CATLOperation.OR):
+        children = [catl2stl(ch) for ch in catl_ast.children]
+        if catl_ast.op == CATLOperation.AND:
+            op = STLOperation.AND
+        else:
+            op = STLOperation.OR
+        return STLFormula(op, children=children)
+    elif catl_ast.op == CATLOperation.IMPLIES:
+        left = catl2stl(catl_ast.left)
+        right = catl2stl(catl_ast.right)
+        return STLFormula(STLOperation.IMPLIES, left=left, right=right)
+    elif catl_ast.op == CATLOperation.NOT:
+        child = catl2stl(catl_ast.child)
+        return STLFormula(STLOperation.NOT, child=child)
+    elif catl_ast.op in (CATLOperation.ALWAYS, CATLOperation.EVENT):
+        child = catl2stl(catl_ast.child)
+        if catl_ast.op == CATLOperation.ALWAYS:
+            op = STLOperation.ALWAYS
+        else:
+            op = STLOperation.EVENT
+        return STLFormula(op, child=child, low=catl_ast.low, high=catl_ast.high)
+    elif catl_ast.op == CATLOperation.UNTIL:
+        left = catl2stl(catl_ast.left)
+        right = catl2stl(catl_ast.right)
+        return STLFormula(STLOperation.UNTIL, left=left, right=right,
+                          low=catl_ast.low, high=catl_ast.high)
+
+
+if __name__ == '__main__':
+    formulae = (
+        'F[0, 2] T(4, test, {(a, 2), (b, 3)})'
+        '&& G[1, 7] T(2, test, {(a, 1), (c, 4)})'
+        '&& F[3, 5] T(3, test2, {(b, 1), (d, 2)})'
+        '&& F[3, 5] L(test2, {(b, 1), (d, 2)})',
+        #
+        'F[0,25] T(3,blue,{(C1,1),(C2,1)})'
+        '&& F[0,25] T(2,orange,{(C1,1),(C2,1)})'
+        '&& (L(orange,{(C1,1),(C2,1)}) U[0,25] T(3,blue,{(C1,1),(C2,1)}))'
+    )
+
+    for formula in formulae:
+        print('Formula:', formula)
+        lexer = catlLexer(InputStream(formula))
+
+        tokens = CommonTokenStream(lexer)
+
+        parser = catlParser(tokens)
+        t = parser.catlProperty()
+        print(t.toStringTree())
+
+        ast = CATLAbstractSyntaxTreeExtractor().visit(t)
+        print('CATL:', ast)
+
+        stl = catl2stl(ast)
+        print('STL:', stl)