khoca 0.4.dev7__tar.gz → 1.1__tar.gz

khoca-1.1/.github/workflows/build_wheels.yml

@@ -0,0 +1,53 @@
+name: Reusable workflow for cibuildwheel
+
+on:
+  workflow_call:
+    inputs:
+      operating-systems:
+        default: >-
+          ["ubuntu"]
+        type: string
+        required: true
+      system-versions:
+        default: >-
+          ["latest"]
+        type: string
+        required: true
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}-${{ matrix.version }}
+    runs-on: ${{ matrix.os }}-${{ matrix.version }}
+    strategy:
+      matrix:
+        os: ${{ fromJson(inputs.operating-systems) }}
+        version: ${{ fromJson(inputs.system-versions) }}
+    env:
+      CIBW_REPAIR_WHEEL_COMMAND_MACOS: "export MACOSX_DEPLOYMENT_TARGET=${{ matrix.version }}.0; delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # Used to host cibuildwheel
+      - uses: actions/setup-python@v5
+      - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==2.22.0
+
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+
+      - name: Analyse
+        if: always()
+        run: sh analyse.sh
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: khoca.tar
+          path: /Users/runner/work/khoca/khoca.tar
+        if: always()
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl

khoca-1.1/.github/workflows/build_wheels_linux.yml

@@ -0,0 +1,23 @@
+name: Build wheels Linux
+
+on:
+  push:
+    tags:
+      - "*" # Push events of new tags
+  workflow_dispatch:
+    # Allow to run manually
+
+jobs:
+  build_wheels:
+    uses: ./.github/workflows/build_wheels.yml
+    with:
+      operating-systems: >-
+        ["ubuntu"]
+      system-versions: >-
+        ["latest"]
+
+  pypi-publish:
+    name: Upload wheels to PyPI
+    needs: build_wheels
+    uses: ./.github/workflows/publish_pypi.yml
+    secrets: inherit

khoca-1.1/.github/workflows/build_wheels_macos.yml

@@ -0,0 +1,41 @@
+name: Build wheels MacOS
+
+on:
+  push:
+    tags:
+      - "*" # Push events of new tags
+  workflow_dispatch:
+    # Allow to run manually
+
+jobs:
+  build_wheels:
+    uses: ./.github/workflows/build_wheels.yml
+    with:
+      operating-systems: >-
+        ["macos"]
+      system-versions: >-
+        ["13", "14"]
+
+  pypi-publish:
+    # https://github.com/pypa/gh-action-pypi-publish
+    name: Upload wheels to PyPI
+    needs: build_wheels
+    runs-on: ubuntu-latest
+    env:
+      CAN_DEPLOY: ${{ secrets.PYPI_TOCKEN_KHOCA != '' }}
+    steps:
+
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-wheels*
+          path: wheelhouse
+          merge-multiple: true
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_TOKEN_KHOCA }}
+          packages_dir: wheelhouse/
+          skip_existing: true
+          verbose: true

khoca-1.1/.github/workflows/build_wheels_windows.yml

