prefscript 1.1__tar.gz → 2.0.2__tar.gz

{prefscript-1.1 → prefscript-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: prefscript
-Version: 1.1
+Version: 2.0.2
 Summary: Partial Recursive Functions for Scripting
 Author-email: José Luis Balcázar <jose.luis.balcazar@upc.edu>
 Project-URL: Homepage, https://github.com/balqui/prefscript
@@ -8,35 +8,41 @@ Project-URL: Bug Tracker, https://github.com/balqui/prefscript/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pytokr>=1.0
+Requires-Dist: lark
+Dynamic: license-file
 
 # PReFScript: 
 ## Partial Recursive Functions for Scripting
 
-Author: Jose L Balcazar, ORCID 0000-0003-4248-4528
+Author: Jose Luis Balcazar, ORCID 0000-0003-4248-4528
 
 Project started: mid Germinal 2003.
 
-Current version: 1.1, late Thermidor 2024.
-
 Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
 
 A Python-based environment to explore and experiment with partial 
 recursive functions; naturally doubles as a (purely functional) 
 programming language, but it is not intended to be used much as such.
 
+Current version: 2.0.2, late Fructidor 2026. Previous version 1.2 
+of mid Messidor 2026 is *incompatible*.
+
 ### Scripts
 
-In PReFScript, a script is a sequence of functions defined in terms of each
-other and of a few basic functions via the partial recursion rules 
-of composition and minimization. All functions are from the
-natural numbers into the natural numbers and may be undefined
-for some inputs. In order to handle tuples or sequences of natural
-numbers, a Cantor-like encoding is used.
-The always available basic functions include: 
+In PReFScript, a script is a sequence of functions defined 
+in terms of each other and of a few basic functions via the 
+partial recursion rules of composition and minimization. 
+All functions are from the natural numbers into the natural 
+numbers and may be undefined for some inputs. 
+
+In order to handle tuples or sequences of natural numbers, 
+a Cantor-like encoding is used; 
+see <https://github.com/balqui/cantorpairs/blob/main/README.md>.
+
+Specifically, the always available basic functions include: 
 `k_1`, the constant 1 function;
 `id`, the identity function;
 addition and multiplication, `add` and `mul` respectively,
@@ -47,14 +53,21 @@ pair  `<x.y>` and computes `max(0, x - y)` so that we always stay
 within the natural numbers; and two functions related to projections
 of Cantor-encoded sequences.
 
-Scripts are maintained in objects of the class PReFScript,
-that can be imported into your own Python program. 
-Alternatively, a stand-alone interpreter is also provided. 
-Thus, you have available two main ways of programming in PReFScript.
-
 ### Installation and ways to use PReFScript functions
 
-See [doc.md](https://github.com/balqui/prefscript/blob/main/docs/doc.md) 
-for all the details (somewhat incomplete as of today).
+The usual `pip`-based process should work. Differently from
+previous versions, all functionality in 2.0.* is fully compatible
+with a `pipx` installation. You may need to specify `--upgrade`
+flags, depending on your previous installation. LLMs say that
+`uv` should work as well.
+
+The current version installs a stand-alone interpreter.
+See [doc.md](https://github.com/balqui/prefscript/blob/main/docs/doc.md).
+
+*The following applied to the previous version 1.2*:
+Scripts were maintained in objects of the class PReFScript,
+that could be imported into your own Python program. 
+Thus, you had available two main ways of programming in 
+PReFScript. All this does not apply anymore to versions 2.0.*.
 
 

prefscript-2.0.2/README.md

@@ -0,0 +1,57 @@
+# PReFScript: 
+## Partial Recursive Functions for Scripting
+
+Author: Jose Luis Balcazar, ORCID 0000-0003-4248-4528
+
+Project started: mid Germinal 2003.
+
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
+
+A Python-based environment to explore and experiment with partial 
+recursive functions; naturally doubles as a (purely functional) 
+programming language, but it is not intended to be used much as such.
+
+Current version: 2.0.2, late Fructidor 2026. Previous version 1.2 
+of mid Messidor 2026 is *incompatible*.
+
+### Scripts
+
+In PReFScript, a script is a sequence of functions defined 
+in terms of each other and of a few basic functions via the 
+partial recursion rules of composition and minimization. 
+All functions are from the natural numbers into the natural 
+numbers and may be undefined for some inputs. 
+
+In order to handle tuples or sequences of natural numbers, 
+a Cantor-like encoding is used; 
+see <https://github.com/balqui/cantorpairs/blob/main/README.md>.
+
+Specifically, the always available basic functions include: 
+`k_1`, the constant 1 function;
+`id`, the identity function;
+addition and multiplication, `add` and `mul` respectively,
+that interpret the single number received as the Cantor encoding
+of a pair `<x.y>` and compute the corresponding operation on `x` and 
+`y`; modified difference `diff` that receives likewise a Cantor-encoded
+pair  `<x.y>` and computes `max(0, x - y)` so that we always stay
+within the natural numbers; and two functions related to projections
+of Cantor-encoded sequences.
+
+### Installation and ways to use PReFScript functions
+
+The usual `pip`-based process should work. Differently from
+previous versions, all functionality in 2.0.* is fully compatible
+with a `pipx` installation. You may need to specify `--upgrade`
+flags, depending on your previous installation. LLMs say that
+`uv` should work as well.
+
+The current version installs a stand-alone interpreter.
+See [doc.md](https://github.com/balqui/prefscript/blob/main/docs/doc.md).
+
+*The following applied to the previous version 1.2*:
+Scripts were maintained in objects of the class PReFScript,
+that could be imported into your own Python program. 
+Thus, you had available two main ways of programming in 
+PReFScript. All this does not apply anymore to versions 2.0.*.
+
+

{prefscript-1.1 → prefscript-2.0.2}/pyproject.toml

@@ -1,24 +1,39 @@
 [build-system]
-requires = ["setuptools >= 61.0"]
+requires = ["setuptools>=68.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "prefscript"
-version = "1.1"
-authors = [ { name = "José Luis Balcázar", email = "jose.luis.balcazar@upc.edu" }, ]
+version = "2.0.2"
+authors = [
+    { name = "José Luis Balcázar", email = "jose.luis.balcazar@upc.edu" }
+]
 description = "Partial Recursive Functions for Scripting"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    ]
-dependencies = [ "pytokr>=1.0" ]
+]
+
+dependencies = [
+    "lark",
+]
 
 [project.urls]
 "Homepage" = "https://github.com/balqui/prefscript"
 "Bug Tracker" = "https://github.com/balqui/prefscript/issues"
 
 [project.scripts]
-prefscript = "prefscript:run"
+prefscript = "prefscript.prefscript:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+prefscript = [
+    "stdprfs/*.prfs",
+    "examples/*.prfs",
+]
+

prefscript-2.0.2/src/prefscript/__init__.py

@@ -0,0 +1,2 @@
+
+# ~ from prefscript.prefscript import __version__

{prefscript-1.1/src → prefscript-2.0.2/src/prefscript}/ascii7io.py

@@ -1,5 +1,14 @@
 '''
+Project started mid Germinal 2023:
+PReFScript: A Partial Recursive Functions Lab
+
+Ancillary module, early Thermidor 2024:
 Single-integer encoding and decoding of (printable) 7-bit ASCII strings
+Currently employed for versions up to 1.2, this docstring expanded 
+by mid Messidor 2026 with no change to code.
+
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
 '''
 
 TWO_pow_7 = 1 << 7

prefscript-2.0.2/src/prefscript/basicfun.py

@@ -0,0 +1,72 @@
+'''
+Project started mid Germinal 2003:
+PReFScript: A Partial Recursive Functions Lab
+
+Module version early Thermidor 2026:
+basicfun: class BasicFun to have everything that concerns the list 
+of basic functions in a single place. A dict of FunData.
+
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
+'''
+
+from . import cantorpairs as cp
+from .fundata import FunData
+    
+class BasicFun(dict):
+    '''
+    Dictionary with the info required for each basic function.
+    '''
+    def __init__(self):
+        dict.__init__(self)
+
+        self["k_1"]   = FunData(
+"k_1", 
+"The constant 1 function", 
+"basic", tuple(),
+"lambda x: 1", cp.dp(0, 0))
+
+        self["id"]    = FunData(
+"id",
+"The identity function", 
+"basic", tuple(),
+"lambda x: x", cp.dp(0, 1))
+
+        self["s_tup"] = FunData(
+"s_tup", 
+"Single-argument version of suffix tuple", 
+"basic", tuple(),
+"lambda x: cp.s_tup(cp.pr_L(x), cp.pr_R(x))", cp.dp(0, 2))
+
+        self["proj"]  = FunData(
+"proj",
+"Single-argument version of projection", 
+"basic", tuple(),
+"lambda x: cp.pr(cp.pr_L(x), cp.pr_R(x))", cp.dp(0, 3))
+
+        self["add"]   = FunData(
+"add",
+"Addition x+y of the two components of input <x.y>", 
+"basic", tuple(),
+"lambda x: cp.pr_L(x) + cp.pr_R(x)", cp.dp(0, 4))
+
+        self["mul"]   = FunData(
+"mul",
+"Multiplication x*y of the two components of input <x.y>",
+"basic", tuple(),
+"lambda x: cp.pr_L(x) * cp.pr_R(x)", cp.dp(0, 5))
+
+        self["diff"]  = FunData(
+"diff",
+"Modified difference max(0, x-y) of the two components of input <x.y>",     
+"basic", tuple(),
+"lambda x: max(0, cp.pr_L(x) - cp.pr_R(x))", cp.dp(0, 6))
+
+    def showgnums(self):
+        for f in sorted(self, key = lambda x: cp.pr_R(self[x].index)):
+            i = cp.pr_R(self[f].index)
+            print(f"{i}: {self[f].fname}, {self[f].docst}, Goedel number <0.{i}> = {self[f].index}")
+
+if __name__ == "__main__":
+    BasicFun().showgnums()
+

prefscript-2.0.2/src/prefscript/cantorpairs/__init__.py

@@ -0,0 +1,2 @@
+from .src.cantorpairs.cantorpairs_src import __version__, dp, pr_L, pr_R, tup_e, tup_i, s_tup, pr, seq
+from .src.cantorpairs.ensure import Ensure, ensure

{prefscript-1.1/src/cantorpairs/src → prefscript-2.0.2/src/prefscript/cantorpairs}/cp_ex.py

@@ -7,7 +7,7 @@ Ancillary functions for the Partial Recursive Functions lab.
 Examples of usage of pairing and tupling.
 '''
 
-import cantorpairs as cp
+import src.cantorpairs as cp
 
 for i in range(4):
   for j in range(4):
@@ -35,4 +35,8 @@ while t:
     print(t, cp.pr_L(t))
     t = cp.pr_R(t)
 
+cp.Ensure().that('a' == 'a', "'a' is OK")
+z = 54321
+print(f"Sequence {z} is {cp.seq(z)}")
+cp.Ensure().that('a' == 'b', "'a' is not 'b'")
 

prefscript-2.0.2/src/prefscript/cantorpairs/cp_ex_alt.py

@@ -0,0 +1,48 @@
+'''
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528, april 2023 onwards 
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
+
+Ancillary functions for the Partial Recursive Functions lab.
+
+Examples of usage of pairing and tupling.
+
+MOVE THIS FILE ONE LEVEL UP IN THE FILE TREE BEFORE RUNNING.
+
+Adjacent file cp_ex.py has the right import to run here.
+'''
+
+import cantorpairs as cp
+
+for i in range(4):
+  for j in range(4):
+    print(i, j, cp.dp(i, j))
+
+for i in range(90, 100):
+  print(cp.pr_L(i), cp.pr_R(i), cp.dp(cp.pr_L(i), cp.pr_R(i)), i) 
+
+t = cp.tup_e(4, 7, 56, 101)
+for i in range(5):
+    'last call is actually out of range'
+    print(cp.pr(t, i))
+
+st = cp.s_tup(t, 2)
+print(st)
+for i in range(3):
+    print(cp.pr(st, i))
+
+while t:
+    print(t, cp.pr_L(t))
+    t = cp.pr_R(t)
+
+t = cp.tup_i(range(8, 16))
+while t:
+    print(t, cp.pr_L(t))
+    t = cp.pr_R(t)
+
+cp.Ensure().that('a' == 'a', "'a' is OK")
+z = 54321
+print(f"Sequence {z} is {cp.seq(z)}")
+
+# ~ cp.Ensure().that('a' == 'b', "'a' is not 'b'")
+
+cp.ensure.that(1 == 2, "no kidding...")

prefscript-2.0.2/src/prefscript/cantorpairs/src/cantorpairs/__init__.py

@@ -0,0 +1,2 @@
+from .cantorpairs_src import __version__, dp, pr_L, pr_R, tup_e, tup_i, s_tup, pr, seq
+from .ensure import Ensure

prefscript-1.1/src/cantorpairs/src/cantorpairs.py → prefscript-2.0.2/src/prefscript/cantorpairs/src/cantorpairs/cantorpairs_src.py

@@ -1,5 +1,10 @@
 '''
-Author: Jose L Balcazar, ORCID 0000-0003-4248-4528, april 2023 onwards 
+Project started: mid Germinal 2023.
+Current version: 1.2, late Fructidor 2026.
+Not pip-installable as of today. 
+See README at `https://github.com/balqui/cantorpairs`.
+
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528 
 Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
 
 Ancillary functions for PReFScript, the Partial Recursive Functions lab.
@@ -9,9 +14,7 @@ adapted from `https://en.wikipedia.org/wiki/Pairing_function`
 The dotted pair is a bijection between `NxN` and `N-{0}`:
 the natural number zero is used as "nil".
 
-Project started: mid Germinal 2003.
-Current version: 0.2, early Thermidor 2024.
-Not pip-installable as of today. See README at `https://github.com/balqui/cantorpairs`
+See files cp_ex*.py for usage examples.
 
 After each push, the following extra incantation is most likely 
 necessary in the local copy of the git repo for `prefscript`:
@@ -19,41 +22,18 @@ necessary in the local copy of the git repo for `prefscript`:
 '''
 
 from functools import cache
-from math import isqrt
+from math import isqrt       # instead of math.sqrt
 
-__version__ = "0.3"
+__version__ = "1.2"
 
 @cache
 def _isqrt(n):
-	return isqrt(n)
-
-# ~ def _isqrt(n):
-    # ~ '''
-    # ~ int square root via binary search, own program
-    # ~ because math.sqrt fails with big numbers, e.g. the
-    # ~ decoding of dp(10, 10^17) comes out wrong.
-    # ~ '''
-    # ~ def rr(n, k):
-        # ~ """
-        # ~ Pre: k <= sqrt(n)
-        # ~ Post: a <= sqrt(n) < b and b - a = k
-        # ~ """
-        # ~ if 4*k*k > n:
-            # ~ return k, 2*k
-        # ~ a, b = rr(n, 2*k)
-        # ~ m = (a + b)//2 # m = a + k
-        # ~ if m*m <= n:
-            # ~ return m, b
-        # ~ else:
-            # ~ return a, m
-    # ~ assert n >= 0
-    # ~ if n == 0:
-        # ~ return 0
-    # ~ return rr(n, 1)[0]
+    "Formerly used to switch between various sqrt programs"
+    return isqrt(n)
 
 @cache
 def _unpair(z):
-    "local sq root instead of math.sqrt"
+    "uses local sq root"
     assert z > 0
     w = (_isqrt(8*(z - 1) + 1) - 1)//2
     t = (w*w + w)//2
@@ -115,3 +95,18 @@ def pr(t, k):
     returns zero (meaning end of tuple) if k is too large
     '''
     return pr_L(s_tup(t, k))
+
+def proj(t, k):
+    '''
+    projection function, alternative name
+    '''
+    return pr(t, k)
+
+def seq(z):
+    "list form of the sequence encoded by z"
+    ls = list()
+    while z != 0:
+        ls.append(pr_L(z))
+        z = pr_R(z)
+    return ls
+

prefscript-2.0.2/src/prefscript/cantorpairs/src/cantorpairs/ensure.py

@@ -0,0 +1,29 @@
+'''
+Project started: mid Germinal 2023.
+This module started: early Fructidor 2026.
+Current version: 1.0.
+Not pip-installable as of today. 
+See README at `https://github.com/balqui/cantorpairs`
+
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_License)
+
+Ancillary functions for PReFScript, the Partial Recursive Functions lab.
+
+Implements a variant of "assert" that is not disabled from the command line.
+See files cp_ex*.py for usage examples.
+
+After each push, the following extra incantation is most likely 
+necessary in the local copy of the git repo for `prefscript`:
+`git submodule update --remote`
+'''
+
+class Ensure:
+
+    class Failed(Exception): pass
+
+    def that(cls, assertion, message):
+        if not assertion:
+            raise cls.Failed(message)
+
+ensure = Ensure()

prefscript-2.0.2/src/prefscript/codegen.py

@@ -0,0 +1,187 @@
+'''
+Project started mid Germinal 2003:
+PReFScript: A Partial Recursive Functions Lab
+
+Module version early Fructidor 2026:
+Lark-based code generator, makes the script for PReFScript 2.0 onwards.
+
+Author: Jose L Balcazar, ORCID 0000-0003-4248-4528
+Copyleft: MIT License (https://en.wikipedia.org/wiki/MIT_
+'''
+
+from lark import Transformer, v_args
+from pathlib import Path            # for handling imported files
+
+from .cantorpairs import ensure
+from .fundata import FunData
+from .parser import prfsparser
+from .script import PReFScript       # for the recursive calls on imports
+
+# A handful of ancillary functions
+
+def funfactgen():
+    "function name factory generator, get names by calling funfact"
+    i = 69
+    while True:
+        yield f"___{i}"
+        i += 1
+
+funfact = funfactgen().__next__
+
+def seemsfactgen(nm):
+    return nm.startswith('___') and nm[3:].isdigit()
+
+FILENAMES = set()                   # main and imported in order to 
+                                    # avoid import cycles - a bit ugly,
+                                    # consider designing some other way
+
+
+@v_args(inline=True)
+class ScriptMaker(Transformer):
+    '''
+    Instances of transformers traverse the AST in postorder. 
+    They need one method for each sort of tree node, that is, 
+    grammar label; these methods receive the transformed 
+    subtrees and must return the transformed current node.
+
+    The v_args decorator allows the methods in the Transformer
+    instance to avoid the "children" tuple and refer directly
+    to the subtree funspec's.
+
+    ScriptMaker objects contain a local PReFScript that is 
+    "in construction": they transform each AST 'funspec' node into 
+    a FunData which gets added to the script, returning its name.
+    Imports are handled via recursive calls on a fresh script that
+    gets added to the script under construction afterwards.
+    
+    The 'program' simply returns the finally constructed script.
+
+    Instead of inheriting the name, we set up surrogates and
+    leave for later the name change if convenient.
+    '''
+
+    def __init__(self, script, filename, import_folder = None, imported = False):
+        "filename must be an already resolved Path()"
+        super().__init__(self)
+        self.script = script
+        self.imported = imported
+        if import_folder is not None:
+            self.import_folder = Path(import_folder)
+        else:
+            self.import_folder = None
+        self.filename = filename
+        FILENAMES.add(self.filename)
+
+    def ascii_const(self, strconst):
+        nm = funfact()
+        fdat = FunData(nm, howdf = "ascii_const", defon = (strconst,))
+        self.script.define(fdat)
+        return nm
+
+    def single(self, cname):
+        nm = cname.value
+        ensure.that(not seemsfactgen(nm), f"Error: name {nm} is disallowed.")
+        if nm not in self.script:
+            self.script.define(FunData(nm))
+        return nm
+
+    def parenth(self, same):
+        return same
+
+    def comp(self, left, right):
+        nm = funfact()
+        fdat = FunData(nm, howdf = "comp", defon = (left, right))
+        self.script.define(fdat)
+        return nm
+
+    def pair(self, left, right):
+        nm = funfact()
+        fdat = FunData(nm, howdf = "pair", defon = (left, right))
+        self.script.define(fdat)
+        return nm
+
+    def mu(self, test):
+        nm = funfact()
+        fdat = FunData(nm, howdf = "mu", defon = (test,))
+        self.script.define(fdat)
+        return nm
+
+    def rec(self, recurse, base, is_base):
+        nm = funfact()
+        fdat = FunData(nm, howdf = "rec", defon = (recurse, base, is_base))
+        self.script.define(fdat)
+        return nm
+
+    def program(self, *imports_and_defuns):
+        return self.script
+
+    def docstring(self, *docstrings):
+        "They are tokens, but somehow each can be handled as string"
+        return ' '.join(ds.strip('"') for ds in docstrings)
+
+    def defun(self, cname, docstring, alias):
+        "First two cases after skipping main are functions already in the script"
+        nm = cname.value
+        if nm == "main" and self.imported:
+            "silently ignore it"
+            return ''
+        if seemsfactgen(alias):
+            "name to override"
+            fspec = self.script[alias]
+            if docstring:
+                ensure.that(not fspec.docst, 
+                    f"Unexpectedly found already a previous docstring in {nm}.")
+                fspec.docst = docstring
+            fspec.fname = nm
+            self.script.remove(alias)
+        elif nm in self.script:
+            "pending name to be completed"
+            ensure.that(self.script[nm].howdf == "pending",
+                f"Seems that you have two defs of {self.script[nm]}.")
+            self.script.remove(nm) # o/w defining it will fail
+            fspec = FunData(nm, docst = docstring,
+                            howdf = "alias", defon = (alias,))
+        else:
+            fspec = FunData(nm, docst = docstring,
+                            howdf = "alias", defon = (alias,))
+        self.script.define(fspec)
+        return nm
+
+    def importing(self, filename):
+
+        def attempt(candidate, filename, cnt):
+            "try candidate folder, careful with std.prfs"
+            path = (candidate / filename).resolve()
+            if path.exists():
+                ensure.that(filename != "std.prfs" or cnt == 0, 
+                    "Presence of a nonstandard std.prfs file in " +
+                    f"path {path} is disallowed.")
+                return path
+
+        filename = filename.strip('"')
+        if not filename.endswith(".prfs"):
+            filename += ".prfs"
+
+        import_folders = list()
+        if self.import_folder is not None:
+            import_folders.append(self.import_folder)
+        import_folders.append(self.filename.parent)
+        import_folders.append(Path(__file__).parent / "stdprfs")
+
+        importpath = None
+        cnt = len(import_folders)
+        for candidate in import_folders:
+            "ordered search for the imported file"
+            cnt -= 1
+            importpath = attempt(candidate, filename, cnt)
+            if importpath is not None:
+                break
+        ensure.that(importpath is not None, 
+            f"Did not find {filename} to import.")
+        if importpath not in FILENAMES:
+            FILENAMES.add(importpath)
+            local_ast = prfsparser(open(importpath).read())
+            local_scrmk = ScriptMaker(PReFScript(), importpath, imported = True)
+            local_scr = local_scrmk.transform(local_ast)
+            self.script |= local_scr
+        return ''

prefscript-2.0.2/src/prefscript/examples/00.prfs

@@ -0,0 +1 @@
+main: id

prefscript-2.0.2/src/prefscript/examples/01_k_0.prfs

@@ -0,0 +1,5 @@
+main: k_0
+k_0: comp diff pair k_1 k_1
+
+
+