@@ -0,0 +1,59 @@
+name: Build wheels Windows
+
+on:
+  push:
+    tags:
+      - "*" # Push events of new tags
+  workflow_dispatch:
+    # Allow to run manually
+
+jobs:
+  build_wheels:
+    name: Build Windows wheels for 64 bit Python
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    steps:       
+      - uses: actions/checkout@v4
+      - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+
+      - uses: actions/setup-python@v5
+        name: Install a Python to use for building
+        with:
+          python-version: '3.12'
+
+      - uses: msys2/setup-msys2@v2
+        name: Setup an msys2 environment
+        with:
+          msystem: UCRT64
+          release: false
+          install: >-
+            base-devel
+            m4
+            bison
+            make
+            patch
+            sed
+            mingw-w64-x86_64-toolchain
+            mingw-w64-x86_64-gmp
+          pacboy: gcc:p
+          path-type: inherit
+          
+      - name: Install cibuildwheel
+        run: |
+          python -m pip install cibuildwheel==2.20.0
+
+      - name: Build many wheels
+        run: |
+          python -m cibuildwheel --output-dir wheelhouse
+
+      - name: Analyse
+        if: always()
+        run: sh analyse.sh
+
+      - uses: actions/upload-artifact@v4
+        name: Save the wheels as artifacts
+        with:
+          path: ./wheelhouse/*.whl

khoca-1.1/.github/workflows/publish_pypi.yml

@@ -0,0 +1,25 @@
+name: Reusable workflow to publish to PyPI
+
+on:
+  workflow_call:
+
+jobs:
+  pypi-publish:
+    # https://github.com/pypa/gh-action-pypi-publish
+    name: Upload wheels to PyPI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-wheels*
+          path: wheelhouse
+          merge-multiple: true
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_TOKEN_KHOCA }}
+          packages_dir: wheelhouse/
+          skip_existing: true
+          verbose: true

khoca-1.1/.github/workflows/publish_source_pypi.yml

@@ -0,0 +1,26 @@
+name: Publish sources to PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish-sources:
+    name: Upload source distro to PyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+    - uses: actions/setup-python@v5
+    - name: Prepare
+      run: |
+        python -m pip install --upgrade pip
+        pip install cython setuptools
+    - name: Create distribution
+      run: python3 setup.py sdist
+    - name: Publish distro to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_TOKEN_KHOCA }}
+        packages_dir: dist/
+        verbose: true

khoca-1.1/.gitignore

@@ -0,0 +1,11 @@
+bin/__pycache__/
+bin/pui.so
+src/krasner/krasner.o
+src/planar_algebra/coefficient_rings.o
+src/planar_algebra/planar_algebra.o
+src/planar_algebra/smith.o
+src/planar_algebra/sparsemat.o
+src/python_interface/pui.cpp
+src/python_interface/pui.o
+src/python_interface/pythonInterface.o
+src/shared.o

{khoca-0.4.dev7 → khoca-1.1}/Dockerfile

@@ -14,10 +14,12 @@ ENV LANG C.UTF-8
 ENV SHELL /bin/bash
 # install prerequisites
 RUN apt-get -qq update \
-    && apt-get -qq install -y --no-install-recommends git g++ make libgmp-dev pari-gp2c python3 python3-dev python3-pip \
+    && apt-get -qq install -y --no-install-recommends git g++ make libgmp-dev pari-gp2c python3 python3-dev pipx python-is-python3\
     && apt-get -qq clean \
     && rm -r /var/lib/apt/lists/* \
-    && pip install cython \
+    && pipx install cython \
+    && pipx ensurepath \
+    && export PATH="$PATH:/root/.local/bin" \
     && git clone https://github.com/soehms/khoca.git \
     && cd khoca/ \
     && make

{khoca-0.4.dev7 → khoca-1.1}/Makefile

@@ -1,6 +1,6 @@
 CC=g++
-PYTHONVERSION=3.8
-GENERALCFLAGS=-c -std=c++11 -I/usr/include/python$(PYTHONVERSION) -D__STDC_LIMIT_MACROS -Wall -Wextra -march=native
+PYTHONVERSION=$(shell python -c "import sys;t='{v[0]}.{v[1]}'.format(v=list(sys.version_info[:2]));sys.stdout.write(t)")
+GENERALCFLAGS=-c -std=c++11 -I/usr/include/python$(PYTHONVERSION) -D__STDC_LIMIT_MACROS -Wall -Wextra
 
 STATIC_DIRECTIVE=-lpython$(PYTHONVERSION) -lgmpxx -lgmp -L/usr/local/lib -lpari
 # To compile a version of the library that contains static copies of mpir and pari, set variable STATIC to 1.

khoca-1.1/PKG-INFO

@@ -0,0 +1,218 @@
+Metadata-Version: 2.1
+Name: khoca
+Version: 1.1
+Summary: Khoca as pip installable package
+Home-page: https://github.com/soehms/khoca/
+Author: Sebastian Oehms
+Author-email: seb.oehms@gmail.com
+License: GPLv2+
+Keywords: Knot theory,Khovanov homology
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Description-Content-Type: text/markdown
+License-File: COPYING
+
+
+Khoca is a packaging of Lukas Lewark's Khovanov homology calculator
+[khoca](https://github.com/LLewark/khoca/)  for easy installation in
+[sage](http://www.sagemath.org/).
+
+From the original page:
+
+# README for Khoca, a knot homology calculator
+
+The same text as in this README file is available (with illustrations) at
+http://lewark.de/lukas/khoca.html
+
+Khoca is computer program to calculate sl(N)-homology of knots. The program has
+been written for joint projects with Andrew Lobb such as [3, 4]. The paper [3]
+also contains a description of the algorithm used by khoca. The main innovation
+is to use Krasner's calculation of the sl(N)-homology of the basic two-crossing
+tangle [2] for calculations of the homology of bipartite knots.
+
+Khoca calculates the following:
+
+* Khovanov sl(2)-homology of arbitrary links, given as a braid or in PD code.
+* Khovanov-Rozansky sl(N)-homology with N > 2 of bipartite knots, given by a
+  certain encoding of a matched diagram of the knot (see [3] and section
+  "Encoding of matched diagrams" below).
+* Homology over the integers, the rationals or a prime field.
+* Either equivariant homology, or homology with an arbitrary fixed potential.
+* All pages of the spectral sequence of filtered homology over a field.
+* Reduced and unreduced homology.
+* Homology of sums and mirror images of knots.
+
+You are encouraged to contact me with any kind of questions or comments
+regarding khoca. If you are using khoca for a project or publication, please
+cite this web page, or the paper [3].
+
+## Installation
+
+Binaries for Linux are available for download from 
+http://lewark.de/lukas/khoca.html
+They should run on any Linux installation that has python3.6. Binaries for
+Windows or Mac are not available at the moment.
+
+The source code, including instructions on how to compile it, is available at
+the GitHub repository khoca:
+https://github.com/LLewark/khoca
+
+To run Khoca in Docker type:
+
+```bash
+docker run -it soehms/khoca:latest
+```
+
+Its download size is 162 MB and it will need 516 MB of disk space on your
+device. To create a new (resp. locally own) Docker image cd to the khoca
+directory type
+
+```bash
+docker build -f Dockerfile --tag khoca:<your_tag> .
+```
+
+If your machine has an older CPU it can happen that you get *Illegal Instruction*
+errors. In that case you better should use the image `soehms/khoca:old_cpu`.
+
+
+## Usage
+
+To use the program, run khoca.py (a python3 script) from the command line.
+khoca.py takes three arguments:
+
+1. The coefficient ring; `0` for integers, `1` for rationals, a prime `p` for the
+corresponding finite field.
+
+2. A sequence of N integers `a_0, ..., a_{N-1}` separated by a non-digit
+character, defining the Frobenius algebra `F[X]/(X^N + a_{N-1}X^{N-1} + ... +
+a_0)`.  Alternatively, `e` followed by a number `N` for equivariant computation
+over `sl(N)`. For example, `-1.0.0` gives the Frobenius algebra `F[X]/(X3 - 1)`.
+
+3. A root of the polynomial given in 2. for the calculation of reduced homology
+(for the dependence of reduced homology on a root, see [3]).  For example, to
+get the standard graded reduced homology, use 0 as root. If you are not
+interested in reduced homology, it does not matter what root you chose (and
+khoca does not check that the number is actually a root).
+
+The option `-p` will show progress bars, `-v` will give more verbose
+non-mathematical information, and `-h` will print a short help text. Each
+argument after the first three arguments, can be one of the following.
+
+1. `BraidX` calculates homology of a link given as closure of the braid `X`,
+formatted as in knotscape (`a` = first Artin generator, `A` = its inverse, `b` =
+second Artin generator, etc.). This works only for `sl(2)` homology, otherwise
+output is nonsensical.
+
+2. `PdX` calculates homology of a link given in PD notation (as e.g. given on
+KnotInfo). Again, this works only for `sl(2)` homology, otherwise output is
+nonsensical.
+
+3. `GaussX` calculates homology of a bipartite knot given as a matched diagram,
+following the convention explained in the section below. This works for `sl(N)`
+homology for all `N`.
+
+4. `MirrorX` takes the dual of the result at spot `X`.
+
+5. `SumXY` computes the homology of the connected sum of the results saved at
+spots `X` and `Y` (numbers separated by a non-digit character).
+
+6. `CalcX` outputs the result saved at spot `X`. If you forget this command, the
+program will have no output.
+
+The program keeps a stack of computed homologies, enumerated 0,1,2... . Each of
+the commands 1 - 5 puts a new homology on that stack, whereas the command 6.
+prints the homology at a certain spot. This is mainly useful to compute
+homology of sums of knots.
+
+Here are some examples:
+
+```bash
+./khoca.py 0 0.0 0 braidaBaB calc0
+```
+
+calculates the classical `sl(2)` Khovanov homology (both reduced and unreduced)
+of the closure of the braid `aBaB` (knotscape notation), i.e. the figure-eight
+knot.
+
+
+```bash
+./khoca.py 0 e2 0 pd[[4,2,5,1],[8,6,1,5],[6,3,7,4],[2,7,3,8]] calc0
+```
+
+calculates integral equivariant `sl(2)` homology of the figure-eight knot.
+
+
+```bash
+./khoca.py 7 0.-1 0 braidabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef
+calc0 -p
+```
+
+calculates Khovanov homology of the `(7,8)`-torus knot over `F7` with perturbed
+potential, displaying progress bars. This calculation takes roughly two
+minutes, and shows that the spectral sequence does not collapse on the second
+page, refuting the knight-move conjecture over finite fields (cf. [1]).
+
+
+```bash
+./converters/montesinos.py [1/5,1/3,-1/2]
+```
+
+outputs `[12,4,16,10,15,9,14,13]`, the code for a matched diagram of the
+`(5,3,-2)`-pretzel knot, aka the `(3,5)`-torus knot, aka `10_{124}`. So
+
+```bash
+./khoca.py 1 1.0.0.0.0 0 gauss[12,4,16,10,15,9,14,13] calc0 calculates
+```
+
+rational `sl(5)` homology and the corresponding Rasmussen invariant of the `(3,5)`
+torus knot.
+
+
+```bash
+./khoca.py 1 1.0 0 braidaaa dual0 sum0+1 braidaBaB sum2+3 calc4
+```
+
+calculates `sl(2)` homology of the sum of the trefoil, its mirror image and a figure-8-knot.
+
+
+# Encoding of matched diagrams
+
+This section describes how to encode a matched knot diagram, i.e. a diagram
+that consists of `n` copies of the basic 2-crossing tangle. Resolving each basic
+tangle into two intervals and a chord results in a single circle with n
+non-intersecting (red) chords, which may be on either side of the circle.
+Enumerate the `2n` chord endpoints by walking around the circle. If a chord
+connects the points `i` and `j`, let `f(i) = j`. Write down the list `f(1), f(2), ...,
+f(2n)` omitting `f(i)` if `f(i) < i`. Moreover, make the list entries signed, and
+let the sign reflect the sign of the two crossings of the corresponding
+2-crossing tangle. This list of `n` non-zero integers uniquely determines the
+matched diagram. As an example, the standard diagram of `6_1` is matched and
+encoded as `[-4,6,5]`.
+
+"Half" of Montesinos knots are bipartite [3]. You may use the python3 script
+`./converters/montesinos.py` to obtain the encoding of a matched diagram of
+Montesinos knots.
+
+# References
+
+[1] Bar-Natan: Fast Khovanov Homology Computations, Journal of Knot Theory and
+its Ramifications 16 (2007), no.3, pp. 243-255, arXiv:math/0606318, MR2320156.
+
+[2] Daniel Krasner: A computation in Khovanov-Rozansky Homology, Fundamenta
+Mathematicae 203 (2009), pp. 75-95, arXiv:0801.4018, MR2491784.
+
+[3] Lukas Lewark and Andrew Lobb: New Quantum Obstructions to Sliceness,
+Proceedings of the London Mathematical Society 112 (2016), no. 1, pp. 81-114,
+arXiv:1501.07138, MR3458146.
+
+[4] Lukas Lewark and Andrew Lobb: Upsilon-like concordance invariants from
+sl(n) knot cohomology, arXiv:1707.00891.
+
+
+Lukas Lewark, 2018

{khoca-0.4.dev7 → khoca-1.1}/__init__.py

@@ -26,7 +26,8 @@
 # The main work is done by pui.pyx via run_commandline, which is called
 # by the instance call of this class.
 
-from .khoca import run_commandline
+from khoca.khoca import run_commandline
+from khoca.bin.pui import PyComplexStack
 
 
 class InteractiveCalculator:
@@ -39,7 +40,7 @@ class InteractiveCalculator:
         >>> KH = InteractiveCalculator()
         >>> KH
         Khovanov homology calculator for Frobenius algebra: Z[X] / (1*X^2).
-        >>> KH('braidaBaB')
+        >>> KH('braidaBaB')    # doctest: +NORMALIZE_WHITESPACE
         [[[-2, 4, 0, 1], [-1, 2, 0, 1], [0, 0, 0, 1], [1, -2, 0, 1], [2, -4, 0, 1],
           [-2, 4, 0, 0], [-1, 4, 0, 0], [-1, 2, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0],
           [1, 0, 0, 0], [1, -2, 0, 0], [2, -2, 0, 0]], [[-2, 3, 0, 1], [-2, 5, 0, 1],
@@ -49,7 +50,7 @@ class InteractiveCalculator:
           [-1, 3, 0, 0], [0, 3, 0, 0], [0, -1, 0, 0], [1, -1, 0, 0], [0, 1, 0, 0],
           [1, 1, 0, 0], [2, -3, 2, 1], [1, -3, 0, -1], [2, -3, 0, -1], [1, -1, 0, 0],
           [2, -1, 0, 0]]]
-        >>> res, mess = KH('braidaaa', print_messages=True); mess
+        >>> res, mess = KH('braidaaa', print_messages=True); mess # doctest: +NORMALIZE_WHITESPACE
         ['Result:', 'Reduced Homology:', 'Non-equivariant homology:',
          't^-3q^8 + t^-2q^6 + t^0q^2', 'Unreduced Homology:',
          'Non-equivariant homology:', 't^-3q^9 + t^-2q^5 + t^0q^1 + t^0q^3 + t^-2q^7[2]']
@@ -125,7 +126,8 @@ class InteractiveCalculator:
             self._equivariant = 'e%s' %equivariant
 
         self._description = None
-        dummy = self('braidaA', ' ')
+        self._stack = PyComplexStack()
+        self('braidaA', ' ') # sets self._description
 
     def __repr__(self):
         r"""
@@ -138,9 +140,9 @@ class InteractiveCalculator:
             Khovanov homology calculator for Frobenius algebra: F_5[X] / (1*X^2 + 1).
         """
         return 'Khovanov homology calculator for %s' %self._description
-      
 
-    def __call__(self, link, command=None, print_messages=False, verbose_on=False, progress_bars=False):
+
+    def __call__(self, link, command=None, print_messages=False, verbose=False, progress=False):
         r"""
         Instance call to apply the calculator to a link with respect to a
         certain command.
@@ -153,17 +155,17 @@ class InteractiveCalculator:
               a list of lists is accepted which will be interpreted as a list
               of crossings in pd-notation. Alternatively you can declare the
               link by a string. The following formats are accepted:
- 
+
               - ``BraidX`` for a braid formatted as in knotscape (``a`` = first
                 Artin generator, ``A`` = its inverse, ``b`` = second Artin
                 generator, etc.). This works only for ``sl(2)`` homology,
-                otherwise output is nonsensical.
+                otherwise output is nonsensical
               - ``PdX`` for input in PD notation (as e.g. given on !KnotInfo).
                 Again, this works only for ``sl(2)`` homology, otherwise output
-                is nonsensical.
+                is nonsensical
               - ``GaussX`` for bipartite knot given as a matched diagram,
                 following the convention explained in the section below. This
-                works for ``sl(N)`` homology for all ``N``.
+                works for ``sl(N)`` homology for all ``N``
 
             - ``command`` -- a command given as string as explained in the
               command line version of the functionality. This can be:
@@ -171,24 +173,23 @@ class InteractiveCalculator:
               - ``MirrorX`` takes the dual of the result at spot ``X``
               - ``SumXY`` computes the homology of the connected sum of the
                 results saved at spots ``X`` and ``Y`` (numbers separated by
-                a non-digit character).
+                a non-digit character)
               - ``CalcX` outputs the result saved at spot X. If you forget
-                this command, the program will have no output.
+                this command, the program will have no output
 
               If this keyword argument is not given it will be interpreted
               as ``Calc0`` by default.
 
-              - ``print_messages`` boolean (default is ``False``). If set to 
+              - ``print_messages`` boolean (default is ``False``). If set to
                 ``True`` the print output of the command line version is
                 returned as a list on the second output position. By default
                 all print messages to ``stdout`` of the command line version
-                are suppressed.
-              - ``verbose_on`` boolean (default is ``False``). If it is set
-                to ``True`` all print messages to ``stdout`` together with
-                special verbose messages of the command line version are
-                printed.
-              - ``progress_bars`` boolean (default is ``False``). If it is
-                set to ``True`` progress bars will be printed.
+                are suppressed
+              - ``verbose`` boolean (default is ``False``). If it is set to
+                ``True`` all print messages to ``stdout`` together with special
+                verbose messages of the command line version are printed
+              - ``progress`` boolean (default is ``False``). If it is set to
+                ``True`` progress bars will be printed
 
         OUTPUT:
 
@@ -200,7 +201,7 @@ class InteractiveCalculator:
 
             If the option ``print_messages`` is given, than the output contains
             a second result which is a list of all suppressed print messages.
-            
+
 
         ..NOTE:
 
@@ -216,7 +217,7 @@ class InteractiveCalculator:
             >>> from khoca import InteractiveCalculator
             >>> KH = InteractiveCalculator(1, (1, 0), 0); KH
             Khovanov homology calculator for Frobenius algebra: Q[X] / (1*X^2 + 1).
-            >>> KH('braidaaa', 'dual0 sum0+1 braidaBaB sum2+3 calc4', print_messages=True)
+            >>> KH('braidaaa', 'dual0 sum0+1 braidaBaB sum2+3 calc4', print_messages=True) # doctest: +NORMALIZE_WHITESPACE
             ([[[-5, 10, 0, 1], [-4, 8, 0, 1], [-4, 8, 0, 1], [-3, 6, 0, 1],
                [-3, 6, 0, 1], [-3, 6, 0, 1], [-2, 4, 0, 1], [-2, 4, 0, 1],
                [-2, 4, 0, 1], [-2, 4, 0, 1], [-2, 4, 0, 1], [-2, 4, 0, 1],
@@ -241,12 +242,9 @@ class InteractiveCalculator:
               'Page 3 = infinity:', 't^0q^-1 + t^0q^1'])
         """
         # Todo: allow Python type inputs like tuples ..
-        from .khoca import verbose, progress
-        verbose = 0
-        if verbose_on:
-            verbose = 1
-        if progress_bars:
-            progress = 1
+        from .khoca import set_options
+        verbose = int(verbose); progress = int(progress)
+        set_options(verbose, progress)
         arg_list = [None]
         arg_list.append(self._coefficient_ring)
         if self._equivariant:
@@ -255,6 +253,7 @@ class InteractiveCalculator:
             arg_list.append(self._frobenius_algebra)
         arg_list.append(self._root)
 
+
         if type(link) in (tuple, list):
             # Allow more Python like ways to declare the link
             try:
@@ -282,25 +281,27 @@ class InteractiveCalculator:
         arg_list += cmd_list
 
         # redirect print outputs to a list to
-        # return it optionally to the user 
+        # return it optionally to the user
         print_output = []
         def no_print(s):
             print_output.append(s)
 
-        if verbose_on:
+        if verbose:
             if print_messages:
                 raise ValueError('All messages are printed in verbose mode')
-            res = run_commandline(arg_list, print, 0)
+            with self._stack:
+                res = run_commandline(arg_list, print, progress)
             return res
 
         # capture print output from the shared library
         # and use the to set the description resp.
-        # return it optionally to the user 
+        # return it optionally to the user
         import py
         capture = py.io.StdCaptureFD(err=False, in_=False)
 
         try:
-            res = run_commandline(arg_list, no_print, 0)
+            with self._stack:
+                res = run_commandline(arg_list, no_print, progress)
         except:
             out, err = capture.reset()
             raise
@@ -311,6 +312,6 @@ class InteractiveCalculator:
 
         if print_messages:
             if  out:
-                print_output += [out]
+                print_output += [out][:-1]
             return res, print_output
         return res